机器学习笔记-Gradient Boosted Decision Tree

集成学习系列：

• Blending and Bagging
• Adaptive Boosting
• Decision Tree
• Random Forest
• Gradient Boosted Decision Tree

Gradient Boosted Decision Tree（梯度提升决策树）

上一篇介绍了Random Forest$RandomForest$，该算法利用Bagging$\text{Bagging}$ 中的bootstrap$\text{bootstrap}$ 机制得到不同的Decision Tree$\text{Decision Tree}$ ， 然后将这些Decision Tree$\text{Decision Tree}$ 融合起来。除了基本的Bagging$\text{Bagging}$ 和Decision Tree$\text{Decision Tree}$ 之外，Random Forest$\text{Random Forest}$ 还在decision tree$\text{decision tree}$ 中加入了更多的随机性。有了这些机制之后，我们发现这个算法可以利用OOB$\text{OOB}$ 数据做self validation$\text{self validation}$ ， 进一步结合self validation$\text{self validation}$ 的机制和permutation test$\text{permutation test}$ 的做法我们利用random forest$\text{random forest}$ 来做feature selection$\text{feature selection}$ 。

提升方法(boosting)$(boosting)$ 的代表性算法是AdaBoost$\text{AdaBoost}$。提升树是以分类或者回归树为基本学习器的提升方法。由于树的线性组合可以很好的拟合训练数据，即使数据中的输入和输出之间的关系很复杂也没关系，所以提升树是一个高功能的学习算法。本篇讨论针对不同问题的提升树学习算法。其主要的区别在于使用的损失函数不同，首先介绍使用指数损失的分类问题，此时的提升树算法只需要将Adaboost$\text{Adaboost}$ 算法的弱分类器设置为加了限制的二分类树即可，可以说提升树算法用于分类是Adaboost$\text{Adaboost}$ 的特殊情况。接下来介绍提升树算法损失函数为平方损失时候的回归问题，之后我们会发现对回归问题的提升树算法来说，只需要在每一轮使得弱学习器来简单的拟合当前模型的残差就好了。提升树利用加法模型和前向分步算法实现优化过程，当损失函数为平方损失或者是指数损失时分别为我们上述讨论的回归问题和分类问题。但是对于一般的损失函数而言，每一步的优化并不简单。这样便有了梯度提升算法。其关键是利用损失函数的负梯度在当前模型的值作为回归问题提升树算法中的残差的近似值来进行回归树的拟合。

1 - 提升树模型

1.1 - 提升树用于分类-Adaboost的特殊情况

先再回顾下random forest$\text{random forest}$ 的算法的形式：外层是一个bagging$\text{bagging}$ ， 可以使用bootstrap$\text{bootstrap}$ 的方式来得到不同的gt$g_t$ ，内层是一个加了更多randomness$\text{randomness}$ 的randomized-decision tree$\text{randomized-decision tree}$ 。
再回忆下adaboost$\text{adaboost}$ 算法的步骤：在这个算法中，每一轮每一个样本被赋予一个权重u(t)n$u_n^{(t)}$ ，算法通过最小化被 u(t)n$u_n^{(t)}$ 加权的 Ein$E_{in}$ 来得到gt$g_t$ ，再计算gt$g_t$ 的权重αt${\alpha }_t$ 来融合得到最终的G$G$ 。

我们之前将decision tree$\text{decision tree}$ 搭配bagging$\text{bagging}$ 得到了random forest$\text{random forest}$ ，同样地，我们可以将decision tree$\text{decision tree}$ 搭配adaboost$\text{adaboost}$ 得到boosting tree$\text{boosting tree}$提升树算法。但是现在我们需要面对的一个新的问题是，在算法boosting tree$\text{boosting tree}$ 中， 决策树作为弱学习器是处理不了加权的数据的， 而在adaboost$\text{adaboost}$ 中每一轮的数据都是带有权重的数据， 也就是adaboost$\text{adaboost}$ 中的base algorithm$\text{base algorithm}$ 要能够解决如下的最小化问题：

minimize Euin=1N∑n=1Nun⋅err(yn,h(xn))$$minimize{E}_{in}^u=\frac{1}{N}\sum _{n=1}^N{u}_n\cdot err(y_n,h(x_n))$$

因为decision tree$\text{decision tree}$ 有很多种实现，有很多技巧在里面。所以我们决定将decision tree$\text{decision tree}$ 当做是一个黑盒子，我们不再要求这个黑盒子可以处理加权的数据，而是对加权的数据本身做处理，使之变为不加权的数据然后喂给decision tree$\text{decision tree}$ 。

其实这一点是很容易做到， 权重是从bagging$\text{bagging}$ 中的bootstrap$\text{bootstrap}$ 中得到的，在做bootstrap$\text{bootstrap}$ 的时候，得到了几份(xn,yn)$(x_n,y_n)$ ， 那么(xn,yn)$(x_n,y_n)$ 的权重就是几：(xn,yn)$(x_n,y_n)$ 的权重是3代表抽取到了3份(xn,yn)$(x_n,y_n)$ ，权重是4代表抽取到了4份(xn,yn)$(x_n,y_n)$ ，所以权重就代表了在资料中有几份(xn,yn)$(x_n,y_n)$ 的复制。所以我们就可以根据bootstrap$\text{bootstrap}$ 的计算机制得到的权重u(t)n$u_n^{(t)}$ 先对资料进行抽样，这样就得到了一笔新的大小为N′$N^{\prime }$ 资料D~t${\tilde{D}}_t$ ， 在这笔资料中就隐含了权重的信息。现在看来，在bagging$\text{bagging}$ 中我们是先bootstrap$\text{bootstrap}$ ，通过得到的样本数量获得权重；现在在boosting tree$\text{boosting tree}$ 中，我们利用了这个过程的逆过程，根据权重来得到样本的数量，这样做的目的是为了不改变底层的decision tree$\text{decision tree}$ 算法。

