Scikit-Learn各算法详细参数速查手册(中文)

Scikit-Learn各算法详细参数速查手册(中文)

martin

• Scikit-Learn各算法详细参数速查手册中文
  • 线性模型
    • 1 线性回归
    • 2 线性回归的正则化
      • 21 Lasso回归L1正则
      • 22 岭回归L2正则
      • 23 ElasticNet弹性网络正则
    • 3 逻辑回归
    • 4 线性判别分析
  • 决策树
    • 1 回归决策树
    • 2分类决策树
  • 贝叶斯分类器
    • 1 高斯贝叶斯分类器
    • 2 多项贝叶斯分类器
    • 3 伯努利贝叶斯分类器
  • K近邻
    • 1 KNN分类器
    • 2 KNN回归器
  • 数据降维
    • 1 PCA
    • 2 超大规模数据降维IncrementalPCA
  • 聚类
    • 1 K均值KMeans聚类
    • 2 密度DBSCAN聚类
    • 3 层次AgglomerativeClustering聚类
  • 支持向量机
    • 1 线性分类SVM
    • 2 非线性分类SVM
    • 3 线性回归SVR
    • 4 非线性回归SVR
  • 集成学习
    • 概念
    • Bagging
    • Boosting
    • 1 AdaBoost
      • 算法过程
      • 基分类器权值a与训练数据集权值w的分析
      • AdaBoost推导
      • 11 AdaBoostClassifier
      • 12 AdaBoostRegressor
    • 2 Gradient Tree Boosting
      • 21 GradientBoostingClassifier
      • 22 GradientBoostingRegressor
    • 3 Random Forest
      • 31 RandomForestClassifier
      • 32 RandomForestRegressor
  • 参考书籍

---

1. 线性模型

1.1 线性回归

LinearRegression是scikit-learn提供的线性回归模型，其原型为：
class sklearn.linear_model.LinearRegression(fit_intercept=True, normalize=False, copy_X=True, n_jobs=1)

• [x] 导包
  
  • from sklearn.linear_model import LinearRegression
• [x] 参数
  
  • fit_intercept : 一个布尔值，指定是否需要计算b值。如果为False，那么不计算b值。
  • normalize : 一个布尔值。如果为True，那么训练样本会在回归之前被归一化。
  • copy_X : 一个布尔值。如果为True，则会被复制。
  • n_jobs : 一个正数。任务并行时指定的CPU数量。如果为-1则使用所有可用的CPU。
• [x] 属性
  
  • coef_ : 权重向量。
  • intercept_ : 截距b值。
• [x] 方法
  
  • fit(X,y) : 训练模型。
  • predict(X) : 用模型预测，返回预测值。
  • score(X,y) : 返回性能得分。设预测集为 Ttest ，真实值为 yi ，真实值的均值为 y¯ ，预测值为 y^i ，则：
    
    score=1−∑Ttest(yi−y^i)2(yi−y¯)2

1.2 线性回归的正则化

1.2.1 Lasso回归（L1正则）

原型为：
class sklearn.linear_model.Lasso(alpha=1.0,fit_intercept=True,normalize=False,precompute=False,
copy_X=True,max_iter=1000,tol=0.0001,warm_start=False,positive=False,random_state=None,
selection=’cyclic’)

• [x] 导包
  
  • from sklearn.linear_model import Lasso
• [x] 参数
  
  • alpha : α 值，其值越大则正则化项的占比越大。
  • fit_intercept ：一个布尔值，指定是否需要计算b值。如果为False，那么不计算b值。
  • max_iter : 一个整数，指定最大迭代次数。
  • normalize :一个布尔值。如果为True，那么训练样本会在回归之前被归一化。
  • copy_X : 一个布尔值。如果为True，则会被复制。
  • precompute : 一个布尔值或者一个序列。决定是否提前计算Gram矩阵来加速计算。
  • tol : 一个浮点数，指定判断迭代收敛与否的阈值
  • warm_start : 一个布尔值。如果为True，那么使用前一次训练结果继续训练。否则从头开始训练
  • positive : 一个布尔值。如果为True，那么要求权重向量的分量都为正数。
  • selection : 一个字符串，可以为‘cyclic’或者‘random’。它指定了当每轮迭代的时候，选择权重向量的那个分量来更新。
    
    • cyclic：更新的时候，从前向后依次选择权重向量的一个分量来更新。
    • random：更新的时候，随机选择权重向量的一个分量来更新。
  • random_state : 一个整数或者一个RandomState实例，或者None。
    
    • 整数，则指定了随机数生成器的种子。
    • RandomState，则指定了随机数生成器。
    • None，则默认使用随机数生成器。
• [x] 属性
  
  • coef_ : 权重向量。
  • intercept_ : 截距b值。
  • n_iter_ : 实际迭代次数。
• [x] 方法
  
  • fit(X,y) : 训练模型。
  • predict(X) : 用模型预测，返回预测值。
  • score(X,y) : 返回性能得分。设预测集为 Ttest ，真实值为 yi ，真实值的均值为 y¯ ，预测值为 y^i ，则：
    
    score=1−∑Ttest(yi−y^i)2(yi−y¯)2

1.2.2 岭回归（L2正则）

原型为：
class sklearn.linear_model.Ridge(alpha=1.0, fit_intercept=True, normalize=False, copy_X=True, max_iter=None, tol=0.001, solver=’auto’, random_state=None)

• [x] 导包
  
  • from sklearn.linear_model import Ridge
• [x] 参数
  
  • alpha : α 值，其值越大则正则化项的占比越大。
  • fit_intercept ：一个布尔值，指定是否需要计算b值。如果为False，那么不计算b值。
  • max_iter : 一个整数，指定最大迭代次数。
  • normalize :一个布尔值。如果为True，那么训练样本会在回归之前被归一化。
  • copy_X : 一个布尔值。如果为True，则会被复制。
  • solver : 一个字符串，指定求解最优化问题的算法。可以为：
    
    • auto : 根据数据集自动选择算法。
    • svd :使用奇异值分解计算回归系数。
    • cholesky :使用scipy.linalg.solve函数来求解。
    • sparse_cg :使用scipy.sparse.linalg.cg函数来求解。
    • lsqr :使用scipy.sparse.linalg.lsqr函数来求解。
    • sag :使用随机梯度下降来求解
  • tol : 一个浮点数，指定判断迭代收敛与否的阈值
  • random_state : 一个整数或者一个RandomState实例，或者None。
    
    • 整数，则指定了随机数生成器的种子。
    • RandomState，则指定了随机数生成器。
    • None，则默认使用随机数生成器。
• [x] 属性
  
  • coef_ : 权重向量。
  • intercept_ : 截距b值。
  • n_iter_ : 实际迭代次数。
• [x] 方法
  
  • fit(X,y) : 训练模型。
  • predict(X) : 用模型预测，返回预测值。
  • score(X,y) : 返回性能得分。设预测集为 Ttest ，真实值为 yi ，真实值的均值为 y¯ ，预测值为 y^i ，则：
    
    score=1−∑Ttest(yi−y^i)2(yi−y¯)2

1.2.3 ElasticNet（弹性网络正则）

原型为：
class sklearn.linear_model.ElasticNet(alpha=1.0, l1_ratio=0.5, fit_intercept=True, normalize=False, precompute=False, max_iter=1000, copy_X=True, tol=0.0001, warm_start=False, positive=False, random_state=None, selection=’cyclic’)

• [x] 导包
  
  • from sklearn.linear_model import ElasticNet
• [x] 参数
  
  • alpha : α 值，其值越大则正则化项的占比越大。
  • l1_ratio : ρ 值。公式为：
    
    αρ||ω||1+α(1−ρ)2||ω||22，α≥0，0≤ρ≤1
  • fit_intercept ：一个布尔值，指定是否需要计算b值。如果为False，那么不计算b值。
  • max_iter : 一个整数，指定最大迭代次数。
  • normalize :一个布尔值。如果为True，那么训练样本会在回归之前被归一化。
  • copy_X : 一个布尔值。如果为True，则会被复制。
  • precompute : 一个布尔值或者一个序列。决定是否提前计算Gram矩阵来加速计算。
  • tol : 一个浮点数，指定判断迭代收敛与否的阈值
  • warm_start : 一个布尔值。如果为True，那么使用前一次训练结果继续训练。否则从头开始训练
  • positive : 一个布尔值。如果为True，那么要求权重向量的分量都为正数。
  • selection : 一个字符串，可以为‘cyclic’或者‘random’。它指定了当每轮迭代的时候，选择权重向量的那个分量来更新。
    
    • cyclic：更新的时候，从前向后依次选择权重向量的一个分量来更新。
    • random：更新的时候，随机选择权重向量的一个分量来更新。
  • random_state : 一个整数或者一个RandomState实例，或者None。
    
    • 整数，则指定了随机数生成器的种子。
    • RandomState，则指定了随机数生成器。
    • None，则默认使用随机数生成器。
• [x] 属性
  
  • coef_ : 权重向量。
  • intercept_ : 截距b值。
  • n_iter_ : 实际迭代次数。
• [x] 方法
  
  • fit(X,y) : 训练模型。
  • predict(X) : 用模型预测，返回预测值。
  • score(X,y) : 返回性能得分。设预测集为 Ttest ，真实值为 yi ，真实值的均值为 y¯ ，预测值为 y^i ，则：
    
    score=1−∑Ttest(yi−y^i)2(yi−y¯)2

1.3 逻辑回归

Logistic Regression是scikit-learn提供的逻辑回归模型，其原型为：
class sklearn.linear_model.LogisticRegression(penalty=’l2’, dual=False, tol=0.0001, C=1.0, fit_intercept=True, intercept_scaling=1, class_weight=None, random_state=None, solver=’liblinear’, max_iter=100, multi_class=’ovr’, verbose=0, warm_start=False, n_jobs=1)

• [x] 导包
  
  • from sklearn.linear_model import LogisticRegression
