目录

• 一、Bagging
• 随机森林（Random Forest，RF）
• Extra Trees
• Totally Random Trees Embedding
• Isolation Forest
• 多输出任务
• 二、Boosting（提升）
• AdaBoost算法
• AdaBoost分类算法（自适应提升算法）
• Adaboost回归算法
• 梯度提升Gradient boosting
• 梯度提升树GBDT（Gradient Boosting Decision Tree）
• GBDT回归算法
• GBDT分类算法：二分类
• GBDT分类算法：多分类
• 随机梯度提升SGD
• XGBoost
• Python
• 自定义多个模型的集成
• Bagging：分类
• Bagging：回归
• 随机森林：分类
• 随机森林：回归
• Extra Trees：分类
• Extra Trees：回归
• Totally random forest trees（TRFT）
• Isolation Forest（IForest）
• AdaBoost：分类
• AdaBoost：回归
• 梯度提升：分类
• 梯度提升：回归
• GBDT：回归
• GBDT：分类
• XGBoost
• 其他库
• 读取数据
• 训练模型

关于集成算法的参考

1. 在概率近似正确（PAC）学习的框架下，一个概念是强可学习的充分必要条件是这个概念是弱可学习的。
2. 集合算法是从弱学习算法出发，反复学习得到一系列弱分类器（基分类器），然后将这些弱分类器组合成一个强分类器。大部分提升方法都是改变训练数据的概率分布（训练数据的权值分布），针对不同的训练数据分布调用弱学习算法学习一系列弱分类器。
   集成学习框架可分为三种：

• Bagging从训练集中通过随机采样形成每个基模型所需要的子训练集，各模型之间没有关系，对所有基模型预测的结果进行综合产生最终的预测结果。
  
• Boosting训练过程为阶梯状，基模型按次序一一进行训练（实现上可以做到并行），基模型的训练集按照某种策略每次都进行一定的转化。对所有基模型预测的结果进行线性综合产生最终的预测结果
  
• Stacking：将训练好的所有基模型对训练基进行预测，第j个基模型对第i个训练样本的预测值将作为新的训练集中第i个样本的第j个特征值，最后基于新的训练集进行训练。同理，预测的过程也要先经过所有基模型的预测形成新的测试集，最后再对测试集进行预测
  

3. 偏差和方差
   偏差是预测值和真实值之间的差异，体现在训练集的准确度上；方差是预测值作为随机变量时预测结果的离散程度，方差大时容易过拟合。
   
   
4. Bagging和Boosting都是由基函数线性组合而成。Bagging中的基函数最好是强学习器（多次抽样，总体方差是基函数方差的1/N），否则可能导致整体模型的准确度低。Boosting可以是弱学习器。

一、Bagging

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

随机森林（Random Forest，RF）

随机森林建立在Bagging的基础上，用CART决策树作为弱学习器，对样本进行随机抽样（同原数据集大小），同时在决策树进行拆分时每个节点都使用随机抽样特征（不再是全部特征），泛化能力更强，结果由平均或投票确定。
【优点】：可以给出个特征对于输出的重要性矩阵；产生的模型方差小，泛化能力强；可以并行计算，速度快；对缺失值不敏感。
【缺点】：对噪音较大的样本集容易过拟合；值比较多的特征容易对模型产生影响。
【过程】有放回地随机抽样获得样本子集作为一个CART决策树的训练集，每次对节点进行拆分时，随机抽取一部分特征，根据拆分准则（信息增益、信息增益率或基尼指数）选择拆分点，最终形成一颗树。最终以最多的预测类或预测值的平均作为随机森林的输出结果。
【特征重要性】可以计算正例经过的结点，进而，可以使用经过结点的数目、经过结点的gini系数和等指标。或者，随机替换一列数据，重新建立决策树，计算新模型的正确率变化，从而考虑这一列特征的重要性。参考
随机森林的变种还有Extra Trees（每个决策树都用原始训练集，不抽样；选用随机特征值划分决策树）

Extra Trees

Extra trees是基于随机森林，但样本使用原始训练集，在特征划分时随机选择特征的值进行划分（不再使用具体准则）。

Totally Random Trees Embedding

简称TRTE，是一种无监督的将低维的数据集映射到高维的方法，从而让映射到高维的数据可以更好的用于分类或回归。
TRTE在数据转化的过程用了类似于RF的方法，建立T个决策树来拟合数据。当决策树建立完毕后，数据集里的每个数据在T个决策树中叶节点的位置也定下来了。从而将样本在每颗决策树中用one-hot（在对应节点为1，不在为0）编码表示的结果按树的顺序合在一起，映射结果维度$n_out \le Node*Tree$no​ut≤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$x用T颗树进行拟合，计算每颗决策树上该样本点所在的叶节点对应的深度$h_t(x)$ht​(x)，从而可计算平均高度$\overline h_t(x)$ht​(x)。
样本点$x$x对应的异常概率为：$s(x,m)=2^{-\frac{\overline h(x)}{c(m)}}$s(x,m)=2−c(m)h(x)​，其中$m$m是训练样本个数，$c(m)=2ln(m-1)+\xi -2\frac{m-1}{m}$c(m)=2ln(m−1)+ξ−2mm−1​，$\xi$ξ是欧拉常数。
$s(x,m)$s(x,m)的取值范围是[0,1]，取值越接近1，则$x$x是异常点的概率越大。