所以在boosting tree$\text{boosting tree}$ 中，我们没有更改decision tree$\text{decision tree}$ 的部分， 没有更改adaptive boosting$\text{adaptive boosting}$ 的部分， 而是在中间的环节按照样本的权重做了一个抽样的过程得到新的资料 D~t${\tilde{D}}_t$ 然后喂给 decision tree$\text{decision tree}$ 。

boosting tree$\text{boosting tree}$ ：
AdaBoost+sampling∝u(t)+DecisionTree(D~t)$AdaBoost+sampling\propto u^{(t)}+DecisionTree({\tilde{D}}_t)$

1.2 - 提升树的一些改进

在adaboost$adaboost$ 中，当得到了一个gt$g_t$ 的时候，我们下一步需要作出的决定是这个gt$g_t$ 该以多大的权重加入到G$G$ 中。这个权重我们记为αt${\alpha }_t$ ， αt${\alpha }_t$ 的计算公式如下：

αt=ln⧫t=ln1−ϵtϵt−−−−−√$${\alpha }_t=ln{⧫}_t=ln\sqrt{\frac{1-{ϵ}_t}{{ϵ}_t}}$$

其中ϵt${ϵ}_t$ 指的是gt$g_t$ 的错误率。

这样可能会出现一个问题：
如果我们用于训练的资料完全是不同的，那么一棵完全长成的决策树的Ein$E_{in}$ 就是0$0$ ， 那么Euin=0$E_{in}^u=0$ ， 那么ϵt=0${ϵ}_t=0$ ，所以αt=∞${\alpha }_t=\mathrm{\infty }$ 。所以在这种情况下，最终只是得到了一棵“最好”的树，这就违背了我们的大主题：aggregation$aggregation$ 。
问题出在哪里呢？因为我们把所有的数据都喂给了算法， 并且算法能得到的是一个完全长成的树。所以如果要解决这个问题的话，有两个方面可以着手：

• 不要把所有的数据都喂给算法；
• 对决策树构造算法做一些限制；

通过这样的技巧我们就可以得到一棵“弱”一点的树。其实我们通过bootstrap$\text{bootstrap}$ 抽样已经做到了不将所有的数据都喂给算法。另外通过采用简单的策略，例如限制决策树的高度也可以得到一棵比较“弱”的树。

所以在实际的应用中，提升树通常是如下的形式：原来的adaboost$\text{adaboost}$ 算法的框架下，根据权重进行采样sampling$\text{sampling}$ ，从而得到隐含有权重意义的数据D~t${\tilde{D}}_t$ ，并且通过这样的采样方式也可以避免得到一棵所谓“最好”的树，然后将D~t${\tilde{D}}_t$ 喂给decision tree$\text{decision tree}$ ，但是decision tree$decisiontree$ 的构造要加一点限制，通常是限制树的高度，也就是利用数据D~t${\tilde{D}}_t$ 构造一棵pruned decision tree$\text{pruned decision tree}$ 。

boosting tree$\text{boosting tree}$ ：
AdaBoost+sampling∝u(t)+pruned Decision Tree(D~t)$AdaBoost+sampling\propto u^{(t)}+prunedDecisionTree({\tilde{D}}_t)$

1.3 - 提升树实例

上面提到在boosting tree$\text{boosting tree}$ 算法中，决策树在构造的时候需要限制树的高度， 得到一些“弱”一点的树， 再和adaboost$\text{adaboost}$ 搭配起来。我们考虑一种极端的情况，如果我们限制树的高度小于等于1，此时的决策树变为决策树桩。那么adaboost$\text{adaboost}$ 和这样的decision tree（height<=1）$\text{decision tree}（height<=1）$ 搭配起来会是什么样子的呢？其实这个时候的boosting tree$\text{boosting tree}$ 就退化为了boosting stump$\text{boosting stump}$ 。

因为针对每一个样本集合，这时decision tree（CART）$decisiontree（CART）$ 需要做的就只是选择一个分支条件 b(x)$b(x)$ 将样本集合划分为两个子树。其划分的依据就是要使得划分之后的数据的不纯度最低：

b(x)=argmindecision stump h(x)∑c=12|Dc with h|⋅impurity(Dc with h)$$b(x)=\underset{decisionstumph(x)}{argmin}\sum _{c=1}^2|D_{c}withh|\cdot impurity(D_{c}withh)$$

这个时候就几乎不会出现ϵ=0$ϵ=0$ 的情况， 那么这个时候也不见得会做抽样，而是直接在decision stump$decisionstump$ 中考虑权重。

所以简单来说，提升树用于分类只是将AdaBoost$\text{AdaBoost}$ 算法框架中的弱分类器限制为二类分类树即可。

2 - 优化视角下的Adaboost

2.1 - Adaboost的指数损失函数

这一小节通过分析得到AdaBoost$\text{AdaBoost}$ 算法的损失函数是实际上是指数损失L=exp(−ys)$L=exp(-ys)$ 。并且可以证明，AdaBoost$\text{AdaBoost}$ 算法是前向分步算法在损失函数为指数函数时的加法模型。

首先我们回忆一下AdaBoost$\text{AdaBoost}$ 中每一个样本的权重的计算公式，u(t+1)n$u_n^{(t+1)}$ 是根据u(t)n$u_n^{(t)}$ 计算得到的。如果该样本划分不正确，那么u(t+1)n=u(t)n⋅⧫t$u_n^{(t+1)}=u_n^{(t)}\cdot {⧫}_t$ ；如果该样本划分正确，那么u(t+1)n=u(t)n/⧫t$u_n^{(t+1)}=u_n^{(t)}/{⧫}_t$ 。我们再来审视一下这个更新规则：样本划分不正确的意思就是：yn≠gt(xn)$y_n\ne g_t(x_n)$ ；样本划分正确的意思就是：yn=gt(xn)$y_n=g_t(x_n)$ 。那么权重u$u$ 的更新规则就变为：