• [x] 参数
  
  • penalty : 一个字符串，指定了正则化策略。
    
    • l2 : 优化目标为 12||ω⃗ ||22+CL(ω⃗ ) 。
    • l1 : 优化目标为 12||ω⃗ ||1+CL(ω⃗ ) 。
  • dual : 一个布尔值。如果为True，则求解对偶形式(只在penalty=‘l2’且solver=‘liblinear’有对偶形式)，如果为False，则求解原始形式。
  • C : 一个浮点数。它指定了罚项系数的倒数。如果它的值越小，则正则化项越大。
  • fit_intercept : 一个布尔值，指定是否需要计算b值。如果为False，那么不计算b值。
  • intercept_scaling : 一个浮点数。只有当solver=‘liblinear’才有意义。当采用fit_intercept时，相当于人造了一个特征，该特征恒为1，其权重为b。在计算正则化项的时候，该人造特征也被考虑了。因此为了降低这个人造特征的影响，需要提供intercept_scaling。
  • class_weight : 一个字典或者字符串‘balanced’。
    
    • 字典 : 字典给出每个分类的权重。
    • balanced : 每个分类的权重与该分类在样本集中出现的频率成反比。
    • 未指定 : 每个分类权重都为1。
  • max_iter : 一个整数，制定最大迭代数。
  • random_state :一个整数或者一个RandomState实例，或者None。
    
    • 整数，则指定了随机数生成器的种子。
    • RandomState，则指定了随机数生成器。
    • None，则默认使用随机数生成器。
  • solver : 一个字符串，指定了求解最优化的算法，可以为：
    
    • newton-cg : 使用牛顿法。只适用于penalty=‘l2’。
    • lbfgs : 使用L-BFGS拟牛顿法。只适用于penalty=‘l2’。
    • liblinear : 使用liblinear，适用于小数据集。
    • sag : 使用Stochastic Average Gradient Descent算法，适用于大数据集。只适用于penalty=‘l2’。
  • tol : 一个浮点数，指定判断迭代收敛与否的阈值
  • multi_class : 一个字符串，指定对于多分类问题的策略，可以为：
    
    • ovr : 采用one-vs-rest策略。
    • multinomial : 直接采用多分类逻辑回归策略，不能与liblinear共存。
  • verbose : 一个正数。用于开启关闭迭代中输出日志。
  • warm_start: 一个布尔值。如果为True，那么使用前一次训练结果继续训练。否则从头开始训练
  • n_jobs : 一个正数。任务并行时指定的CPU数量。如果为-1则使用所有可用的CPU。
• [x] 属性
  
  • coef_ : 权重向量。
  • intercept_ :b值。
  • n_iter :实际迭代次数。
• [x] 方法
  
  • fit(X,y) : 训练模型。
  • predict(X) : 用模型预测，返回预测值。
  • predict_log_proba(X) : 返回一个数组，数组的元素依次是X预测为各个类别的概率的对数值。
  • predict_proba(X) : 返回一个数组，数组的元素依次是X预测为各个类别的概率值。
  • score(X,y) : 返回在(X,y)上预测的准确率(accuracy)。

1.4 线性判别分析

LinearDiscriminationAnalysis是scikit-learn提供的线性判别分析模型，其原型为：
class sklearn.discriminant_analysis.LinearDiscriminantAnalysis(solver=’svd’, shrinkage=None, priors=None, n_components=None, store_covariance=False, tol=0.0001)[source]

• [x] 导包
  
  • from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
• [x] 参数
  
  • solver : 一个字符串，指定求解最优化问题的算法，可以为：
    
    • svd：奇异值分解，对于有大规模特征的数据推荐用此种算法。
    • lsqr：最小平方QR分解法，可以结合shrinkage，适合大且稀疏的矩阵。
    • eigen：特征值分解法，可以结合shrinkage。
  • shrinkage : 字符串‘auto’或者浮点数或者None。该参数通常在训练样本数量小于特征数量的场合下使用。该参数只有在solver=lsqr或者eigen下才有意义。
  • priors : 一个数组，数组中的元素依次指定了每个类别的先验概率。如果为None，则认为每个类别的先验概率是均等的。
  • n_components :
  • store_covariance :
  • tol :
• [x] 属性
  
  • coef_ : 权重向量。
  • intercept_ : b值。
  • covariance :一个数组，依次给出每个类别的协方差矩阵。
  • means_ : 一个数组，依次给出每个类别的均值向量。
  • xbar_ : 给出了整体样本的均值向量。
  • n_iter : 实际迭代次数。
• [x] 方法
  
  • fit(X,y) : 训练模型。
  • predict(X) : 用模型预测，返回预测值。
  • predict_log_proba(X) : 返回一个数组，数组的元素依次是X预测为各个类别的概率的对数值。
  • predict_proba(X) : 返回一个数组，数组的元素依次是X预测为各个类别的概率值。
  • score(X,y) : 返回在(X,y)上预测的准确率(accuracy)。

---

2. 决策树

2.1 回归决策树

DescisionTreeRegressor实现了回归决策树，用于回归问题，其原型为：
class sklearn.tree.DecisionTreeRegressor(criterion=’mse’, splitter=’best’, max_depth=None, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features=None, random_state=None, max_leaf_nodes=None, min_impurity_split=1e-07, presort=False)[source]

• [x] 导包
  
  • from sklearn.tree import DecisionTreeRegressor
• [x] 参数
  
  • criterion : 一个字符串，指定切分质量的评价标准。默认为‘mse’，且只支持该字符串，表示均方误差。
  • splitter : 一个字符串，指定切分原则，可以为：
    
    • best : 表示选择最优的切分。
    • random ： 表示随机切分。
  • max_features : 可以为整数、浮点、字符或者None，指定寻找best split时考虑的特征数量。
    
    • 如果是整数，则每次切分只考虑max_features个特征。
    • 如果是浮点数，则每次切分只考虑max_features*n_features个特征(max_features指定了百分比)。
    • 如果是字符串‘auto’，则max_features等于n_features。
    • 如果是字符串‘sqrt’，则max_features等于sqrt(n_features)。
    • 如果是字符串‘log2’，则max_features等于log2(n_features)。
    • 如果是字符串None，则max_features等于n_features。
  • max_depth : 可以为整数或者None，指定树的最大深度。
    
    • 如果为None，表示树的深度不限(知道每个叶子都是纯的，即叶子结点中的所有样本点都属于一个类，或者叶子中包含小于min_sanples_split个样本点)。
    • 如果max_leaf_nodes参数非None，则忽略此项。
  • min_samples_split : 为整数，指定每个内部节点(非叶子节点)包含的最少的样本数。
  • min_samples_leaf : 为整数，指定每个叶子结点包含的最少的样本数。
  • min_weight_fraction_leaf : 为浮点数，叶子节点中样本的最小权重系数。
  • max_leaf_nodes : 为整数或None，指定叶子结点的最大数量。
    
    • 如果为None，此时叶子节点数不限。
    • 如果非None，则max_depth被忽略。
  • class_weight : 一个字典、字典的列表、字符串‘balanced’或者None，他指定了分类的权重。权重形式为：{class_label:weight}
    
    • 如果为None，则每个分类权重都为1.
    • 字符串‘balanced’表示每个分类的权重是各分类在样本出现的频率的反比。
  • random_state : 一个整数或者一个RandomState实例，或者None。
    
    • 如果为整数，则它指定了随机数生成器的种子。
    • 如果为RandomState实例，则指定了随机数生成器。
    • 如果为None，则使用默认的随机数生成器。
  • presort : 一个布尔值，指定了是否要提前排序数据从而加速寻找最优切分的过程。设置为True时，对于大数据集会减慢总体训练过程，但对于小数据集或者设定了最大深度的情况下，则会加速训练过程。
• [x] 属性
  
  • feature_importances_ : 给出了特征的重要程度。该值越高，则特征越重要(也称为Gini importance)。
  • max_features_ : max_feature的推断值。
  • n_features_ : 当执行fit后，特征的数量。
  • n_outputs_ : 当执行fit后，输出的数量。
  • tree_ : 一个Tree对象，即底层的决策树。
• [x] 方法
  
  • fit(X,y) : 训练模型。
  • predict(X) : 用模型预测，返回预测值。
  • score(X,y) : 返回性能得分。设预测集为 Ttest ，真实值为 yi ，真实值的均值为 y¯ ，预测值为 y^i ，则：
    
    score=1−∑Ttest(yi−y^i)2(yi−y¯)2

2.2分类决策树

DescisionTreeClassifier实现了分类决策树，用于分类问题，其原型为：
class sklearn.tree.DecisionTreeClassifier(criterion=’gini’, splitter=’best’, max_depth=None, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features=None, random_state=None, max_leaf_nodes=None, min_impurity_split=1e-07, class_weight=None, presort=False)

• [x] 导包
  
  • from sklearn.tree import DecisionTreeClassifier

• [x] 参数

  • criterion : 一个字符串，指定切分质量的评价标准。可以为：

    • ‘gini’ ：表示切分标准是Gini系数。切分时选取基尼系数小的属性切分。
      数据集基尼指数：Gini(D)=1−∑k=1K(|Ck||D|)2
      给定特征A，根据其是否取某一个可能值a，样本集D被分为D1和D2
      Gini(D,A)=|D1||D|Gini(D1)+|D2||D|Gini(D2)
    • ‘entropy’ ： 表示切分标准是熵。切分时选取熵大的属性切分。数据集总量为 |D| ，共有 K 个类，每个类数量为 |Ck| ，根据特征A可以将数据集切分，每个数据集数量为 |Di|:
      数据集D的经验熵：H(D)=−∑k=1K|Ck||D|log2|Ck||D|
      特征A对数据集D的经验条件熵：H(D|A)=∑i=1n|Di||D|H(Di)=−∑i=1n|Di||D|∑k=1K|Dik||Di|log2|Dik||Di|
      计算信息增益：g(D,A)=H(D)−H(D|A)

  • splitter : 一个字符串，指定切分原则，可以为：

    • best : 表示选择最优的切分。
    • random ： 表示随机切分。
  • max_features : 可以为整数、浮点、字符或者None，指定寻找best split时考虑的特征数量。
    
    • 如果是整数，则每次切分只考虑max_features个特征。
    • 如果是浮点数，则每次切分只考虑max_features*n_features个特征(max_features指定了百分比)。
    • 如果是字符串‘auto’，则max_features等于n_features。
    • 如果是字符串‘sqrt’，则max_features等于sqrt(n_features)。
    • 如果是字符串‘log2’，则max_features等于log2(n_features)。
    • 如果是字符串None，则max_features等于n_features。
  • max_depth : 可以为整数或者None，指定树的最大深度。
    
    • 如果为None，表示树的深度不限(知道每个叶子都是纯的，即叶子结点中的所有样本点都属于一个类，或者叶子中包含小于min_sanples_split个样本点)。
    • 如果max_leaf_nodes参数非None，则忽略此项。
  • min_samples_split : 为整数，指定每个内部节点(非叶子节点)包含的最少的样本数。
  • min_samples_leaf : 为整数，指定每个叶子结点包含的最少的样本数。
  • min_weight_fraction_leaf : 为浮点数，叶子节点中样本的最小权重系数。
  • max_leaf_nodes : 为整数或None，指定叶子结点的最大数量。
    
    • 如果为None，此时叶子节点数不限。
    • 如果非None，则max_depth被忽略。
  • class_weight : 一个字典、字典的列表、字符串‘balanced’或者None，他指定了分类的权重。权重形式为：{class_label:weight}
    
    • 如果为None，则每个分类权重都为1.
    • 字符串‘balanced’表示每个分类的权重是各分类在样本出现的频率的反比。
  • random_state : 一个整数或者一个RandomState实例，或者None。
    
    • 如果为整数，则它指定了随机数生成器的种子。
    • 如果为RandomState实例，则指定了随机数生成器。
    • 如果为None，则使用默认的随机数生成器。
  • presort : 一个布尔值，指定了是否要提前排序数据从而加速寻找最优切分的过程。设置为True时，对于大数据集会减慢总体训练过程，但对于小数据集或者设定了最大深度的情况下，则会加速训练过程。