多输出任务

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

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

二、Boosting（提升）

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

Boosting面临四个问题：

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

AdaBoost算法

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

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

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

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

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

Adaboost回归算法

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

梯度提升Gradient boosting

梯度提升算法首先给定一个总体目标损失函数（不再是关于特征的函数，而是关于弱学习器的函数），定义域是所有可行的弱函数集合；通过迭代的选择一个使总体损失函数在其负梯度方向上（总体损失函数一阶可导）下降得最快的基函数（若损失函数为均方差，则等价于对上一轮的残差进行拟合），实现逐渐逼近总体损失函数的局部最优值。称为Gradient是因为在添加新模型时用了梯度下降算法来实现损失函数最小化。
【损失函数】构造关于总体模型的损失函数：$L(y, F(x))=\frac{1}{2}(y-F(x))^2$L(y,F(x))=21​(y−F(x))2或$L(y, F(x))=|y-F(x)|$L(y,F(x))=∣y−F(x)∣，其中$F(x)$F(x)是要构造的总体模型，由一簇弱学习器（基函数）$f_i(x)$fi​(x)加权求和得到的：$F(x)=\sum\gamma_if_i(x)+const$F(x)=∑γi​fi​(x)+const，const是可能存在的常数项。从而转化为求解不同的弱学习器$f_i(x)$fi​(x)，使得最终损失函数达到最优。
【求解】初始函数$F_0(x)$F0​(x)假设为常函数：
对$L(y, F(x))=\frac{1}{2}(y-F(x))^2$L(y,F(x))=21​(y−F(x))2以均值作为最优解；对$L(y, F(x))=|y-F(x)|$L(y,F(x))=∣y−F(x)∣以中位数作为最优解。
按照贪心思路得到第m轮迭代得到的总体函数：
$F_m(x)=F_{m-1}(x)+argmin_{F_m}\sum^nL(y^{(i)},F_{m}(x^{(i)}))=F_{m-1}(x)+argmin_{f_m}\sum^nL(y^{(i)},F_{m-1}(x^{(i)})+f_m(x^{(i)}))$Fm​(x)=Fm−1​(x)+argminFm​​∑nL(y(i),Fm​(x(i)))=Fm−1​(x)+argminfm​​∑nL(y(i),Fm−1​(x(i))+fm​(x(i)))（式1），
其中$n$n是样本量，$x^{(i)}$x(i)是第$i$i个样本 。可理解为新的总体模型$F_m(x)$Fm​(x)是在上一轮迭代得到的模型$F_{m-1}(x)$Fm−1​(x)的基础上，找到新的弱学习器$f_m(x_i)$fm​(xi​)，使总体损失函数最小$argmin_{f_m}\sum^nL(y^{(i)},F_{m-1}(x^{(i)})+f_m(x^{(i)}))$argminfm​​∑nL(y(i),Fm−1​(x(i))+fm​(x(i)))。
【梯度下降】将损失函数看做是关于$F(x)$F(x)的函数，利用梯度下降（根据泰勒展开式获得：$f(x_{k})=f(x_{k-1}+x_{k}-x_{k-1})\approx f(x_{k-1})+\nabla f(x_{k-1})(x_{k}-x_{k-1})$f(xk​)=f(xk−1​+xk​−xk−1​)≈f(xk−1​)+∇f(xk−1​)(xk​−xk−1​)，在$x_{k-1}$xk−1​上对$f_(x_k)$f(​xk​)进行展开），可找到$F$F的更新方式，使得$L$L在其梯度方向上下降最快，有：$F_m(x_i):=F_{m-1}(x_i)+\beta\bigg[\frac{\partial L(y_i, F(x_i)))}{\partial F(x_i)}\bigg]_{F(x) = F_{m-1}(x)}$Fm​(xi​):=Fm−1​(xi​)+β[∂F(xi​)∂L(yi​,F(xi​)))​]F(x)=Fm−1​(x)​，$\beta$β是梯度下降的学习率。非常好的参考
【伪残差】令伪残差$r_{mi} = -\bigg[\frac{\partial L(y_i, F(x_i)))}{\partial F(x_i)}\bigg]_{F(x) = F_{m-1}(x)}$rmi​=−[∂F(xi​)∂L(yi​,F(xi​)))​]F(x)=Fm−1​(x)​
由于$F_m(x)=F_{m-1}(x)+\gamma_mf_m(x)$Fm​(x)=Fm−1​(x)+γm​fm​(x)，可以得到：$f_m(x_i)$fm​(xi​)应尽可能拟合$r_{mi}$rmi​，实现$f_m(x_i)=r_{mi}$fm​(xi​)=rmi​。
从而整个过程变为：用$(x_i,r_{mi})\;\; (i=1,2,..n)$(xi​,rmi​)(i=1,2,..n)建立新的基函数$f_m(x)$fm​(x)对$r_{mi}$rmi​进行拟合，按步长$\gamma_m$γm​进行移动，则有：
$F_m(x)=F_{m-1}(x)-\gamma_m\sum^n\nabla_{F_{m-1}}L(y^{(i)}, F_{m-1}(x^{(i)}))=F_{m-1}(x)+\gamma_mf_m(x)$Fm​(x)=Fm−1​(x)−γm​∑n∇Fm−1​​L(y(i),Fm−1​(x(i)))=Fm−1​(x)+γm​fm​(x)，
其中可用线性搜索得到最优步长：
$\gamma_m=argmin_\gamma\sum^nL(y^{(i)},F_{m-1}(x^{(i)})-\gamma·\nabla_{F_{m-1}}L(y^{(i)}, F_{m-1}(x^{(i)})))=argmin_\gamma\sum^nL(y^{(i)},F_{m-1}(x^{(i)})+\gamma·f_m(x))$γm​=argminγ​∑nL(y(i),Fm−1​(x(i))−γ⋅∇Fm−1​​L(y(i),Fm−1​(x(i))))=argminγ​∑nL(y(i),Fm−1​(x(i))+γ⋅fm​(x))。（可以对$\gamma$γ进行阈值限制）
如此迭代不断找到新的$f(x)$f(x)使总体损失函数变小，此方法即为提升。
若$L$L关于$F$F二阶可导，还可以从极值角度考虑，令$L&#x27;=0$L′=0，而$L&#x27;$L′可用泰勒展开式进行展开，从而可以计算出$f_m$fm​的具体形式参考：

