机器学习 笔记（一）

概念&基础

流程：

fit就是拟合

分类任务：
二分类：不是0就是1
多分类：数字识别、图像识别、风险评级
多标签分类：多种类型进行归类
回归任务： 结果是一个连续数字的值，而非一个类别。

监督学习： 给机器的训练数据拥有“标记”或者“答案”。一般用于分类、回归
非监督学习： 给机器的训练数据没有“标记”或者“答案”。一般用于聚类分析、降维、异常检测
半监督学习： 一部分数据有答案，另一部分数据没有。先用非监督学习对数据进行处理，再用监督学习进行训练和预测
增强学习： 根据周围环境的情况，采取行动，根据采取行动的结果，学习行为方式。

欠拟合： 不能完整表述数据关系
过拟合： 过多的表达了数据间的噪音关系

---

Numpy

import numpy as np
np.array  np.dtype  np.zeros  np.full  np.arange  np.linspace  
np.random.randint  np.random.seed  np.random.random()  np.random.normal()
axis(0指行，1指列) 

# 合并拼接
np.concatenate([x,y])
np.vstack([x,y])  np.hstack([x,y])

# 分割
np.split()  np.vsplit()  np.hsplit()

# 运算
A.dot(B) 乘积
A.T 转置
np.tile() 堆叠
np.linalg.inv()  矩阵的逆
np.linalg.pinv() 伪逆矩阵
np.sum() .min()  .max() .prod()乘积 .mean() .median() .percentile()百分位
np.var()方差  .std()标准差

# 索引
np.argmin() 最小值索引  argsort() 元素索引
np.shuffle() 打乱顺序   np.sort() 
np.partition()  argpartition()

# fancy indexing
np.count_nonzero()  np.any() np.all() 

---

Matplotlib

import matplotlib.pyplot as plt
# 折线图
plt.plot(x,y,color="颜色",linestyle="线性"，label="图示")
plt.show()
plt.xlim()  ylim()  xy轴的范围
plt.axis([x0,x1,y0,y1])  调节xy轴的范围
plt.xlabel()  ylabel()  xy标签
plt.legrnd()  显示图例
plt.title() 标题

# 散点图
plt.scatter(x,y,alpha="透明度")

#bar 条形图
plt.bar()

# 直方图
plt.hist()

---

数据预处理

数据归一化

数据分布没有明显边界：均值归一化（StandardScaler）
数据分布有明显边界：最值归一化（MinMaxScaler）

StandardScaler

# 测试集必须使用训练集的均值和方差，即 standardScalar.fit(X_train) 后的数据
from sklearn.preprocessing import StandardScaler
standardScalar = StandardScaler()
standardScalar.fit(X_train)
standardScalar.mean_    均值
standardScalar.scale_   方差
standardScalar.transform(X_train)  归一化

MinMaxScaler

from sklearn.preprocessing import MinMaxScaler
minmaxscaler = MinMaxScaler()
minmaxscaler.fit(X_train)
X_train = minmaxscaler.transform(X_train)
X_test_standard = minmaxscaler.transform(X_test) 
kNeighbors = KNeighborsClassifier(n_neighbors=3)
kNeighbors.fit(X_train,y_train)
kNeighbors.score(X_test_standard, y_test)

---

KNN

附近最近的k个点，解决分类问题，1最好，0最差
需要对数据进行归一化处理
缺点：维数灾难、不可解释、容易受异常值的影响
距离计算方式：欧拉距离、曼哈顿距离、明可夫斯基距离-------具体算法自行百度

KNeighborsClassifier 超参数