• [x] 属性
  
  • classes_ : 分类的标签值。
  • feature_importances_ : 给出了特征的重要程度。该值越高，则特征越重要(也称为Gini importance)。
  • max_features_ : max_feature的推断值。
  • n_classes_ : 给出了分类的数量。
  • n_features_ : 当执行fit后，特征的数量。
  • n_outputs_ : 当执行fit后，输出的数量。
  • tree_ : 一个Tree对象，即底层的决策树。
• [x] 方法
  
  • fit(X,y) : 训练模型。
  • predict(X) : 用模型预测，返回预测值。
  • predict_log_proba(X) : 返回一个数组，数组元素依次为X预测为各个类别的概率值的对数值。
  • predict_proba(X) : 返回一个数组，数组元素依次为X预测为各个类别的概率值。
  • score(X,y) : 返回在(X,y)上预测的准确率(accuracy)。

---

3. 贝叶斯分类器

朴素贝叶斯算法

• 输入
  
  • 训练集 T=(x1,y1),(x2,y2),...,(xN,yN) , xi=(x(1)i,x(2)i,...,x(n)i)T , x(j)i 为第i个样本的第j个特征，其中 x(j)i∈{aj1,aj2,...,ajsj} , ajl为第j个特征可能渠道的第l个值，j=1,2,...,n,l=1,2,...,sj,y∈{c1,c2,...,cK} 。
• 算法步骤
  
  • 计算先验概率的估计值以及条件概率的估计值。
    
    • P(Y=ck)=∑Ni=1I(yi=ck)N;k=1,2,...,K
    • P(X(j)=ajl|y=ck)=∑Ni=1I(x(j)i=ajl,yi=ck)∑Ni=1I(yi=ck)
      
      
      j=1,2,...,n;l=1,2,...,sj;k=1,2,...,K
  • 对于给定的实例 x ，计算： P(Y=ck)∏P(X(j)|Y=ck),k=1,2,...,K
  • 计算并返回实例 x 的分类 :y=argmaxP(Y=ck)∏nj=1P(X(j)=x(j)|Y=ck)

三大算法均是朴素贝叶斯算法，区别在于假设了不同的 P(X(j)|Y=ck) 分布。
GaussianNB假设:

P(X(j)|Y=ck)=12πσ2k−−−−√exp(−(X(j)−μk)22σ2k)

MultinomialNB假设:

P(X(j)=ajl|Y=ck)=∑Ni=1I(x(j)i=ajl,yi=ck)+a∑Ni=1I(yi=ck)+sja

BernoulliNB假设：

P(X(j)|Y=ck)=pX(j)+(1−p)(1−X(j))

3.1 高斯贝叶斯分类器

GaussianNB是高斯贝叶斯分类器，它假设特征的条件概率分布满足高斯分布：

P(X(j)|y=ck)=12πσ2k−−−−√exp(−(X(j)−μk)22σ2k)

其原型为：
class sklearn.naive_bayes.GaussianNB(priors=None)

• [x] 导包
  
  • from sklearn.naive_bayes import GaussianNB
• [x] 参数
  
  • priors : 类的先验概率。如果指定的先验概率并不适合数据。
• [x] 属性
  
  • class_prior_ : 一个数组，形状为(n_classes)，是每个类别的概率 P(y=ck) 。
  • class_count_ : 一个数组，形状为(n_classes)，是每个类别包含的样本数量。
  • theta_ : 一个数组，形状为(n_classes，n_features)，是每个类别上每个特征的均值 μk 。
  • sigma_ : 一个数组，形状为(n_classes，n_features)，是每个类别上每个特征的标准差 σk
• [x] 方法
  
  • fit(X,y) : 训练模型。
  • partial_fit(X,y) : 追加训练模型，该方法主要用于大规模数据集的训练，此时大规模数据集被分成多个小数据集然后分别训练。
  • predict(X) : 用模型预测，返回预测值。
  • predict_log_proba(X) : 返回一个数组，数组元素依次为X预测为各个类别的概率值的对数值。
  • predict_proba(X) : 返回一个数组，数组元素依次为X预测为各个类别的概率值。
  • score(X,y) : 返回在(X,y)上预测的准确率(accuracy)。

3.2 多项贝叶斯分类器

MultinomialNB是多项贝叶斯分类器，它假设特征的条件概率分布满足多项分布。

贝叶斯估计：

设第 j 个特征 x(j) 可能取值为 aj1,aj2,...,ajsj ，则条件概率 P(X(j)=ajl|Y=ck) 的极大似然估计为：

极大似然估计：P(X(j)=ajl|y=ck)=∑Ni=1I(x(j)i=ajl,yi=ck)∑Ni=1I(yi=ck)

j=1,2,...,n

l=1,2,...,sj

k=1,2,...,K

用极大似然估计可能会出现分母 ∑Ni=1I(yi=ck)=0 的情况，此时可以采用贝叶斯估计(最大后验估计)：

贝叶斯估计：P(X(j)=ajl|y=ck)=∑Ni=1I(x(j)i=ajl,yi=ck)+a∑Ni=1I(yi=ck)+sja

其等价于在 X(j) 的各个取值的频数上赋予了一个正数 a(也叫λ) 。

• 当 a=0 时，为极大似然估计。

• 当 a=1 时，为拉普拉斯平滑。
  其原型为：
  class sklearn.naive_bayes.MultinomialNB(alpha=1.0, fit_prior=True, class_prior=None)

• [x] 导包

  • from sklearn.naive_bayes import MultinomialNB
• [x] 参数
  
  • alpha : 一个浮点数，指定 α 值。
  • fit_prior : 布尔值。如果为True，则不去学习 P(y=ck) ，替代以均匀分布；如果为False，则去学习 P(y=ck) 。
  • class_prior : 一个数组它指定了每个类别的先验概率 P(y=c1) ， P(y=c2) ，…, P(y=cK) ，如果指定了该参数，则每个分类的先验概率不再从数据集中学习。
• [x] 属性
  
  • class_log_prob_ : 一个数组对象，形状为(n_classes)，给出了每个类别调整后的经验概率分布的对数值。
  • feature_log_prob_ : 一个数组对象，形状为(n_classes,n_features)。给出了 P(X(j)|y=ck) 的经验概率分布的对数。
  • class_count_ : 一个数组，形状为(N_classes)，是每个类别包含的训练样本数。
  • feature_count_ : 一个数组，形状为(n_classes,n_features)。训练过程中，每个类别每个特征遇到的样本数。
• [x] 方法
  
  • fit(X,y) : 训练模型。
  • partial_fit(X,y) : 追加训练模型，该方法主要用于大规模数据集的训练，此时大规模数据集被分成多个小数据集然后分别训练。
  • predict(X) : 用模型预测，返回预测值。
  • predict_log_prob(X) : 返回一个数组，数组元素依次为X预测为各个类别的概率值的对数值。
  • predict_prob(X) : 返回一个数组，数组元素依次为X预测为各个类别的概率值。
  • score(X,y) : 返回在(X,y)上预测的准确率(accuracy)。

3.3 伯努利贝叶斯分类器

BernoulliNB是伯努利贝叶斯分类器。它假设特征的条件概率分布满足二项分布：

P(X(j)|Y=ck)=pX(j)+(1−p)(1−X(j))

其中，要求特征的取值为 X(j)∈{0,1} ，且 P(X(j)=1|y=ck)=p 。其原型为：
class sklearn.naive_bayes.BernoulliNB(alpha=1.0, binarize=0.0, fit_prior=True, class_prior=None)

• [x] 导包
  
  • from sklearn.naive_bayes import BernoulliNB
• [x] 参数
  
  • alpha : 一个浮点数，指定 α 值。
  • binarize : 一个浮点数或者None。
    
    • None：假定数据已经是二元化了。
    • 浮点数，那么会以该值作为阈值，特征值大于它的作为1，小于它的作为0。
  • fit_prior : 布尔值。如果为True，则不去学习 P(y=ck) ，替代以均匀分布；如果为False，则去学习 P(y=ck) 。
  • class_prior : 一个数组它指定了每个类别的先验概率 P(y=c1) ， P(y=c2) ，…, P(y=cK) ，如果指定了该参数，则每个分类的先验概率不再从数据集中学习。
• [x] 属性
  
  • class_log_prob_ : 一个数组对象，形状为(n_classes)，给出了每个类别调整后的经验概率分布的对数值。
  • feature_log_prob_ : 一个数组对象，形状为(n_classes,n_features)。给出了 P(X(j)|y=ck) 的经验概率分布的对数。
  • class_count_ : 一个数组，形状为(N_classes)，是每个类别包含的训练样本数。
  • feature_count_ : 一个数组，形状为(n_classes,n_features)。训练过程中，每个类别每个特征遇到的样本数。
