6、集合算法

fengsuiwoxing21

已于 2022-05-19 14:30:40 修改

阅读量2.1k

点赞数

分类专栏：机器学习文章标签：集成算法机器学习 sklearn

于 2019-08-09 16:37:22 首次发布

本文链接：https://blog.csdn.net/fengsuiwoxing/article/details/87861416

版权

机器学习专栏收录该内容

3 篇文章 1 订阅

订阅专栏

Bagging从训练集中通过随机采样形成每个基模型所需要的子训练集，各模型之间没有关系，对所有基模型预测的结果进行综合（平均或者投票，有hard votiong和soft voting之分）产生最终的预测结果。
Boosting训练过程为阶梯状，基模型按次序一一进行训练（实现上可以做到并行），基模型的训练集按照某种策略每次都进行一定的转化。对所有基模型预测的结果进行线性综合产生最终的预测结果。
- Adaboosting：对同样数据集，每次训练模型后，根据预测结果对样本权重进行调整（提高错误样本权重，降低正确样本权重），然后继续对该批数据进行模型训练；最后将各模型的结果进行综合就是最终结果。
- Gradient Boosting：对一批数据进行训练后，对残差再进行训练建立新模型，以此类推，最终结果是各基模型的和。
Stacking：将训练好的所有基模型对训练集进行预测，第 $j$ 个基模型以第 $i$ 个训练样本的预测值将作为其训练集中的第 $i$ 个特征值，最后基于新的训练集进行训练。同理，预测的过程也要先经过所有基模型的预测形成新的测试集，最后再对测试集进行预测

偏差和方差
偏差是预测值和真实值之间的差异，体现在训练集的准确度上；方差是预测值作为随机变量时预测结果的离散程度，体现在测试集的准确度上，方差大时容易过拟合。通过集合众多弱学习器来解决高偏差问题，基函数最好是低方差高偏差的。

一、Bagging

Bagging集成算法是Bootstrap Aggregating的缩写，对数据集通过有放回的随机采样建多个模型，各模型之间没有关系；对所有基模型预测的结果进行综合产生最终的预测结果，常用算数平均或最多票数的种类。对弱学习器没有限制，但常用的是决策树和神经网络。
随机采样(bootsrap)是从训练集里用有放回的方式抽取固定个数的样本，之前采集到的样本在放回后仍可能被抽到。
通常随机抽样后的形成的新样本集合大小和原数据集大小相同。若有 $m$ 个样本，则每次抽中概率为 $\frac{1}{m}$ ，在 $m$ 次采样中都为被抽取到的概率是 $(1-\frac{1}{m})^m$ ，从而有 $(1-\frac{1}{m})^m \to \frac{1}{e} \simeq 0.368$ ，即有约36.8%的样本会始终无法被采集。这部分样本成为袋外样本（Out Of Bag，OOB），通常用于检测模型泛化能力。
Bagging算法由于每次都用随机抽样来训练模型，因此泛化能力强，方差小，但由于未使用全部数据，偏差会大。

随机森林（Random Forest，RF）

随机森林建立在Bagging的基础上，用CART决策树作为弱学习器，对样本进行有放回的随机抽样（同原数据集大小），大小和元数据集相同；再对每个决策树的特征进行随机筛选（是在根节点，不再是全部特征；也可以理解为在节点划分上随机从特征中抽取选择最优划分特征）;建每颗树时的有放回样本抽样会有约1/3样本无法被抽到，可用于做袋外估计（OOB，outofbag）来评估性能；最终一个样本的预测结果由各树进行投票或平均。
RandomForest只能接受数值型变量，对于分类变量，需要进行如One-Hot编码的转换。
【重点参数】各树间的相关性与决策树所用特征量有关，特征越多，相关性可能越强；减少使用的特征个数，树的相关性和分类能力都会降低。
【有放回抽样原因】每颗决策树都用完全不同的数据来构建，则每棵树都是“片面”的，缺少共性，对最终的汇总结果没有帮助。
【袋外估计】效果与K折交叉验证相似。
【优点】：可以给出各特征对于输出的重要性矩阵；产生的模型方差小，泛化能力强；采用袋外估计，无需进行K折交叉验证；可以并行计算，速度快；对缺失值不敏感。
【缺点】：对噪音较大的样本集容易过拟合；值比较多的特征容易对模型产生影响。
【特征重要性】判断每个特征在随机森林的每颗树上做了多大的贡献，然后取平均值即可。其中关于贡献的计算方式有：

基于基尼指数变化量：该特征在所有树中的变化和 $VIM_j=\sum_{j\_tree}(\sum_{i\_node}(G_{before\_split}-G_{left\_node}-G_{right\_node}))$ ，之后再做归一化即可 $\frac{VIM_j}{\sum VIM_j}$
基于袋外数据错误率：对于一树用OOB样本得到误差 $e_1$ ；然后随机改变OOB中的第 $j$ 列中样本的顺序，并保持其他列不变，得到新的误差 $e_2$ 。通过 $e_1-e_2$ 来刻画特征 $j$ 的重要性。依据是，如果一个特征很重要，那么其变动后会非常影响测试误差，如果测试误差没有怎么改变，则说明特征 $j$ 不重要。

打乱特征j的样本顺序由两种方法：
1）是使用均匀分布或者正态分布随机值来抽样替换原特征；
2）是通过permutation test（随机排序测试、置换检验）将原来的所有N个样本的第 $j$ 个特征值重新打乱分布（相当于重新洗牌），保证了特征替代值与原特征的分布是近似的（只是重新洗牌而已）。参考

经过结点的数目等指。可以算出每个特征平均减少了多少不纯度，并把它平均减少的不纯度作为特征选择的标准。随机森林基于不纯度的排序结果非常鲜明，在得分最高的几个特征之后的特征，得分急剧的下降。参考
随机森林的变种还有Extra Trees（每个决策树都用原始训练集，不抽样；选用随机特征值划分决策树）
随机森林的基评估器都拥有较低的偏差和较高的方差，因为决策树本身是预测比较”准“，比较容易过拟合的模型，装袋法本身也要求基分类器的准确率必须要有50%以上。所以以随机森林为代表的装袋法的训练过程旨在降低方差，即降低模型复杂度。

Extra Trees

Extra trees是基于随机森林，但样本使用原始训练集，在特征划分时随机选择特征并随机选择划分阈值进行划分（不再使用具体准则）。
极大的抑制了过拟合，但增加了拟合的偏差

Totally Random Trees Embedding

简称TRTE，是一种无监督的将低维的数据集映射到高维的方法，从而让映射到高维的数据可以更好的用于分类或回归。
TRTE在数据转化的过程用了类似于RF的方法，建立T个决策树来拟合数据。当决策树建立完毕后，数据集里的每个数据在T个决策树中叶节点的位置也定下来了。从而将样本在每颗决策树中用one-hot（在对应节点为1，不在为0）编码表示的结果按树的顺序合在一起，映射结果维度 $n_out \le Node*Tree$ 。实际上是实现了高维离散化。
示例：有3颗决策树，每个决策树有5个叶子节点，某个数据特征x划分到第一个决策树的第2个叶子节点，第二个决策树的第3个叶子节点，第三个决策树的第5个叶子节点。则x映射后的特征编码为(0,1,0,0,0, 0,0,1,0,0, 0,0,0,0,1)，有15维的高维特征。这里特征维度之间加上空格是为了强调三颗决策树各自的子编码。映射到高维特征后，可以继续使用监督学习的各种分类回归算法了。

Isolation Forest