参数:
        n_neighbors: int, 可选参数(默认为 5),查询的默认邻居的数量

        weights（权重）: str or callable(自定义类型), 可选参数(默认为 ‘uniform’)
                用于预测的权重函数。可选参数如下:
                       - ‘uniform’ : 统一的权重，就是比较个数占比
                       - ‘distance’ : 权重点等于他们距离的倒数。就是比较距离的倒数，选择更近的
                       - [callable] : 自定义的方法

        algorithm（算法）: {‘auto’, ‘ball_tree’, ‘kd_tree’, ‘brute’}, 可选参数（默认为 'auto'）
        leaf_size（叶子数量）: int, 可选参数(默认为 30)
                传入BallTree或者KDTree算法的叶子数量。此参数会影响构建、查询BallTree或者KDTree的速度，以及存储BallTree或者KDTree所需要的内存大小。 此可选参数根据是否是问题所需选择性使用。

         p: integer, 可选参数(默认为 2)，距离算法的选择，1是曼哈顿距离，2是欧拉距离，其它是明可夫斯基距离
         
         metric（矩阵）: string or callable, 默认为 ‘minkowski’，用于树的距离矩阵
         metric_params（矩阵参数）: dict, 可选参数(默认为 None)，给矩阵方法使用的其他的关键词参数。

         n_jobs: int, 可选参数(默认为 1)
                用于搜索邻居的，可并行运行的任务数量。如果为-1, 任务数量设置为CPU核的数量。

基本应用

from sklearn.neighbors import KNeighborsClassifier
kNN_classifier = KNeighborsClassifier(n_neighbors=6)
kNN_classifier.fit(X_train, y_train)
score = kNN_classifier.score(X_test,y_test)
y_pred = kNN_classifier.predict(x)

网格搜索 找到更好的超参数

param_grid = [
    {
        'weights': ['uniform'], 
        'n_neighbors': [i for i in range(1, 11)]
    },
    {
        'weights': ['distance'],
        'n_neighbors': [i for i in range(1, 11)], 
        'p': [i for i in range(1, 6)]
    }
]
knn_clf = KNeighborsClassifier()
grid_search = GridSearchCV(knn_clf, param_grid, , n_jobs=-1, verbose=2，cv = 5)
grid_search.fit(X_train, y_train)
grid_search.best_estimator_
grid_search.best_score_
grid_search.best_params_
grid_search.best_estimator_.score(X_test_standard, y_test)

KNeighborsRegressor 解决线性回归的问题

from sklearn.neighbors import KNeighborsRegressor

knn_reg = KNeighborsRegressor()
knn_reg.fit(X_train_standard, y_train)
knn_reg.score(X_test_standard, y_test)

---

线性回归

典型的参数学习，采用正规方程解。损失函数尽可能小（最小二乘法），目标函数尽可能大。
多元线性回归不需要对数据进行归一化处理。对数据具有强解释性。

线性回归算法的指标：
均方误差 MSE
均方根误差 RMSE
平均绝对误差 MAE
R Squared

from sklearn.metrics import mean_squared_error
from sklearn.metrics import mean_absolute_error
from sklearn.metrics import r2_score

mean_squared_error(y_test, y_predict)
mean_absolute_error(y_test, y_predict)
r2_score(y_test, y_predict)

基本应用

from sklearn.linear_model import LinearRegression

lin_reg = LinearRegression()
lin_reg.fit(X_train, y_train)
lin_reg.coef_  返回的参数矩阵
lin_reg.intercept_   截距
lin_reg.score(X_test, y_test)

---

梯度下降法

不是机器学习算法，一种基于搜索的最优化方法。最小化一个损失函数。
需要进行数据归一化

随机梯度下降法

from sklearn.linear_model import SGDRegressor
sgd_reg = SGDRegressor()
sgd_reg.fit(X_train_standard, y_train)
sgd_reg.score(X_test_standard, y_test)

---

主成分分析法

主要用于数据的降维、降噪
均值为0

PCA超参数