• [x] 方法
  
  • fit(X,y) : 训练模型。
  • partial_fit(X,y) : 追加训练模型，该方法主要用于大规模数据集的训练，此时大规模数据集被分成多个小数据集然后分别训练。
  • predict(X) : 用模型预测，返回预测值。
  • predict_log_prob(X) : 返回一个数组，数组元素依次为X预测为各个类别的概率值的对数值。
  • predict_prob(X) : 返回一个数组，数组元素依次为X预测为各个类别的概率值。
  • score(X,y) : 返回在(X,y)上预测的准确率(accuracy)。

---

4. K近邻

• KNeighborsClassifier将待预测样本点最近邻的k个训练样本点中出现次数最多的分类作为待预测样本点的分类。
• KNeighborsRegressor将待预测样本点最近邻的k个训练样本点的平均值作为待预测样本点的分类。

4.1 KNN分类器

KNeighborsClassifier是scikit-learn提供的K近邻算法分类模型，其原型为：
class sklearn.neighbors.KNeighborsClassifier(n_neighbors=5, weights=’uniform’, algorithm=’auto’, leaf_size=30, p=2, metric=’minkowski’, metric_params=None, n_jobs=1, **kwargs)

• [x] 导包
  
  • from sklearn.neighbors import KNeighborsClassifier
• [x] 参数
  
  • n_neighbors : 一个整数，指定k值。
  • weights : 一字符串或者可调用对象，指定投票权重类型。即这些邻居投票权可以为相同或者不同。
    
    • uniform : 本节点的所有邻居节点的投票权重都相等。
    • distance : 本节点的所有邻居节点的投票权重与距离成反比，即越近节点，其投票权重越大。
    • [callable] : 一个可调用对象，它传入距离的数组，返回同样形状的权重数组。
  • algorithm : 一个字符串，指定最近邻的算法，可以为下：
    
    • ball_tree : 使用BallTree算法。
    • kd_tree : 使用KDTree算法。
    • brute : 使用暴力搜索算法。
    • auto : 自动决定最合适算法。
  • leaf_size : 一个整数，指定BallTree或者KDTree叶节点的规模。它影响树的构建和查询速度。
  • metric : 一个字符串，指定距离度量。默认为‘minkowski’(闵可夫斯基)距离。
  • P : 整数值。
    
    • p=1： 对应曼哈顿距离。
    • p=2 : 对应欧氏距离。
  • n_jobs : 并行性。默认为-1表示派发任务到所有计算机的CPU上。
• [x] 方法
  
  • fit(X,y) : 训练模型。
  • predict(X) : 预测模型。
  • score(X,y) : 返回在(X,y)上预测的准确率(accuracy)。
  • predict_proba(X) : 返回样本为每种标记的概率。
  • kneighbors([X,n_neighbors,return_distace]) : 返回样本点的k邻近点。如果return_distance=True，同时还返回到这些近邻点的距离。
  • kneighbors_graph([X,n_neighbors,mode]) : 返回样本点的连接图。

4.2 KNN回归器

KNeighborsRegressor是scikit-learn提供的K近邻算法回归模型，其原型为：
class sklearn.neighbors.KNeighborsRegressor(n_neighbors=5, weights=’uniform’, algorithm=’auto’, leaf_size=30, p=2, metric=’minkowski’, metric_params=None, n_jobs=1, **kwargs)

• [x] 导包
  
  • from sklearn.neighbors import KNeighborsRegressor
• [x] 参数
  
  • n_neighbors : 一个整数，指定k值。
  • weights : 一字符串或者可调用对象，指定投票权重类型。即这些邻居投票权可以为相同或者不同。
    
    • uniform : 本节点的所有邻居节点的投票权重都相等。
    • distance : 本节点的所有邻居节点的投票权重与距离成反比，即越近节点，其投票权重越大。
    • [callable] : 一个可调用对象，它传入距离的数组，返回同样形状的权重数组。
  • algorithm : 一个字符串，指定最近邻的算法，可以为下：
    
    • ball_tree : 使用BallTree算法。
    • kd_tree : 使用KDTree算法。
    • brute : 使用暴力搜索算法。
    • auto : 自动决定最合适算法。
  • leaf_size : 一个整数，指定BallTree或者KDTree叶节点的规模。它影响树的构建和查询速度。
  • metric : 一个字符串，指定距离度量。默认为‘minkowski’(闵可夫斯基)距离。
  • P : 整数值。
    
    • p=1： 对应曼哈顿距离。
    • p=2 : 对应欧氏距离。
  • n_jobs : 并行性。默认为-1表示派发任务到所有计算机的CPU上。
• [x] 方法
  
  • fit(X,y) : 训练模型。
  • predict(X) : 预测模型。
  • score(X,y) : 返回性能得分。设预测集为 Ttest ，真实值为 yi ，真实值的均值为 y¯ ，预测值为 y^i ，则：
    
    score=1−∑Ttest(yi−y^i)2(yi−y¯)2
  • predict_proba(X) : 返回样本为每种标记的概率。
  • kneighbors([X,n_neighbors,return_distace]) : 返回样本点的k邻近点。如果return_distance=True，同时还返回到这些近邻点的距离。
  • kneighbors_graph([X,n_neighbors,mode]) : 返回样本点的连接图。

---

5. 数据降维

5.1 PCA

PCA是scikit-learn中提供的PCA模型，其原型为：
class sklearn.decomposition.PCA(n_components=None, copy=True, whiten=False, svd_solver=’auto’, tol=0.0, iterated_power=’auto’, random_state=None)

• [x] 导包
  
  • from sklearn.decomposition import PCA
• [x] 参数
  
  • n_components : 一个整数，指定降维后的维数。
    
    • None : 则选择它的值为min(n_samples,n_features)。
    • 字符mle：则使用MLE算法来猜测降维后的维度。
    • 如为大于0小于1的浮点数：指定降维后的维数占原来的维数百分比。
  • copy ： 一个布尔值。如果为False，则直接用原始数据来训练，结果会覆盖原始数据所在的数组。
  • whiten ：一个布尔值。如果为True，则将特征向量除以n_samples倍的特征值，从而保证非相关输出的方差为1。
  • tol : 一个浮点数，指定arpack他特征值求解器的收敛阈值（如果为0，则自动选择）。
  • svd_solver :字符串。
    
    • auto :默认根据X的形状和n_component选择。如果输入数据大于500x500，提取的组件数低于数据最小尺寸的80%，则启用更有效的“随机”方法。否则，完整的SVD将被计算并可选择性地截断。
    • full ：调用scipy.linalg.svd包进行分解选择。
    • arpack：通过调用scipy.sparse.linalg.svds来进行截断，但必须满足0 < n_components < X.shape1。
    • randomized：用Halko等方法随机运行SVD。
  • random_state : 整数或者一个RandomState实例或者None。
    
    • 整数：控制伪随机数种子。
    • None ：使用Numpy进行随机。
  • iterated_power : 整数或者‘auto’。指定使用svd_solver = ‘randomized’方法进行高效迭代。
• [x] 属性
  
  • components_ : 主成分数组。
  • explained_variance_ : 每个成分对应的explained variance。
  • explained_variance_ratio_ : 一个数组，元素是每个主分成的explained variance的比例。
  • mean_ : 一个数组，元素是每个特征的统计平均值。
  • n_components_ : 一个整数，指示主成分有多少各元素。
• [x] 方法
  
  • fit(X,y) : 训练模型。
  • transform(X) : 执行降维。
  • fit_transform(X,y) : 训练模型并降维。
  • inverse_transform(X) : 执行升维(逆向操作)，将数据从低维空间逆向转换到原始空间。

5.2 超大规模数据降维IncrementalPCA

IncrementalPCA适用于超大规模数据，它可以将数据分批加载进内存。其原型为：
class sklearn.decomposition.IncrementalPCA(n_components=None, whiten=False, copy=True, batch_size=None)

• [x] 导包
  
  • from sklearn.decomposition import IncrementalPCA
• [x] 参数
  
  • n_components : 一个整数，指定降维后的维数。
    
    • None : 则选择它的值为min(n_samples,n_features)。
    • 字符mle：则使用MLE算法来猜测降维后的维度。
    • 如为大于0小于1的浮点数：指定降维后的维数占原来的维数百分比。
  • bath_size : 一个整数或者None，指定每个批次训练时，使用的样本数量。只有当调用fit()/partial_fit()方法时才会用到该参数。
    
    • 为None ： 则有算法自动推断。
  • copy ： 一个布尔值。如果为False，则直接用原始数据来训练，结果会覆盖原始数据所在的数组。
  • whiten ：一个布尔值。如果为True，则将特征向量除以n_samples倍的特征值，从而保证非相关输出的方差为1。
• [x] 属性
  
  • components_ : 主成分数组。
  • explained_varicance_ : 每个成分对应的explained variance。
  • explained_variance_ratio_ : 一个数组，元素是每个主分成的explained variance的比例。
  • mean_ : 一个数组，元素是每个特征的统计平均值。
  • var_ : 一个数组，元素是每个特征的经验方差。每调用一次partial_fit()方法，就会更新一次该属性。
  • n_components_ : 一个整数，指示主成分有多少各元素。
  • n_samples_seen_ : 一个整数，只是目前已经处理了多少个样本。每调用一次partial_fit()方法，就会更新一次该属性。每调用一个fit()方法就会清零该属性。
• [x] 方法
  
  • fit(X,y) : 训练模型。
  • partial_fit(X,y) : 继续训练模型，使用bath_size个样本。
  • transform(X) : 执行降维。
  • fit_transform(X,y) : 训练模型并降维。
  • inverse_transform(X) : 执行升维(逆向操作)，将数据从低维空间逆向转换到原始空间。

---

6. 聚类

6.1 K均值（KMeans）聚类

KMeans是scikitlearn提供的k均值聚类算法模型，其原型为：
class sklearn.cluster.KMeans(n_clusters=8, init=’k-means++’, n_init=10, max_iter=300, tol=0.0001, precompute_distances=’auto’, verbose=0, random_state=None, copy_x=True, n_jobs=1, algorithm=’auto’)

• [x] 导包
  
  • from sklearn.cluster import KMeans