简称IForest，是一种异常点监测方法。
随机采样时，所采子样本量远远小于原始训练集个数（通过部分数据来区分异常点）。每次建立决策树时，随机选择一个划分特征，并随机选择划分阈值。通过较小的决策树深度进行建模（少量异常点检测一般不用大规模树）。
对于异常点的判断是，将测试样本点 $x$ 用T颗树进行拟合，计算每颗决策树上该样本点所在的叶节点对应的深度 $h_t(x)$ ，从而可计算平均高度 $\overline h_t(x)$ 。
样本点 $x$ 对应的异常概率为： $s(x,m)=2^{-\frac{\overline h(x)}{c(m)}}$ ，其中 $m$ 是训练样本个数， $c(m)=2ln(m-1)+\xi -2\frac{m-1}{m}$ ， $\xi$ 是欧拉常数。
$s (x, m)$ 的取值范围是[0,1]，取值越接近1，则 $x$ 是异常点的概率越大。

多输出任务

多输出任务是对一个输入样本会输出多个目标值（多个y，不是y的多个值）。以回归为例，对单输出任务是求解 $\theta$ 使得 $X\theta=Y$ ，二多输出任务是求解 $\theta=(\theta_1,\theta_2)$ 使得 $X(\theta_1,\theta_2)=(Y_1,Y_2)$ 。对多输出任务，若各输出间相互独立，则多输出效果同多个单输出任务效果相似；但若各输出间有关联，则结果会不同与单输出任务的组合。

参考：https://www.cnblogs.com/pinard/p/6156009.html

二、Boosting（提升）

【工作机制】首先从训练集用初始权重训练出一个弱学习器1，根据弱学习的学习误差率表现来更新训练样本的权重。使得之前弱学习器1学习误差率高的训练样本点的权重变高，使得这些误差率高的点在后面的弱学习器2中得到更多的重视。然后基于调整权重后的训练集来训练弱学习器2。如此重复进行，直到弱学习器数达到事先指定的数目T，最终将这T个弱学习器通过集合策略进行整合，得到最终的强学习器。　内部用的是加法模型将各弱学习器线性相加。AdaBoost、GDBT、XGBoost、LightGBM都是boosting算法关于弱学习器的组合。

Boosting面临四个问题：

如何计算学习误差率 $e$ ?
如何得到弱学习器权重系数 $\alpha$ ?
如何更新样本权重向量 $D$ ?
使用何种结合策略？

AdaBoost算法

AdaBoost非常好的参考
AdaBoost算法（Adaptive Boost）可用于分类数据（二分类），对多分类任务，需要将任务通过OvR（一对多）转换成二分类任务；也可以用于回归。
AdaBoost每次都用全部数据，主要通过调整样本权重来建立各次迭代时的弱学习器。能够在学习过程中不断减少训练误差，且训练误差是以指数速度下降的。由于重视误分类样本的权重，因此对异常样本敏感，影响最终的强学习器的预测准确性。
AdaBoost算法可以认为是加法模型（弱学习器的线性组合）、损失函数为指数函数、学习算法为前向分布算法时的学习方法。

AdaBoost分类算法（自适应提升算法）

【思路】初始化时给数据集每个样本一个权重，用带权重的数据集来训练弱学习器。训练出模型后，针对这个模型中预测错误的样本，增加其权重值；对预测正确的样本，减少其权重。再根据计算出的误差给弱学习器一个权重。然后用新的样本权重调整后的样本继续训练新的弱学习器，重复得到B个模型。最后将B个弱学习器用对应的权重加总作为整体的强学习器。各弱学习器间相互依赖（样本权重受上一模型影响）。整个学习过程中使用的都是同一批样本，只是调整样本权重。
【过程】输入：训练集 $T=\{(x_,y_1),(x_2,y_2), ...(x_m,y_m)\}$ ；分类y={-1,+1}

初始化训练集的权值分布： $(w_{1,1}, w_{1,2}, ...w_{1,m}) ;\;\; w_{1,i}=\frac{1}{m};\;\; i =1,2...m$
对 $k = 1 、 2 、 \dots M$
a) 使用有权值分布 $D (k)$ 的训练集学习得到分类器 $G_k(x)$ （输出0/1）
b) 计算 $G_k(x)$ 在训练集上的分类误差率： $e_k=\sum{P(G_k(x_i)≠y_i)}=\sum{w_{k,i}I(G_k(x_i)≠y_i)}$ （ $I(G_k(x_i)≠y_i)$ 是指示函数，与实际类不相同时取1，相同时取0。分类误差率是与实际类别不同的样本的权值和）
c) 计算 $G_k(x)$ 的系数 $\alpha_m=\frac{1}{2}log\frac{1-e_k}{e_k}$ ，表示基本分类器 $G_m(x)$ 的重要性。误差越小 $\alpha$ 值越大： $e_k>0.5时\alpha <0$ ； $e_k<0.5时\alpha >0$ 。
d) 更新数据集的权值分布： $D(k+1)= (w_{k+1,1}, w_{k+1,2}, ...w_{k+1,m})$ ，
其中 $w_{k+1,i}=\frac{w_{k,i}}{Z_k}e^{-\alpha_ky_iG_k(x_i)}$ ， $Z_k=\sum{w_{k,i}e^{-\alpha_ky_iG_k(x_i)}}$
实际就是分别改变误分类样本和正确分类样本的权重，使正确分类的权值减小，错误分类的权值变大。
构建基本分类器的线性组合： $f(x)=\sum{\alpha_kG_k(x)}= f_{k-1}(x) + \alpha_kG_k(x)$ 。 $f(x)>0时\hat y=1$ ； $f(x)<0时\hat y=0$ 。 $f (x)$ 值大小反映对应类的预测置信度。
也可以对弱学习器添加正则项（学习步长）： $f_{k}(x) = f_{k-1}(x) + \nu\alpha_kG_k(x)$ ， $\nu \leq 1$ 。
到达指定迭代次数（还可以对树进行限制）或分类误差率达到一定值后停止迭代，得到最终的分类器： $G(x)=sign(f(x))=sign(\sum{\alpha_kG_k(x)})$

【Adaboost是前向分步学习算法】对第k轮迭代： $f_{k}(x) = f_{k-1}(x) + \alpha_kG_k(x)$
【损失函数为指数函数】定义总体损失函数 $\underbrace{arg\;min\;}_{\alpha, G} \sum\limits_{i=1}^{m}exp(-y_if_{k}(x))$
利用前向分步学习算法的关系可以得到损失函数为 $(\alpha_k, G_k(x)) = \underbrace{arg\;min\;}_{\alpha, G}\sum\limits_{i=1}^{m}exp[(-y_i) (f_{k-1}(x) + \alpha_kG_k(x))]$
令 $w_{ki}^{'} = exp(-y_if_{k-1}(x))$ ，它的值不依赖于 $\alpha, G$ ，是上一轮中确定的结果，仅仅依赖于 $f_{k−1}(x)$ ，随着每一轮迭代而改变，与本轮最小化时所求 $G_k$ 无关。从而有 $(\alpha_k, G_k(x)) = \underbrace{arg\;min\;}_{\alpha, G}\sum\limits_{i=1}^{m}w_{ki}^{'}exp[-y_i\alpha_k G_k(x)]$ 。
又由于 $G_k(x) = \underbrace{arg\;min\;}_{G}\sum\limits_{i=1}^{m}w_{ki}^{'}I(y_i \neq G(x_i))$ ，从而带入损失函数，对 $\alpha$ 求导并使其为0，可得： $\alpha_k = \frac{1}{2}log\frac{1-e_k}{e_k}$
$e_k$ 即为我们前面的分类误差率： $e_k = \frac{\sum\limits_{i=1}^{m}w_{ki}^{’}I(y_i \neq G(x_i))}{\sum\limits_{i=1}^{m}w_{ki}^{’}} = \sum\limits_{i=1}^{m}w_{ki}I(y_i \neq G(x_i))$
【何时停止建树？？】

Adaboost回归算法

对于第 $k$ 个弱学习器，总体最大误差： $E_k= max|y_i - G_k(x_i)|\;i=1,2...m$
对每个样本的误差根据不同定义可以有：若为线性误差，则 $e_{ki}= \frac{|y_i - G_k(x_i)|}{E_k}$ ；若为平方误差，则时 $e_{ki}= \frac{(y_i - G_k(x_i))^2}{E_k^2}$ ；若为指数误差，则 $e_{ki}=1-exp(\frac{-y_i + G_k(x_i))}{E_k})$ 。
最终得到第k个弱学习器的误差率： $e_k = \sum\limits_{i=1}^{m}w_{ki}e_{ki}$
第k个弱学习器的样本 $i$ 的权重 $\alpha_{k,i}=\frac{e_{k,i}}{1-e_{k,i}}$ ，则第 $k + 1$ 个弱学习器的样本集权重系数为 $w_{k+1,i}=\frac{w_{ki}}{Z_k}\alpha_k^{1-e_{ki}}$ ，其中 $Z_k = \sum\limits_{i=1}^{m}w_{ki}\alpha_k^{1-e_{ki}}$ 。
弱学习器的结合策略是对加权的弱学习器，取权重倒数的对数的中位数对应的弱学习器作为强学习器，最终的强回归器为 $f(x) =G_{k^*}(x)$ ， $G_{k^*}(x)$ 是 $ln\frac{1}{\alpha_k}, k=1,2,....K$ 的中位数值对应序号 $k^∗$ 对应的弱学习器。