【伪残差和残差的关系】当损失函数为$L(F)=(y-F)^2$L(F)=(y−F)2时， 对$F$F的导数（不是对x求导）是$2(y-F)$2(y−F)，这就是残差，从而新的函数$f_m(x)$fm​(x)对伪残差的最大拟合实际就是对上轮迭代所得残差的最大拟合。若损失函数为其他函数时未必。
上面是从梯度（伪残差）角度考虑的，还可从损失函数角度考虑：$L(F)=(y-F)^2=(y-(F_{m-1}+f_m(x)))^2=((y-F_{m-1})-f_m(x))^2=(resid_{m-1}-f_m(x))^2$L(F)=(y−F)2=(y−(Fm−1​+fm​(x)))2=((y−Fm−1​)−fm​(x))2=(residm−1​−fm​(x))2，从而新模型是对上一次拟合的残差进行最大化拟合。
以上是基于损失函数对总体模型$F(x)$F(x)可导的，但$F(x)$F(x)是否关于x可导不一定（即$f(x)$f(x)是否对x可导）。梯度提升是线性可加模型，可加指的是对基函数是可加的（基函数的返回值），而不是对x是可加的（若基函数是决策树，决策树的输出是各节点的预测值）。
【正则化】在使用提升方法时，通常会在模型权值基础上再增加一个学习率$v$v（衰减因子Shrinkage）：$F_m(x)=F_{m-1}(x)+v·\gamma_mf_(x)$Fm​(x)=Fm−1​(x)+v⋅γm​f(​x)，$f(x)$f(x)对应的预测是上次迭代所得残差。一般使用的学习率$v\lt 0.1$v<0.1。
另外可以在每次迭代时随机无放回抽样，从而增加模型随机性，减小方差（随机梯度提升SGD）。
【损失函数及对应梯度】上文中使用的损失函数是$L(y_m, F_{m}(x))=\frac{1}{2}(y-F_{m}(x))^2$L(ym​,Fm​(x))=21​(y−Fm​(x))2，梯度是$y-F(x)$y−F(x)通常用于回归任务。
绝对损失函数$L(y, F(x))=|y-F(x)|$L(y,F(x))=∣y−F(x)∣，梯度是$sign(y-F(x))$sign(y−F(x))。
对二分类任务可以用逻辑回归的损失函数（logistic loss）：$L(y,F(x))=ylogp+(1-y)log(1-p)$L(y,F(x))=ylogp+(1−y)log(1−p)，其中$p=\frac{1}{1+e^{-F(x)}}$p=1+e−F(x)1​，梯度是$y-\frac{1}{1+e^{-F_{m-1}(x)}}$y−1+e−Fm−1​(x)1​。
多分类任务使用Sofmax的损失函数。
指数损失函数$L(y_m, F_{m}(x))=e^{(-y*F_m(x))}$L(ym​,Fm​(x))=e(−y∗Fm​(x))。当损失函数为指数函数式，梯度提升算法相当于二分类的Adaboost算法参考
【示例】以逻辑回归为例，对每个类的预测其概率时，形成$\hat y^{(i)}=(p_1,p_2,p_n)$y^​(i)=(p1​,p2​,pn​)，对实际所属类可视为概率1，其余为0，如$y^{(i)}=(1,0,0)$y(i)=(1,0,0)，从而可以计算$\hat y^{(i)}$y^​(i)与$y^{(i)}$y(i)间的距离，从而构造$f(x)$f(x)的损失函数并计算伪残差，之后再对该伪残差继续用逻辑回归建模，理论上直到所有残差为零时（或达到阈值）停止。分类的损失函数可以是预测类与真实类不一致的数量、叶节点的熵按叶节点占总体样本的比重做加权后的值……。
【问题点】具体如何求$\gamma_m$γm​？

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