• [x] 参数
  
  • n_clusters : 一个整数，指定分类数量。
  • init : 一个字符串，指定初始均值向量的策略，可以为以下值：
    
    • k-means++ : 该初始化策略选择的初始均值向量相互之间都距离较远，它的效果较好。
    • random ： 从数据集中随机选择K个样本作初始均值向量。
    • 提供一个数组，数组形状为(n_clusters,n_features)，该数组作为初始均值向量。
  • n_init : 一个整数，指定了k均值算法的运行次数，每一次都会选择一组不同的初始化均值向量，最终算法会选择最佳的分类簇作为最终结果。
  • algorithm : 一个字符串。
    
    • ‘full’ ：使用EM算法。
    • ‘elkan’ ：使用三角变化使得该算法更具效率，但不支持稀疏数据。
    • ‘auto’ ： 使用‘full’处理稀疏数据，使用‘elkan’处理稠密数据。
  • max_iter : 一个整数，指定了单轮kmeans算法中最大的迭代次数。算法总的迭代次数为：max_iter*n_init。
  • precompute_distances : 可以为布尔值或者字符串‘auto’。该参数指定是否提前计算好样本之间的距离（如果提前计算需要更多内存，但是算法会运行更快）。
    
    • ‘auto’ ：如果n_samples*n_clusters > 12 million，则不提前计算。
    • ‘True’ ：提前计算。
    • ‘False’ ：不提前计算。
  • tol : 一个浮点数，指定了算法收敛的阈值。
  • n_jobs : 一个整数，指定任务并行时指定CPU数量，如果为-1使用全部CPU。
  • verbose : 一个整数。如果为0，则不输出日志，如果为1，则每隔一段时间打印一次日志，如果大于1则打印日志更频繁。
  • random_state : 一个整数或者一个RandomState实例，或者None。
    
    • 如果为整数：指定了随机数生成器种子。
    • 如果为RandomState实例，则指定了随机数生成器。
    • 如果为None，则使用默认的随机数生成器。
  • copy_x : 布尔值，用于precompute_distances=True的情况。
    
    • 如果为True，则预计算距离的时候，并不会修改原数据。
    • 如果为False，则预计算距离的时候，会修改原数据用于节省内存，然后当算法结束时，会将原数据返还，但可能会因为浮点数的表示会产生一些误差。
• [x] 属性
  
  • cluster_centers_ : 给出分类簇的均值向量。
  • labels_ : 给出每个样本所属的簇的标记。
  • inertia_ : 给出了每个样本距离他们各自最近的簇中心的距离之和。
• [x] 方法
  
  • fit(X,y) : 训练模型。
  • fit_predict(X,y) : 训练模型并预测每个样本所属的簇。它等价于先调用fit()方法，后调用predict()方法。
  • predict(X) : 预测样本所属的簇。
  • score(X,y) : 给出了样本距离簇中心的偏移量的相反数。

6.2 密度（DBSCAN）聚类

DBSCAN是scikit-learn提供的密度聚类算法模型，其原型为：
class sklearn.cluster.DBSCAN(eps=0.5, min_samples=5, metric=’euclidean’, algorithm=’auto’, leaf_size=30, p=None, n_jobs=1)

• [x] 导包
  
  • from sklearn.cluster import DBSCAN
• [x] 参数
  
  • eps : ϵ 参数，用于确定邻域的大小。
  • min_samples : MinPts参数，用于判断核心对象。
  • metric : 一个字符串或者可调用对象，用于计算距离。如果是字符串，则必须是在metrics.pairwise.calculate_distance中指定它。
  • algorithm : 一个字符串，用于计算两点距离并找出最近邻点，可以为如下：
    
    • ‘auto’：由算法自动选取合适的算法。
    • ‘ball_tree’ : 用ball树来搜索。
    • ‘kd_tree’ : 用kd树来搜索。
    • ‘brute’ ：暴力搜索。
  • leaf_size : 一个整数，用于指定当algorithm=ball_tree或者kd_tree时，树的叶节点大小。该参数会影响构建树、搜索最近邻速度，同时影响存储树的内存。
  • p : 闵可夫斯基距离p参数。
• [x] 属性
  
  • core_sample_indices_ : 核心样本在原始训练集中的位置。
  • components_ ： 核心样本的一份副本。
  • labels_ : 每个样本所属的簇的标记。对于噪声样本，其簇标记为-1样本
• [x] 方法
  
  • fit(X,y) : 训练模型。
  • fit_predict(X,y) ： 训练模型并预测每个样本的所属簇的标记。

6.3 层次（AgglomerativeClustering）聚类

AgglomerativeClustering是scikitlearn提供的层次聚类算法模型。其原型为：
class sklearn.cluster.AgglomerativeClustering(n_clusters=2, affinity=’euclidean’, memory=Memory(cachedir=None), connectivity=None, compute_full_tree=’auto’, linkage=’ward’, pooling_func=)

• [x] 导包
  
  • from sklearn.cluster import AgglomerativeClustering
• [x] 参数
  
  • n_clusters : 一个整数，指定分类簇的数量。
  • connectivity : 一个数组或者可调用对象或者为None，用于指定连接矩阵，它指出了每个样本可连接的样本。
  • affinity : 一个字符串或者可调用对象，用于计算距离，可以为：’euclidean’,’l1’,’l2’,’manhattan’,’cosine’,’precomputed’,如果linkage=’ward’，则’affinity’必须是’euclidean’。
  • memory : 用于缓存输出结果，默认不缓存。
  • compute_full_tree : 通常当训练了n_clusters之后，训练过程就停止，但是如果为True则会继续训练从而生成一棵完整的树。
  • linkage : 一个字符串，用于指定链接算法。
    
    • ‘ward’ ：单链接single-linkage算法，采用 dmin 。
    • ‘complete’ ：全连接complete-linkage算法，采用 dmax 。
    • ‘average’ ：均连接average-linkage算法，采用 davg 。
  • pooling_func : 一个可调用对象，它的输入是一组特征值，输出是一个数值。
• [x] 属性
  
  • labels_ : 每个样本的簇标记。
  • n_leaves_ : 分层树的叶节点数量。
  • n_components : 连接图中联通分量的估计值。
  • children : 一个数组，给出了每个非叶节点中的子节点数量。
• [x] 方法
  
  • fit(X,y) : 训练模型。
  • fit_predict(X,y) : 训练模型并预测每个样本所属的标记。

---

7. 支持向量机

• 优点
  支持向量机SVM本质上是非线性方法，在样本量比较少的时候，容易抓住数据和特征之间的非线性关系(相比线性分类方法如Logistic regression)，因此尅解决非线性问题、可以避免神经网络结构选择和局部极小点的问题，可以提高泛化性，可以解决高维问题。
• 缺点
  SVM对缺失数据敏感，对非线性问题没有解决的通用方案，必须谨慎选择核函数来处理，计算复杂度高。主流算法是 O(n2) ，这样对大规模数据就显得无力了。不仅如此，由于其存在两个对结果影响相当大的超参数(如果是RBF核，是核函数的参数gamma以及惩罚项C)，这两个超参数无法通过概率方法进行计算，只能通过穷举试验求出，计算时间要远高于不少类似的非线性分类器。

7.1 线性分类SVM

LinearSVC实现了线性分类支持向量机，它是根据liblinear实现的，可以用于二分类、也可以用于多分类，其原型为：
class sklearn.svm.LinearSVC(penalty=’l2’, loss=’squared_hinge’, dual=True, tol=0.0001, C=1.0, multi_class=’ovr’, fit_intercept=True, intercept_scaling=1, class_weight=None, verbose=0, random_state=None, max_iter=1000)

• [x] 导包
  
  • from sklearn.svm import LinearSVC
• [x] 参数
  
  • C : 一个浮点数，罚项系数。C值越大对误分类的惩罚越大。
  • loss : 字符串，表示损失函数，可以为如下值：
    
    • ‘hinge’：此时为合页损失(他是标准的SVM损失函数)。
    • ‘squared_hinge’：合页损失函数的平方。
  • penalty :字符串，指定‘l1’或者‘l2’，罚项范数。默认为‘l2’(他是标准的SVM范数)。
  • dual :布尔值，如果为True，则解决对偶问题，如果是False，则解决原始问题。当n_samples>n_features是，倾向于采用False。
  • tol :浮点数，指定终止迭代的阈值。
  • multi_class :字符串，指定多分类的分类策略。
    
    • ‘ovr’ ：采用one-vs-rest策略。
    • ‘crammer_singer’:多类联合分类，很少用，因为他计算量大，而且精度不会更佳，此时忽略loss,penalty,dual等参数。
  • fit_intecept :布尔值，如果为True，则计算截距，即决策树中的常数项，否则忽略截距。
  • intercept_scaling :浮点值，若提供了，则实例X变成向量[X,intercept_scaling]。此时相当于添加一个人工特征，该特征对所有实例都是常数值。
  • class_weight : 可以是个字典或者字符串‘balanced’。指定个各类的权重，若未提供，则认为类的权重为1。
    
    • 如果是字典，则指定每个类标签的权重。
    • 如果是‘balanced’，则每个累的权重是它出现频数的倒数。
  • verbose :一个整数，表示是否开启verbose输出。
  • random_state :一个整数或者一个RandomState实例，或者None。
    
    • 如果为整数，指定随机数生成器的种子。
    • 如果为RandomState，指定随机数生成器。
    • 如果为None，指定使用默认的随机数生成器。
  • max_iter :一个整数，指定最大迭代数。
• [x] 属性
  
  • coef_ : 一个数组，它给出了各个特征的权重。
  • intercept_ : 一个数组，它给出了截距。
• [x] 方法
  
  • fit(X,y) :训练模型。
  • predict(X) : 用模型进行预测，返回预测值。
  • score(X,y) : 返回在(X,y)上的预测准确率。

7.2 非线性分类SVM

SVC实现了非线性分类支持向量机，它是根据libsvm实现的，可以用于二分类，也可以用于多分类，其原型为：
class sklearn.svm.SVC(C=1.0, kernel=’rbf’, degree=3, gamma=’auto’, coef0=0.0, shrinking=True, probability=False, tol=0.001, cache_size=200, class_weight=None, verbose=False, max_iter=-1, decision_function_shape=None, random_state=None)

• [x] 导包
  
  • from sklearn.svm import SVC