梯度提升Gradient boosting

一、理论推导

梯度提升算法是以基函数为变量求解损失函数最小化，基于加法模型，利用前向分布算法，根据泰勒一阶展开式得出基函数尽可能拟合上一模型的负梯度时，能够使损失函数最小化，实现逐渐逼近总体损失函数的局部最优值。
称为Gradient是因为在添加新模型时用了梯度下降算法来实现损失函数最小化。
【加法模型】 $F(x)=\sum \beta_mf_m(x)$
【前向分布算法】 $F_t(x)=F_{t-1}(x)+\beta_tf_t(x)$
【损失函数】总体模型的损失函数： $F(x))=\sum^N L(y_i, \sum^m\beta_mf_m(x_i))$
【泰勒一阶展开式】 $f(x+\Delta x)=f(x)+\Delta f'(x)$
【梯度下降】由于损失 $F(x))=\sum^N L(y_i, \sum^m\beta_tf_t(x_i))=\sum L(y_i, F_{t-1}(x_i)+\beta_tf_t(x_i))$ 是关于 $F (x)$ 的函数，对与每个样本，根据一阶泰勒展开式可得 $L(y_i, F_{t-1}(x_i)+\beta_tf_t(x_i)) \approx F_{t-1}(x_i)+\beta_t f_t(x_i)\frac{L(y_i,F_{t-1}(x_i))}{F_{t-1}(x_i)}$ 。由于 $\beta_t\gt0$ ，从而根据梯度下降知识可知，当 $f_t(x_i)=-\frac{L(y_i, F_{t-1}(x_i))}{F_{t-1}(x_i)}$ （梯度下降）时有（平方项大于0）， $L(y_i,F_{t-1}(x_i))\ge L(y_i,F_t(x_i))$ 。此时可成功降低每个样本点上的预测损失。从而有 $F_t(x)=F_{t-1}(x)+f_t(x)$ 。参考，非常好的参考
以上是基于损失函数对总体模型 $F (x)$ 可导的，但 $F (x)$ 是否关于x可导不一定（即 $f (x)$ 是否对x可导）。
对于 $\beta_t$ 可以通过以为搜索找到： $\beta_t=argmin_{\beta}\sum L(y_i, h_{t-1}(x_i)+\beta f_t(x_i))$ 。
对初始的 $f_0(x)$ ，可以用常量，如均值等。
对于不同的基函数、不同的损失函数，都可以用上述解法来做。当损失函数为 $L(F)=(y-F)^2$ 时，对 $F$ 的导数（不是对x求导）是 $2 (y - F)$ ，这就是残差，从而新的函数 $f_m(x)$ 对伪残差的最大拟合实际就是对上轮迭代所得残差的最大拟合。若损失函数为其他函数时未必。
如此迭代不断找到新的 $f (x)$ 使总体损失函数变小，此方法即为梯度提升。

【推导方法二】
若 $L$ 关于 $F$ 二阶可导，还可以从极值角度考虑，令 $L^{'} = 0$ ，而 $L^{'}$ 可用泰勒展开式进行展开，从而可以计算出 $f_m$ 的具体形式参考：

二、损失函数和梯度

【回归任务】
均方误差损失函数 $L(y_m, F_{m}(x))=\frac{1}{2}(y-F_{m}(x))^2$ 此时梯度就是残差 $y - F (x)$ 。
绝对损失函数 $L (y, F (x)) = ∣ y - F (x) ∣$ ，梯度是 $s i g n (y - F (x))$ 。
【分类任务】
二分类任务用逻辑回归的损失函数（logistic loss）： $L (y, F (x)) = y l o g p + (1 - y) l o g (1 - p)$ ，其中 $p=\frac{1}{1+e^{-F(x)}}$ ，梯度是 $y-\frac{1}{1+e^{-F_{m-1}(x)}}$ 。
多分类任务使用Sofmax的损失函数。
指数损失函数 $L(y_m, F_{m}(x))=e^{(-y*F_m(x))}$ 。当损失函数为指数函数式，梯度提升算法相当于二分类的Adaboost算法参考
【示例】以逻辑回归为例，对每个类，预测其概率时，形成 $\hat y^{(i)}=(p_1,p_2,p_n)$ ，对实际所属类可视为概率1，其余为0，如 $y^{(i)}=(1,0,0)$ ，从而可以计算 $\hat y^{(i)}$ 与 $y^{(i)}$ 间的距离，从而构造 $f (x)$ 的损失函数并计算伪残差，之后再对该伪残差继续用逻辑回归建模，理论上直到所有残差为零时（或达到阈值）停止。分类的损失函数可以是预测类与真实类不一致的数量、叶节点的熵按叶节点占总体样本的比重做加权后的值……。

三、优化方法

【正则化】在使用提升方法时，通常会在模型权值基础上再增加一个学习率 $v$ （衰减因子Shrinkage），将上轮迭代的结果以一定比例缩减，削弱每个基函数的影响，让后面有更大的学习空间： $F_t(x)=F_{t-1}(x)+v·\beta_tf_t(x)$ 。一般会把学习率设置得小一点（ $v\lt 0.1$ ），然后迭代次数设置得大一点。
另外在每次迭代时对样本可以进行随机无放回抽样，从而增加模型随机性，减小方差，即随机梯度提升SGD方法。

梯度提升树GBDT（Gradient Boosting Decision Tree）