u(t+1)n=u(t)n⋅⧫−yngt(xn)t$$u_n^{(t+1)}=u_n^{(t)}\cdot {⧫}_t^{-y_n{g}_t(x_n)}$$

而αt=ln(⧫t)=ln(1−ϵtϵt−−−−√)${\alpha }_t=ln({⧫}_t)=ln(\sqrt{\frac{1-{ϵ}_t}{{ϵ}_t}})$ ，所以⧫t=eαt${⧫}_t=e^{{\alpha }_t}$
更新规则进一步变为：

u(t+1)n=u(t)n⋅exp(−ynαtgt(xn))$$u_n^{(t+1)}=u_n^{(t)}\cdot exp(-y_n{\alpha }_t{g}_t(x_n))$$

通过这样的表达我们看到样本(xn,yn)$(x_n,y_n)$ 最终的权重u(T+1)n$u_n^{(T+1)}$ 和初始的u(1)n$u_n^{(1)}$ 的关系如下：

u(T+1)n=u(1)n⋅∏t=1Texp(−ynαtgt(xn))=1N⋅exp(−yn∑t=1Tαtgt(xn))$$u_n^{(T+1)}=u_n^{(1)}\cdot \prod _{t=1}^{T}exp(-y_n{\alpha }_t{g}_t(x_n))=\frac{1}{N}\cdot exp(-y_n\sum _{t=1}^T{\alpha }_t{g}_t(x_n))$$

我们将∑Tt=1αtgt(x)$\sum _{t=1}^T{\alpha }_t{g}_t(x)$ 称为voting score$\text{voting score}$。因为最后我们需要根据这个分数加一个sign$sign$ 的操作来做分类的决定，即我们最终得到的模型是：G(x)=sign(∑Tt=1αtgt(x))$G(x)=sign(\sum _{t=1}^T{\alpha }_t{g}_t(x))$ 。从上面的式子可以看出AdaBoost$\text{AdaBoost}$ 中的每一个数据点的权重u(T+1)n$u_n^{(T+1)}$ 正比于负yn$y_n$ 和voting score$\text{voting score}$ 的乘积的exponential$\text{exponential}$ 。

我们知道AdaBoost$\text{AdaBoost}$ 是linear blending$\text{linear blending}$ 的延伸， 也就是要将g$g$ 线性的融合在一起。在linear blending$\text{linear blending}$ 中我们可以将整个过程分为两步：1. 将所有的g$g$ 当做是一个特征转换；2. 将特征转换之后的结果使用一个线性的模型融合起来。

linear blending=linear model+hypothesis as transform$linearblending=linearmodel+hypothesisastransform$

G(xn)=sign(∑t=1Tαtwtgt(xn)ϕt(xn))$$G(x_n)=sign(\sum _{t=1}^T\underset{w_t}{\underbrace{{\alpha }_t}}\underset{{\varphi }_t(x_n)}{\underbrace{g_t(x_n)}})$$

因为gt(xn)$g_t(x_n)$ 可以视为特征转换，我们将其记为ϕt(xn)${\varphi }_t(x_n)$ ，将每一个gt(xn)$g_t(x_n)$ 的权重记为wt$w_t$ 。这时， voting score$votingscore$ 就变成了wTΦ(xn)$w^T\mathrm{\Phi }(x_n)$ 。这样我们就得到了一个我们比较熟悉的形式， 因为在硬间隔的SVM$\text{SVM}$ 中：margin=yn⋅(wTϕ(xn)+b)||w||$margin=\frac{y_n\cdot (w^T\varphi (x_n)+b)}{||w||}$ ， 表示这个数据点距离边界有多远。所以在这里voting score$votingscore$ （虽然和上面的相比少了一些项）也是某一种距离， 也是某一种margin$margin$ ， 也是在某一个空间中这个点到分割线的距离的一种衡量。

所以 yn⋅(voting score)$y_n\cdot (votingscore)$ 就相当于在SVM$SVM$ 中的没有归一化的margin$margin$ ，也可以说是函数间隔。结合我们对SVM$\text{SVM}$ 的认识，我们希望 yn⋅(voting score)$y_n\cdot (votingscore)$ 越大越好，即首先这个值要是个正的，正值保证了划分的正确性；其次要尽量的大，这样就能有更大的置信区间或者说更大的margin$\text{margin}$ 。所以我们就会希望 exp(−yn(voting score))$exp(-y_n(votingscore))$ 越小越好。也就是每一个数据点的权重 u(T+1)n$u_n^{(T+1)}$ 要越小越好。

通过上面的分析我们知道AdaBoost$AdaBoost$想要达到large margin$largemargin$ 的效果，就是要努力的使所有的yn⋅(voting score)$y_n\cdot (votingscore)$ 变大，就是要使所有的exp(−yn(voting score))$exp(-y_n(votingscore))$ 变小。就是要最小化∑Nn=1u(T+1)n$\sum _{n=1}^N{u}_n^{(T+1)}$， 现在可以将adaboost$\text{adaboost}$ 的损失函数定义为：

L=∑n=1Nu(T+1)n=1N∑n=1Nexp(−yn∑t=1Tαtgt(xn))(1)$$\begin{array}{}\text{(1)}& L=\sum _{n=1}^N{u}_n^{(T+1)}=\frac{1}{N}\sum _{n=1}^{N}exp(-y_n\sum _{t=1}^T{\alpha }_t{g}_t(x_n))\end{array}$$

所以得到了AdaBoost$AdaBoost$ 的损失函数为指数损失函数。

2.2 - 又一个0/1误差的上界