• [x] 参数
  
  • C : 一个浮点数，罚项系数，C越大惩罚越大。
  • kernel : 一个字符串，指定核函数。
    
    • ’linear’ :线性核 K(x⃗ ,z⃗ )=x⃗ ∗z⃗  。
    • ‘poly’:多项式核 K(x⃗ ,z⃗ )=(γ(x⃗ ∗z⃗ +1)+r)p ，其中 p 由 degree 参数决定， γ 由 gamma 参数决定， r 由 coef0 参数决定。
    • ‘rbf’:默认值，高斯核函数 K(x⃗ ,z⃗ )=exp(−γ||x⃗ −z⃗ ||2) ，其中 γ 由 gamma 参数决定。
    • ‘sigmoid’: K(x⃗ ,z⃗ )=tanh(γ(x⃗ ,z⃗ )+r) ，其中 γ 由 gamma 参数决定， r 由 coef0 参数指定。
    • ‘precomputed’:表示提供了kernel matrix，或者提供一个可调用对象，该对象用于计算kernel matrix。
  • degree : 一个整数，指定当核函数是多项式核函数时，多项式的系数。对于其它核函数该参数无效。
  • gamma :一个浮点数。当核函数是’rbf’,’poly’,’sigmoid’时，核函数的系数。如果为‘auto’，则表示系数为 1n_features 。
  • coef0 :浮点数，用于指定核函数中的自由项。只有当核函数是‘poly’和‘sigmoid’时有效。
  • probability :布尔值。如果为True，则会进行概率估计。它必须在训练之前设定好，且会拖慢训练速度。
  • shrinking : 布尔值。如果为True，则使用启发式收缩。
  • tol :浮点数，指定终止迭代的阈值。
  • cache_size :浮点值，指定了kernel cache的大小，单位为MB。
  • class_weight : 可以是个字典，或者字符串‘balanced’。指定各个类的权重，若为提供，则权重均为1。
  • verbose :是否开启verbose输出。
  • max_iter :一个整数，指定最大迭代次数。
  • decision_function_shape :为字符串或者None，指定决策函数的形状。
    
    • ‘ovr’ ：采用one-vs-rest策略，那么决策函数形状是(n_samples,n_classes)。
    • ‘ovo’ ：使用‘one-vs-one’准则，那么决策函数形状是(n_samples,n_classes*(n_classes-1)/2)。
  • random_state :一个整数或者一个RandomState实例，或者None。
    
    • 如果为整数，指定随机数生成器的种子。
    • 如果为RandomState，指定随机数生成器。
    • 如果为None，指定使用默认的随机数生成器。
• [x] 属性
  
  • support_ :一个数组，形状为[n_SV]，支持向量的下标。
  • support_vectors_ :一个数组，形状为[n_SV,n_features]，支持向量。
  • n_support_ :一个数组，形状为[n_class]，每一个分类的支持向量个数。
  • dual_coef_ : 一个数组，形状为[n_class-1,n_SV]。对偶问题中，在分类决策函数中每一个支持向量的系数。
  • coef_ :一个数组，形状为[n_class-1,n_features]。原始问题中，每个特征的系数。只有在linear kernel中有效。
  • intercept_:一个数组，形状为[n_class*(n_class-1)/2]。决策函数中的常数项。
• [x] 方法
  
  • fit(X,y) : 训练模型。
  • predict(X) : 用模型进行预测，返回预测值。
  • score(X,y) : 返回在（X，y）上预测的准确度。
  • predict_log_proba(X) : 返回一个数组，数组的元素依次是X预测为各个类别的概率的对数值。
  • predict_proba(X) :返回一个数组，数组的元素依次是X预测为各个类别的概率。

7.3 线性回归SVR

LinearSVR实现了线性回归支持向量机，它基于liblinear实现，其原型为：
class sklearn.svm.LinearSVR(epsilon=0.0, tol=0.0001, C=1.0, loss=’epsilon_insensitive’, fit_intercept=True, intercept_scaling=1.0, dual=True, verbose=0, random_state=None, max_iter=1000)

• [x] 导包
  
  • from sklearn.svm import LinearSVR
• [x] 参数
  
  • C: 一个浮点值，罚项系数。
  • loss:字符串，表示损失函数，可以为：
    
    • ‘epsilon_insensitive’:此时损失函数为 Lϵ (标准的SVR)
    • ‘squared_epsilon_insensitive’:此时损失函数为 Lϵ
  • epsilon:浮点数，用于lose中的 ϵ 参数。
  • dual:布尔值。如果为True，则解决对偶问题，如果是False则解决原始问题。
  • tol:浮点数，指定终止迭代的阈值。
  • fit_intercept:布尔值。如果为True，则计算截距，否则忽略截距。
  • intercept_scaling:浮点值。如果提供了，则实例X变成向量[X,intercept_scaling]。此时相当于添加了一个人工特征，该特征对所有实例都是常数值。
  • verbose:是否开启verbose输出。
  • random_state:一个整数或者一个RandomState实例，或者None。
    
    • 如果为整数，指定随机数生成器的种子。
    • 如果为RandomState，指定随机数生成器。
    • 如果为None，指定使用默认的随机数生成器。
  • max_iter:一个整数，指定最大迭代次数。
• [x] 属性
  
  • coef_:一个数组，他给出了各个特征的权重。
  • intercept_:一个数组，他给出了截距，及决策函数中的常数项。
• [x] 方法
  
  • fit(X,y):训练模型。
  • predict(X):用模型进行预测，返回预测值。
  • score(X,y):返回性能得分。设预测集为 Ttest ，真实值为 yi ，真实值的均值为 y¯ ，预测值为 y^i ，则：
    
    score=1−∑Ttest(yi−y^i)2(yi−y¯)2

7.4 非线性回归SVR

SVR实现了非线性回归支持向量机，它是基于libsvm实现的，其原型为：
class sklearn.svm.SVR(kernel=’rbf’, degree=3, gamma=’auto’, coef0=0.0, tol=0.001, C=1.0, epsilon=0.1, shrinking=True, cache_size=200, verbose=False, max_iter=-1)

• [x] 导包
  
  • from sklearn.svm import SVR
• [x] 参数
  
  • C:一个浮点值，罚项系数。
  • epsilon:浮点数，用于lose中的 ϵ 参数。
  • kernel: 一个字符串，指定核函数。
    
    • ’linear’ :线性核 K(x⃗ ,z⃗ )=x⃗ ∗z⃗  。
    • ‘poly’:多项式核 K(x⃗ ,z⃗ )=(γ(x⃗ ∗z⃗ +1)+r)p ，其中 p 由 degree 参数决定， γ 由 gamma 参数决定， r 由 coef0 参数决定。
    • ‘rbf’:默认值，高斯核函数 K(x⃗ ,z⃗ )=exp(−γ||x⃗ −z⃗ ||2) ，其中 γ 由 gamma 参数决定。
    • ‘sigmoid’: K(x⃗ ,z⃗ )=tanh(γ(x⃗ ,z⃗ )+r) ，其中 γ 由 gamma 参数决定， r 由 coef0 参数指定。
    • ‘precomputed’:表示提供了kernel matrix，或者提供一个可调用对象，该对象用于计算kernel matrix。
  • degree:一个整数，指定当核函数是多项式核函数时，多项式的系数。对于其它核函数该参数无效。
  • gamma:一个浮点数。当核函数是’rbf’,’poly’,’sigmoid’时，核函数的系数。如果为‘auto’，则表示系数为 1n_features 。
  • coef0:浮点数，用于指定核函数中的自由项。只有当核函数是‘poly’和‘sigmoid’时有效。
  • shrinking:布尔值。如果为True，则使用启发式收缩。
  • tol:浮点数，指定终止迭代的阈值。
  • cache_size:浮点值，指定了kernel cache的大小，单位为MB。
  • verbose:指定是否开启verbose输出。
  • max_iter:一个整数，指定最大迭代步数。
• [x] 属性
  
  • support_ :一个数组，形状为[n_SV]，支持向量的下标。
  • support_vectors_ :一个数组，形状为[n_SV,n_features]，支持向量。
  • n_support_ :一个数组，形状为[n_class]，每一个分类的支持向量个数。
  • dual_coef_ : 一个数组，形状为[n_class-1,n_SV]。对偶问题中，在分类决策函数中每一个支持向量的系数。
  • coef_ :一个数组，形状为[n_class-1,n_features]。原始问题中，每个特征的系数。只有在linear kernel中有效。
  • intercept_:一个数组，形状为[n_class*(n_class-1)/2]。决策函数中的常数项。
• [x] 方法
  
  • fit(X,y) : 训练模型。
  • predict(X) : 用模型进行预测，返回预测值。
  • score(X,y):返回性能得分。设预测集为 Ttest ，真实值为 yi ，真实值的均值为 y¯ ，预测值为 y^i ，则：
    
    score=1−∑Ttest(yi−y^i)2(yi−y¯)2

---

8. 集成学习

概念

• 每个基分类器的精度必须要> 12 。
• 基分类器之间要有差异性。

Bagging

Bagging这个词是根据BootstrapAggregation这个词组创造的一个新词。Bootstrap，是指拔靴带，是帮助穿靴子时的一个纽带。统计学上的Bootstrap一般称为自助法，是指从m个训练样本中随机有放回的抽样m次，重复此过程T次。然后对每个样本集进行训练，最后结果由T个训练器投票表决最终答案。

Bagging典型的代表就是Random Forest，不过随机森林与Bagging有点不同：

• 基分类器只能是决策树。
• 随机森林不光是样本随机，也有特征随机。

由于以上两点，在样本充足的条件下，随机森林一般的结果都比任何一个单分类器效果要好。

Boosting

Boosting就不同了，他是一种串行模型，取的是全部样本来学习，但是它会进行多次重复学习，并且每次学习都会在之前一步的学习结果上在进行学习和改进，改进的是对上一次分错的节点的权重，为的是在本次学习中上次分错的节点在本次会得到更多关注，进而分类正确。Adaboost是Boosting的一种。

下面给出一个例题，可以对Boosting有一个直观的认识：

x	0	1	2	3	4	5	6	7	8	9
y	1	1	1	-1	-1	-1	1	1	1	-1

• 阈值v取2.5时误差率为0.3（x < 2.5时取1，x > 2.5时取-1，则6 7 8分错，误差率为0.3）
• 阈值v取8.5时误差率为0.3（x < 8.5时取1，x > 8.5时取-1，则3 4 5分错，误差率为0.3）
• 所以无论阈值v取2.5，还是8.5，总得分错3个样本，故可任取其中任意一个如2.5。
  

对于m=2步：