参考1 参考2 很好的参考
【特点】梯度提升树是基函数为CART回归树的梯度提升法的应用。GBDT的核心在于每次对上轮所得总体模型的负梯度进行拟合（损失函数是均方误差时就是对上轮残差进行拟合），通过累加所有树的结果作为最终结果（分类树的结果无法累加，故GBDT中的树都是回归树）。虽然调整后可用于分类任务（通过基函数返回概率），但基函数不是分类学习器。最终结果是对各树结果的加权求和得到总体结果
GBDT主要由三个概念组成：Regression Decistion Tree（即DT)，Gradient Boosting（即GB)，Shrinkage (算法的一个重要演进分枝，目前大部分源码都按该版本实现）
【基函数】最好是低方差和高偏差的，从而可以通过多次迭代减小偏差。
CART决策树不用很深，可接受单个基函数的高偏差，通过集合来减小偏差。

【损失函数】GBDT可以用一些健壮的损失函数，对异常值的鲁棒性非常强。比如 Huber损失函数和Quantile损失函数。
【A、分类算法常用损失函数】：

指数损失函数 $L (y, f (x)) = e x p (- y f (x))$ ，其负梯度计算和叶节点的最佳负梯度拟合参见Adaboost。
对数损失函数，分为二元分类和多元分类两种。

B、回归算法常用损失函数】：

均方差 $L(y, f(x)) =(y-f(x))^2$
绝对损失 $L (y, f (x)) = ∣ y - f (x) ∣$ ，对应负梯度为： $sign(y_i-f(x_i))$
Huber损失，是均方差和绝对损失的折衷产物，对于远离中心的异常点，采用绝对损失，而中心附近的点采用均方差。这个界限一般用分位数点度量。损失函数如下： $\begin{cases} \frac{1}{2}(y-f(x))^2& {|y-f(x)| \leq \delta}\\ \delta(|y-f(x)| - \frac{\delta}{2})& {|y-f(x)| > \delta} \end{cases}$ 。对应负梯度误差是： $r(y_i, f(x_i))= \begin{cases} y_i-f(x_i)& {|y_i-f(x_i)| \leq \delta}\\ \delta sign(y_i-f(x_i))& {|y_i-f(x_i)| > \delta} \end{cases}$
分位数损失函数，对应的是分位数回归的损失函数： $=\sum\limits_{y \geq f(x)}\theta|y - f(x)| + \sum\limits_{y < f(x)}(1-\theta)|y - f(x)|$ ,　其中 $\theta$ 为分位数，需要我们在回归前指定。对应的负梯度误差为： $r(y_i, f(x_i))= \begin{cases} \theta& { y_i \geq f(x_i)}\\ \theta - 1 & {y_i < f(x_i) } \end{cases}$
对于Huber损失和分位数损失，主要用于健壮回归，也就是减少异常点对损失函数的影响。

【正则化】：

一种是对弱学习器添加学习率。
第二种正则化的方式是通过子采样比例（subsample）。取值为(0,1]。注意这里的子采样和随机森林不一样，随机森林使用的是放回抽样，而这里是不放回抽样。如果取值为1，则全部样本都使用，等于没有使用子采样。如果取值小于1，则只有一部分样本会去做GBDT的决策树拟合。选择小于1的比例可以减少方差，即防止过拟合，但是会增加样本拟合的偏差，因此取值不能太低。推荐在[0.5, 0.8]之间。
使用了子采样的GBDT有时也称作随机梯度提升树(Stochastic Gradient Boosting Tree, SGBT)。由于使用了子采样，程序可以通过采样分发到不同的任务去做boosting的迭代过程，最后形成新树，从而减少弱学习器难以并行学习的弱点。通过自采样的SGBT可以达到部分并行
第三种是对于弱学习器即CART回归树进行正则化剪枝。

GBDT回归算法

每次随机无放回抽样建立CART决策树，总体损失函数用均方差（决策树的损失函数依赖于决策树）。对第 $t$ 轮迭代，有上一次迭代的残差（伪残差） $r_{t-1,i}$ 。参考过程示例

利用 $x_i,r_{t-1,i})\;\; (i=1,2,..n)$ 拟合一颗CART回归树，对应的叶节点区域 $R_{tj}, j =1,2,..., J$ ，其中 $J$ 为叶节点的个数。每一个叶结点的样本都可以使CART回归决策树的损失函数最小（拟合叶子节点中的残差最好），叶节点的输出值 $b_{mj}$ 如下：
$b_{tj} = \underbrace{arg\; min}_{b}\sum\limits_{x_i \in R_{tj}} L(y_i,f_{t-1}(x_i) +b)$ 。即用标签（上轮的残差或梯度值）的平均值表示该叶子节点拟合到的值： $b_{tj}=ave_{ x_i\in R_{mj}}r_{t-1,i}$ 。
得到本轮的决策树拟合函数如下： $h_t(x) = \sum\limits_{j=1}^{J}b_{tj}I(x \in R_{tj})$ 。
从而本轮得到的强学习器： $F_{t}(x) = F_{t-1}(x)+\gamma_{t}f_t(x)=F_{t-1}(x)+\sum_{j=1}^{J}b_{tj}I(x \epsilon R_{tj})$
$b_{tj}$ 可以看作是基于损失函数 $L$ 的每个叶子节点的最理想的常数更新值，也可以认为是既有下降方向，又有下降步长的值。

树的建立依赖于树模型自身（如用基尼指数作为分割准则），之后获得伪残差才是关键。
【问题】具体如何确定各树的权重

GBDT分类算法：二分类

过程同GBDT回归算法，但使用损失函数不同：用指数损失函数，则GBDT退化为Adaboost算法；用对数似然损失函数，类似逻辑回归，可得到预测概率值。参考
A）以对数似然损失函数logloss作为损失函数为例： $\in \{0,1\}$ 好示例参考参考

选取对数似然函数为损失函数：
$\large L\left(y_i,F_m(x_i)\right)=-ln(p_i^{y_i}(1-p_i)^{(1-y_i)})=-(y_ilogp_i+(1-y_i)log(1-p_i))$ ，其中 $\large p_i=\frac{1}{1+e^{-F(x_i)}}$ 是标签为1的概率。将 $p_i$ 带入可得 $\large L\left(y_i,F_m(x_i)\right)=-(y_iF_m(x_i)-log(1+e^{F_m(x_i)}))$ 。 $F(x_i)=log(\frac{p_i}{1-p_i})$
初始化： $F_0(x)=log\left(\frac{\sum_{i=1}^N y_i}{\sum_{i=1}^N(1-y_i)}\right)$ ，以样本中标签为1类的样本与标签为0类的样本量之比的对数（对数几率）作为 $F_0(x)$ 的初始值（第一次预测）。
$F (x)$ 就是模型最终输出的连续值，是样本 $x$ 经过所建立的多棵树后，在每棵树中对应叶节点的梯度的累加。 $F (x)$ 可看做是逻辑回归中的 $f(x)=w^Tx$ 。将最终输出 $F (x)$ 通过Sigmod函数可转换为对应的概率。通过不断拟合F来得到更好的p，从而获得与真实概率（0/1）最接近的预测概率p。
在第 $m$ 轮（ $\ge 1$ ）迭代中，损失函数 $L$ 所对应的负梯度为： $\large r_i=-\left[\frac{\partial L(y_i,F(\mathbf{x}_i))}{\partial F(\mathbf{x}_i)}\right]_{F(x)=F_{m-1}(x)}=y_i-\frac{1}{1+e^{-F_{m-1}(x_i)}}=y_i-\hat p_i$ ， $y_i$ 是标签为1对应的概率0/1。每次拟合的相当于是 $w^Tx$ 部分的残差，可转化为剩余的概率（预测为1）。
令对数似然函数对 $F_0(x)$ 求导后的梯度 $r_0$ 为零，可求解出最优解的 $F_0(x)=log\left(\frac{\sum_{i=1}^N y_i}{\sum_{i=1}^N(1-y_i)}\right)$ 。从而可以由 $F_0$ 计算对应的负梯度 $r_0$ ，之后开始对梯度进行拟合。
对 $x, r_{m-1})$ 用CART回归树进行最优拟合（可对决策树的生成进行具体设置，树不易过深），所得决策树叶节点 $j$ 对应的估计值计算公式为：
$\gamma_{mj} =\frac{\sum_{x_i\in R_{mj} \large r_{m-1,i}}}{\sum_{x_{i} \in R_{mj}} \large( y_i - r_{m-1,i})·(1-y_i+\large r_{m-1,i})}$ （ $L^{'} = 0$ 时 $L$ 可获极值，而 $L^{'}$ 可按泰勒展开式展开一次，从而可解得 $f_m(x)=\frac{\sum y_i-p_i}{\sum p_i*(1-p_i)}$ ，将 $p$ 由 $r = y - p$ 表示即可参考）， $\large r_{m-1,i}$ 是样本 $x_i$ 在上轮中的梯度值， $R_{mj}$ 是第 $m$ 轮生成的第 $j$ 个叶节点构成的空间 $R$ 。实际是模型乘以模型对应的权重后的结果，可以认为是既有负梯度方向（树实现了对上轮的梯度的最大拟合），又有学习步长的值。
综上，第 $m$ 轮迭代后，总体模型 $F_m(x)=F_{m-1}(x)+\sum_{j=1}^J\large \gamma_{mj} I(x \in R_{mj})$ ， $I(x\in R_{mj})$ 是当 $x$ 在第 $m$ 颗树的第 $j$ 叶节点空间 $R$ 时为1，否则为0。
属于1分类的概率为 $\large p_i=\frac{1}{1+e^{-F(x_i)}}$ ；属于0分类的概率为 $\large p_i=\frac{e^{-F(x_i)}}{1+e^{-F(x_i)}}$
重复3~6，直到达到指定迭代次数、梯度变化小于阈值时停止。