参数：
     n_components：降维后的特征维度数目
     copy: 表示是否在运行算法时，将原始数据复制一份。默认为True，则运行PCA算法后，原始数据的值不会有任何改变。
     whiten： 白化。所谓白化，就是对降维后的数据的每个特征进行标准化，让方差都为1。
     svd_solver： 即指定奇异值分解SVD的方法，有4个可以选择的值：{‘auto’, ‘full’, ‘arpack’, ‘randomized’}。
          'randomized' 一般适用于数据量大，数据维度多同时主成分数目比例又较低的PCA降维，它使用了一些加快SVD的随机算法。
          'full' 则是传统意义上的SVD，使用了scipy库对应的实现。
          'arpack' 和randomized的适用场景类似，区别是randomized使用的是scikit-learn自己的SVD实现，而arpack直接使用了scipy库的sparse SVD实现。当svd_solve设置为'arpack'时，保留的成分必须少于特征数，即不能保留所有成分。
           默认是'auto'，即PCA类会自己去在前面讲到的三种算法里面去权衡，选择一个合适的SVD算法来降维。

     当设置 n_components == 'mle'时，需要和参数svd_solver一起使用，且svd_solver需要选择 'full' 参数；
     即pca = PCA(n_components = 'mle',svd_solver='full')；同时要保证输入数据的样本数多于特征数才可执行成功。
     
     explained_variance_：降维后的各主成分的方差值，方差值越大，则说明越是重要的主成分
     explained_variance_ratio_：降维后的各主成分的方差值占总方差值的比例，这个比例越大，则越是重要的主成分

PCA

from sklearn.decomposition import PCA
from sklearn.neighbors import KNeighborsClassifier

pca = PCA(n_components=2)
pca.fit(X_train)
X_train_reduction = pca.transform(X_train)
X_test_reduction = pca.transform(X_test)
knn_clf = KNeighborsClassifier()
knn_clf.fit(X_train_reduction, y_train)
pca.explained_variance_ratio_
pca = PCA(0.95)  个数能解释原来的数据95%以上的方差
pca.n_components_

---

多项式回归

添加新的特征

超参数

参数：
   degree：多项式的阶数
   interaction_only： 如果值为true(默认是false),则会产生相互影响的特征集
   include_bias：是否包含偏差列

基本应用

from sklearn.preprocessing import PolynomialFeatures
poly = PolynomialFeatures(degree=2)
poly.fit(X)
X2 = poly.transform(X)

from sklearn.linear_model import LinearRegression
lin_reg2 = LinearRegression()
lin_reg2.fit(X2, y)
y_predict2 = lin_reg2.predict(X2)

Pipeline 基本应用

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

poly_reg = Pipeline([
    ("poly", PolynomialFeatures(degree=2)),
    ("std_scaler", StandardScaler()),
    ("lin_reg", LinearRegression())
])

# 按照管道一步步往下执行
poly_reg.fit(X, y)
y_predict = poly_reg.predict(X)

---

交叉验证

网格搜索就是采用的交叉验证

基本应用

from sklearn.model_selection import cross_val_score
knn_clf = KNeighborsClassifier()
cross_val_score(knn_clf, X_train, y_train，cv = 5)

---

模型正则化

过拟合是因为参数过大，正则化是为了让参数尽可能的小

岭回归 ----- L2正则项

超参数

参数：
    alpha: 正则项系数，值越大正则项占比越大。初始值建议一开始设置为0，这样先确定一个比较好的学习率，学习率一旦确定，给alpha一个较小的         值，然后根据验证集上的准确率，增大或减小10倍。10倍是粗调节，当确定了合适的数量级后，再在同一个数量级内细调节。
    fit_intercept：布尔值，指定是否需要计算截距b值。False则不计算b值。
    normalize:布尔值。如果等于True，模型训练之前会把数据归一化。
    copy_X:布尔值。如果设置为True，则会复制一份训练数据。
    max_iter：整数。指定了最大迭代次数。如果为None，则采用默认值。
    tol:阈值。判断迭代是否收敛或者是否满足精度的要求。
    solver:字符串。指定求解最优化问题的算法。
           (1).solver='auto',根据数据集自动选择算法。
           (2).solver='svd',采用奇异值分解的方法来计算
           (3).solver='cholesky',采用scipy.linalg.solve函数求解最优解。
           (4).solver='sparse_cg',才哟个scipy.sparse.linalg.cg函数来求取最优解。
           (5).solver='sag',采用Stochastic Average Gradient descent算法求解最优化问题。
    random_state:一个整数或者一个RandomState实例，或者为None。它在solver="sag"时使用。
           (1).如果为整数，则它指定了随机数生成器的种子。
           (2).如果为RandomState实例，则指定了随机数生成器。
           (3).如果为None，则使用默认的随机数生成器。