画出0/1 error$\text{0/1 error}$ 和AdaBoost error$\text{AdaBoost error}$ 的曲线发现，exponential error$exponentialerror$（图中的曲线）是0/1 error$0/1error$ （图中的折线）的一个上限。我们之前就碰到过0/1 error$0/1error$ 的一些上限，SVM$\text{SVM}$ 的hinge error(max(1−sy,0))$\text{hinge error}(max(1-sy,0))$ ，logistic regression$\text{logistic regression}$ 的scale cross entropy(ln(1+exp(−ys)))$\text{scale cross entropy}(ln(1+exp(-ys)))$都是0/1 error$0/1error$ 的上限，我们之前都是利用这些上限将0/1 error$0/1error$ 做到最小，从而将分类问题做好。

现在我们从另一个角度看到Adaboost$Adaboost$ 通过最小化∑Nn=1u(T+1)n$\sum _{n=1}^N{u}_n^{(T+1)}$ 以使得得到的边界有large margin$largemargin$ 的效果，所以adaboost$adaboost$ 算法在函数

∑n=1Nexp(−yn∑t=1Tαtgt(xn))(2)$$\begin{array}{}\text{(2)}& \sum _{n=1}^{N}exp(-y_n\sum _{t=1}^T{\alpha }_t{g}_t(x_n))\end{array}$$

上做最小化，我们就将(2)$(2)$ 定义为adaboost error measure$adaboosterrormeasure$ 。最终通过最小化erradaˆ$er{r}_{\widehat{ada}}$ 将err0/1$er{r}_{0/1}$ 做到最好。

• err0/1(s,y)=|[ys≤0]|$er{r}_{0/1}(s,y)=|[ys\le 0]|$
• erradaˆ(s,y)=exp(−ys)$er{r}_{\widehat{ada}}(s,y)=exp(-ys)$

在AdaBoost$AdaBoost$ 中既然我们想要所有的样本点的权重越小越好，也就是想要最后的权重的总和越小越好，也就是要在上式(1)$(1)$ 中做最小化。AdaBoost$AdaBoost$ 就是要做如下的一个最优化的问题：

minhEADA=1N∑n=1Nexp(−yn∑t=1Tαtgt(xn))$$\underset{h}{min}{E}_{ADA}=\frac{1}{N}\sum _{n=1}^{N}exp(-y_n\sum _{t=1}^T{\alpha }_t{g}_t(x_n))$$

解决上述最优化问题利用的工具是梯度下降法，梯度下降法的思路基本上是：当想要最小化一个函数的时候，可以看看从当前的点出发往哪个方向v$v$ 走一小步会使得结果变好。 通常的方法是在该点附近使用泰勒公式进行展开，之后通过分析可以得到能使得函数变小的最好的方向就是负梯度的方向。沿着这个方向走一个小小的步长η$\eta$ ， 这样就离我们的目标更近了一步。

泰勒展开

min||v||=1 Ein(wt+ηv)≈Ein(wt)+ηvT▽Ein(wt)(3)$$\begin{array}{}\text{(3)}& \underset{||v||=1}{min}{E}_{in}(w_t+\eta v)\approx E_{in}(w_t)+\eta v^T▽E_{in}(w_t)\end{array}$$

现在如果我们想要找一个函数gt$g_t$ 当做方向，（向量和函数在本质上是一样的。当操作的对象是向量的时候，我们根据下标index$index$ 可以得到向量中的值；当操作的对象是函数的时候，我们根据输入x$x$ 可以得到函数的输出值，所以向量的index$index$ 是整数，函数的index$index$ 是实数。这样看来，函数就是无限维度的向量）。在gradient descent$gradientdescent$ 中，我们想要找一个好的向量方向，沿着这个向量方向走一个步长η$\eta$ 来做最优化；在这里我们想要找一个好的函数h(x)$h(x)$ ，沿着这个函数走一个步长η$\eta$ 来做最优化。
当前的adaboost$adaboost$ 已经得到函数是∑t−1τ=1ατgτ(xn)$\sum _{\tau =1}^{t-1}{\alpha }_{\tau }{g}_{\tau }(x_n)$ , 所以就是要在∑t−1τ=1ατgτ(xn)$\sum _{\tau =1}^{t-1}{\alpha }_{\tau }{g}_{\tau }(x_n)$ 上加一个好的函数h(xn)$h(x_n)$ （向量方向）和步长 η$\eta$ 的乘积ηh(xn)$\eta h(x_n)$ 来使得最终的结果变好一点。

minh Eadaˆ=1N∑n=1Nexp(−yn(∑τ=1t−1ατgτ(xn)+ηh(xn)))(4)$$\begin{array}{}\text{(4)}& \underset{h}{min}\widehat{E_{ada}}=\frac{1}{N}\sum _{n=1}^{N}exp(-y_n(\sum _{\tau =1}^{t-1}{\alpha }_{\tau }{g}_{\tau }(x_n)+\eta h(x_n)))\end{array}$$

现在我们要想办法将(4)$(4)$ 变成(3)$(3)$ 的形式，

minhEadaˆ=1N∑n=1Nexp(−yn(∑τ=1t−1ατgτ(xn)+ηh(xn)))=1N∑n=1Nexp((−yn)∑τ=1t−1ατgτ(xn))⋅exp(−ynηh(xn))=∑n=1Nu(t)nexp(−ynηh(xn))≈taylor∑n=1Nu(t)n(1−ynηh(xn))=∑n=1Nu(t)n−η∑n=1Nu(t)nynh(xn)$$\begin{array}{rl}\underset{h}{min}\widehat{E_{ada}}& =\frac{1}{N}\sum _{n=1}^{N}exp(-y_n(\sum _{\tau =1}^{t-1}{\alpha }_{\tau }{g}_{\tau }(x_n)+\eta h(x_n)))\\ & =\frac{1}{N}\sum _{n=1}^{N}exp((-y_n)\sum _{\tau =1}^{t-1}{\alpha }_{\tau }{g}_{\tau }(x_n))\cdot exp(-y_n\eta h(x_n))\\ & =\sum _{n=1}^N{u}_n^{(t)}exp(-y_n\eta h(x_n))\\ & \stackrel{taylor}{\approx }\sum _{n=1}^N{u}_n^{(t)}(1-y_n\eta h(x_n))\\ & =\sum _{n=1}^N{u}_n^{(t)}-\eta \sum _{n=1}^N{u}_n^{(t)}{y}_{n}h(x_n)\end{array}$$