参考1 参考2 很好的参考
【特点】梯度提升树是基函数为CART回归树的梯度提升法的应用。GBDT的核心在于每次对上轮的误差进行拟合（残差向量是梯度变化最大方向），通过累加所有树的结果作为最终结果（分类树的结果无法累加，故GBDT中的树都是回归树）。虽然调整后可用于分类任务（通过基函数返回概率），但基函数不是分类学习器。
GBDT主要由三个概念组成：Regression Decistion Tree（即DT)，Gradient Boosting（即GB)，Shrinkage (算法的一个重要演进分枝，目前大部分源码都按该版本实现）
【基函数】最好是低方差和高偏差的，从而可以通过多次迭代减小偏差。一般用CART决策树，树不用很深（高偏差）
GBDT可以用一些健壮的损失函数，对异常值的鲁棒性非常强。比如 Huber损失函数和Quantile损失函数。
【分类算法常用损失函数】：

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

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

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

【正则化】：

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

GBDT回归算法

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

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

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

GBDT分类算法：二分类

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

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

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

1. 损失函数：$L(y, F(x)) = log(1+ exp(-2yF(x)))$L(y,F(x))=log(1+exp(−2yF(x)))，$F(x)=\frac{1}{2}log[\frac{Pr(y=1|x)}{Pr(y=-1|x)}]$F(x)=21​log[Pr(y=−1∣x)Pr(y=1∣x)​]，其中$Pr(y=1|x)$Pr(y=1∣x)是预测$x$x为1的概率，$Pr(y=-1|x)$Pr(y=−1∣x)是预测x为-1的概率。
2. 对应负梯度为：$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))}$rm−1,i​=−[∂F(xi​)∂L(y,F(xi​)))​]F(x)=Fm−1​(x)​=1+exp(2yi​Fm−1​(xi​))2yi​​
3. 初始化$F_0(x)$F0​(x)，之后和计算出$R_{0,i}$R0,i​
4. 第$m$m轮迭代中，用$(x, r_{m-1})$(x,rm−1​)构建决策树，对$r_{m-1}$rm−1​进行拟合，从而决策树的叶节点$j$j的估计值计算公式为：
   $\gamma_{mj} = argmin_{r}\sum_{x_{i}\in R_{mj}} log(1+exp(-2y_{i}(F_{m-1}(x_{i})+\gamma)))$γmj​=argminr​∑xi​∈Rmj​​log(1+exp(−2yi​(Fm−1​(xi​)+γ)))
   一般用近似结果：$\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}|) }$γmj​=∑xi​∈Rmj​​∣rm−1,i​∣(2−∣rm−1,i​∣)∑xi​∈Rmj​​rm−1,i​​
5. 最终输出模型为$F_m(x)=F_{m-1}(x)+\gamma_{mj}I(x_i \in R_{tj})$Fm​(x)=Fm−1​(x)+γmj​I(xi​∈Rtj​)，从而有$p_{+}(x)=p= \frac{1}{1+e^{-2F(x)}}$p+​(x)=p=1+e−2F(x)1​，$p_{-}(x)=1-p= \frac{1}{1+e^{2F(x)}}$p−​(x)=1−p=1+e2F(x)1​。从而可以利用概率进行分类。

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

GBDT分类算法：多分类

采用OvR，实质上是在每轮训练时都是同时训练多颗树：是否A类一颗树，是否B类一个数，是否C类一棵树…，真实类的概率视为1，其余视为0，从而可以计算负梯度（残差），损失函数用对数似然损失函数。非常好的实例参考
对某轮训练，假设类别数为K，则对数似然损失函数为：$L(y, f(x)) = - \sum\limits_{k=1}^{K}y_klog\;p_k(x)$L(y,f(x))=−k=1∑K​yk​logpk​(x)，其中如果样本x输出类别为$k$k，则$y_k=1$yk​=1，否则为0。实际是本轮的K颗树之和。
在本轮的K颗树中，每颗树对样本x预测结果为$f_l(x)$fl​(x)，则可综合得属于第$k$k类的概率$p_k(x)$pk​(x)的表达式为：$p_k(x) =\frac{exp(f_k(x))}{\sum\limits_{l=1}^{K} exp(f_l(x))}$pk​(x)=l=1∑K​exp(fl​(x))exp(fk​(x))​
结合上面两式，我们可以计算出第$t$t轮的第$i$i个样本属于类别$l$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)$rtil​=−[∂f(xi​)∂L(yi​,f(xi​)))​]fk​(x)=fl,t−1​(x)​=yil​−pl,t−1​(xi​)
这里的误差就是样本$i$i在OvR策略下，对应类别为$l$l时的真实概率（是则为1，否为0）和$t−1$t−1轮预测概率的差值。
对于生成的决策树，我们各个叶子节点$J$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}))$ctjl​=cjl​argmin​​i=0∑m​k=1∑K​L(yk​,ft−1,l​(x)+j=0∑J​cjl​I(xi​∈Rtj​))
一般使用近似值代替：$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}|)}$ctjl​=KK−1​xi​∈Rtil​∑​∣rtil​∣(1−∣rtil​∣)xi​∈Rtjl​∑​rtil​​
从而可以继续对残差进行建模拟合，重复上述过程。
除了负梯度计算和叶子节点的最佳负梯度拟合的线性搜索，多元GBDT分类和二元GBDT分类以及GBDT回归算法过程相同。
参考

随机梯度提升SGD

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

XGBoost

【优点】