B）以指数损失作为损失函数为： $\in\{-1, +1\}$

损失函数： $L (y, F (x)) = l o g (1 + e x p (- 2 y F (x)))$ ， $F(x)=\frac{1}{2}log[\frac{Pr(y=1|x)}{Pr(y=-1|x)}]$ ，其中 $P r (y = 1 ∣ x)$ 是预测 $x$ 为1的概率， $P r (y = - 1 ∣ x)$ 是预测x为-1的概率。
对应负梯度为： $r_{m-1,i} = -\bigg[\frac{\partial L(y, F(x_i)))}{\partial F(x_i)}\bigg]_{F(x) = F_{m-1}\;\; (x)} = \frac{2y_i}{1+exp(2y_iF_{m-1}(x_i))}$
初始化 $F_0(x)$ ，之后和计算出 $R_{0,i}$
第 $m$ 轮迭代中，用 $x, r_{m-1})$ 构建决策树，对 $r_{m-1}$ 进行拟合，从而决策树的叶节点 $j$ 的估计值计算公式为：
$\gamma_{mj} = argmin_{r}\sum_{x_{i}\in R_{mj}} log(1+exp(-2y_{i}(F_{m-1}(x_{i})+\gamma)))$
一般用近似结果： $\gamma_{mj}=\frac{\sum_{x_{i} \in R_{mj}} \large r_{m-1, i} }{\sum_{x_{i} \in R_{mj}} |\large r_{m-1, i}|(2-|\large r_{m-1, i}|) }$
最终输出模型为 $F_m(x)=F_{m-1}(x)+\gamma_{mj}I(x_i \in R_{tj})$ ，从而有 $p_{+}(x)=p= \frac{1}{1+e^{-2F(x)}}$ ， $p_{-}(x)=1-p= \frac{1}{1+e^{2F(x)}}$ 。从而可以利用概率进行分类。

除了负梯度计算和叶子节点的最佳负梯度拟合的线性搜索，二元GBDT分类和GBDT回归算法过程相同。

GBDT分类算法：多分类

采用OvR，实质上是在每轮训练时都是同时训练多颗树：是否A类一颗树，是否B类一个数，是否C类一棵树…，真实类的概率视为1，其余视为0，从而可以计算负梯度（残差），损失函数用对数似然损失函数。非常好的实例参考
对某轮训练，假设类别数为K，则对数似然损失函数为： $\sum\limits_{k=1}^{K}y_klog\;p_k(x)$ ，其中如果样本x输出类别为 $k$ ，则 $y_k=1$ ，否则为0。实际是本轮的K颗树之和。
在本轮的K颗树中，每颗树对样本x预测结果为 $f_l(x)$ ，则可综合得属于第 $k$ 类的概率 $p_k(x)$ 的表达式为： $p_k(x) =\frac{exp(f_k(x))}{\sum\limits_{l=1}^{K} exp(f_l(x))}$
结合上面两式，我们可以计算出第 $t$ 轮的第 $i$ 个样本属于类别 $l$ 时的负梯度（伪残差）为： $r_{til} = -\bigg[\frac{\partial L(y_i, f(x_i)))}{\partial f(x_i)}\bigg]_{f_k(x) = f_{l, t-1}\;\; (x)} = y_{il} - p_{l, t-1}(x_i)$
这里的误差就是样本 $i$ 在OvR策略下，对应类别为 $l$ 时的真实概率（是则为1，否为0）和 $t - 1$ 轮预测概率的差值。
对于生成的决策树，我们各个叶子节点 $J$ 的最佳负梯度拟合值为： $c_{tjl} = \underbrace{arg\; min}_{c_{jl}}\sum\limits_{i=0}^{m}\sum\limits_{k=1}^{K} L(y_k, f_{t-1, l}(x) + \sum\limits_{j=0}^{J}c_{jl} I(x_i \in R_{tj}))$
一般使用近似值代替： $c_{tjl} = \frac{K-1}{K} \; \frac{\sum\limits_{x_i \in R_{tjl}}r_{til}}{\sum\limits_{x_i \in R_{til}}|r_{til}|(1-|r_{til}|)}$
从而可以继续对残差进行建模拟合，重复上述过程。
除了负梯度计算和叶子节点的最佳负梯度拟合的线性搜索，多元GBDT分类和二元GBDT分类以及GBDT回归算法过程相同。
参考

随机梯度提升SGD

全称Stochastic gradient boosting，每次迭代都对残差样本采用无放回的降采样，用部分样本训练基函数的参数，从而防止过拟合。令训练样本数占所有残差有样本的比例为g，当g=1时为原始模型。推荐使用样本比例 $0.5\le g \le 0.8$ 。
较小的g能够增强随机性，防止过拟合，并且收敛速度快。降采样的另一好处是可以用剩余样本做模型验证。

Light GBM

和XGBoost是同一算法的不同实现。后来又进化出了CatBoost。
XGBoost缺点：1）每轮迭代都遍历数据多次，将所有数据转入内存后读写训练集会消耗大量时间。2）预排序方法的时间和空间消耗都很大。3）XGBoost只能接受数值型变量，对于分类变量，需要进行如One-Hot编码的转换。
LightGBM可以接受分类变量。会计算梯度值/二阶导。
【Light GBM原理】
1）直方图算法：把连续的浮点特征值离散化成 $k$ 个整数，构造一个宽度为 $k$ 的直方图（每个特征都按相同步长进行离散化？），在遍历数据的时候，根据离散化后的值作为索引在直方图中累积统计量。当遍历一次数据后，直方图累积了需要的统计量，只需遍历 $k$ 个直方图的值离散值找到最优的分割点。

XGBoost中用预排序的方法，计算过程中按value的排序，逐个数据样本计算划分的增益。
按照bin来索引“直方图”，所以不用按照每个“特征”来排序，也不用一一去对比不同“特征”的值，大大的减少了运算量。