泰勒展开式：exp(x)=1+x+x22!+x33!+⋅+xNN!+⋯$exp(x)=1+x+\frac{x^2}{2!}+\frac{x^3}{3!}+\cdot +\frac{x^N}{N!}+\cdots$

通过上面的操作得到了和在gradient descient$gradientdescient$ 中类似的形式，现在我们的目标是要找到一个好的 h$h$ 来最小化∑Nn=1u(t)n(−ynh(xn))$\sum _{n=1}^N{u}_n^{(t)}(-y_{n}h(x_n))$ 。对于二分类问题来说：

===∑n=1Nu(t)n(−ynh(xn))∑n=1Nu(t)n{−1if yn=h(xn)1if yn≠h(xn)−∑n=1Nu(t)n+∑n=1Nu(t)n{0if yn=h(xn)2if yn≠h(xn)−∑n=1Nu(t)n+2Eu(t)in⋅N(1)(2)(3)(4)$$\begin{array}{}\text{(1)}& & \sum _{n=1}^N{u}_n^{(t)}(-y_{n}h(x_n))\text{(2)}& =& \sum _{n=1}^N{u}_n^{(t)}\{\begin{array}{r}-1if{y}_n=h(x_n)\\ 1if{y}_n\ne h(x_n)\end{array}\text{(3)}& =& -\sum _{n=1}^N{u}_n^{(t)}+\sum _{n=1}^N{u}_n^{(t)}\{\begin{array}{r}0if{y}_n=h(x_n)\\ 2if{y}_n\ne h(x_n)\end{array}\text{(4)}& =& -\sum _{n=1}^N{u}_n^{(t)}+2E_{in}^{u^{(t)}}\cdot N\end{array}$$

我们的出发点是要找到一个好的h(x)$h(x)$ 让∑Nn=1u(t)n(−ynh(xn))$\sum _{n=1}^N{u}_n^{(t)}(-y_{n}h(x_n))$ 变小，经过上面的推导发现想要让∑Nn=1u(t)n(−ynh(xn))$\sum _{n=1}^N{u}_n^{(t)}(-y_{n}h(x_n))$ 变小的就要让Eu(t)in$E_{in}^{u^{(t)}}$ 变小。能够使得Eu(t)in$E_{in}^{u^{(t)}}$ 变小的正是adaboost$adaboost$ 中的base algorithm$basealgorithm$ 算法 A$\mathcal{A}$ 。所以 base algorithm$basealgorithm$ 找到了一个好的函数方向。我们原来认为A$\mathcal{A}$ 找到的gt$g_t$ 只是为了让Eu(t)in$E_{in}^{u^{(t)}}$ 变小， 现在经过这样的推导发现，这个gt$g_t$ 是一个能够让Eadaˆ$E_{\widehat{ada}}$ 变小的函数方向。

adaboost$adaboost$ 通过大概的最小化Eadaˆ=∑Nn=1u(t)nexp(−ynηh(xn))$\widehat{E_{ada}}=\sum _{n=1}^N{u}_n^{(t)}exp(-y_n\eta h(x_n))$ 得到了一个好的函数（方向），按照gradient descent$gradientdescent$ 的做法，现在要做的就是沿着这个方向走一小步。但是在这里我们不仅仅满足于只走一小步，而是想要走一大步。也就是说在gt$g_t$ 被固定了之后，想要选择一个最大的η$\eta$ 来使得Eadaˆ$\widehat{E_{ada}}$ 最小：

minηEadaˆ=∑n=1Nu(t)nexp(−ynηgt(xn))◯$$\underset{\eta }{min}\widehat{E_{ada}}=\sum _{n=1}^N\underset{◯}{\underbrace{u_n^{(t)}exp(-y_n\eta g_t(x_n))}}$$

那么怎么来得到这个最好的步长 η$\eta$ 呢？

• 当yn=gt(xn)$y_n=g_t(x_n)$ 的时候，◯=u(t)nexp(−η)$◯=u_n^{(t)}exp(-\eta )$
• 当yn≠gt(xn)$y_n\ne g_t(x_n)$ 的时候，◯=u(t)nexp(+η)$◯=u_n^{(t)}exp(+\eta )$

Eadaˆ=(∑n=1Nu(t)n)⋅((1−ϵ)exp(−η)+ϵt exp(+η))$$\widehat{E_{ada}}=(\sum _{n=1}^N{u}_n^{(t)})\cdot ((1-ϵ)exp(-\eta )+{ϵ}_{t}exp(+\eta ))$$

对η$\eta$ 求导来得到最优解:

∂Eadaˆ∂η=0⟶ηt=ln1−ϵtϵ−−−−−√=αt$$\frac{\mathrm{\partial }\widehat{E_{ada}}}{\mathrm{\partial }\eta }=0⟶{\eta }_t=ln\sqrt{\frac{1-{ϵ}_t}{ϵ}}={\alpha }_t$$

所以这样看来， adaboost$adaboost$ 使用base algorithm A$basealgorithm\mathcal{A}$ 来得到一个最好的函数方向，当最好的函数方向gt$g_t$ 得到之后，adaboost$adaboost$ 给这个gt$g_t$ 一个权重或者说是票数αt${\alpha }_t$ ，现在我们知道了这个由adaboost$adaboost$ 给出的权重αt${\alpha }_t$ 是一个最佳问题的解。所以adaboost$adaboost$ 通过也可以称为steepest descent with approximate functional gradient$steepestdescentwithapproximatefunctionalgradient$ 。

3 - Gradient Boosting

上一小节对adaboost$\text{adaboost}$ 做了另一种解释，adaboost$\text{adaboost}$ 的每一轮可以看做是在最小化exponential error$\text{exponential error}$ ：在每一轮中首先找出一个h$h$ ，将这个h$h$ 作为gt$g_t$ ；然后再决定要沿着这个gt$g_t$ 走多远的距离，这个距离会变成gt$g_t$ 的权重αt${\alpha }_t$。所以一共有两个最佳化的过程：一个是对h$h$ 的最佳化过程， 一个是对η$\eta$ 的最佳化过程。

minηminh1N∑n=1Nexp(−yn(∑τ=1t−1αtgτ(xn)+ηh(xn)))(1)$$\begin{array}{}\text{(1)}& \underset{\eta }{min}\underset{h}{min}\frac{1}{N}\sum _{n=1}^{N}exp(-y_n(\sum _{\tau =1}^{t-1}{\alpha }_t{g}_{\tau }(x_n)+\eta h(x_n)))\end{array}$$

这样的概念可以不可以用在不同的error function$\text{error function}$ 上呢？也就是说不再仅仅只是(1)$(1)$ 中的exponential error$\text{exponential error}$ 。例如如果我们想做的是logistic regression$logisticregression$ 的话，我们关注的error$error$ 是cross entropy error$crossentropyerror$ ，如果我们想做的是regression$regression$ 的话，我们关注的error$error$ 是squared error$squarederror$ 。

3.1 - 前向分步算法优化加法模型

基于上述的讨论，将（1）$（1）$ 式进行扩展，将err$err$ 换掉，不再局限于使用exponential error$exponentialerror$ ，而是可以使用任何我们感兴趣的error function$errorfunction$ 。

minηminh1N∑n=1Nerr(∑τ=1t−1αtgτ(xn)+ηh(xn),yn)(1)$$\begin{array}{}\text{(1)}& \underset{\eta }{min}\underset{h}{min}\frac{1}{N}\sum _{n=1}^{N}err(\sum _{\tau =1}^{t-1}{\alpha }_t{g}_{\tau }(x_n)+\eta h(x_n),y_n)\end{array}$$

这是一个新的aggregation$aggregation$ 的模型：从当前已经得到的模型∑t−1τ=1αtgτ(xn)$\sum _{\tau =1}^{t-1}{\alpha }_t{g}_{\tau }(x_n)$ 出发，沿着h(xn)$h(x_n)$ 走步长η$\eta$ ，目的是为了让err$err$ 变小，所以同样的在每一轮都是做两件事：先决定一个好的方向h$h$ 作为gt$g_t$ ，然后决定要沿着这个gt$g_t$ 更新多远得到步长η$\eta$ 并作为权重αt${\alpha }_t$ 将gt$g_t$ 融入到最中的G$G$ 中。所以这样的模型很像是adaboost$adaboost$ 只不过是对adaboost$adaboost$ 做了延伸，我们称之为gradientBoost$gradientBoost$ ，由不同的error funciton$errorfunciton$ 就可以解决不同的问题例如regression$regression$ 或者是soft classification$softclassification$ 。

3.2 - 提升树用于回归

当我们想要使用boosting tree$\text{boosting tree}$ 做regression$regression$ 的时候应该怎么做呢？我们关心的是squared error$squarederror$ ：err(s,y)=(s−y)2$err(s,y)=(s-y{)}^2$

minηminh1N∑n=1Nerr(∑τ=1t−1ατgτ(xn)sn+ηh(xn),yn)$$\underset{\eta }{min}\underset{h}{min}\frac{1}{N}\sum _{n=1}^{N}err(\underset{s_n}{\underbrace{\sum _{\tau =1}^{t-1}{\alpha }_{\tau }{g}_{\tau }(x_n)}}+\eta h(x_n),y_n)$$

我们将使用当前已经得到的模型∑t−1τ=1ατgτ(xn)$\sum _{\tau =1}^{t-1}{\alpha }_{\tau }{g}_{\tau }(x_n)$ 对样本xn$x_n$ 做出的预测结果记为sn$s_n$ ，我们的目的就是要从sn$s_n$ 出发沿着某个h(xn)$h(x_n)$ 更新某个步长η$\eta$ 来使得err$err$ 变小。 所以第一步我们首先找一个最好的h(x)$h(x)$ 作为gt$g_t$ ：

minh1N∑n=1Nerr(sn+ηh(xn),yn)≈tarlorminh1N∑n=1Nerr(sn,yn)+1N∑n=1Nηh(xn)∂err(s,yn)∂s|s=sn=minhconstants+ηN∑n=1Nh(xn)2(sn−yn)◯$$\begin{array}{rl}& \underset{h}{min}\frac{1}{N}\sum _{n=1}^{N}err(s_n+\eta h(x_n),y_n)\\ & \stackrel{tarlor}{\approx }\underset{h}{min}\frac{1}{N}\sum _{n=1}^{N}err(s_n,y_n)+\frac{1}{N}\sum _{n=1}^N\eta h(x_n)\frac{\mathrm{\partial }err(s,y_n)}{\mathrm{\partial }s}{|}_{s=s_n}\\ & =\underset{h}{min}\underset{◯}{\underbrace{constants+\frac{\eta }{N}\sum _{n=1}^{N}h(x_n)2(s_n-y_n)}}\end{array}$$

我们现在是要找一个h(xn)$h(x_n)$ 来使得◯$◯$ 最小， 那么易知当h(xn)=−∞⋅(sn−yn)$h(x_n)=-\mathrm{\infty }\cdot (s_n-y_n)$ 的时候，上式可以取得最小。因为首先−(sn−yn)$-(s_n-y_n)$ 保证了结果是负数，再乘以一个∞$\mathrm{\infty }$ ，就是负的无穷大，这是最直观的该最小化问题的解。 但是因为在这里h(xn)$h(x_n)$ 相当于一个方向， 所以应该对其长度进行一下限制，这样就可以避免出现−∞$-\mathrm{\infty }$ 。并且长度的问题最后交给步长 η$\eta$ 来解决。
基于以上的讨论我们应该解决的问题是：

min||h||=1constants+ηN∑n=1Nh(xn)2(sn−yn)$$\underset{||h||=1}{min}constants+\frac{\eta }{N}\sum _{n=1}^{N}h(x_n)2(s_n-y_n)$$

但是这样的话变成了需要求解一个有条件||h||=1$||h||=1$ 的最佳化问题，因为我们并不在乎h$h$ 的大小，所以我们将其作为一个惩罚项放入目标函数中的，只是限制使得h(x)$h(x)$ 不要太大即可，新的问题变为：

minhconstants+ηN∑n=1N(2h(xn)(sn−yn)+h(xn)2)=constants+ηN∑n=1N(constant+(h(xn)−(yn−sn)residual)2)$$\begin{array}{rl}& \underset{h}{min}constants+\frac{\eta }{N}\sum _{n=1}^N(2h(x_n)(s_n-y_n)+h(x_n{)}^2)\\ & =constants+\frac{\eta }{N}\sum _{n=1}^N(constant+(h(x_n)-\underset{residual}{\underbrace{(y_n-s_n)}}{)}^2)\end{array}$$

yn$y_n$ 是目标值，sn$s_n$ 是目前给出的预测值， 我们将yn−sn$y_n-s_n$ 定义为残差residual$residual$。为了达到最小化的目的，就是要找一个h$h$ ， 使得对于所有的样本来说，h(xn)$h(x_n)$ 和(yn−sn)$(y_n-s_n)$ 尽可能的接近，即h(xn)$h(x_n)$ 和(yn−sn)$(y_n-s_n)$ 的均方误差要尽可能的小。

所以我们回归问题的提升树只要在每一轮都拟合当前模型的残差就好了， 即在数据{(xn,yn−sn)}$\{(x_n,y_n-s_n)\}$ 上做一个regression$regression$ 就好了。

所以当我们使用gradientboost$gradientboost$ 来做regression$regression$ 的时候，我们需要利用base algorithm$basealgorithm$ 在residual$residual$ 数据{(xn,yn−sn)}$\{(x_n,y_n-s_n)\}$ 上找一个好的gt$g_t$ （方向）； 而在adaboost$adaboost$ 中的base algorithm$basealgorithm$ 是根据加权的数据{xn,yn}$\{x_n,y_n\}$ 来找到一个好的gt$g_t$ 。

在上一步中我们知道了怎么找到一个好的gt$g_t$ 了，也就是要求解一个regression$regression$ 问题来拟合xn$x_n$ 和yn−sn$y_n-s_n$ ， 现在的问题是，当找到了一个好的gt$g_t$ 之后，我们要怎么决定这个gt$g_t$ 的权重 η$\eta$ 呢？同样是求解如下的一个最优化的问题：

minη1N∑n=1N(sn+ηgt(xn)−yn)2=1N∑n=1N((yn−sn)residual−ηgt(xn))2$$\underset{\eta }{min}\frac{1}{N}\sum _{n=1}^N(s_n+\eta g_t(x_n)-y_n{)}^2=\frac{1}{N}\sum _{n=1}^N(\underset{residual}{\underbrace{(y_n-s_n)}}-\eta g_t(x_n){)}^2$$

为了最小化我们需要求解的是一个在数据集{(gt(xn),residual)}$\{(g_t(x_n),residual)\}$ 上的单变量η$\eta$ 的线性回归问题。所以当使用gradientboost$gradientboost$ 来做regression$regression$ 的时候，在需要求解gt$g_t$ 的权重αt${\alpha }_t$ 的时候是使用gt$g_t$ 来做一个特征转换，然后求解一个简单的linear regression$linearregression$ 。

把以上讨论的东西都合在一起就得到了一个算法我们称之为Gradient Boosted Decision Tree(GBDT)$GradientBoostedDecisionTree(GBDT)$ 。刚刚只是讲解了gradient boosted$gradientboosted$ ，这里的decision tree$decisiontree$ 用做base learner$baselearner$ 。

Gradient Boosted Decision Tree(GBDT)$GradientBoostedDecisionTree(GBDT)$
for regression$forregression$
s1=s2=⋯=sN=0$s_1=s_2=\cdots =s_N=0$
for t=1,2,⋯,T$fort=1,2,\cdots ,T$
1. obtain gt by A({(xn,yn−sn)}) where A is a(squared error) regression algorithm$obtain{g}_{t}by\mathcal{A}(\{(x_n,y_n-s_n)\})where\mathcal{A}isa(squarederror)regressionalgorithm$
2. compute αt=OneVarLinearRegression({(gt(xn),yn−sn)})$compute{\alpha }_t=OneVarLinearRegression(\{(g_t(x_n),y_n-s_n)\})$
3. update sn⟵sn+αtgt(xn)$update{s}_n⟵s_n+{\alpha }_t{g}_t(x_n)$
returnG(x)=∑αtgt(x)$returnG(x)=\sum _{}^{}{\alpha }_t{g}_t(x)$

因为初始的s1=s2=⋯=sN=0$s_1=s_2=\cdots =s_N=0$ ，所以在第一轮的时候base learner$baselearner$ ， 这里是用decision tree$decisiontree$ 做的是一个正常的regression$regression$ ， 从第二轮之后才在数据{(xn,yn−sn)}$\{(x_n,y_n-s_n)\}$上做regression$regression$ 。 在得到了gt$g_t$ 之后我们要想办法得到一个αt${\alpha }_t$ ，这时就是在{(gt(xn),yn−sn)}$\{(g_t(x_n),y_n-s_n)\}$上做一个单变量的回归问题。当计算完成之后， 就需要对每一个样本的分数进行更新，sn⟵sn+αtgt(xn)$s_n⟵s_n+{\alpha }_t{g}_t(x_n)$ 。这样做了T$T$ 轮之后就可以得到一堆decision tree$decisiontree$ 最后得到G$G$ 。

---

通过上述的推导可以引出gradient boosting$\text{gradient boosting}$ 。 到现在为止我们分析了提升树算法的损失函数为指数损失函数和平方误差损失函数的情况，但是对于一般的损失函数而言，优化的过程并不是这么简单的。针对这一问题Feridman$\text{Feridman}$ 提出了梯度提升（gradient boosting$\text{gradient boosting}$ ）。其关键有点类似提升树用于回归的推导：利用损失函数的负梯度在当前模型的值作为回归问题提升树中的残差的近似值，以此来拟合一个回归树。

rn≈−[∂L(y,f(xi))∂f(xi)]f(x)=fm−1(x)$$r_n\approx -[\frac{\mathrm{\partial }L(y,f(x_i))}{\mathrm{\partial }f(x_i)}{]}_{f(x)=f_{m-1}(x)}$$

4 - Summary of Aggregation Models

4.1 - Blending Models

用于当手头已经有了一些gt$g_t$ 的时候，将它们进行集成， 集成的方式有如下的三种：

• uniform$uniform$ ：每一个gt$g_t$ 都是同样的地位，可以通过voting$voting$ 或者是averaging$averaging$ 来进行集成。
• non$non$ -uniform$uniform$ ：如果每一个gt$g_t$ 有不同的重要性的时候，可以将这些gt$g_t$ 看成是特征转换，然后再喂给一个linear model$linearmodel$ 来学习每一个gt$g_t$ 的权重。
• conditional$conditional$ ：如果要在不同的情况下使用不同的gt$g_t$ ， 同样将每一个gt$g_t$ 看成是特征转换， 只是在第二个阶段的学习当中， 使用non linear model$nonlinearmodel$ 而不是linear model$linearmodel$ 。这样的模型称为stacking$stacking$ 。

通过uniform$uniform$ 的方式，不同的gt$g_t$ 会取长补短，相互修正，得到的模型比较稳定。通过non uniform$nonuniform$ 或者是conditional$conditional$ 的方式可以得到比较复杂的模型，但是要小心overfitting$overfitting$ 的风险。

4.2 - Aggregation-Learning Modeling

learning$learning$ 指的是我们还没有g$g$，我们要边学g$g$ 边考虑怎么样对它们进行集成，

• Bagging$Bagging$：通过bootstrap$bootstrap$ 机制来得到不同的gt$g_t$ ， 然后通过uniform$uniform$ 的形式进行集成
• AdaBoost$AdaBoost$：adaboost$adaboost$ 通过更新每一笔资料的权重的方式来得到很不一样的gt$g_t$ ，在得到了gt$g_t$ 之后依据它们的表现来决定其在最终的G$G$ 中的权重αt${\alpha }_t$ 。从最佳化的角度来说，gt$g_t$ 是能够使得error$error$ 降低的最好的方向，类似于梯度下降中的负梯度方向，这个权重可以理解为要在gt$g_t$ 的方向上更新的最大的步长。
• Decision Tree$DecisionTree$：通过寻找不同的特征划分数据，最后在不同的条件下使用不同的g$g$ 。
• GradientBoost$GradientBoost$：将adaboost$adaboost$ 延伸到gradientboost$gradientboost$ ，不同于adaboost$adaboost$ ，在学习g$g$ 的时候不是通过更新样本的权重，例如在regression$regression$ 的时候，是对residual$residual$ 进行拟合从而得到好的g$g$ 。

4.3 - Aggregation of Aggregation Models

• decision tree + bagging$\text{decision tree + bagging}$ 可以得到random forest$\text{random forest}$
• decision tree + adaboost$\text{decision tree + adaboost}$ 可以得到boostin tree$\text{boostin tree}$
• decision tree + gradient boost$\text{decision tree + gradient boost}$ 可以得到gradient boost decision tree$\text{gradient boost decision tree}$

4.4 - Specialty of Aggregation Models

为什么aggregation$aggregation$ 这样的模型可以表现的很好呢？主要由于两个方面的原因：首先aggregation$aggregation$ 解决了underfitting$underfitting$ ，因为集成了很多的g$g$ 的表现，可以把这些g$g$ 看成是对原始特征不同的feature transform$featuretransform$ ；另一个方面来说当集成了很多的g$g$ 之后，会得到一个比较“中庸”的结果，aggregation$aggregation$ 达到了regularzation$regularzation$ 的效果，

5 - 总结

这篇的主要内容是Gradient Boosted Decision Tree$GradientBoostedDecisionTree$ 。首先先讲述了如何将adaboost$adaboost$ 和decision tree$decisiontree$ 进行搭配来得到adaboost decision tree$adaboostdecisiontree$ ，为此引入了sampling and pruning$samplingandpruning$ 来得到一棵棵比较弱的decisiontree$decisiontree$ ，这样adaboost$adaboost$ 和decision tree$decisiontree$ 的组合才能发挥最大的效果。之后我们使用optimization$optimization$ 的角度来重新的看adaboost$adaboost$ ， 发现adaboost$adaboost$ 每一次找到一个gt$g_t$ 就是找了一个好的方向， 这个gt$g_t$ 的权重αt${\alpha }_t$ 其实就是一个适当的步长。我们将这个模型延伸得到了gradient boosting$gradientboosting$ ，引入不同种类的error$error$ ，经过推导发现当gradient boosting$gradientboosting$ 用于regression$regression$ 的时候其实base learner$baselearner$ 是在做一个residual fitting$residualfitting$ 。