1. 同时使用一阶、二阶信息，可以更快的在训练集上收敛。可以使用线性分类器。
2. 可自定义损失函数，可以用损失函数的一阶和二阶导，也可以用自定义一阶和二阶导损失函数（评价标准）。通过正则化对树的节点数、节点权重进行惩罚，减少过拟合。
3. xgboost借鉴了随机森林的做法，支持列抽样，不仅能降低过拟合，还能减少计算，这也是xgboost异于传统gbdt的一个特性。对缺失值的处理。对于特征的值有缺失的样本，xgboost可以自动学习出它的分裂方向。
4. XGBoost在根据特征进行节点拆分时使用了并行计算（树的建立仍是串行，Boosting一般为串行计算），并使用C语言，速度快（并行是在特征分割上，不是建树过程间。xgboost在训练之前，先对数据进行排序，然后保存block结构，后面的迭代中重复的使用这个结构，大大减小计算量。这个block结构也使得并行成为了可能，在进行节点的分裂时，需要计算每个特征的增益，最终选增益最大的那个特征去做分裂，那么各个特征的增益计算就可以开多线程进行）。
5. 由于“随机森林族”本身具有过拟合特性，因此XGBoost也有该特性。

【理论】
梯度提升是通过损失函数$L$L对总体模型$F$F求导来寻找使$L$L在负梯度方向上下降最快的$F$F。从而根据一阶泰勒展开式，利用梯度下降法对$F$F进行更新，最终转换为弱学习器$f$f对上一轮梯度的拟合，从而得到新的总体模型$F_m$Fm​。若$L$L对$F$F进行二阶泰勒展开式来计算，则称为XGBoost方法。XGBoost要求弱学习器必须是回归，同GBDT要求相同。
损失函数可表示为$L(F_t)=\sum L(y_i, \hat y_i^t)=\sum L(y_i, \hat y_i^{(t-1)}+f_t(x_i))+\Omega(f_t)+C$L(Ft​)=∑L(yi​,y^​it​)=∑L(yi​,y^​i(t−1)​+ft​(xi​))+Ω(ft​)+C，$\Omega(f_t)$Ω(ft​)是关于$f_t$ft​的函数（如正则项），C是可能的常数项。$f_t(x)$ft​(x)是对上轮迭代后所得残差$y-\hat y_{t-1}$y−y^​t−1​的拟合。

常用损失函数：

• 均方误差：$L(y_i, \hat y_i)=(y_i-\hat y_i)^2$L(yi​,y^​i​)=(yi​−y^​i​)2
• 逻辑回归损失函数：$L(y_i, \hat y_i)=y_iln(1+e^{-\hat y_i})+(1-y_i)ln(1+e^{\hat y_i})$L(yi​,y^​i​)=yi​ln(1+e−y^​i​)+(1−yi​)ln(1+ey^​i​) ，
  一阶导$g=\frac{\partial L(y, F_{t-1})}{F_{t-1}}=-y(1-\frac{1}{1+e^{F_{t-1}}})+(1-y)\frac{1}{1+e^{-y_{t-1}}}=Pred-Label$g=Ft−1​∂L(y,Ft−1​)​=−y(1−1+eFt−1​1​)+(1−y)1+e−yt−1​1​=Pred−Label
  二阶导$h=\frac{\partial^2 L(y, F_{t-1})}{F_{t-1}}=\frac{e^{-y_{t-1}}}{(1+e^{-y_{t-1}})^2}=Pred*(1-Pred)$h=Ft−1​∂2L(y,Ft−1​)​=(1+e−yt−1​)2e−yt−1​​=Pred∗(1−Pred)

由于二阶泰勒展开式：$f(x+\triangle x)\approx f(x)+f&#x27;(x)\triangle x+\frac{1}{2}f&#x27;&#x27;(x)\triangle x^2$f(x+△x)≈f(x)+f′(x)△x+21​f′′(x)△x2，且$L(F)$L(F)是关于总体模型$F$F的函数，$F$F是每次迭代后总体模型的输出$F_0、F_1…$F0​、F1​…。
因此，令根据总体损失函数关于$F$F的一阶导和二阶导在$F_{t-1}$Ft−1​处的值（或自定义）：
$g_i=[\frac{\partial L(F)}{\partial F}]_{F=F_{t-1}}=\frac{\partial L(y_i, \hat y_i^{(t-1)})}{\partial\hat y_i^{(t-1)}}$gi​=[∂F∂L(F)​]F=Ft−1​​=∂y^​i(t−1)​∂L(yi​,y^​i(t−1)​)​和$h_i=[\frac{\partial^2 L(F)}{\partial F}]_{F=F_{t-1}}=\frac{\partial^2 L(y_i, \hat y_i^{(t-1)})}{\partial\hat y_i^{(t-1)}}$hi​=[∂F∂2L(F)​]F=Ft−1​​=∂y^​i(t−1)​∂2L(yi​,y^​i(t−1)​)​
从而可以有：$L(F_t)=\sum_{i=1}^nL(y_i, \hat y_i^{t-1}+f_t(x_i)) \approx \sum_{i=1}^n[L(y_i, \hat y_i^{(t-1)})+g_if_t(x_i)+\frac{1}{2}h_if_t^2(x_i)]+\Omega(f_t)+C$L(Ft​)=∑i=1n​L(yi​,y^​it−1​+ft​(xi​))≈∑i=1n​[L(yi​,y^​i(t−1)​)+gi​ft​(xi​)+21​hi​ft2​(xi​)]+Ω(ft​)+C，$i$i是第$i$i个样本，$t$t是第$t$t个弱学习器。即损失函数$L(F)$L(F)在$F_{t-1}$Ft−1​处展开，将$F_t$Ft​视为$x$x，$F_{t-1}$Ft−1​视为$x_0$x0​；而$f(x)=F_t(x)-F_{t-1}(x)$f(x)=Ft​(x)−Ft−1​(x)，可视为$\triangle x$△x。