优点：可以大幅降低内存消耗。XGBoost预排序算法每遍历一个特征值就需要计算一次分裂的增益，而直方图算法只需要计算kk次（kk可以认为是常数），时间复杂度从O(data * #feature) 优化到O(k* features)。虽然特征离散化后无法找到精确分割点，但影响有限。同时离散化也带来了一定的正则化效果，避免过拟合。

2）存储记忆优化，占用空间少
用bin描述数据特征时无需像XGBoost那样存储每个排序后数据的序列，只需要存储以更小的内存代价存储bin即可（原值上亿的存为1即可）
3）深度限制的节点展开发提高模型精度
XGBoost使用Level-wise同时分裂同一层的叶子，容易进行多线程优化，但因不加区分对待同一层的叶子而带来很多没必要的开销，使叶子的分裂增益较低。Light GBM使用Leaf-wise，每次从当前所有叶子中找到分裂增益最大的一个叶子，然后分列，从而减少分裂次数。同时增加最大深度限制，避免过拟合。
在这里插入图片描述

三、Stacking

还可以在增加模型层数。有点类似神经网络。Stacking容易引发过拟合问题。

将多个模型的预测结果作为不同特征，对其用另一模型进行建模，从而将前期的基模型混合在一起获取各模型的权重：
1、用多种模型分别建模，通过对训练集进行拟合建模，然后用测试集进行预测（不用训练集是因为第一阶段训练模型时已用训练集；若仍用训练集进行预测供之后使用，则参数不准，可能过拟合）。
2、用1中的预测结果作为特征，再重新建立模型（用测试集作为训练集），此时作为最终模型。
3、用2所得模型对训练集进行预测（实际是转换了测试集和训练集的定义），获得结果，并用此时的得分进行模型评价。
4、实际中，先将数据分为训练数据和测试数据。对训练集先利用交叉验证（KFold）获取第一步中的模型，并将交叉验证时所用的测试数据用于预测。然后对单个模型中交叉验证时由测试集得到的预测结果进行行拼接得到和训练集相同大小的数据集，对多个模型分别做此操作并进行列拼接，从而作为步骤2中建立新模型所依赖的原始数据建模。通过不泄露数据来保证训练数据的质量，整个过程用的都是最开始切分的训练集（第一步的建模实际用的是训练集的一部分）。最终使用从未使用过的测试集对整体模型进行评价。（可用mlens.ensemble.SuperLearner()实现4的并行操作）

融合模型时也可以分不同阶段使用不同模型（分段处理）。

Python

from sklearn import ensemble

投票分类器

ensemble.VotingClassifier(estimators, voting='hard', weights=None, n_jobs=1, flatten_transform=None)

结合多个不同的弱学习器，采用多数表决（硬投票majority vote）或平均预测概率（软投票）的方式来预测分类标签。
estimators是(string, estimator)构成的列表，其中string是自定义的拟合器的名称，estimator是拟合器实例化对象。voting指定组合策略，"hard"是对分类模型用投票最多的类作为输出（少数服从多数）、"soft"是根据弱学习器输出的概率的均值判断所属类别（要求弱学习器能够输出概率）。weights指定各分类器的权重。n_jobs指定并行任务数。flatten_transform当voting="soft"时，是否将输出结果表示为(样本量, 分类器个数*类别个数)的矩阵。
属性：named_estimators以字典形式返回自定义的弱学习器别名及其模型。
方法：fit(X, y, sample_weight=None)调用各弱学习器的fit方法进行模型拟合
fit_transform(X)返回各弱学习器对X估计的类别标签或概率值，形状是(样本量，弱学习器个数)。是fit和transform的结合。
predict(X)预测类别。 predict_proba(X)预测概率。
score(X, y, sample_weight=None)获取得分。

Bagging：分类

# 有放回抽样
ensemble.BaggingClassifier(base_estimator=None, n_estimators=10, max_samples=1.0, max_features=1.0, bootstrap=True, 
                           bootstrap_features=False, oob_score=False, warm_start=False, n_jobs=1, random_state=None, verbose=0)

base_estimator指定基学习器。n_estimators指定基学习器个数。max_samples指定抽样个数或比例。max_features指定特征抽样个数或比例。bootstrap指定是否放回抽样，False无放回抽样。boostrap_features指定对特征抽样时是否有放回（对样本、特征同时有放回抽样时可称为random_patches）。oob_score是否用袋外(out-of-bag)样本来评估泛化精度，有放回抽样时，总体的约37%是从未抽到过的。
属性：estimators_返回模型列表。
estimators_samples_每个模型对应的样本数据。
estimators_features_每个模型对应的特征。
oob_score_获取袋外样本估计所得得分。和基模型的得分保持一致（是什么，如何自定义？）。
oob_prediction_获取袋外样本的估计值。

Bagging：回归

ensemble.BaggingRegressor(base_estimator=None, n_estimators=10, max_samples=1.0, max_features=1.0, bootstrap=True, 
                          bootstrap_features=False, oob_score=False, warm_start=False, n_jobs=1, random_state=None, verbose=0)

base_estimator可以是LogisticRegressor()等基础模型。通过有放回的抽样建立n_estimators个简单回归模型，进而每个基础模型结果的平均值作为最终结果

随机森林：分类

rf_clf = ensemble.RandomForestClassifier(n_estimators=10, criterion='gini', 
                                max_depth=None, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, 
                                max_features='auto', max_leaf_nodes=None, min_impurity_decrease=0.0, min_impurity_split=None, 
                                bootstrap=True, oob_score=False, n_jobs=1, random_state=None, verbose=0, warm_start=False, 
                                class_weight=None)

决策树用的是CART决策树，特征数组用的是numpy的float32类型，不是这样的格式会自动copy后再运行。参数由Bagging框架的参数和CART的参数构成。结合网格搜索model_selection.GridSearchCV()进行参数选择。参考
【Bagging参数】n_estimators生成的树个数（太小时容易欠拟合；太大时计算量会太大，且达到一定的数量后，再增大弱学习器所获得的模型提升会很小），重阳100、200、300、500、800、1200。bootstrap是否进行有放回抽样。oob_score是否用袋外样本out-of-bag（随机森林中建模时未被抽到的样本，约37%）来评估准确性（更能评价泛化能力）。random_state随机种子，控制随机森林的生成，但不控制一棵树的生成（决策树生成过程中也有随机）。verbose控制树的可见等级。warm_start是否热启动（使用上次的结果作为初始值进行参数估计）。class_weight以字典形式指定类的权重{class_label:weight}，对多输出问题，以字典构成的列表来表示权重，字典中分别指定多输出的权重；也可以是"balanced"等权重。
【CART参数】criterion划分准则，有"gini"基尼系数、"entropy"信息增益。max_depth最大树深度，None不限制，一般取10-100（15就很高了）。max_teatures随机选择的特征最大个数或比例（可防止过拟合，特征较多时使用，是决策树分割一个节点时考虑的），"auto"和"sqrt"是 $\sqrt{特征数}$ 、log2、None是全部特征。min_samples_split生成子节点前节点最少样本量，为小数时是总样本比例（小样本可不设置）。min_samples_leaf生成的叶节点含有的最少样本量，为小数时是总样本比例（小样本可不设置）。min_weight_fraction_leaf子节点的最小样本权重和，小于该值时回合兄弟节点一起被减掉（有较多缺失值或类别分布失衡时要考虑）。max_leaf_nodes最大的叶节点数。min_impurity_decrease划分时节点的最小不纯度（基尼系数或均方差），若该节点的不纯度小于阈值，则不再划分（一般不用调整）。
属性：feature_importances_返回特征重要性矩阵，值越大越重要。
classes_类别的数组。n_classes_类别个数。n_features_总特征个数。n_outputs_输出个数？
base_estimator随机森林所使用的决策树模型对象。estimators_返回所建的树列表。
estimator_params随机森林中的参数名称元组，对应的参数值可以以属性方式从对象中获得，如bootstrap是否bootstrap抽样建树。class_weight类别权重。criterion使用的划分准则。oob_score_输出训练模型时用袋外数据验证的得分。oob_decision_function_袋外数据计算得分时的决策函数，若n_estimators非常小，有可能在进行随机放回抽样的过程中没有数据掉落在袋外，此时oob_decision_function_的结果UI是NaN。
方法：fit(X, y, sample_weight=None)用训练数据X,y拟合模型，sample_weight是样本权重。
perdict(X)对数据集X进行预测，X是np.float32。返回的是随机森林中各树通过加权后得到的结果，以最高得分对应的类作为最终结果。predict_proba(X)返回样本在各树中判断类别的概率（判断类别占比）均值，各标签按字典顺序排列，预测的类概率是叶中相同类的样本的分数。predict_log_proba(X)返回样本点归属于各个标签的对数概率。
score(X, y, sample_weight=None )返回模型的准确率
apply(X)将随机森林中的各树应用到X上，返回所有树的预测结果，形状是(样本量, 树个数)数组。返回每个样本被分到的叶节点的索引。
decision_path(X)数据X在随机森林中的决策路径。返回的是节点索引的CSR稀疏矩阵，形状为(样本量, 节点数)，

调参

先根据学习曲线找到合适的弱学习器n_estimators个数
利用复杂度-泛化误差方法（方差-偏差方法），对参数逐个调整（网格搜索较慢，且无法理解参数组合的由来。可以按照max_depth、max_leaf_nodes、criterion、min_samples_split、min_samples_leaf、max_features顺序进行调参。结合下图进行调整。

然后对决策树最大深度和内部节点再划分前所需最小样本量进行搜索，确定树的最大深度。再将内部节点再划分前所需最小样本量与子节点最少样本量一起调参，确定这两个参数。最后再确定最大特征数。

随机森林：回归

ensemble.RandomForestRegressor(n_estimators=10, criterion='mse', 
                               max_depth=None, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, 
                               max_features='auto', max_leaf_nodes=None, min_impurity_decrease=0.0, min_impurity_split=None, 
                               bootstrap=True, oob_score=False, n_jobs=1, random_state=None, verbose=0, warm_start=False)

Extra Trees：分类

et_clf = ensemble.ExtraTreesClassifier(n_estimators=10, criterion='gini', max_depth=None, min_samples_split=2, 
                              min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features='auto', 
                              max_leaf_nodes=None, min_impurity_decrease=0.0, min_impurity_split=None, 
                              bootstrap=False, oob_score=False, n_jobs=1, random_state=None, verbose=0, 
                              warm_start=False, class_weight=None)

对决策点划分时用随机特征及随机阈值进行划分。
n_estimators指定弱学习器个数。criterion指定拆分准则。max_depth树的最大深度。

Extra Trees：回归

ensemble.ExtraTreesRegressor(n_estimators=10, criterion='mse', max_depth=None, min_samples_split=2, 
                             min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features='auto', 
                             max_leaf_nodes=None, min_impurity_decrease=0.0, min_impurity_split=None, 
                             bootstrap=False, oob_score=False, n_jobs=1, random_state=None, verbose=0, 
                             warm_start=False)

Totally random forest trees（TRFT）

ensemble.RandomTreesEmbedding(n_estimators=10, max_depth=5, min_samples_split=2, min_samples_leaf=1, 
                              min_weight_fraction_leaf=0.0, max_leaf_nodes=None, min_impurity_decrease=0.0, 
                              min_impurity_split=None, sparse_output=True, n_jobs=1, random_state=None, verbose=0, 
                              warm_start=False)

sparse_output指定输出是否为稀疏结果。

Isolation Forest（IForest）

ensemble.IsolationForest(n_estimators=100, max_samples='auto', contamination=0.1, max_features=1.0, bootstrap=False, 
                         n_jobs=1, random_state=None, verbose=0)

max_samples指定随机采样样本比例或个数，"auto"默认取256和样本量中最小者。contamination指定数据中的噪声点占比，是(0,0.5)的小数。bootstrap是否有放回随机抽样，True时有放回。
方法： fit(X,y) predict(X)显示是否异常值（-1是，1不是） fit_predict(X,y) score_samples(X)

AdaBoost：分类

参考

ensemble.AdaBoostClassifier(base_estimator=None, n_estimators=50, learning_rate=1.0, 
                            algorithm='SAMME.R', random_state=None)

base_estimator指定基函数（DecisioonTreeClassifier()，可以是任意分类器，常用CART或神经网络MLP，直接设置参数），基函数必须支持样本加权，且有classes_、n_classes_属性；若选择SAMMEE.R算法，基函数必须支持预测概率（除了有predict方法，还要有predict_proba方法）。n_estimators指定生成的最大基函数个数（太小易欠拟合，太大易过拟合，通常与learning_rate一起考虑）。learning_rate指定对基函数的惩罚项(0,1]（学习率，从小值开始调）。algorithm指定对权重的度量算法，“SAMME”（慢、误差大，用对样本集分类效果作为弱学习器权重）、“SAMME.R”（快，基函数必须有predict_proba方法，使用了对样本集分类的预测概率大小来作为弱学习器权重）。random_state指定随机种子。
属性：estimators_以列表返回基函数。classes_返回分类水平。n_classes_返回分类水平个数。estimator_weights_返回各弱分类器的权重。estimator_errors_以数组返回弱分类器的误差。feature_importances_返回特征的重要性（若基函数支持）
方法： fit()
predict(X)返回预测的分类
predict_proba(X)返回预测的几率
predict_log_proba(X)返回预测的对数几率
score(X,y,sample_weight=None)返回预测结果与实际分类间的准确率。
staged_decision_function(X)以生成器返回(样本量, 类别数)的数组，是样本在各基函数中判断的结果（对应classes_属性中相同索引的类）。若是二分类，则仅有一列；否则列数同类别数（-1对应的是0类，1对应的是1类）。
staged_score(X, y)以生成器返回样本在各弱学习器中经加权后返回的结果的得分
staged_predict(X)以生成器返回样本在各弱学习器中经加权后返回的预测分类结果
staged_predict_proba(X)以生成器返回样本在各弱学习器中经加权后返回的预测对数几率

AdaBoost：回归

用的是AdaBoost.R2方法（同原理部分）

ensemble.AdaBoostRegressor(base_estimator=None, n_estimatores=50, learning_rate=1.0, 
                           loss="linear", random_state=None)

base_estimator指定基函数（DecisionTreeRegressor()，可以是任意回归学习器，直接设置参数），基函数必须支持样本加权。n_estimators指定生成的最大基函数个数（太小易欠拟合，太大易过拟合，通常与learning_rate一起考虑）。learning_rate指定对基函数的惩罚项(0,1]（学习率，从小值开始调）。loss指定基函数中使用的损失函数，"linear"线性、"square"平方、"exponential"指数。random_state指定随机种子。
属性：estimators_以列表返回各次迭代所得基函数。estimator_weights_以数组返回弱分类器的权重。estimator_errors_以数组返回弱分类器的误差。feature_importances_以数组返回特征的重要性（若基函数支持）。

GBDT：回归

在sklearn中，回归GradientBoostingRegressor()和分类GradientBoostingClassifier()只是为了方便用户使用，最终两者都是共同继承BaseGradientBoosting()，GradientBoostingRegressor()、GradientBoostingClassifier()只是完成一些学习器参数配置的任务。
sklearn中以负例的先验概率为初始值，即 $F_0=\frac{n_0}{N}$

ensemble.GradientBoostingRegressor(loss='ls', learning_rate=0.1, n_estimators=100, subsample=1.0, alpha=0.9,  init=None, 
                                   criterion='friedman_mse', min_samples_split=2, min_samples_leaf=1, 
                                   min_weight_fraction_leaf=0.0, max_depth=3, min_impurity_decrease=0.0, 
                                   min_impurity_split=None, random_state=None, max_features=None, 
                                   max_leaf_nodes=None, verbose=0, warm_start=False, presort='auto')

Boosting框架参数：loss指定损失函数，有"ls"均方差（噪声不多时好）、"lad"绝对离差、“huber”（噪声点多时好）、"qunatile"分位数回归损失函数（适合分段预测，要设置alpha参数）。learning_rate指定对基函数的学习率（Shrinkage），通常从较小的值开始，并与弱学习器个数共同调参。n_estimators指定弱学习器个数。subsample指定每次迭代时无放回的子采样比例，小于1为随机梯度Boosting（减小方差，增加偏差），可用于减小方差，但会增加偏差，一般[0.5,0.8]。alpha当损失函数为最小二乘法的损失函数时，需要指定对应的分位点；当损失函数是huber时，需要指定（噪声较多时可降低值）。init指定基函数的初始值（ $f_0$ ），是一个估计器对象（有fit、predict方法），不输入时用训练集中类别之比的对数做初始化。
CART决策树参数：criterion指定决策树的拆分准则，"friedman_mse"经Friedman提升后的均方误差、"mse"均方误差、“mae"平均离差。min_samples_split切分节点时节点包含的最少样本量，样本量不大时无需设置。min_samples_leaf叶节点中最少样本量或比例。min_weight_fraction_leaf。max_depth指定树的最大深度，一般不深，样本多特征也多时设置此项，通常10-100。min_impurity_decrease最小不纯度变化的阈值。min_impurity_split节点拆时的最小不纯度，小于该阈值时不再拆分，一般不用修改。max_features划分时所用最大特征个数，可以是"log2”（ $log_2N$ ）、“sqrt”/“auto”（ $\sqrt N$ ）、浮点数、整数，特征小于50时无需设置。max_leaf_nodes最大叶节点个数，特征不多时无需考虑。persort是否先排序数据以加快寻找最佳分拆点，不能用于稀疏数据。
属性：feature_importances_特征重要性（值越大越重要）。 oob_improvement_通过袋外样本（为用于拟合模型的数据）计算的损失函数值提高度??。train_score各模型的训练得分。loss_返回损失函数。init返回初始基函数。estimators_返回各轮迭代所得模型。
调参技巧：通过网格搜索，在默认值下，先在较小的学习率下，在多个迭代次数中找到合适的迭代次数。然后对深度、节点划分时所包含的最小样本量进行搜索，找到合适值。先固定深度，再对节点划分时所包含的最小样本量、叶节点最少样本量一起调参，找到二者的组合。数据量大时，可再对最大特征数进行搜索。之后对子采样比例进行搜索。最后在寻找学习率。参数调参参考

GBDT：分类

ensemble.GradientBoostingClassifier(loss="deviance", learning_rate=0.1, n_estimator=100, subsample=1.0, criterion="friedman_mse", 
                                  min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, maxx_depth=3, 
                                  min_impurity_decrease=0.0, min_impurity_split=None, init=None, random_state=None, 
                                  max_features=None, verbose=0, max_leaf_nodes=None, warm_start=False, presort='auto')

Boosting框架参数：loss指定损失函数，"deviance"对数似然损失函数、"exponential"指数损失函数（对二分类等价于Adaboost算法）。learning_rate指定对基函数的学习率（Shrinkage），通常从较小的值开始，并与弱学习器个数共同调参。n_estimators指定弱学习器个数。subsample指定每次迭代时无放回的子采样比例，小于1为随机梯度Boosting（减小方差，增加偏差），可用于减小方差，但会增加偏差，一般[0.5,0.8]。init指定基函数的初始值（ $f_0$ ），是一个估计器对象（有fit、predict方法），不输入时用训练集中类别之比的对数做初始化。
CART决策树参数：criterion指定决策树的拆分准则，"friedman_mse"经Friedman提升后的均方误差、"mse"均方误差、“mae"平均离差。min_samples_split切分节点时节点包含的最少样本量，样本量不大时无需设置。min_samples_leaf叶节点中最少样本量或比例。min_weight_fraction_leaf。max_depth指定树的最大深度，一般不深，样本多特征也多时设置此项，通常10-100。min_impurity_decrease最小不纯度变化的阈值。min_impurity_split节点拆时的最小不纯度，小于该阈值时不再拆分，一般不用修改。max_features划分时所用最大特征个数，可以是"log2”（ $log_2N$ ）、“sqrt”/“auto”（ $\sqrt N$ ）、浮点数、整数，特征小于50时无需设置。max_leaf_nodes最大叶节点个数，特征不多时无需考虑。persort是否先排序数据以加快寻找最佳分拆点，不能用于稀疏数据。
属性：feature_importances_特征重要性（值越大越重要）。 oob_improvement_通过袋外样本（为用于拟合模型的数据）计算的损失函数值提高度？？。train_score各模型的训练得分。loss_返回损失函数。init返回初始基函数。estimators_返回各轮迭代所得模型。
调参技巧：通过网格搜索，在默认值下，先在较小的学习率下，在多个迭代次数中找到合适的迭代次数。然后对深度、节点划分时所包含的最小样本量进行搜索，找到合适值。先固定深度，再对节点划分时所包含的最小样本量、叶节点最少样本量一起调参，找到二者的组合。数据量大时，可再对最大特征数进行搜索。之后对子采样比例进行搜索。最后在寻找学习率。

Light GBM

import lightgbm
lightgbm.LGBMRegressor()

task默认值=train，可选项=train，prediction；指定我们希望执行的任务，该任务有两种类型：训练和预测。application默认值=regression，type=enum，options=options。regression执行回归任务。binary二分类。multiclass多分类。lambdaranklambrank应用。datatype=string;training data，LightGBM将从这些数据中进行训练。num_iterations默认值为100，类型为int，表示提升迭代次数，也就是提升树的棵树。num_leaves每个树上的叶子数，默认值为31，类型为int(使用的是leaf-wise算法，调节树的复杂度时使用num_leaves而不是max_depth)。device默认值=cpu；可选项：cpu，gpu，也就是我们使用什么类型的设备去训练我们的模型，选择GPU会使得训练过程更快。mindatain_leaf每个叶子上的最少数据。feature_fraction指定每次迭代所需要的特征的比例。bagging_fraction指定每次迭代所需要的数据部分，并且它通常是被用来提升训练速度和避免过拟合的（要与bagging_freq同时设置）。min_gain_to_split默认值为1；执行分裂的最小的信息增益。min_sum_hessian_in_leaf。max_bin最大的桶的数量，用来装数值的。min_data_in_bin每个桶内最少的数据量。numthreads默认值为OpenMPdefault，类型为int，指定LightGBM算法运行时线程的数量。label类型为string，指定标签列。categorical_feature类型为string；指定我们想要进行模型训练所使用的特征类别。num_class默认值为1，类型为int；仅仅需要在多分类的场合。
样本分布非平衡时，可用param[‘is_unbalance’]=True。

直方梯度增强

from sklearn.experimental import enable_hist_gradient_boosting
from sklearn.ensemble import HistGradientBoostingClassifier
from sklearn.ensemble import HistGradientBoostingRegressor
HistGradientBoostingClassifier(max_bins=255, max_iter=100)

max_bins指定直方图分箱个数，个数越少速度越快，但精度也会有所降低。max_iter树的个数

三、堆积法Stacking

#0.22版本开始有，之前用from mlxtend.classifier import StackingClassifier
ensemble.StackingClassifier(estimatrors, final_estimator=None, cv=None, stack_method='auto', 
                            n_jobs=None, passthrough=False, verbose=0)

estimatros是由(str, 模型实例)作为元素构成的列表，str指定实例的别名，模型实例可以是make_pipeline(StandardScaler(), LinearSVC(random_state=42))。final_estimatro用于合并基学习器的模型，默认是LogisticRegression。cv指定交叉验证次数，None默认使用5折交叉验证、整数指定交叉验证次数、交叉验证的生成器、(训练集、测试集)构成的生成器，为None或整数时用StratifiedKFold()，其余用KFold()。stack_method指定stacking的方法，由’auto’（对每个基学习器尝试使用之后的堆积方法）、‘predict_proba’、‘decision_function’、‘predict’。n_jobs指定并行核个数。passthrough为False时，仅在预测时使用final_estimator，True时训练时也是用。
方法：estimators_是根据全部X拟合的模型列表，元素可以被drop从而移除出stacing模型。named_estimators_哦通过名称获得基学习器。final_estimator_是最终的模型。stack_method_返回基学习器的方法名称列表。