• 阈值v取2.5时误差率为0.1666*3（x < 2.5时取1，x > 2.5时取-1，则6 7 8分错，误差率为0.1666*3）。
• 阈值v取5.5时误差率最低为0.0715*4（x > 5.5时取1，x < 5.5时取-1，则0 1 2 9分错，误差率为0.0715*3 + 0.0715）。
• 阈值v取8.5时误差率为0.0715*3（x < 8.5时取1，x > 8.5时取-1，则3 4 5分错，误差率为0.0715*3）。

为何采用加法模型

• 问：如果不采用加法模型，只是把上一次分类错的点的权重调高不行吗？
• 答：这样做不可行，因为在每次权值更改后，错分类样本的权重被增大，那么就会出现当错分样本权值很大时相当于把正确分类样本的权重变小了，会导致正确样本错分。

8.1 AdaBoost

算法过程

下面介绍AdaBoost算法的过程：
1. 初始化训练数据的权值分布：

D1=(w11,w12,w13,...,w1N),w1i=1N,i=1,2,...,N

2. 对 m=1,2,...,M
(a) 使用具有权值分布 Dm 的训练集学习，得到基本分类器：

Gm(x):X−>{−1,+1}

(b) 计算 Gm(x) 在训练数据集上的分类误差：

em=P(Gm(xi)≠yi)=∑Ni=1wmiI(Gm(xi)≠yi)∑Ni=1wmi=∑i=1NwmiI(Gm(xi)≠yi)

上式中，∑i=1Nwmi=1

(c) 计算 Gm(x) 的系数：

αm=12log1−emem

(d) 更新数据集的权值分布：

Dm+1=(wm+1,1,wm+1,2,...,wm+1,N)

wm+1,i=wmiZme−αmyiGm(xi)

其中，Zm=∑i=1Nwmie−αmyiGm(xi)，是规范化因子

(e) 重复 (a)−(d) 步 m 次得到 m 个权值 a 和 m 个基分类器 G(x)

3. 构建基本分类器的线性组合：

f(x)=∑m=1MamGm(x)

4. 最终得到分类器：

G(x)=sign(f(x))=sign(∑m=1MamGm(x))

基分类器权值 a 与训练数据集权值 w 的分析

1. 先来看基分类器的权值 α ，公式如下:

α=12log1−emem

我们知道AdaBoost是将多个弱分类器组合起来形成一个很强的分类器，但这里有个隐含条件：弱分类器。什么叫弱分类器？意思就是在效果上比随机猜想要好的分类器。比如二分类问题，随机猜想的正确率是0.5，所以说弱分类器的正确率一定要比0.5高，于是它的错误率 em<0.5 ，所以 α会随着em的减小而增大 ，这是什么意思？意思是，如果我的基分类器的错误率很小，也就是正确率很大，那么在众多基分类器中我给予它很大的权值 α ，让它能发挥更大的作用。

2. 再来看训练数据集分布的权值分配，公式如下：

wm+1,i=wm,iZme−amyiG(xi)=⎧⎩⎨wm,iZme−am，Gm(xi)=yiwm,iZmeam，Gm(xi)≠yi

由公式可知，对训练集的样例正确分类与错误分类之间，错误分类样本的权值被放大： e2αm=1−emem 倍，所以，在下一轮学习中将会被更大关注。

AdaBoost推导

AdaBoost模型是由基本分类器组成的 加法模型 ，损失函数是 指数函数 。

1. 加法模型： f(x)=∑Mm=1αmGm(x)

2. 损失函数： L(y,f(x))=e−yf(x)

3. 每次训练后的基分类器都是乘以 α 再与前一个模型线性相加，所以对于第 m−1 次训练后模型为：

fm−1(x)=fm−2(x)+αm−1Gm−1(x)=α1G1(x)+...+αm−1Gm−1(x)

4. 于是，在第 m 次训练后有： fm(x)=fm−1(x)+αmGm(x)

5. 目标是每一次的损失在训练集上最小，所以最小化目标函数为：

(αm,Gm(x))=min∑i=1Ne−yifm(xi)=min∑i=1Ne−yi[fm−1(xi)+αmGm(x)]=min∑i=1Ne−yifm−1(xi)−yiαmGm(x)=min∑i=1Nwmie−yiαmGm(x)

上式中，将 e−yifm−1(xi)=wmi ，因为 wmi 既不依赖 α 也不依赖与 G ，所以与最小无关。

6. 于是，有：

min∑i=1Nwmie−yiαmGm(x)=min∑yi=Gm(xi)wmie−a+∑yi≠Gm(xi)wmiea=min(e−a∑i=1NwmiI(yi=Gm(xi))+eα∑i=1NwmiI(yi≠Gm(xi)))=min(e−a∑i=1Nwmi[1−I(yi≠Gm(xi))]+eα∑i=1NwmiI(yi≠Gm(xi)))=min((eα−e−α)∑i=1NwmiI(yi≠Gm(xi))+e−a∑i=1Nwmi)

所以，我们得到了优化的目标函数：

L(α)=(eα−e−α)∑i=1NwmiI(yi≠Gm(xi))+e−a∑i=1Nwmi

7. 对6中的目标函数关于 α 求导，令 ∂L(α)∂α=0 ，求的最小值：

∂L(α)∂α=−e−a∑i=1Nwmi+(eα+e−α)∑i=1NwmiI(yi≠Gm(xi))=0

等价于：

(eα+e−α)∑i=1NwmiI(yi≠Gm(xi))=e−a∑i=1Nwmi

因为： em=∑Ni=1wmiI(yi≠Gm(xi)) ， ∑Ni=1wmi=1

所以有：

(eα+e−α)em=e−a

等价于：

e2a=1−emem

解得：

α=12ln1−emem

8. 由于之前有个假设： wmi=e−yifm−1(xi) ，而这个式子又可以化为：

wm+1,i=e−yifm(xi)=e−yi[fm−1(xi)+αmGm(xi)]=wmie−yiαmGm(xi)

于是，就有了更新公式：

wm+1,i=wmie−yiαmGm(xi)

，与AdaBoost算法中的更新公式只差了个规范化因子而已。

8.1.1 AdaBoostClassifier

AdaBoostClassifier是scikit-learn提供的AdaBoost分类器，其原型为：
class sklearn.ensemble.AdaBoostClassifier(base_estimator=None, n_estimators=50, learning_rate=1.0, algorithm=’SAMME.R’, random_state=None)

• [x] 导包
  
  • from sklearn.ensemble import AdaBoostClassifier
• [x] 参数
  
  • base_estimator:是一个基础分类器对象。默认为DecisionTreeClassifier。该基础分类器必须支持带权重的学习。
  • n_estimator:一个整数，指定基础分类器的数量（默认50）。当然如果训练集已经完美地训练好了，可能算法会提前停止。此时基础分类器的数量少于该值。
  • learning_rate:为浮点数。默认为1.它用于每一步的步长，防止步长太大而跨过了极值点。通常learning_rate越小，则需要的基础分类器数量就会越多，因此在learning_rate和n_estimators之间会有所折中。learning_rate为下式中的v。
    
    Hm(x⃗ )=Hm−1(x⃗ )+vαmhm(x⃗ )
  • algorithm:一个字符串，指定算法，该算法用于多分类问题，默认为’SAMME.R’。
    
    • ‘SAMME.R’:使用SAMME.R算法，基础分类器必须支持计算类别的概率。
    • ‘SAMME’：使用SAMME算法。
  • random_state:一个整数或者一个RandomState实例，或者None。
    
    • 如果为整数，指定随机数生成器的种子。
    • 如果为RandomState，指定随机数生成器。
    • 如果为None，指定使用默认的随机数生成器。
• [x] 属性
  
  • estimators_:所有训练过的基础分类器。
  • classes_:所有类别标签。
  • n_classes_:类别数量。
  • estimator_weights_:每个基础分类器的权重。
  • estimator_errors_:每个基础分类器的分类误差。
  • feature_importances_:每个特征的重要性。
• [x] 方法
  
  • fit(X,y):训练模型。
  • predict(X):用模型进行预测，返回预测值。
  • predict_log_proba(X):返回一个数组，数组的元素依次是X预测为各个类别的概率的对数值。
  • predict_proba(X):返回一个数组，数组的元素依次是X预测为各个类别的概率值。
  • score(X,y):返回在（X,y）上预测的准确率。
  • staged_predict(X):返回一个数组，数组元素依次是每一轮迭代结束时尚未完成的集成分类器的预测值。
  • staged_predict_proba(X):返回一个二维数组，数组元素依次是每一轮迭代结束时尚未完成的集成分类器预测X为各个类别的概率值。
  • staged_score(X,y):返回一个数组，数组元素依次是每一轮迭代结束时尚未完成的集成分类器的预测准确率。

---

8.1.2 AdaBoostRegressor

AdaBoostRegressor是scikit-learn提供的AdaBoost回归器，其原型为：
class sklearn.ensemble.AdaBoostRegressor(base_estimator=None, n_estimators=50, learning_rate=1.0, loss=’linear’, random_state=None)

• [x] 导包
  
  • from sklearn.ensemble import AdaBoostRegressor
• [x] 参数
• base_estimator:是一个基础回归器对象。默认为DecisionTreeRegressor。该基础回归器必须支持带权重的学习。
  
  • n_estimator:一个整数，指定基础回归器的数量（默认50）。当然如果训练集已经完美地训练好了，可能算法会提前停止。此时基础回归器的数量少于该值。
  • learning_rate:为浮点数。默认为1.它用于每一步的步长，防止步长太大而跨过了极值点。通常learning_rate越小，则需要的基础回归器数量就会越多，因此在learning_rate和n_estimators之间会有所折中。learning_rate为下式中的v。
    
    Hm(x⃗ )=Hm−1(x⃗ )+vαmhm(x⃗ )
  • loss:一个字符串，指定了损失函数，可以为：
    
    • ‘linear’：线性损失函数（默认）。
    • ‘square’：平方损失函数。
    • ‘exponential’：指数损失函数。
  • random_state:一个整数或者一个RandomState实例，或者None。
    
    • 如果为整数，指定随机数生成器的种子。
    • 如果为RandomState，指定随机数生成器。
    • 如果为None，指定使用默认的随机数生成器。