上式含义：在尽可能对目标值进行拟合以实现预测误差尽可能小的基础上，弱学习器应当有尽可能少的节点，节点取值也尽量偏差不大（防止过拟合风险）

对决策树模型的$f(x)$f(x)，其结果可表示为叶节点数T、叶节点的值$w=(w_1,w_2,…w_T)$w=(w1​,w2​,…wT​)的组合，样本$x$x在决策树中的结果可表示为$f(x)=w_{q(x)}$f(x)=wq(x)​，其中$q(x)$q(x)是第$q$q个节点。
对弱学习器$f(x)$f(x)来说，可以对叶节点数$T$T和叶节点值$w$w分别施加惩罚项，得到：$\Omega(f_t)=\gamma T+\frac{1}{2}\lambda\sum_{j=1}^Tw_j^2$Ω(ft​)=γT+21​λ∑j=1T​wj2​，其中$T$T是决策树叶节点个数，$w_j$wj​是第$j$j个叶节点对应的值（后面会被求解出来）。公式对决策树的惩罚方式不是唯一的，可定义其他形式。
对第$t$t个弱学习器，$L(y_i, \hat y_i^{(t-1)})$L(yi​,y^​i(t−1)​)是在上一轮学习得到的总体模型$F(f(x))$F(f(x))对应的残差，是一定值，与当前$f(x)$f(x)无关，从而可以与常数项C合并，进而有：
$L(f_t)=\sum_{i=1}^n[g_if_t(x_i)+\frac{1}{2}h_if_t^2(x_i)]+\Omega(f_t)+C\\ \qquad=\sum_{i=1}^n[g_iw_{q(x_i)}+\frac{1}{2}h_iw_{q(x_i)}^2]+\gamma T+\frac{1}{2}\lambda\sum_{j=1}^Tw_j^2+C（从样本角度考虑）\\ \qquad=\sum_{j=1}^T[(\sum g_i)w_j+\frac{1}{2}(\sum h_i)w_j^2]+\gamma T+\frac{1}{2}\lambda\sum_{j=1}^Tw_j^2+C（从树所生成的叶节点角度考虑，w_{q(x)}是某一个w_j）\\ \qquad=\sum_{j=1}^T[(\sum g_i)w_j+\frac{1}{2}(\sum h_i+\lambda)w_j^2]+\gamma T+C\\ \qquad=\sum_{j=1}^T[(\sum g_i)w_j]+\frac{1}{2}(\sum h_i+\lambda)w_j^2]+\gamma·T+C$L(ft​)=∑i=1n​[gi​ft​(xi​)+21​hi​ft2​(xi​)]+Ω(ft​)+C=∑i=1n​[gi​wq(xi​)​+21​hi​wq(xi​)2​]+γT+21​λ∑j=1T​wj2​+C（从样本角度考虑）=∑j=1T​[(∑gi​)wj​+21​(∑hi​)wj2​]+γT+21​λ∑j=1T​wj2​+C（从树所生成的叶节点角度考虑，wq(x)​是某一个wj​）=∑j=1T​[(∑gi​)wj​+21​(∑hi​+λ)wj2​]+γT+C=∑j=1T​[(∑gi​)wj​]+21​(∑hi​+λ)wj2​]+γ⋅T+C
其中$w_{q(x_i)}$wq(xi​)​是第$t$t个弱学习器（最新的）$f_t(x)$ft​(x)对数据$x_i$xi​输出到第$q(x_i)$q(xi​)叶节点时所对应的结果值。

决策树的作用是对给定输入得到输出叶节点所对应的值。
将损失函数从样本角度转换到各弱学习器生成的节点考虑，从而整体损失函数仅与最后一个弱学习器的叶节点输出值$w_j$wj​、叶节点个数T、超参$\lambda、\gamma$λ、γ有关。$L$L关于$F$F在前一轮迭代所得一阶导$h_i$hi​和二阶导$g_i$gi​（在第t轮是定值）。

对于$L(f_t)=\sum_{j=1}^T[(\sum g_i)w_j]+\frac{1}{2}(\sum h_i+\lambda)w_j^2]+\gamma·T+C$L(ft​)=∑j=1T​[(∑gi​)wj​]+21​(∑hi​+λ)wj2​]+γ⋅T+C，定义$G_j=\sum g_i$Gj​=∑gi​，$H_j=\sum h_i$Hj​=∑hi​，从而有$L(f_t)=\sum_{j=1}^T[G_jw_j+\frac{1}{2}(H_j+\lambda)w_j^w]+\gamma T+C$L(ft​)=∑j=1T​[Gj​wj​+21​(Hj​+λ)wjw​]+γT+C。
对$w$w求偏导得：$\frac{\partial J(f_t)}{\partial w_j}=G_j+(H_j+\lambda)w_j$∂wj​∂J(ft​)​=Gj​+(Hj​+λ)wj​，令其为零（此时得到$L$L的极值），可得$w_j=-\frac{G_j}{H_j+\lambda}$wj​=−Hj​+λGj​​
将$w_j$wj​回到入损失函数，得到$L(f_t)=-\frac{1}{2}\sum_{j=1}^T\frac{G_j^2}{H_j+\lambda}+\gamma T$L(ft​)=−21​∑j=1T​Hj​+λGj2​​+γT