基本应用

from sklearn.linear_model import Ridge

def RidgeRegression(degree, alpha):
    return Pipeline([
        ("poly", PolynomialFeatures(degree=degree)),
        ("std_scaler", StandardScaler()),
        ("ridge_reg", Ridge(alpha=alpha))
    ])
    
ridge1_reg = RidgeRegression(20, 1)
ridge1_reg.fit(X_train, y_train)

y1_predict = ridge1_reg.predict(X_test)
mean_squared_error(y_test, y1_predict)

LASSO ---- L1正则项

超参数

参数：
    alpha:正则化项中alpha值。
    fit_intercept:布尔值，指定是否需要计算截距b值。False则不计算b值。
    normalize：布尔值。如果等于True，模型训练之前会把数据归一化。
    precompute:一个布尔值或者一个序列。它决定是否提前计算Gram矩阵来加速计算。
    max_iter：指定最大迭代次数。
    copy_X:布尔值。如果设置为True，则会复制一份训练数据。
    tol:阈值。判断迭代是否收敛或者是否满足精度的要求。
    warm_start:布尔值。如果为True，那么使用前一次训练结果继续训练。否则从头开始训练。
    positive:布尔值。如果为True，那么强制要求权重向量的分量都为正数。
    random_state:一个整数或者一个RandomState实例，或者None。
           (1):如果为整数，则它指定了随机数生成器的种子。
           (2):如果为RandomState实例，则它指定了随机数生成器。
           (3):如果为None，则使用默认的随机数生成器。
   selection:字符串，可以是"cyclic"或"random"。它指定了当每轮迭代的时候，选择权重向量的哪个分量来更新。
          (1)"random":更新的时候，随机选择权重向量的一个分量来更新。
          (2)"cyclic":更新的时候，从前向后依次选择权重向量的一个分量来更新。

基本应用

from sklearn.linear_model import Lasso

def LassoRegression(degree, alpha):
    return Pipeline([
        ("poly", PolynomialFeatures(degree=degree)),
        ("std_scaler", StandardScaler()),
        ("lasso_reg", Lasso(alpha=alpha))
    ])
lasso1_reg = LassoRegression(20, 0.01)
lasso1_reg.fit(X_train, y_train)

y1_predict = lasso1_reg.predict(X_test)
mean_squared_error(y_test, y1_predict)

弹性网 — ElasticNet

ElasticNet回归是对Lasso回归和岭回归的融合，其正则化项是L1范数和L2范数的一个权衡。

超参数

参数：
   alpha:正则化项中alpha值。
   l1_ratio:正则化项中的l1_ratio值。就是L1,L2的比例
   fit_intercept:布尔值，指定是否需要计算截距b值。False则不计算b值。
   normalize：布尔值。如果等于True，模型训练之前会把数据归一化。
   precompute:一个布尔值或者一个序列。它决定是否提前计算Gram矩阵来加速计算。
   max_iter：指定最大迭代次数。
   copy_X:布尔值。如果设置为True，则会复制一份训练数据。
   tol:阈值。判断迭代是否收敛或者是否满足精度的要求。
   warm_start:布尔值。如果为True，那么使用前一次训练结果继续训练。否则从头开始训练。
   positive:布尔值。如果为True，那么强制要求权重向量的分量都为正数。
   random_state:一个整数或者一个RandomState实例，或者None。
          (1):如果为整数，则它指定了随机数生成器的种子。
          (2):如果为RandomState实例，则它指定了随机数生成器。
          (3):如果为None，则使用默认的随机数生成器。
  selection:字符串，可以是"cyclic"或"random"。它指定了当每轮迭代的时候，选择权重向量的哪个分量来更新。
         (1)"random":更新的时候，随机选择权重向量的一个分量来更新。
         (2)"cyclic":更新的时候，从前向后依次选择权重向量的一个分量来更新。