• [x] 属性
  
  • estimators_:所有训练过的基础回归器。
  • estimator_weights_:每个基础回归器的权重。
  • estimator_errors_:每个基础回归器的误差。
  • feature_importances_:每个特征的重要性。
• [x] 方法
  
  • fit(X,y):训练模型。
  • predict(X):用模型进行预测，返回预测值。
  • score(X,y):返回性能得分。设预测集为 Ttest ，真实值为 yi ，真实值的均值为 y¯ ，预测值为 y^i ，则：
    
    score=1−∑Ttest(yi−y^i)2(yi−y¯)2
  • staged_predict(X):返回一个数组，数组元素依次是每一轮迭代结束时尚未完成的集成回归器的预测值。
  • staged_score(X,y):返回一个数组，数组元素依次是每一轮迭代结束时尚未完成的集成回归器的预测准确率。

---

8.2 Gradient Tree Boosting

8.2.1 GradientBoostingClassifier

GradientBoostingClassifier是scikit-learn提供的梯度提升决策树，其原型为：
class sklearn.ensemble.GradientBoostingClassifier(loss=’deviance’, learning_rate=0.1, n_estimators=100, subsample=1.0, criterion=’friedman_mse’, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_depth=3, min_impurity_split=1e-07, init=None, random_state=None, max_features=None, verbose=0, max_leaf_nodes=None, warm_start=False, presort=’auto’)

• [x] 导包
  
  • from sklearn.ensemble import GradientBoostingClassifier
• [x] 参数
  
  • loss:一个字符串，指定损失函数，可以为：
    
    • ‘deviance’：此时损失函数为对数损失函数： L(Y,P(Y|X))=−logP(Y|X) 。
    • ‘exponential’：此时使用指数损失函数，注意该损失只能用于二分类。
  • n_estimators :一个整数，指定基础决策树的数量（默认为100）。GBDT对过拟合有很好的鲁棒性，因此该值越大越好。
  • learning_rate:为浮点数。默认为1.它用于每一步的步长，防止步长太大而跨过了极值点。通常learning_rate越小，则需要的基础分类器数量就会越多，因此在learning_rate和n_estimators之间会有所折中。learning_rate为下式中的v。
    
    Hm(x⃗ )=Hm−1(x⃗ )+vαmhm(x⃗ )
    。
  • max_depth:一个整数或者None，指定每一个基础决策树模型的最大深度。如果max_leaf_noeds不是None，则忽略此参数。
  • criterion:字符串。用来衡量切分的质量。默认为‘friedman_mse’。可以为：
    
    • ‘friedman_mse’ 改进型的均方误差。
    • ‘mse’：标准的均方误差。
    • ‘mae’：平均绝对误差。
  • min_samples_split:一个整数，指定了每个基础决策树模型分裂所需最小样本数。
  • min_samples_leaf:一个整数，指定了每个基础决策树模型叶节点所包含的最小样本数。
  • min_weight_fraction_leaf:一个浮点数。叶节点的最小加权权重。当不提供sample_weight时，样本的权重是相等的。
  • subsample:一个浮点数，指定了提取原始训练集中的一个子集用于训练基础决策树，该参数就是子集占原始训练集的大小， 0<subsample<1 。
  • max_features:一个整数，浮点数或者None。代表节点分裂是参与判断的最大特征数。整数为个数，浮点数为所占比重。
  • max_leaf_nodes:为整数或者None，指定了每个基础决策树模型的最大叶节点数量。
  • min_impurity_split:一个浮点数，指定在树生长的过程中，节点分裂的阈值，默认为1e-7。
  • init:一个基础分类器对象或者None，该分类器对象用于执行初始的预测。如果为None，则使用loss.init_estimator。
  • verbose:一个整数，如果为0则不输出日志，如果为1，则每隔一段时间输出日志，大于1输出日志会更频繁。
  • warm_start:布尔值。当为True是，则继续使用上一次训练结果。否则重新开始训练。
  • random_state:一个整数或者一个RandomState实例，或者None。
    
    • 如果为整数，指定随机数生成器的种子。
    • 如果为RandomState，指定随机数生成器。
    • 如果为None，指定使用默认的随机数生成器。
  • presort:一个布尔值或者‘auto’，是否对数据进行显示以加速最佳分割的发现。默认情况下，自动模式将在密集的数据上使用presorting，默认为稀疏数据的正常排序。在稀疏的数据上设置显示值将会导致错误。
• [x] 属性
  
  • feature_importance_:一个数组，给出了每个特征的重要性（值越高重要性越大）。
  • oob_improvement_:一个数组，给出了每增加一棵基础决策树，在包外估计（即测试集）的损失函数的改善情况。（及损失函数减少值）。
  • train_score_:一个数组，给出每增加一棵基础决策树，在训练集上的损失函数的值。
  • loss:具体损失函数对象。
  • init:初始预测使用的分类器。
  • estimators_:一个数组，给出了每个基础决策树。
• [x] 方法
  
  • fit(X,y):训练模型。
  • predict(X):用模型进行预测，返回预测值。
  • predict_log_proba(X):返回一个数组，数组的元素依次是X预测为各个类别的概率的对数值。
  • predict_proba(X):返回一个数组，数组的元素依次是X预测为各个类别的概率值。
  • score(X,y):返回在（X,y）上预测的准确率。
  • staged_predict(X):返回一个数组，数组元素依次是每一轮迭代结束时尚未完成的集成分类器的预测值。
  • staged_predict_proba(X):返回一个二维数组，数组元素依次是每一轮迭代结束时尚未完成的集成分类器预测X为各个类别的概率值。

---

8.2.2 GradientBoostingRegressor

GradientBoostingRegressor是scikit-learn提供的提升树回归模型，其原型为：
class sklearn.ensemble.GradientBoostingRegressor(loss=’ls’, learning_rate=0.1, n_estimators=100, subsample=1.0, criterion=’friedman_mse’, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_depth=3, min_impurity_split=1e-07, init=None, random_state=None, max_features=None, alpha=0.9, verbose=0, max_leaf_nodes=None, warm_start=False, presort=’auto’)

• [x] 导包
  
  • from sklearn.ensemble import GradientBoostingRegressor
• [x] 参数
• loss:一个字符串，指定损失函数，可以为：
  - ‘ls’：此时损失函数为平方损失函数。
  - ‘lad’：此时使用指数绝对值损失函数。
  - ‘quantile’：分位数回归（分位数指的是百分之几），采用绝对值损失。
  - ‘huber’：此时损失函数为上述两者的综合，即误差较小时，采用平方损失，在误差较大时，采用绝对值损失。通过 α 参数的指定比例，该损失函数的定义为：
  LHuber=⎧⎩⎨12(y−f(x))2，if|y−f(x)|≤aa|y−f(x)|−12a2，else
  
  
  • alpha:一个浮点数，只有当loss=‘huber’或者loss=‘quantile’时才有效。
  • n_estimators :一个整数，指定基础决策树的数量（默认为100）。GBRT对过拟合有很好的鲁棒性，因此该值越大越好。
  • learning_rate:为浮点数。默认为1.它用于每一步的步长，防止步长太大而跨过了极值点。通常learning_rate越小，则需要的基础回归器数量就会越多，因此在learning_rate和n_estimators之间会有所折中。learning_rate为下式中的v。
    
    Hm(x⃗ )=Hm−1(x⃗ )+vαmhm(x⃗ )
    。
  • max_depth:一个整数或者None，指定每一个基础决策树模型的最大深度。如果max_leaf_noeds不是None，则忽略此参数。
  • criterion:字符串。用来衡量切分的质量。默认为‘friedman_mse’。可以为：
    
    • ‘friedman_mse’ 改进型的均方误差。
    • ‘mse’：标准的均方误差。
    • ‘mae’：平均绝对误差。
  • min_samples_split:一个整数，指定了每个基础决策树模型分裂所需最小样本数。
  • min_samples_leaf:一个整数，指定了每个基础决策树模型叶节点所包含的最小样本数。
  • min_weight_fraction_leaf:一个浮点数。叶节点的最小加权权重。当不提供sample_weight时，样本的权重是相等的。
  • subsample:一个浮点数，指定了提取原始训练集中的一个子集用于训练基础决策树，该参数就是子集占原始训练集的大小， 0<subsample<1 。
  • max_features:一个整数，浮点数或者None。代表节点分裂是参与判断的最大特征数。整数为个数，浮点数为所占比重。
  • max_leaf_nodes:为整数或者None，指定了每个基础决策树模型的最大叶节点数量。
  • min_impurity_split:一个浮点数，指定在树生长的过程中，节点分裂的阈值，默认为1e-7。
  • init:一个基础回归器对象或者None，该回归器对象用于执行初始的预测。如果为None，则使用loss.init_estimator。
  • verbose:一个整数，如果为0则不输出日志，如果为1，则每隔一段时间输出日志，大于1输出日志会更频繁。
  • warm_start:布尔值。当为True是，则继续使用上一次训练结果。否则重新开始训练。
  • random_state:一个整数或者一个RandomState实例，或者None。
    
    • 如果为整数，指定随机数生成器的种子。
    • 如果为RandomState，指定随机数生成器。
    • 如果为None，指定使用默认的随机数生成器。
  • presort:一个布尔值或者‘auto’，是否对数据进行显示以加速最佳分割的发现。默认情况下，自动模式将在密集的数据上使用presorting，默认为稀疏数据的正常排序。在稀疏的数据上设置显示值将会导致错误。
• [x] 属性
  
  • feature_importance_:一个数组，给出了每个特征的重要性（值越高重要性越大）。
  • oob_improvement_:一个数组，给出了每增加一棵基础决策树，在包外估计（即测试集）的损失函数的改善情况。（及损失函数减少值）。
  • train_score_:一个数组，给出每增加一棵基础决策树，在训练集上的损失函数的值。
  • loss:具体损失函数对象。
  • init:初始预测使用的分类器。
  • estimators_:一个数组，给出了每个基础决策树。
• [x] 方法
  
  • fit(X,y):训练模型。
  • predict(X):用模型进行预测，返回预测值。
  • predict_log_proba(X):返回一个数组，数组的元素依次是X预测为各个类别的概率的对数值。
  • predict_proba(X):返回一个数组，数组的元素依次是X预测为各个类别的概率值。
  • score(X,y):返回性能得分。设预测集为 Ttest ，真实值为 yi ，真实值的均值为 y¯ ，预测值为 y