以上可以理解为：对第t轮迭代的树模型$f_t(x)$ft​(x)，可以通过设置叶节点数和叶节点的权重值的惩罚项、损失函数关于$F$F的导数在上轮迭代中得到的一阶导和二阶导函数值（还与本轮叶节点有关，导数根据总体损失函数计算或自己定义），就可以得到总体损失函数。从而可以寻找合适的$f_t$ft​获得最佳叶节点划分，使得当前损失函数与划分后的损失函数变化最大。当前树是对上轮残差$（y-\hat y_{t-1}）$（y−y^​t−1​）的拟合。

【贪心法建立$f_t(x)$ft​(x)】：弱学习器可以用C4.5或CART决策树；利用二叉树，通过贪心法，对每次划分前后的总体损失函数进行比较，选择使得损失函数变化最大的特征和对应的划分点（划分准则不再是决策树自身的准则）：
决策树$f_t(x)$ft​(x)是对上轮迭代所得总体模型残差$(y-\hat y_t)$(y−y^​t​)进行拟合。具体生成节点时，先初始化$F_0(f_0(x))$F0​(f0​(x))，如均值。之后各轮迭代时，对某一节点，有总体损失$L(f_t^m(x))$L(ftm​(x))，对某一特征根据其值进行划分，计算划分后的新生成的$f_t^{m+1}(x)$ftm+1​(x)所对应的损失函数：
$L(f_t^{m+1}(x))=L_{左枝}(f_t^{m+1}(x))+L_{右枝}(f_t^{m+1}(x))$L(ftm+1​(x))=L左枝​(ftm+1​(x))+L右枝​(ftm+1​(x))
计算划分前后的损失函数值变化：$Gain=L(f_t^m)-L(f_t^{m+1})=\frac{1}{2}[\frac{G_L^2}{H_L+\lambda}+\frac{G_R^2}{H_R+\lambda}-\frac{(G_L+G_R)^2}{H_L+H_R+\lambda}]-\gamma$Gain=L(ftm​)−L(ftm+1​)=21​[HL​+λGL2​​+HR​+λGR2​​−HL​+HR​+λ(GL​+GR​)2​]−γ
对各特征的不同值划分后的损失函数变化进行比较，选择变化最大的划分方式，从而构造出树的一次分枝。
划分时可设置阈值，损失函数变化小于该阈值时停止划分，即完成一次树的建立。每次划分都是实现局部最优，只能确保当前树的此次划分会使总体损失函数最小化。参考

建立当前弱学习器时，对每个节点的拆分，都要比较所有特征的所有值，寻找使总体损失函数最小化的划分（其实就是导数在上轮迭代时所得值的不同组合方式）。 XGBoost的并行也是在此处实现的（不同特征的拆分形成叶节点，导数值已定，只是组合方式不同），建立决策树时仍然是串行，每次都依赖于上一轮迭代。

Python

from sklearn import ensemble

自定义多个模型的集成

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

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)

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)

随机森林：分类

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生成的树个数（太小时容易欠拟合；太大时计算量会太大，且达到一定的数量后，再增大弱学习器所获得的模型提升会很小）。bootstrap是否用bootstrap抽样进行建树。oob_score是否用袋外样本out-of-bag（随机森林中建模时未被抽到的样本）来评估准确性（更能评价泛化能力）。random_state随机种子。verbose控制树的可见等级。warm_start是否热启动（使用上次的结果作为初始值进行参数估计）。class_weight以字典形式指定类的权重{class_label:weight}，对多输出问题，以字典构成的列表来表示权重，字典中分别指定多输出的权重；也可以是"balanced"等权重。
【CART参数】criterion划分准则，有"gini"基尼系数、"entropy"信息增益。max_teatures每次生成树时使用的特征个数或比例，"auto"和"sqrt"是$\sqrt{特征数}$特征数​、log2、None是全部特征。max_depth最大树深度，None不限制，一般取10-100。min_samples_split生成子节点前节点最少样本量，为小数时是总样本比例（小样本可不设置）。min_samples_leaf生成的叶节点含有的最少样本量，为小数时是总样本比例（小样本可不设置）。min_weight_fraction_leaf子节点的最小样本权重和，小于该值时回合兄弟节点一起被减掉（有较多缺失值或类别分布失衡时要考虑）。max_features随机选择的特征最大个数（可防止过拟合，特征较多时考虑）。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使用的划分准则
方法：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稀疏矩阵，形状为(样本量, 节点数)，
调参：利用网格搜索先找到合适的弱学习器个数。然后对决策树最大深度和内部节点再划分前所需最小样本量进行搜索，确定树的最大深度。再将内部节点再划分前所需最小样本量与子节点最少样本量一起调参，确定这两个参数。最后再确定最大特征数。

随机森林：回归

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：分类

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时有放回。

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_以数组返回特征的重要性（若基函数支持）。