基本应用

from sklearn.linear_model import ElasticNet
regr = ElasticNet(random_state=0)
regr.fit(X, y) 
print(regr.coef_) 
print(regr.intercept_) 
y1_predict = regr.predict(X_test)

---

逻辑回归

一般解决二分类问题，使训练数据的标签值与预测出来的值之间的误差最小化。
需要求逻辑回归损失函数的梯度，求出参数。

超参数

参数：
   penalty:字符串，指定了正则化策略。默认为"L2"
   dual:布尔值。默认为False。如果等于True，则求解其对偶形式。只有在penalty="L2"并且solver="liblinear"时才有对偶形式
   tol:阈值。判断迭代是否收敛或者是否满足精度的要求。
   C:float,默认为1.0.指定了正则化项系数的倒数。必须是一个正的浮点数。他的值越小，正则化项就越大。
   fit_intercept:bool值。默认为True。如果为False,就不会计算b值。
   intercept_scaling：float, default 1。只有当solver="liblinear"并且fit_intercept=True时，才有意义。
   class_weight：dict or 'balanced', default: None。
   random_state:int, RandomState instance or None, default: None
   solver:字符串，指定求解最优化问题的算法。{'newton-cg', 'lbfgs', 'liblinear', 'sag', 'saga'},default: 'liblinear'
          (1)solver='liblinear',对于小数据集，'liblinear'是很好的选择。对于大规模数据集，'sag'和'saga'处理起来速度更快。
          (2)solver='newton-cg',采用牛顿法
          (3)solver='lbfgs',采用L-BFGS拟牛顿法。
          (4)solver='sag',采用Stochastic Average Gradient descent算法。
          (5)对于多分类问题，只有'newton-cg'，'sag'，'saga'和'lbfgs'处理多项损失; 'liblinear'仅限于'ovr'方案。
          (6)newton-cg', 'lbfgs' and 'sag' 只能处理 L2 penalty, 'liblinear' and 'saga' 能处理 L1 penalty。
    max_iter:指定最大迭代次数。default: 100。
    multi_class：{'ovr', 'multinomial'}, default: 'ovr'。指定对分类问题的策略。
         使用multinomial 采用ovo方式来分类，需要使用solver参数，教程用了newton-cg。
         LogisticRegression(multi_class="multinomial", solver="newton-cg")
    verbose:用于开启或者关闭迭代中间输出日志功能。
    warm_start:布尔值。如果为True，那么使用前一次训练结果继续训练。否则从头开始训练。
    n_jobs:int, default: 1。指定任务并行时的CPU数量。如果为-1，则使用所有可用的CPU。

基本应用

from sklearn.linear_model import LogisticRegression

log_reg = LogisticRegression()
log_reg.fit(X_train, y_train)
log_reg.score(X_test, y_test)

# 耗时更长
from sklearn.linear_model import LogisticRegressionCV

log_reg_cv = LogisticRegressionCV()
log_reg_cv.fit(X_train, y_train)

---

OvO and OvR

多分类

from sklearn.multiclass import OneVsRestClassifier

ovr = OneVsRestClassifier(log_reg)
ovr.fit(X_train, y_train)
ovr.score(X_test, y_test)


from sklearn.multiclass import OneVsOneClassifier

