【机器学习】一文理解集成学习Boosting思想之GBDT、XGBoost，附带案例

前言

AdaBoost

前面我们介绍了使用 Boosting 思想的 AdaBoost ，它是通过前一轮决策的结果来给样本设置权重，决策正确的权重减小，决策错误的权重增加；然后将加权后的数据集输入下一个弱学习器训练，直到达到训练停止条件。

Boosting 思想的GBDT、XGBoost，在目前的竞赛和工业界中使用非常频繁，能够有效的应用到分类、回归，更是因为近几年被应用于构建搜索排序的机器学习模型而引起广泛关注。虽然用起来不难，但是要想完整理解它的原理及推导不是那么容易，本篇尽可能通过简单的方式来介绍。

本篇代码可见：Github

一、提升树模型

在介绍 GBDT 前，我们先来理解何为提升树：

提升树是以决策树为基本分类器（弱分类器）的提升方法，提升树被认为是模型性能最好的方法之一。

• 对于分类问题决策树为二叉分类树；
• 对于回归问题决策树为二叉回归树。

提升树模型可以表示为决策树的加法模型：

$$f_M(x)=\sum _{m=1}^{M}T(x;{\Theta }_m)$$

其中，$T(x;{\Theta }_m)$表示决策树；${\Theta }_m$表示决策树的参数；$M$表示数的个数

1、提升树算法

由于提升树是树的线性组合，而树的线性组合可以很好地拟合训练数据，即使数据中的输入和输出之间的关系很复杂也是如此，所以提升树是一个高功能的学习算法。

提升树学习算法的主要区别在于使用的损失函数不同：

• 平方误差损失函数的回归问题；
• 指数损失函数的分类问题；
• 一般损失函数的一般决策问题。

1. 分类问题

\quad\quad 对于二分类问题，提升树只需要将 AdaBoost 算法中的基本分类器（弱学习器）限定为二分类数即可，可以说这时的提升树是AdaBoost 算法的特殊情况，具体参考 AdaBoost 的介绍来理解。

2. 回归问题

\quad\quad 已知一个训练数据集$T=\{(x_1,y_1),(x_2,y_2),...,(x_N,y_N)\}$，$x_i\in \mathcal{X}\subseteq R^n$，$\mathcal{X}$为输入空间，$y_i\in \mathcal{Y}\subseteq R$，$\mathcal{Y}$为输出空间。

如果将输入空间划分为 $J$ 个互相不相交的区域 $R_1，R_2，...，R_J$，并且在每个区域上确定输出的常量 $c_j$，那么决策树可表示为：

$$T(x;\Theta )=\sum _{j=1}^J{c}_{j}I(x\in R_j)$$

$I(x\in R_j)$为指示函数，表示 如果$x$ 在分区$R_j$中返回1，否则返回0；$T(x; Θ) $表示每个区域的输出常量的集合
其中，参数 $\Theta =\{(R_1,c_1),(R_2,c_2),...,(R_j,c_j)\}$表示数的区域划分和各区域上的常量；$J$是回归树的复杂度，即叶子节点

回归问题提升树使用以下前向分步算法：
$$f_0(x)=0$$
$$f_m(x)=f_{m-1}(x)+T(x;{\Theta }_m)m=1,2,3,...,M$$
$$f_M(x)=\sum _{m=1}^{M}T(x;{\Theta }_m)$$
在前向分步算法的第m步，给定当前模型$f_{m-1}(x)$，需求解：
$$\widehat{{\Theta }_m}=arg\underset{{\Theta }_m}{\min }\sum _{i=1}^{N}L(y_i,f_{m-1}(x_i)+T(x;{\Theta }_m))$$
得到 $\widehat{{\Theta }_m}$ ，即第m棵树的参数。

其中，$L(y_i,f_{m-1}(x_i)+T(x;{\Theta }_m))$为损失函数，当使用平方误差损失时：
$$L(y,f(x))=(y-f(x){)}^2$$
$y$为真实值，$f(x)$为预测值

则 $\widehat{{\Theta }_m}$中的损失变为：