梯度提升：分类

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_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"指数损失函数。learning_rate学习率。n_estimators弱学习器个数。
【CART决策树】max_depth树的最大深度。criterion决策树的拆分准则，“friedman_mse”、"mse"均方差、"mae"绝对离差。min_samples_split再拆分前节点所含最小样本量。min_samples_leaf叶节点所含最小样本量。min_weight_fraction_leaf叶节点最小权重和。subsample子采样比例。max_features拆分节点时所用最大特征个数或比例，“auto”、“sqrt”、“log2”。min_impurity_decrease最小不纯度变化量的阈值。init指定基函数的初始值，对象应包含fit和predict方法。verbose过程显示等级。warm_start是否热启动。random_state随机种子。presort是否在建模前先对数据排序，以便加速建模（对稀疏数据不可用）。
属性：feature_importances_返回特征的重要性。oob_improvement_通过袋外样本确定的每次迭代所得损失函数值。train_score_每次用训练集迭代所得得分。loss_损失函数。init初始函数。estimators_各次迭代所得决策树。

梯度提升：回归

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_decrease=0.0, min_impurity_split=None, init=None, random_state=None, 
                                   max_features=None, alpha=0.9, verbose=0, max_leaf_nodes=None, warm_start=False, presort='auto')

【Boosting参数】loss指定损失函数，“ls”、“lad”、“huber”、“quantile”。learning_rate学习率。n_estimators弱学习个数。subsample子采样比例或个数。

GBDT：回归

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

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$f0​），是一个估计器对象（有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$log2​N）、“sqrt”/“auto”（$\sqrt N$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')

loss指定损失函数，"deviance"对数似然损失函数、"exponential"指数损失函数（对二分类等价于Adaboost算法）。

XGBoost

ensemble.GradientBoostingClassifier()

其他库

安装库参考 xgboost库帮助
中文帮助

import xgboost

读取数据

xgboost.DMatrix(data, label=None, missing=None, weight=None, silent=False, feature_names=None, feature_types=None, nthread=None)

DMatrix是XGBoost的内部数据结构，能够实现内存和训练速度的最优化。
data是numpy.array、scipy.sparse、pd.DataFrame，也可以是字符串指定的文本文件路径。label指定训练数据的标签列表。missing视为缺失值的值，None时默认np.nan。weight指定样本权重，对排序任务是各类的权重。silent是否打印建模过程中的信息。feature_names自定义的特征名称列表。feature_types特征数据类型。nthread从numpy.array中加载数据时用的线程数，-1时为最大线程数。

训练模型

xgboost.train(params, dtrain, num_boost_round=10, eval=(), obj=None, feval=None, maximize=False, early_stopping_rounds=None, 
              evals_result=None, verbose_eval=True, xgb_model=None, callback=None, learning_rates=None)

params指定Boost的参数字典：
【树模型的booster参数】booster指定每次迭代的模型（"gbtree"基于树的模型，“gbliner"线性模型）。silent是否输出中间信息（1不输出）。nthread指定线程数。eta（默认0.3）指定对每个模型的学习率（一般为0.01-0.2）。min_child_weight（默认1）最小叶子结点样本权重和（控制叶节点中二阶导的和的最小值，值越小越易过拟合）。max_depth（默认6）树的最大深度（通过交叉验证确定，一般3-10）。max_leaf_nodes树的最大叶节点数（设置后会忽略max_depth）。gamma（默认0）节点分裂后损失函数变化的最小阈值（0.1-0.2）。max_delta_step（默认0）指定每棵树权重改变的最大步长（样本不平衡时使用）。subsample（默认1）控制构建树时随机采样比例（0.5-1）。colsample_bylevel（默认1）控制每次分裂时所用特征列的比例。lambda（默认1）指定L2正则项的惩罚因子。alpha（默认1）指定L1正则化项的惩罚因子（高维数据时可用，可加快算法速度）。scale_pos_weight取值大于0时，在类别补平衡时可加快算法收敛速度（默认1）。
【学习目标参数】objective自定义的损失函数，常用的有"binary:logistic”（二分类逻辑回归的损失函数，返回预测概率而不是类别）；“multi:softmax”（Softmax多分类器的损失函数，返回预测类别而不是概率，还需要设置num_class类别数目）；“multi:softprob”（同multi:softmax，但返回的是所属类别的概率而不是类）。eval_metric对有效数据的度量方法，"rmse"均方根误差、"mae"平均绝对误差、"error"二分类错误率（阈值为0.5）、"merror"多分类错误率、"logloss"负对数似然函数、"mlogloss"多分类logloss损失函数、“auc”。seed随机种子。
sample_type抽样服从的分布，“uniform”。normalize_type正则
dtrain指定训练数据。num_boost_round指定boosting迭代次数。evals以列表指定的训练数据，每个元素是(DMatrix, string)，从而可以用于交叉验证数据集（对列表内每个数据进行一次训练）。obj自定义的损失函数，同objective。
feval自定义的评价函数（一、二阶导）。maximize是否最大化feval参数？？。early_stopping_rounds是否提前停止，要求evals参数中至少有一项（有多项时用最后一个），返回最后一次迭代所得模型；若提前停止，返回对象会有test_score、best_iteration、test_ntree_limit三个属性。evals_result以字典形式指定存储watchlist中的估计结果。verbose_eval指定evals参数中数据建模对应的结果是否可见，也可用数字指定级别。learning_rates以列表形式指定每次迭代的学习率。xgb_model指定存储xgb模型的文件或Booster()实例。callbacks回调函数列表，函数是在每次迭代的最后时执行的。
方法：predicct()
save_model()