ovo = OneVsOneClassifier(log_reg)
ovo.fit(X_train, y_train)
ovo.score(X_test, y_test)

混淆矩阵

评价分类结果
TN(00) FN(10) TP(11) FP (01)

二分类极度偏斜
精准率：TP/(TP+FP) 预测的结果，正确的概率
召回率：TP/(TP+FN) 关注的事件真实发生了，成功的预测的结果
F1 Score: 2*精准率*召回率/(精准率+召回率) 精准率和召回率的调和平均值

基本应用

# 混淆矩阵
from sklearn.metrics import confusion_matrix
confusion_matrix(y_test, y_log_predict)

# 精准率
from sklearn.metrics import precision_score
precision_score(y_test, y_log_predict)
# 多分类
precision_score(y_test, y_predict, average="micro")

# 召回率
from sklearn.metrics import recall_score
recall_score(y_test, y_log_predict)

# 调和平均值
from sklearn.metrics import f1_score
f1_score(y_test, y_predict)

# Precision-Recall曲线
log_reg = LogisticRegression()
log_reg.fit(X_train, y_train)
decision_scores = log_reg.decision_function(X_test)

from sklearn.metrics import precision_recall_curve
precisions, recalls, thresholds = precision_recall_curve(y_test, decision_scores)

# ROC
from sklearn.metrics import roc_curve
fprs, tprs, thresholds = roc_curve(y_test, decision_scores)
# ROC 曲线面积
from sklearn.metrics import roc_auc_score
roc_auc_score(y_test, decision_scores)

---

支撑向量机 SVM

解决的是线性可分问题，尝试寻找一个最优的决策边界
距离两个类别的最近的样本（支撑向量 ）最远，最大化margin
需要对数据进行归一化

基本应用

# 标准化
from sklearn.preprocessing import StandardScaler
standardScaler = StandardScaler()
standardScaler.fit(X)
X_standard = standardScaler.transform(X)

# 线性svm
from sklearn.svm import LinearSVC
# c取值越小，容错空间越大
svc = LinearSVC(C=1e9)
svc.fit(X_standard, y)


# 使用多项式核函数的SVM
from sklearn.svm import SVC
def PolynomialKernelSVC(degree, C=1.0):
    return Pipeline([
        ("std_scaler", StandardScaler()),
        ("kernelSVC", SVC(kernel="poly", degree=degree, C=C))
    ])
poly_kernel_svc = PolynomialKernelSVC(degree=3)
poly_kernel_svc.fit(X, y)

# 高斯核函数
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.svm import SVC

def RBFKernelSVC(gamma):
    return Pipeline([
        ("std_scaler", StandardScaler()),
        ("svc", SVC(kernel="rbf", gamma=gamma))
    ])
svc = RBFKernelSVC(gamma=1)
svc.fit(X, y)

# 解决回归问题
from sklearn.svm import LinearSVR
from sklearn.svm import SVR
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline

def StandardLinearSVR(epsilon=0.1):
    return Pipeline([
        ('std_scaler', StandardScaler()),
        ('linearSVR', LinearSVR(epsilon=epsilon))
    ])
svr = StandardLinearSVR()
svr.fit(X_train, y_train)

---

决策树

信息熵，随机变量不确定度的度量。
熵越大，不确定性越高，越小，不确定性越低。

超参数

参数：
    criterion：默认为"gini"，衡量分类的方法
    splitter：默认为"best"，一种用来在节点中选择分类的策略
    max_features：在进行分类时需要考虑的特征数。
    max_depth：表示树的最大深度。
    min_samples_split：一个节点需要的最少的样本数。默认为2
    min_samples_leaf：一个叶节点所需要的最小样本数。默认为1
    min_weight_fraction_leaf：一个叶节点的输入样本所需要的最小的加权分数。默认为0
    max_leaf_nodes：最多有多少个叶子节点。
    class_weight：类的关联权值
    random_state：随机种子
    persort：是否预分类数据以加速训练时最好分类的查找。默认为False

