从AdaBoost到GBDT再到XGBoost 算法推导 笔记

提升树算法 AdaBoost

同样也是集成算法的随机森林，实质上利用的是Bootstrap抽样生成多个数据集，使用这些数据集构成多可决策树，最终用投票/平均的思想实现分类和预测问题的解决。而提升树是基于残差的训练，最终预测结果=模型1的预测+模型2的预测+…+模型n的预测。

多棵基础决策树f(x)的加权运算

$F(x)$，由M棵
基础决策树构成的最终提升树，
$F_{m-1}(x)$，经过m-1轮迭代后的提升树，
${\alpha }_m$，第m棵基础决策树所对应的权重，
$f_m(x)$，第m棵基础决策树
注：每一棵基础决策树是基于前一棵树的分类结果对样本点设置不同的权重，如果在前一棵基础决策树中将某样本点预测错误，就会增大该样本点的权重。
基于以上，有三个问题要解决，
样本点的权重$w_{mi}$的确定，
基础决策树$f(x)$的选择，
每一棵基础决策树对应的权重${\alpha }_m$的计算。
对于分类问题，提升树的损失函数会使用指数损失函数；
对应预测问题，通常会选择平方损失函数。
$$\begin{array}{rl}L(y,F(x))& =exp(-yF(x))\\ & =exp(-y\sum _{m=1}^M{\alpha }_m{f}_m(x))\\ & =exp(-y(F_{m-1}(x)-{\alpha }_m{f}_m(x))\end{array}$$

如果将所有训练样本点代入损失函数中，一定存在一个最佳的${\alpha }_m$和$f_m(x)$，使得损失函数尽量最大化降低。
$$({\alpha }_m,f_m(x))=argmi{n}_{\alpha ,f(x)}\sum _{i=1}^{N}exp(-y_i(F_{m-1}(x_i)+{\alpha }_m{f}_m(x_i)))$$
可以改写为：
$$({\alpha }_m,f_m(x))=argmi{n}_{\alpha ,f(x)}\sum _{i=1}^N{p}_{mi}exp(-y_i{\alpha }_m{f}_m(x_i))$$
想要求得损失函数的最小值，首先要找到最佳的$f_m(x)$,使得所有训练样本点xi带入$f_m(x)$后误判结果越少越好，最佳的$f_m(x)$可以表示为：
$$f_m(x{)}^{\ast }=argmi{n}_f\sum _{i=1}^N{p}_{mi}I(y_i\ne f_m(x))$$
下一步求解损失函数中的${\alpha }_m$，为了求解方便，先将损失函数改写，
$$\begin{array}{rl}L(y,F(x)& =exp(-y(F_{m-1}(x)+{\alpha }_m{f}_m(x))\\ & =\sum _{i=1}^N{p}_{mi}exp(-y_i{\alpha }_m{f}_m(x_i))\\ & =\sum _{y_i=f_m(x_i)}{p}_{mi}exp(-{\alpha }_m)+\sum _{y_i=f_m(x_i)}{p}_{mi}exp({\alpha }_m)\\ & =\sum _{y_i=f_m(x_i)}{p}_{mi}exp(-{\alpha }_m)+\sum _{y_i\ne f_m(x_i)}{p}_{mi}exp(-{\alpha }_m)-\sum _{y_i\ne f_m(x_i)}{p}_{mi}exp(-{\alpha }_m)+\sum _{y_i=f_m(x_i)}{p}_{mi}exp({\alpha }_m)\\ & =(exp({\alpha }_m)-exp(-{\alpha }_m))\sum _{i=1}^N{p}_{mi}I(y_i\ne f_m(x))+exp(-{\alpha }_m)\sum _{i=1}^N{p}_{mi}\end{array}$$
基于上述的损失函数求解最佳${\alpha }_m$，能够使损失函数取得最小值。
$$\frac{dL(y,F(x))}{d{\alpha }_m}=({\alpha }_m{e}^{{\alpha }_m}+{\alpha }_m{e}^{-{\alpha }_m})\sum _{i=1}^N{p}_{mi}I(y_i\ne f_m(x))-{\alpha }_m{e}^{-{\alpha }_m}\sum _{i=1}^N{p}_{mi}$$
令倒数函数为0，求得，其中$e_m$是错误率，
$${\alpha }_m^{\ast }=0.5log\frac{1-e_m}{e_m}$$
在求得第m轮基础决策树$f_m(x)$以及对应的权重${\alpha }_m$后，便可得到经m次迭代后的提升树$F_m(x)=F_{m-1}(x)+{\alpha }_m^{\ast }{f}_m(x_i{)}^{\ast }$，再根据$p_{mi}=exp[-y_i{F}_{m-1}(x_i)]$，进而可以计算得到第m+1轮基础决策树中样本点的权重$w_{mi}$:
$$w_{m+1,i}=w_{mi}exp[-y_i{\alpha }_m^{\ast }{f}_m(x_i{)}^{\ast }]$$
为了使样本权重单位化，需要将每一个$w_{m+i,i}$与所有样本点的权重和商做处理，即：
$$w_{m+1,i}=\frac{w_{mi}exp(y_i{\alpha }_m^{\ast }{f}_m(x_i{)}^{\ast })}{{\sum }_{i=1}^N{w}_{mi}exp(y_i{\alpha }_m^{\ast }{f}_m(x_i{)}^{\ast })}$$
至此，我们得到了三个问题的解，样本点的权重$w_{mi}$，基础决策树$f(x)$，每一棵基础决策树对应的权重${\alpha }_m$。

在python中的调用

from sklearn.ensemble import AdaBoostClassifier
AdaBoostClassifier(base_estimator=None,n_estimator=50,learning_rate=1.0,algorithm='SAMME.R',random_state=None)

from sklearn.ensemble import AdaBoostRegressor
AdaBoostRegressor(base_estimator=None,n_estimator=50,learning_rate=1.0,algorithm='linear',random_state=None)

#best_estimator:指定提升算法应用的基础分类器，默认为分类决策树(CART)
#n_estimator:指定基础分类器的数量，默认为50个
#learning_rate:指定的学习步长，默认为1.0
#algorithm:指定分类器的算法
#loss:指定损失函数，linear,square,exponential,默认是linear

梯度提升树算法 GBDT

原始的提升算法中，如果损失函数为平方损失或指数损失，求解损失函数的最小值问题会非常简单，当损失函数为更一般的函数，如绝对值损失或Huber损失函数，目标值的求解就会复杂很多。Friedman提出了梯度提升算法，即在m轮基础模型中，利用损失函数的负梯度近似值作为该轮基础模型损失值的近似，并利用这个近似值构建下一轮基础模型。

GBDT(Gradient Boosting Decision Tree，梯度提升树)是一种有监督的集成算法，同样可以用于分类问题的识别和预测问题的解决。拥有三方面的优势，分别是提升Boosting，梯度Gradient和决策树Decision Tree。
“提升”，将多个弱分类器通过线下组合实现强分类器的过程；
“梯度”，算法在Boosting的过程中求解损失函数增强了灵活性和便捷性；
“决策树”，算法所使用的弱分类器为CART决策树。

在python中的调用

from sklearn.ensemble import GradientBoostingClassifier
from sklearn.ensemble import GradientBoostingRegressor
GradientBoostingClassifier(loss='deviance',learning_rate=0.1,n_eatimator=100,subsample=1.0,criterion='friedman_mse',min_sample_split=2,min_sample_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')
GradientBoostingRegressor(loss='ls',learning_rate=0.1,n_eatimator=100,subsample=1.0,criterion='friedman_mse',min_sample_split=2,min_sample_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')

#loss:指定损失函数，对于分类的，可以选择deviance对数似然损失或exponential指数损失函数；对于预测的，可以选择ls平方损失函数或lad绝对值损失函数或huber损失函数或quantile平方损失函数
#subsample:指定基础模型所使用的的抽样比例

XGBoost算法

GBDT模型求解最优化问题应用了一阶导，XGBoost使用一阶和二阶导，而且可以自定义损失函数。还支持并行计算，可以加入正则防止过拟合，支持CART基础模型和线性基础模型，可以对字段进行抽样防止过拟合且减少计算量。

XGBoost的损失函数

提升算法的核心思想就是多个基础模型的线性组合，对于一棵含有t个基础模型的集成树来说可以表示为：
$${\hat{y}}_l^{(t)}=\sum _{k=1}^t{f}_k(x_i)={\hat{y}}_l^{(t-1)}+f_t(x_i)$$
${\hat{y}}_l^{(t)}$，经过t轮迭代后的模型预测值，
${\hat{y}}_l^{(t-1)}$，已知t-1个基础模型的预测值，
$f_t(x_i)$，第t个基础模型，
关键点在于寻找一个能够使目标函数尽可能最大化降低的$f_t$即可，构造目标函数，
$$\begin{array}{rl}Ob{j}^{(t)}& =\sum _{i=1}^{n}L(y_i,{\hat{y}}_l^{(t)})+\sum _{j=1}^t\Omega (f_i)\\ & =\sum _{i=1}^{n}L(y_i,{\hat{y}}_l^{(t-1)}+f_t(x_i))+\sum _{j=1}^t\Omega (f_i)\end{array}$$
$\Omega (f_i)$，第j个基础模型的正则项。为了简单起见，将损失函数表示为平方损失，
$$\begin{array}{rl}Ob{j}^{(t)}& =\sum _{i=1}^n(y_i-({\hat{y}}^{(t-1)}+f_t(x_i)){)}^2+\sum _{j=1}^t\Omega (f_i)\\ & =\sum _{i=1}^n(2f_t(x_i)({\hat{y}}_l^{(t-1)}-y_i)+f_t(x_i{)}^2+(y_i-{\hat{y}}_l^{(t-1)}{)}^2)+\sum _{j=1}^t\Omega (f_i)\end{array}$$
前t-1基础模型已知，${\hat{y}}_l^{(t-1)}$已知，前t-1个基础模型的复杂度也是一致，将已知项设为常数constant，
$$Ob{j}^{(t)}=\sum _{i=1}^n(2f_t(x_i)({\hat{y}}_l^{(t-1)}-y_i)+f_t(x_i{)}^2)+\sum _{j=1}^t\Omega (f_i)+constant$$
$({\hat{y}}_l^{(t-1)}-y_i)$是前t-1个基础模型所产生的的残差。
根据泰勒展开式：
$$f(x+△x)\approx f(x)+f(x{)}^{\prime }△x+f(x{)}^{\prime \prime }△x^2$$
假设令损失函数$L$为泰勒函数中的$f$，令损失函数${\hat{y}}_l^{(t-1)}$为泰勒公式中的$x$，$f_t(x_i)$为泰勒公式中的$△x$，目标函数近似表示为：
$$\begin{array}{rl}Ob{j}^{(t)}& =\sum _{i=1}^{n}L(y_i,{\hat{y}}_l^{(t-1)}+f_t(x_i))+\Omega (f_t)\\ & \approx \sum _{i=1}^n(L(y_i,{\hat{y}}_l^{(t-1)})+g_i{f}_t(x_i)+0.5h_i{f}_t(x_i{)}^2)+\Omega (f_t)+constant\end{array}$$
$g_i$和$h_i$分别是损失函数关于${\hat{y}}_l^{(t-1)}$的一阶导函数值和二阶导函数值。

损失函数的演变
假设基础函数模型$f_t$由CART树构成，对于一棵树来说，可以被拆分为结构部分$q$，叶子节点所对应的输出值$w$。利用这两部分反映树的复杂度，
$$\Omega (f_t)=\gamma T+0.5\lambda \sum _{j=1}^T{w}_j^2$$
$T$，叶子节点的个数，
$w_j^2$，输出向量的平方，
CART树生长越复杂，对应的$T$越大，$\Omega (f_t)$越大。
$$\begin{array}{rl}Ob{j}^{(t)}& \approx \sum _{i=1}^n(L(y_i,{\hat{y}}_l^{(t-1)})+g_i{f}_t(x_i)+0.5h_i{f}_t(x_i{)}^2)+\Omega (f_t)+constant\\ & \approx \sum _{i=1}^n(g_i{f}_t(x_i)+0.5h_i{f}_t(x_i{)}^2)+\gamma T+0.5\lambda \sum _{j=1}^T{w}_j^2+constant\\ & \approx \sum _{i=1}^n(g_i{w}_q(x_i)+0.5h_i{w}_q(x_i{)}^2)+\gamma T+0.5\lambda \sum _{j=1}^T{w}_j^2+constant\\ & \approx \sum _{j=1}^T((\sum _{i\in I_j}{g}_i)w_j+0.5(\sum _{i\in I_j}{h}_i)w_j^2)+\gamma T+0.5\lambda \sum _{j=1}^T{w}_j^2+constant\\ & \approx \sum _{j=1}^T((\sum _{i\in I_j}{g}_i)w_j+0.5(\sum _{i\in I_j}{h}_i+\lambda )w_j^2)+\gamma T+constant\\ & \approx \sum _{j=1}^T((\sum _{i\in I_j}{g}_i)w_j+0.5(\sum _{i\in I_j}{h}_i+\lambda )w_j^2)+\gamma T\\ & \approx \sum _{j=1}^T(G_j{w}_j+0.5(h_j+\lambda )w_j^2)+\gamma T\end{array}$$
$w_{q(x_i)}$，第i个样本点的输入值$x_i$所对应的输出值，
$i\in I_j$，每个叶节点$j$中所包含的样本集合，
$G_j={\sum }_{i\in I_j}{g}_i$，属于叶子节点$j$的样本点对应的$g_i$之和，
$H_j={\sum }_{i\in I_j}{h}_i$，属于叶子节点$j$的样本点对应的$h_i$之和，
最终是寻找一个合理的$f_t$，使得式子尽可能的小。
由于构建XGBoost模型之前需要指定某个损失函数$L$如平方损失，指数损失，Huber损失等，进而某种树结构$q$下的$G_j$和$H_j$是已知的。要想$Ob{j}^{(t)}$的最小化，需要对方程中的$w_j$(每个叶子节点的输出值)求偏导，并令导数为0，
$$\frac{dOb{j}^{(t)}}{d{w}_j}=G_j+(H_j+\lambda )w_j=0$$
$$w_j=-\frac{G_j}{H_j+\lambda }$$
$$\begin{array}{rl}J(f_t))& =\sum _{j=1}^T(G_j{w}_j+0.5(h_j+\lambda )w_j^2)+\gamma T\\ & =-0.5\sum _{j=1}^T(\frac{G_j^2}{H_j+\lambda })+\gamma T\end{array}$$
目前的问题是，树结构$q$该如何选择，即最佳的树结构$q$就对应了最佳的基础模型$f_t$。最笨的方法是测试不同分割字段和分割点下的树结构$q$，并计算出所对应的$J(f_t)$值，从而挑选出使得$J(f_t)$达到最小的树结构。这种枚举计算量很大，通常选择贪心算法，即在某个已有的可划分节点中加入一个分割，并通过计算分割前后的增益值决定是否剪枝，增益计算如下，
$$Gain=0.5(\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$$
$G_L$和$H_L$为某节点分割后对应的左支样本点的导函数，$G_R$和$H_R$为某节点分割后对应的右支样本点的导函数。这里的增益量就是某节点分割为另外两个节点后对应的目标值$J(f_t)$的减少量。
实际应用中，根据某个给定的增益阈值，对树的生长进行剪枝，当节点分割后产生的增益小于阈值时，减掉该分割，否则允许分割。
在python中调用

from xgboosting import XGBClassifier
from xgboosting import XGBRegressor

XGBClassifier(max_septh=3,learning_rate=0.1,n_estimator=100,silent=True,objective='binary:logistic',booster='gbtree',n_jobs=1,nthread=None,gamma=0,min_child_weight=1,max_delta_step=0,subsample=1,colsample_bytree=1,colsample_bylevel=1,reg_alpha=0,reg_lambda=1,scale_pos_weight=1,base_score=0.1,random_state=0,seed=None,missing=None)

XGBRegressor(max_septh=3,learning_rate=0.1,n_estimator=100,silent=True,objective='reg"linear',booster='gbtree',n_jobs=1,nthread=None,gamma=0,min_child_weight=1,max_delta_step=0,subsample=1,colsample_bytree=1,colsample_bylevel=1,reg_alpha=0,reg_lambda=1,scale_pos_weight=1,base_score=0.1,random_state=0,seed=None,missing=None)

#objective:目标函数中的损失函数类型，对于分类型，默认为二分类的logistic损失，也可以是'multi:softmax',表示多分类的损失函数，还可以是'multi:softprob';对于预测型，默认为线性回归损失
#booster:指定基础模型的类型，默认为'gbtree'，即CART模型，也可以是'gblinear'，即线性模型
#gamma:节点分割所需的最小损失函数下降值，即增益值Gain的阈值，默认为0