$$L(y_i,f_{m-1}(x_i)+T(x;{\Theta }_m))$$
$$=[y-(f_{m-1}(x)+T(x;{\Theta }_m){]}^2$$
$$=[r-T(x;{\Theta }_m){]}^2$$

其中，$r=y-f_{m-1}(x)$是当前模型拟合数据的残差

所以对于回归问题的提升树算法来说，只需要简单地拟合当前模型的残差即可。

回归问题的提升树算法:

输入：$T=\{(x_1,y_1),(x_2,y_2),...,(x_N,y_N)\}$，$x_i\in \mathcal{X}\subseteq R^n$，$y_i\in \mathcal{Y}\subseteq R$；
输出：提升树$f_M(x)$
（1）初始化树$f_0(x)=0$
（2）对$m=1,2,...,M$

• （a）计算残差

$$r_{mi}=y_i-f_{m-1}(x_i)i=1,2,...,N$$

• （b）拟合残差 $r_{mi} $ 学习一个回归树，得到$T(x;{\Theta }_m)$
• （c）更新$f_m(x)=f_{m-1}(x)+T(x;{\Theta }_m)$

（3）得到回归提升树：
$$f_M(x)=\sum _{m=1}^{M}T(x;{\Theta }_m)$$

2、实例

通过数据数据进一步理解回归提升树。已知训练数据$x$的取值范围为$[0.5,10.5]$，$y$的取值范围为$[5.0,10.0]$，如下表：

$x_i$	1	2	3	4	5	6	7	8	9	10
$y_i$	5.56	5.70	5.91	6.40	6.80	7.05	8.90	8.70	9.00	9.05

下面就按照上面的回归问题的提升树算法来求：

考虑以下优化问题：
$$\underset{s}{\min }[\underset{c_1}{\min }\sum _{x_i\in R_1}(y_i-c_1{)}^2+\underset{c_2}{\min }\sum _{x_i\in R_2}(y_i-c_2{)}^2]$$
求解训练数据的切分点s：
$$R_1=\{x|x⩽s\}{R}_2=\{x|x>s\}$$
容易求得在$R_1,R_2$内部使平方损失误差达到最小值的$c_1,c_2$为：
$$c_1=\frac{1}{N}\sum _{x_i\in R_1}{y}_i{c}_2=\frac{1}{N}\sum _{x_i\in R_2}{y}_i$$
这里$N_1,N_2$是$R_1,R_2$的样本点数。

第一步：求$T_1(x)$

求训练数据的切分点，根据所给数据，考虑如下切分点：
$$1.5,2.5,3.5,4.5,5.5,6.5,7.5,8.5,9.5$$
对各切分点，不难求出相应的$R_1,R_2,c_1,c_2$及
$$m(s)=\underset{c_1}{\min }\sum _{x_i\in R_1}(y_i-c_1{)}^2+\underset{c_2}{\min }\sum _{x_i\in R_2}(y_i-c_2{)}^2$$

例如，当$s=1.5$时，$R_1=\{1\}，R_2=\{2,3,...,10\}，c_1=5.56，c_2=7.50$
$$m(s)=\underset{c_1}{\min }\sum _{x_i\in R_1}(y_i-c_1{)}^2+\underset{c_2}{\min }\sum _{x_i\in R_2}(y_i-c_2{)}^2=0+15.72=15.72$$

计算所有切分点$s$的$m(s)$，如下表：

s	1.5	2.5	3.5	4.5	5.5	6.5	7.5	8.5	9.5
$m(s)$	15.72	12.07	8.36	5.78	3.91	1.93	8.01	11.73	15.74

由上表可知，当$s=6.5$时$m(s)$达到最小值，此时$R_1=\{1,2,3,4,5,6\}，R_2=\{7,8,9,10\}，c_1=6.24，c_2=8.91$，所以回归树$T_1(x)$为：
$$T_1(x)=\{\begin{array}{l}6.24,x<6.5\\ 8.91,x⩾6.5\end{array}$$
$$f_1(x)=T_1(x)$$

用 $f_1(x)$ 拟合训练数据的残差如下表，$r_{2i}=y_i-f_1(x_i),i=1,2,...,10$

$x_i$	1	2	3	4	5	6	7	8	9	10
$r_{2i}$	-0.68	-0.54	-0.33	0.16	0.56	0.81	-0.01	-0.21	0.09	0.14

用 $f_1(x)$ 拟合训练数据的平方损失误差：
$$L(y,f_1(x))=\sum _{i=1}^{10}(y_i-f_1(x_i){)}^2=1.93$$

第二步：求$T_2(x)$

方法与第一步一样，只是拟合的数据从原数据变为残差数据，可以得到：
$$T_2(x)=\{\begin{array}{l}-0.52,x<3.5\\ 0.22,x⩾3.5\end{array}$$
$$f_2(x)=f_1(x)+T_2(x)=\{\begin{array}{l}5.72,x<3.5\\ 6.46,3.5⩽x<6.5\\ 9.13,x⩾6.5\end{array}$$

用 $f_2(x)$ 拟合训练数据的平方损失误差：
$$L(y,f_2(x))=\sum _{i=1}^{10}(y_i-f_2(x_i){)}^2=0.79$$

重复以上步骤，求得：

$$T_3(x)=\{\begin{array}{l}0.15,x<6.5\\ -0.22,x⩾6.5\end{array}$$
$$L(y,f_3(x))=0.47$$


$$T_4(x)=\{\begin{array}{l}-0.16,x<4.5\\ 0.11,x⩾4.5\end{array}$$
$$L(y,f_4(x))=0.30$$


$$T_5(x)=\{\begin{array}{l}0.07,x<6.5\\ -0.11,x⩾6.5\end{array}$$
$$L(y,f_5(x))=0.23$$


$$T_6(x)=\{\begin{array}{l}-0.15,x<2.5\\ 0.04,x⩾2.5\end{array}$$
$$f_6(x)=f_5(x)+T_6(x)=T_1(x)+T_2(x)+T_3(x)+T_4(x)+T_5(x)+T_6(x)$$
$$f_6(x)=\{\begin{array}{l}5.63,x<2.5\\ 5.82,2.5⩽x<3.5\\ 6.56,3.5⩽x<4.5\\ 6.83,4.5⩽x<6.5\\ 8.95,x⩾6.5\end{array}$$
$$L(y,f_3(x))=0.17$$

假设此时已经满足误差要求，那么 $f(x)=f_6(x)$ 即为所求提升树。

二、GBDT(Gradient Boosting Decison Tree)（梯度提升迭代决策树）

别名：GBT(Gradient Boosting Tree)、GTB(Gradient Tree Boosting)、GBRT(Gradient Boosting Regression Tree)、MART(Multiple Additive Regression Tree)

1、 GBDT 与 AdaBoost 的区别：

• AdaBoost算法是利用前一轮的弱学习器的误差来更新样本权重值，然后一轮一轮的迭代；
• GBDT也是迭代，但是GBDT要求弱学习器必须是CART模型，而且GBDT在模型训练的时候，是要求模型预测的样本损失尽可能的小。

2、直观理解

• 如图，此过程便是上面提到的提升树。假设我们有训练集 $(x_1,x_2,x_3,30)$ ，x为特征，30为年龄；
• 第一次训练的弱分类器预测为20，然后我们用真实值-第一个弱分类器的预测值=残差，作为第二个弱分类器的训练数据 $(x_1,x_2,x_3,10)$
• 第二次训练的弱分类器预测为6，同样计算残差作为第三个弱分类器的训练数据，$(x_1,x_2,x_3,4)$
• 第三次训练的弱分类器预测为4，同样计算残差作为第四个弱分类器的训练数据，$(x_1,x_2,x_3,1)$
• 第四次训练的弱分类器预测为1，此时残差为0，训练结束

假设有个新的待预测数据，按构建子树的顺序进行预测，然后将每个子树的预测结果累加便是预测结果。

3、简单实例

假设训练集如下：

样本编号	购物金额	上网时长	上网时段	对百度知道的使用方式	年龄
A	0.5k	0.5h	晚上上网	提问	14
B	0.8k	1.5h	晚上上网	回答	16
C	1.5k	3.0h	全天上网	提问	24
D	2.0k	3.0h	晚上上网	回答	26

1. 如果按传统的决策树构建，可如下图：

对于训练集，此决策树的准确率为100%；
我们知道在构建决策树的时候，为了尽可能正确分类训练样本，节点划分过程不断重复，有时候就会导致决策树节点过多，造成模型过拟合；

• 假设待预测数据为：购物金额0.5k，上网时长1.5h，晚上上网，提问，14岁
• 传统决策树会预测为16岁

2. 如果使用GBDT来训练

由于数据比较少，我们限定2棵子树，每个子树深度为1，训练结果如下图：

图中，上面一棵树还是按有收入是否划分，下面一棵树以前面一个数的残差作为训练样本，当新的预测值与残差相等（也就第二次计算的残差中为0的），则只需把第二棵树的结论累加到第一棵树上就能得到真实年龄；第二棵树的残差都为0，说明所有样本都正确预测了

• A：0.5k；0.5h；晚上上网；提问；预测年龄：(-1)+15=14
• B：0.8k；1.5h；晚上上网；回答；预测年龄：1+15=16
• C：1.5k；3.0h；全天上网；提问；预测年龄：(-1)+25=24
• D：2.0k；3.0h；晚上上网；回答；预测年龄：1+25=26

其实，我们发现两个方法的准确率都是100%，那么为什么要用GBDT呢？

原因就是，传统的决策树容易过拟合，假设有个新数据待预测：购物金额0.5k，上网时长1.5h，晚上上网，提问，14岁；

• 传统决策树预测结果为16岁；
• GBDT 预测为：(-1)+15=14岁；

现在，我们回头来看看上图，由20变为0，变化比较大，容易造成过拟合；
可以给定步长 step，在构建下一棵树的时候使用step * 残差值作为输入，这样可以避免过拟合。

三、GBDT 算法推导

GBDT由三部分构成：DT(Regression Decistion Tree)、GB(Gradient Boosting)和Shrinkage(衰减)

1、DT(Regression Decistion Tree)——回归决策树

GBDT 中的决策树都是回归树，不是分类树:

• 回归树：用于预测实数值，比如温度、年龄等；
• 分类树：用于分类标签，比如：性别、晴天/阴天、是否等；

我们知道GBDT的思想使用了集成学习，也就是将每棵决策树（弱学习器）的结果累加，得到最终结果：

• 如果我们将每棵回归树的预测结果相加，比如年龄：20岁+6岁+3岁+1岁=30岁 是有意的；
• 但是如果我们将分类树的预测结果相加，比如性别：男+女 = ？ 显然无意义。

因此 GBDT 中决策树只能回归树。

2、GB(Gradient Boosting)——梯度提升

\quad\quad 本篇一开始介绍了提升树利用加法模型与前向分步算法实现学习的优化过程。提升树使用平方误差损失和指数损失函数时，每一步优化都可以如上面的步骤简单实现。但是对于一般损失函数而言，往往每一步优化并不那么容易，针对这个问题，Freidman提出了梯度提升算法，这是利用最速下降法的近似方法，其关键是利用损失函数的负梯度在当前模型的值。

假设 $F(X)$ 是一组最优基函数$f_i(X)$的线性组合：
$$F(X)=\sum _{i=0}^M{f}_i(X)$$
损失函数为：
$$loss=L(y,F(X))$$
最优解为：
$$F^{\ast }(X)=arg\underset{F}{\min }L(y,F(X))$$

（1）假设第m-1轮强学习器为：
$$F_{m-1}(X)=\sum _{i=1}^{m-1}{f}_i(X)$$
损失函数为：
$$loss=L(y,F_{m-1}(X))$$
（2）第m轮强学习器为：
$$F_m(X)=\sum _{i=1}^m{f}_i(X)=F_{m-1}(X)+f_m(X)$$

损失函数为：
$$loss=L(y,(F_{m-1}(X)+f_m(X)))$$

（3）求解本轮的最优$F_m^{\ast }(X)$
$$F_m^{\ast }(X)=F_{m-1}(X)+L(y,(F_{m-1}(X)+f_m(X)))$$
$$=F_{m-1}(X)+arg\underset{f}{\min }\sum _{i=1}^{n}L(y_i,(F_{m-1}(x_i)+f_m(x_i)\left)\right)$$

其中，$n$ 为样本数

以上在每次选择最优基函数$f_m(X)$时比较困难，可以使用梯度下降的方法近似计算：

给定常数$f_0(X)=F_0(X)$：
$$f_0(X)=F_0(X)=arg\underset{c}{\min }\sum _{i=1}^{n}L(y_i,c)$$
根据梯度下降计算学习率：
$${\alpha }_{im}=[\frac{\partial L(y_i,F(x_i))}{\partial F(x_i)}{]}_{F(x_i)=F_{m-1}(x_i)}$$
使用数据$(x_i,{\alpha }_{im}),i=1,2,...,n$计算拟合残差找到一个CART回归树，得到第m棵树：
$$c_{mj}=arg\underset{c}{\min }\sum _{x_i\in lea{f}_j}L(y_i,(f_{m-1}(x_i)+c\left)\right)$$
$$h_m(x)=\sum _{j=1}^{|leaf{|}_m}{c}_{mj}I(x\in lea{f}_{mj})$$
更新模型：
$$F_m(X)=F_{m-1}(X)+\sum _{j=1}^{|leaf{|}_m}{c}_{mj}I(x\in lea{f}_{mj})$$
$$F(X)=f_0(X)+\sum _{m=1}^M\sum _{j=1}^{|leaf{|}_m}{c}_{mj}I(x\in lea{f}_{mj})$$

训练弱学习器：$h_t(x)$使：
$$f_{t-1}(x)\to f_t(x)$$
$$L(y,f_{t-1}(x))\to L(y,(f_{t-1}(x)+h_t(x)\left)\right)$$

3、Shrinkage(衰减)

• 基本思想就是：

\quad\quad 每次走一小步逐渐逼近结果的效果，要比每次迈一大步很快逼近结果的方式更容易避免过拟合。换句话说缩减思想不完全信任每一个棵残差树，它认为每棵树只学到了真理的一小部分，累加的时候只累加一小部分，只有通过多学几棵树才能弥补不足。

Shrinkage仍然以残差作为学习目标，但由于它采用的是逐步逼近目标的方式，导致各个树的残差是渐变的而不是陡变的。之所以这样做也是基于模型过拟合的考虑。

四、GBDT 案例

sklearn 库 ensemble.GradientBoostingRegressor 类API：

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_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’, validation_fraction=0.1, n_iter_no_change=None, tol=0.0001)

常用参数说明：

参数	描述
loss： {‘ls’，‘lad’，‘huber’，‘quantile’}，可选（默认值=‘ls’）	损失函数。'ls’指的是最小二乘回归；‘lad’（最小绝对偏差）是一种高度鲁棒的损失函数，仅基于输入变量的顺序信息；'huber’是两者的结合；'quantile’允许分位数回归（使用alpha来指定分位数）。
learning_rate ： float，optional（默认值= 0.1）	学习率通过learning_rate缩小每棵树的贡献。在learning_rate和n_estimators之间进行权衡。
n_estimators ： int（默认值= 100）	决策树数目，较大数目通常会产生更好的性能
max_depth ： int，optional（默认= 3）	每个决策树的深度
alpha ： float（默认值= 0.9）	huber损失函数和分位数损失函数的α分位数。只有当loss='huber’或loss=‘quantile’

其他参数，有些在之前都有遇到过，也可参考官方文档

1、GBDT 集成线性回归

本案例使用波士顿房屋租赁数据实现线性回归和GBDT预测，并对结果进行比较：

线性回归结果：
训练集上R^2:0.77301
测试集上R^2:0.58922
GBDT结果：
训练集上R^2:0.76730
测试集上R^2:0.64739

可以发现，在测试集上效果有所提升

代码可见：07_GBDT.py

五、XGBoost

1、简介

XGBoost 是 GBDT 的升级版，前面介绍到，GBDT 是一种基于 Boosting 集成思想的学习器，并采用梯度提升的方法进行每一轮的迭代最终组合出强学习器，这样的话算法的运行往往要生成一定数量的树才能达到令我们满意的准确率。当数据集大且较为复杂时，运行一次极有可能需要几千次的迭代运算，这将对我们使用算法造成巨大的计算瓶颈。

针对这一问题，华盛顿大学的陈天奇博士开发出了 XGBoost ，XGBoost 最大的特点在于它能够自动利用CPU的多线程进行并行计算，同时在算法上加以改进，极大地提升了模型训练速度和预测精度。

2、目标函数

在 XGBoost 算法中，目标函数的形式为：
$$Obj(\theta )=L(\theta )+\Omega (\Theta )$$

其中，$L(\theta )$为损失函数，常用损失函数有：

• 平方损失：$L(\theta )={\sum }_i(y_i-{\hat{y}}_i{)}^2$
• Logistic损失：$L(\theta )={\sum }_i[y_{i}ln(1+e^{-\widehat{y_i}})+(1-y_i)ln(1+e^{{\hat{y}}_i})]$

$\Omega (\Theta )$：正则化项

• 引入正则化项是因为我们的目标是希望生成的模型的泛化性能比较好，能够很好的预测新数据，而不是简单的拟合训练集的结果（这样会导致过拟合）；
• 需要在保证模型“简单”的基础上最小化训练误差，这样得到的参数才具有好的泛化性能；
• 正则项就是用于惩罚复杂模型，避免预测模型过分拟合训练数据，常用的正则有 $L_1$ 正则与 $L_2$ 正则。

已知目标函数：
$$Obj(\theta )=L(\theta )+\Omega (\Theta )$$

• 如果目标函数中的损失函数权重过高，那么模型的预测精度则不尽人意；
• 反之如果正则项的权重过高，所生成的模型则会出现过拟合情况，难以对新的数据集做出有效预测；
• 只有平衡好两者之间的关系，控制好模型复杂度，并在此基础上对参数进行求解，生成的模型才会“简单有效”。

3、XGBoost 推导过程

假设某次迭代后集成的模型表示为：
$$\widehat{y_i}=\sum _{k=1}^K{f}_k(X)，f_k\in F$$
其中，$\widehat{y_i}$也就是前文的$f_m(X)$
相对应的目标函数：
$$Obj=\sum _i^{n}L(y_i,\widehat{y_i})+\sum _{k=1}^K\Omega (f_k)$$

接下来，我们按之前介绍GBDT的方式来介绍

这里先给出一些数据，以便接下来使用；假设有如下数据，判断谁愿意去玩游戏：

编号	是否玩电脑	性别	年龄
A	是	男	12
B	否	女	14
C	是	男	25
D	否	女	26
E	否	女	27

图中权重表示该人愿意去玩游戏的得分，得分越大越愿意；得分为负，表示不愿意
最终A的得分为2.9，B的得分为-0.8，C的得分为-0.1，D的得分为-1.9，E的得分为-1.9；

1. 目标函数构建

（1）第 $t-1$ 轮的模型可表示为：
$${\widehat{y_i}}^{(t-1)}=\sum _{k=1}^{t-1}{f}_k(X)$$
损失函数为：
$$Ob{j}^{(t-1)}=\sum _i^{n}L(y_i,{\widehat{y_i}}^{(t-1)})+\sum _{k=1}^{t-1}\Omega (f_k)$$
（2）第 $t$ 轮的模型可表示为：
$${\widehat{y_i}}^{(t)}=\sum _{k=1}^t{f}_k(X)={\widehat{y_i}}^{(t-1)}+f_t(X)$$
目标函数为：
$$Ob{j}^{(t)}=\sum _i^{n}L(y_i,({\widehat{y_i}}^{(t-1)}+f_t(X)\left)\right)+\sum _{k=1}^t\Omega (f_t)$$
$$=\sum _i^{n}L(y_i,({\widehat{y_i}}^{(t-1)}+f_t(X)\left)\right)+\Omega (f_t)+constant$$

（3）考虑使用平方误差作为损失函数，目标函数可写为：
$$Ob{j}^{(t)}=\sum _i^n(y_i-({\widehat{y_i}}^{(t-1)}+f_t(x_i)){)}^2+\Omega (f_t)+constant$$
$$=\sum _i^n\left[2y_i\right({\widehat{y_i}}^{(t-1)}+f_t(x_i))+f_t^2(x_i)]+\Omega (f_t)+constant$$

如果使用其他损失函数，可以采用泰勒展开近似来定义一个近似的目标函数，方便我们进行进一步的计算
泰勒展开：$f(x+\Delta x)\approx f(x)+f^{\prime }(x)\Delta x+\frac{1}{2}{f}^{\prime \prime }(x){\Delta }^{2}x$

（4）按泰勒展开目标函数又可写为：
$$Ob{j}^{(t)}=\sum _{i=1}^n[L(y_i,{\widehat{y_i}}^{(t-1)})+g_i{f}_t(x_i)+\frac{1}{2}{h}_i{f}_t^2(x_i)]+\Omega (f_t)+constant$$

其中，
$$g_i=\frac{\partial L(y_i,{\widehat{y_i}}^{(t-1)})}{\partial {\widehat{y_i}}^{(t-1)}}$$
$$h_i=\frac{{\partial }^{2}L(y_i,{\widehat{y_i}}^{(t-1)})}{\partial {\widehat{y_i}}^{(t-1)}}$$

（5）移除常数项目标函数写为：

$$Ob{j}^{(t)}=\sum _{i=1}^n[g_i{f}_t(x_i)+\frac{1}{2}{h}_i{f}_t^2(x_i)]+\Omega (f_t)$$

2. 定义$\Omega (f)$

$$\Omega (f)=\gamma T+\frac{1}{2}\lambda \sum _{j=1}^T{w}_j^2$$

上式包含了一棵树里面节点的个数（左侧），以及每个树叶子节点上面输出分数的 $L_2$ 模平方（右侧）

• $T$ ：叶子的个数
• $w$：叶子节点的权重
• $\gamma$ 作为叶子节点的系数，使 XGBoost 在优化目标函数的同时相当于做了预剪枝；
• $\lambda$ 作为 $L_2$ 平方模的系数也是要起到防止过拟合的作用

具体计算如下图：

其中，$\gamma ，\lambda$由人为给定

3. 目标函数最小化

$$Ob{j}^{(t)}\approx \sum _{i=1}^n[g_i{f}_t(x_i)+\frac{1}{2}{h}_i{f}_t^2(x_i)]+\gamma T+\frac{1}{2}\lambda \sum _{j=1}^T{w}_j^2$$
$$f_t(x_i)=w_{q(x)}$$

• 树的结构函数$q$表示把输入x映射到对应叶子节点上
• $w$ 给定了每个叶子节点对应的分数，即权重

因此，目标函数可以写为：
$$Ob{j}^{(t)}\approx \sum _{i=1}^n[g_i{w}_{q(x_i)}+\frac{1}{2}{h}_i{w}_{q(x_i)}^2]+\gamma T+\frac{1}{2}\lambda \sum _{j=1}^T{w}_j^2$$
$$=\sum _{j=1}^T[(\sum _{i\in I_j}{g}_i)w_j+\frac{1}{2}(\sum _{i\in I_j}{h}_i+\lambda )w_j^2]+\gamma T$$

记：$$G_j=\sum _{i\in I_j}{g}_i，H_i=\sum _{i\in I_j}{h}_i$$

上式化简为：
$$Ob{j}^{(t)}=\sum _{j=1}^T[G_j{w}_j+\frac{1}{2}(H_j+\lambda )w_j^2]+\gamma T$$

将上式看作一个一元二次方程求最小值问题（变量为$w_j$），处于对称轴处：
$f(x)=a{x}^2+bx+c，a>0$；最小值为：$f(-\frac{b}{2a})$

故：
$$w_j^{\ast }=-\frac{G_j}{H_j+\lambda }$$
$$Ob{j}^{\ast }=-\frac{1}{2}\sum _{j=1}^T\frac{G_j^2}{H_j+\lambda }+\gamma T$$

• 如果树的结构函数$q$确定了，那么相应的目标函数就能够根据上式计算出来。那么树的生成问题也就转换为找到一个最优的树结构$q$，使得它具有最小的目标函数；
• 计算求得的 $Obj$ 代表了当指定一个树的结构的时候，目标函数上面最多减少多少。所有我们可以把它叫做结构分数

4. 枚举树的结构

\quad\quad 当寻找到最优的树结构时，我们可以不断地枚举不同树的结构，利用这个打分函数来寻找出一个最优结构的树，加入到我们的模型中，然后再重复这样的操作；不过枚举所有树结构这个操作不太可行，在这里 XGBoost 采用了常用的贪心法，即每一次尝试去对已有的叶子加入一个分割。对于一个具体的分割方案，我们可以获得的增益可以由如下公式计算得到：
$$Gain=\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$$

其中：
$$\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$代表加入新叶子节点引入的代价

遍历所有分割，选择变化最大的作为最合适的分割；类似决策树中信息增益的作用；

六、XGBoost 案例

需要先安装依赖：pip install xgboost

官方文档：XGBoost
官方: Github

实现步骤如下：

• 加载数据
• 数据处理
• 划分数据（X,Y）
• 数据分割（训练集和测试集）
• 数据转换（XGBoost将数据转换为XGBoost可用的数据类型）
• XGBoost模型构建（参数构建、模型训练、模型保存）
• XGBoost模型预测
• 加载模型、预测
• 画图、找出最重要的特征
  

代码可见：08_使用XGBoost算法实现波士顿房价预测.py

八、集成学习Stacking思想

\quad\quad 集成学习除了Bagging、Boosting思想，还有Stacking，此处只提一下，不做具体介绍，因为现在基本不使用了。

\quad\quad Stacking是指训练一个模型用于组合(combine)其它模型(基模型/基学习器)的技术。即首先训练出多个不同的模型，然后再以之前训练的各个模型的输出作为输入来新训练一个新的模型，从而得到一个最终的模型。一般情况下使用单层的Logistic回归作为组合模型。

Stacking 跟现在比较火的深度学习很相似，所以现在一般不使用Stacking