基本应用

# 分类
# 使用信息熵
from sklearn.tree import DecisionTreeClassifier
dt_clf = DecisionTreeClassifier(max_depth=2, criterion="entropy", random_state=42)
dt_clf.fit(X, y)

# 分类
# 使用基尼系数
from sklearn.tree import DecisionTreeClassifier
dt_clf = DecisionTreeClassifier(max_depth=2, criterion="gini", random_state=42)
dt_clf.fit(X, y)

# 回归
from sklearn.tree import DecisionTreeRegressor
dt_reg = DecisionTreeRegressor()
dt_reg.fit(X_train, y_train)

---

集成学习

多个算法训练同一组数据，结果少数服从多数。

基本应用

from sklearn.ensemble import VotingClassifier
# hard voting
voting_clf = VotingClassifier(estimators=[
    ('log_clf', LogisticRegression()), 
    ('svm_clf', SVC()),
    ('dt_clf', DecisionTreeClassifier(random_state=666))],
                             voting='hard')
voting_clf.fit(X_train, y_train)
voting_clf.score(X_test, y_test)


# soft voting
voting_clf2 = VotingClassifier(estimators=[
    ('log_clf', LogisticRegression()), 
    ('svm_clf', SVC(probability=True)),
    ('dt_clf', DecisionTreeClassifier(random_state=666))],
                             voting='soft')
voting_clf2.fit(X_train, y_train)
voting_clf2.score(X_test, y_test)

Bagging 取样,建立子模型

基本应用

from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import BaggingClassifier

bagging_clf = BaggingClassifier(DecisionTreeClassifier(),
                           n_estimators=500, max_samples=100,
                           bootstrap=True)
bagging_clf.fit(X_train, y_train)
bagging_clf.score(X_test, y_test)

# oob,没有被取到的样本
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import BaggingClassifier

bagging_clf = BaggingClassifier(DecisionTreeClassifier(),
                               n_estimators=500, max_samples=100,
                               bootstrap=True, oob_score=True)
bagging_clf.fit(X, y)
bagging_clf.oob_score_

# 对特征和样本随机取样，bootstrap_features
random_subspaces_clf = BaggingClassifier(DecisionTreeClassifier(),
                               n_estimators=500, max_samples=100,
                               bootstrap=True, oob_score=True,
                               max_features=1, bootstrap_features=True)
random_subspaces_clf.fit(X, y)
random_subspaces_clf.oob_score_

---

随机森林

根据决策树划分了很多子模型，形成了随机森林。

基本应用

from sklearn.ensemble import RandomForestClassifier
rf_clf = RandomForestClassifier(n_estimators=500, oob_score=True, random_state=666, n_jobs=-1)
rf_clf.fit(X, y)

# Extra-Trees
from sklearn.ensemble import ExtraTreesClassifier
et_clf = ExtraTreesClassifier(n_estimators=500, bootstrap=True, oob_score=True, random_state=666, n_jobs=-1)
et_clf.fit(X, y)

# 解决回归问题
from sklearn.ensemble import BaggingRegressor
from sklearn.ensemble import RandomForestRegressor
from sklearn.ensemble import ExtraTreesRegressor

Boosting

集成多个模型，每个模型都在尝试增强整体的效果。

基本应用

# AdaBoostClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import AdaBoostClassifier
ada_clf = AdaBoostClassifier(
    DecisionTreeClassifier(max_depth=2), n_estimators=500)
ada_clf.fit(X_train, y_train)
ada_clf.score(X_test, y_test)

# Gradient Boosting
from sklearn.ensemble import GradientBoostingClassifier
gb_clf = GradientBoostingClassifier(max_depth=2, n_estimators=30)
gb_clf.fit(X_train, y_train)

# 解决回归问题
from sklearn.ensemble import AdaBoostRegressor
from sklearn.ensemble import GradientBoostingRegressor