梯度提升树(GBDT)算法超详细版本

Bertha 。 2023-09-28 21:41 11阅读 0赞

### 一、引言部分 ###

梯度提升树(GBDT)的全称是Gradient Boosting Decision Tree，是 Boosting 算法的一种。

**1. 和 AdaBoost 算法的区别：**

AdaBoost 算法是利用前一轮的弱学习器的误差来更新样本权重值，然后一轮一轮的迭代；

GBDT 也是迭代，使用了前向分布算法，但是弱学习器限定了只能使用CART回归树模型，而且 GBDT 在模型训练的时候，是要求模型预测的样本损失尽可能的小。

首先，**GBDT使用的决策树是CART回归树，无论是处理回归问题还是二分类以及多分类，GBDT使用的决策树通通都是都是CART回归树。**

这里解释一下：

GBDT每次迭代要拟合的是梯度值，是连续值所以要用回归树。

**对于回归树算法来说最重要的是寻找最佳的划分点**，那么回归树中的可划分点包含了所有特征的所有可取的值。

在分类树中最佳划分点的判别标准是熵或者基尼系数，都是用纯度来衡量的，但是在回归树中的样本标签是连续数值，所以再使用熵之类的指标不再合适，取而代之的是平方误差，它能很好的评判拟合程度。

**2. GBDT的学习**

GBDT的核心在于每一棵树学的是之前所有树结论的残差，残差其实就是真实值和预测值之间的差值。

在学习的过程中，首先学习一颗回归树（分类树的结果显然是没办法累加的，所以GBDT中的树都是回归树），然后将`真实值-预测值`得到残差，再把残差作为一个学习目标，学习下一棵回归树，依次类推，直到残差小于某个接近0的阀值或回归树数目达到某一阀值。

其核心思想是每轮通过拟合残差来降低损失函数。总的来说，第一棵树是正常的，之后所有的树的决策全是由残差来决定。

最后，使用梯度下降算法减小损失函数。对于一般损失函数，为了使其取得最小值，通过梯度下降算法，每次朝着损失函数的负梯度方向逐步移动，最终使得损失函数极小的方法（此方法要求损失函数可导）。

**GBDT总共需要进行M次迭代，每次迭代产生一个模型，我们需要让每次迭代生成的模型对训练集的损失函数最小**，而如何让损失函数越来越小呢？我们采用梯度下降的方法，在每次迭代时通过向损失函数的负梯度方向移动来使得损失函数越来越小，这样我们就可以得到越来越精确的模型。

**3. GBDT 直观理解**

每一轮预测和实际值有残差，下一轮根据残差再进行预测，最后将所有预测相加，就是结果（不断去拟合残差，使残差不断减少）。

**4. GBDT的例子**

假如有个人30岁，我们首先用20岁去拟合，发现损失有10岁，这时我们用6岁去拟合剩下的损失，发现差距还有4岁，第三轮我们用3岁拟合剩下的差距，差距就只有一岁了。如果我们的迭代轮数还没有完，可以继续迭代下面，每一轮迭代，拟合的岁数误差都会减小。

如下图所示：

![1300f671e62a4e25800ca6a93dc482ab.png][]

### 二、GBDT损失函数极小化 ###

在GBDT的迭代中，假设我们前一轮迭代得到的强学习器是 f m − 1 ( x ) f\_\{m-1\}(x) fm−1(x)，损失函数是 L ( y , f m − 1 ( x ) ) L(y,f\_\{m-1\}(x)) L(y,fm−1(x))，迭代的目标是找到一个CART回归树模型的弱学习器 h m ( x ) h\_m(x) hm(x)，让本轮的损失函数 L ( y , f m ( x ) ) = L ( y , f m − 1 ( x ) ) + h m ( x ) L(y,f\_m(x))=L(y,f\_\{m-1\}(x))+h\_m(x) L(y,fm(x))=L(y,fm−1(x))\+hm(x)最小。也就是说，本轮迭代找到决策树，要让样本的损失尽量变得更小。

即GBDT初始化时（估计使损失函数极小化的常数值，它是只有一个根节点的树，一般平方损失函数为节点的均值，而绝对损失函数为节点样本的中位数）：  
 f ( x ) = arg ⁡ min ⁡ c ∑ i = 1 m L ( y i , c ) f(x)=\\arg\\min\_\{c\}\\sum\_\{i=1\}^mL(y\_i,c) f(x)=argcmini=1∑mL(yi,c)

面临一个问题：这个损失的拟合不好度量，损失函数各种各样，怎么找到一种通用的拟合方法呢？

### 三、GBDT的负梯度拟合 ###

当损失函数是平方损失和指数损失函数时，梯度提升树每一步优化是很简单的，但是对于一般损失函数而言，往往每一步优化起来不那么容易，针对这一问题， F r i e d m a n Friedman Friedman提出了梯度提升树算法，这是利用最速下降的近似方法，其关键是利用损失函数的负梯度作为提升树算法中的残差的近似值，进而拟合一个CART回归树。

对于提到的三种损失函数，其最小化方法各有不同。当损失函数为下面几种函数时，最小化损失函数的方法如下：

**1. 指数函数**

当损失函数为指数函数时，比如AdaBoost算法的损失函数是指数函数，这时通过前向分步算法来解决。前向分布算法在每轮迭代时，通过将上一轮所生成的模型所产生的损失函数最小化的方法来计算当前模型的参数。

**2. 平方误差损失函数**

在回归树提升算法中，遍历当前输入样例的可能取值，将每种可能值计算一遍损失函数，最终选择损失函数最小的值（很原始）。在计算平方损失误差时，可能出现残差项 y − f m − 1 ( x ) y-f\_\{m-1\}(x) y−fm−1(x)，此时可以通过如下方法来进行优化：每一轮迭代是为了减小上一步模型的残差，为了减少残差，每次在残差的负梯度方向建立一个新的模型，这样一步一步的使得残差越来越小。

**3. 一般损失函数**

对于一般损失函数，可以通过梯度下降的方法来使得损失函数逐步减小，每次向损失函数的负梯度方向移动，直到损失函数值到达谷底。

那么负梯度长什么样呢？第 m m m轮的第 i i i个样本的损失函数的负梯度表示为：  
 r m i = − \[ ∂ L ( x i , f ( x i ) ) ∂ f ( x i ) \] f ( x ) = f m − 1 ( x ) r\_\{mi\}=-\[\\frac\{\\partial L(x\_i,f(x\_i))\}\{\\partial f(x\_i)\}\]\_\{f(x)=f\_\{m-1\}(x)\} rmi=−\[∂f(xi)∂L(xi,f(xi))\]f(x)=fm−1(x)

此时不同的损失函数将会得到不同的负梯度，假设选择平方损失：  
 L ( y , f ( x i ) ) = 1 2 ( y − f ( x i ) ) 2 L(y,f(x\_i))=\\frac\{1\}\{2\}(y-f(x\_i))^2 L(y,f(xi))=21(y−f(xi))2  
则负梯度为：  
 r m i = − \[ ∂ L ( x i , f ( x i ) ) ∂ f ( x i ) \] f ( x ) = f m − 1 ( x ) = y − f ( x i ) r\_\{mi\}=-\[\\frac\{\\partial L(x\_i,f(x\_i))\}\{\\partial f(x\_i)\}\]\_\{f(x)=f\_\{m-1\}(x)\}=y-f(x\_i) rmi=−\[∂f(xi)∂L(xi,f(xi))\]f(x)=fm−1(x)=y−f(xi)  
此时发现**GBDT的负梯度就是残差，所以说对于回归问题，我们要拟合的就是残差**。那么对于分类问题，二分类和多分类的损失函数都是`log`loss。因为损失函数有很多种，所以用负梯度拟合来做通用的拟合方法。

### 四、GBDT中常用的损失函数 ###

在梯度提升分类树有两种可选的损失函数，一种是`‘exponential：指数损失’`，一种是`‘deviance：对数损失’`；

而在梯度提升回归树有四种可选的损失函数，分别为`'ls：平方损失'`，`'lad:绝对损失'`，`'huber：huber损失'`，`'quantile：分位数损失'`。

对于分类算法，其损失函数一般有对数损失函数和指数损失函数两种:

1.  如果是指数损失函数，则损失函数表达式为：  
     L ( y , f ( x ) ) = e x p ( − y f ( x ) ) L(y,f(x))=exp(-yf(x)) L(y,f(x))=exp(−yf(x))  
    其负梯度计算和叶子节点的最佳负梯度拟合参见Adaboost算法原理。
2.  如果是对数损失函数，分为二元分类和多元分类两种：

对于二元分类，用类似于逻辑回归的对数似然损失函数：  
 L ( y , f ( x ) ) = l o g ( 1 + e x p ( − y f ( x ) ) ) L(y,f(x))=log(1+exp(−yf(x))) L(y,f(x))=log(1\+exp(−yf(x)))

对于多元分类：设类别数为k：  
 L ( y , f ( x ) ) = − ∑ k = 1 K y k log ⁡ p k ( x ) L(y,f(x))=−\\sum\_\{k=1\}^Kyk\\log p\_k(x) L(y,f(x))=−k=1∑Kyklogpk(x)  
 y k y\_k yk为样本数据估计值，当一个样本 x x x属于 k k k时， y k = 1 y\_k=1 yk=1，否则 y k = 0 y\_k=0 yk=0。

对于回归算法，常用损失函数有如下4种:

1.  均方差，这个是最常见的回归损失函数：  
     L ( y , f ( x ) ) = ( y − f ( x ) ) 2 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)| L(y,f(x))=∣y−f(x)∣
    
    对应负梯度误差为：  
     s i g n ( y i − f ( x i ) ) sign(y\_i−f(x\_i)) sign(yi−f(xi))
3.  Huber损失，它是均方差和绝对损失的折衷产物，对于远离中心的异常点，采用绝对损失，而中心附近的点采用均方差。这个界限一般用分位数点度量。损失函数如下：  
    ![1cfb3e40a4a44c92918e33cd6c7c689e.png][]  
    对应的负梯度误差为：  
    ![70c88b802c24490fb5d43a7e39d89e65.png][]
4.  分位数损失。它对应的是分位数回归的损失函数，表达式为：  
     L ( y , f ( x ) ) = ∑ y ≥ f ( x ) θ ∣ y − f ( x ) ∣ + ∑ y < f ( x ) ( 1 − θ ) ∣ y − f ( x ) ∣ L(y,f(x))=\\sum\_\{y≥f(x)\}θ|y−f(x)|+\\sum\_\{y<f(x)\}(1−θ)|y−f(x)| L(y,f(x))=y≥f(x)∑θ∣y−f(x)∣\+y<f(x)∑(1−θ)∣y−f(x)∣  
    其中 θ \\theta θ为分位数，需要我们在回归前指定。对应的负梯度误差为：  
    ![76791aaa8e73444595d78ff447f27994.png][]  
    对于Huber损失和分位数损失，主要用于健壮回归，也就是减少异常点对损失函数的影响。

### 五、GBDT算法原理描述 ###

因为分类算法的输出是不连续的类别值，需要一些处理才能使用负梯度，所以GBDT的回归和分类算法这里分开介绍。

**1. GBDT回归算法基本模版：**

输入是训练集样本 T = \{ ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . , ( x m , y m ) \} T=\\\{(x\_1,y\_1),(x\_2,y\_2),...,(x\_m,y\_m)\\\} T=\{(x1,y1),(x2,y2),...,(xm,ym)\}， 最大迭代次数 T T T, 损失函数 L L L。

输出是强学习器 f ( x ) f(x) f(x)，是一颗回归树。

1.  初始化弱学习器（估计使损失函数极小化的常数值，它是只有一个根节点的树，一般平方损失函数为节点的均值，而绝对损失函数为节点样本的中位数）：  
     f 0 ( x ) = arg ⁡ min ⁡ c ∑ i = 1 m L ( y i , c ) f\_0(x)=\\arg\\min\_\{c\}\\sum\_\{i=1\}^mL(y\_i,c) f0(x)=argcmini=1∑mL(yi,c)
2.  对迭代轮数 t = 1 , 2 , . . . , T t=1,2,...,T t=1,2,...,T有（即生成的弱学习器个数）：
    
    (1) 对样本 i = 1 , 2 ， . . . , m i=1,2，...,m i=1,2，...,m，计算负梯度（损失函数的负梯度在当前模型的值将它作为残差的估计，对于平方损失函数为，它就是通常所说的残差；而对于一般损失函数，它就是残差的近似值（伪残差））：  
     r t i = − \[ ∂ L ( y i , f ( x i ) ) ) ∂ f ( x i ) \] f ( x ) = f t − 1 ( x ) r\_\{ti\}=−\[\\frac\{∂L(y\_i,f(x\_i)))\}\{∂f(x\_i)\}\]\_\{f(x)=f\_\{t−1\}(x)\} rti=−\[∂f(xi)∂L(yi,f(xi)))\]f(x)=ft−1(x)
    
    (2)利用 ( x i , r t i ) ( i = 1 , 2 , . . m ) (x\_i,r\_\{ti\})(i=1,2,..m) (xi,rti)(i=1,2,..m)，即 \{ ( x 1 , r t 1 ) , . . . , ( x i , r t i ) \} \\\{(x\_1,r\_\{t1\}),...,(x\_i,r\_\{ti\})\\\} \{(x1,rt1),...,(xi,rti)\}，拟合一颗CART回归树，得到第  t t t 颗回归树。其对应的叶子节点区域为 R t j ， j = 1 , 2 , . . . , J R\_\{tj\}，j=1,2,...,J Rtj，j=1,2,...,J。其中 J J J为回归树t的叶子节点的个数。
    
    (3)对叶子区域 j = 1 , 2 , . . J j =1,2,..J j=1,2,..J，计算最佳拟合值：  
     c t j = arg ⁡ min ⁡ c ∑ x i ∈ R t j L ( y i , f t − 1 ( x i ) + c ) c\_\{tj\}=\\arg\\min\_\{c\}\\sum\_\{x\_i∈R\_\{tj\}\}L(y\_i,f\_\{t−1\}(x\_i)+c) ctj=argcminxi∈Rtj∑L(yi,ft−1(xi)\+c)
    
    (4)更新强学习器：  
     f t ( x ) = f t − 1 ( x ) + ∑ j = 1 J c t j I ( x ∈ R t j ) f\_t(x)=f\_\{t−1\}(x)+\\sum\_\{j=1\}^Jc\_\{tj\}I(x∈R\_\{tj\}) ft(x)=ft−1(x)\+j=1∑JctjI(x∈Rtj)
3.  得到最终的回归树，即强学习器 f ( x ) f(x) f(x)的表达式：  
     f ( x ) = f T ( x ) = f 0 ( x ) + ∑ t = 1 T ∑ j = 1 J c t j I ( x ∈ R t j ) f(x)=f\_T(x)=f\_0(x)+\\sum\_\{t=1\}^T\\sum\_\{j=1\}^Jc\_\{tj\}I(x∈R\_\{tj\}) f(x)=fT(x)=f0(x)\+t=1∑Tj=1∑JctjI(x∈Rtj)

GBDT的分类算法：GBDT的分类算法从思想上和GBDT的回归算法没有区别，但是由于样本输出不是连续的值，而是离散的类别，导致我们无法直接从输出类别去拟合类别输出的误差。

为了解决这个问题，主要有两个方法，一个是用指数损失函数，此时GBDT退化为Adaboost算法。另一种方法是用类似于逻辑回归的对数似然损失函数的方法。也就是说，我们用的是类别的预测概率值和真实概率值的差来拟合损失。这里主要介绍用对数似然损失函数的GBDT分类。而对于对数似然损失函数，我们又有二元分类和多元分类的区别。

**2. 二元GBDT分类算法基本模板(log损失)：**

输入：训练数据集 T = \{ ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . , ( x m , y m ) \} T=\\\{(x\_1,y\_1),(x\_2,y\_2),...,(x\_m,y\_m)\\\} T=\{(x1,y1),(x2,y2),...,(xm,ym)\}，对于二元GBDT用类似于逻辑回归的对数似然损失函数，损失函数为： L ( y , f ( x ) ) = log ⁡ ( 1 + e x p ( − y f ( x ) ) ) L(y,f(x))=\\log(1+exp(−yf(x))) L(y,f(x))=log(1\+exp(−yf(x)))。

输出：分类树 f ( x ) f(x) f(x)

1.  初始化：  
     f 0 ( x ) = 1 2 log ⁡ P ( y = 1 ∣ x ) P ( y = − 1 ∣ x ) f\_0(x)=\\frac\{1\}\{2\}\\log \\frac\{P(y=1|x)\}\{P(y=−1|x)\} f0(x)=21logP(y=−1∣x)P(y=1∣x)
2.  对迭代轮数  t = 1 , 2 , . . . T t=1,2,...T t=1,2,...T 有：

(1)对样本 i = 1 , 2 ， . . . m i=1,2，...m i=1,2，...m，计算负梯度:

其中 y ∈ \{ − 1 , + 1 \} y∈\\\{−1,+1\\\} y∈\{ −1,\+1\}。则此时的负梯度误差为：  
 r t i = − \[ ∂ L ( y , f ( x i ) ) ) ∂ f ( x i ) \] f ( x ) = f t − 1 ( x ) = y i ( 1 + e x p ( y i f ( x i ) ) ) r\_\{ti\}=−\[\\frac\{∂L(y,f(x\_i)))\}\{∂f(x\_i)\}\]\_\{f(x)=f\_\{t−1\}(x)\}=y\_i(1+exp(y\_if(x\_i))) rti=−\[∂f(xi)∂L(y,f(xi)))\]f(x)=ft−1(x)=yi(1\+exp(yif(xi)))

(2)对概率残差 \{ ( x 1 , r t 1 ) , . . . , ( x i , r t i ) \} \\\{(x\_1,r\_\{t1\}),...,(x\_i,r\_\{ti\})\\\} \{(x1,rt1),...,(xi,rti)\}拟合一个分类树，得到第  t t t 棵树的叶节点区域 R t j    ,    j = 1 , 2 , . . . , J R\_\{tj\}\\;,\\;j=1,2,...,J Rtj,j=1,2,...,J。其中 J J J为回归树 t t t的叶子节点的个数:

(3)对叶子区域  j = 1 , 2 , . . J j =1,2,..J j=1,2,..J，即生成的决策树，计算各个叶子节点的最佳负梯度拟合值为：  
 c t j = arg ⁡ min ⁡ c ∑ x i ∈ R t j log ⁡ ( 1 + e x p ( − y i ( f t − 1 ( x i ) + c ) ) ) c\_\{tj\}=\\arg\\min\_\{c\}\\sum\_\{x\_i∈R\_\{tj\}\}\\log(1+exp(−y\_i(f\_\{t−1\}(x\_i)+c))) ctj=argcminxi∈Rtj∑log(1\+exp(−yi(ft−1(xi)\+c)))

由于上式比较难优化，我们一般使用近似值代替：  
 c t j = ∑ x i ∈ R t j r t i ∑ x i ∈ R t j ∣ r t i ∣ ( 1 − ∣ r t i ∣ ) c\_\{tj\}=\\frac\{\\sum\_\{x\_i∈R\_\{tj\}\}r\_\{ti\}\}\{\\sum\_\{x\_i∈R\_\{tj\}\}|r\_\{ti\}|(1−|r\_\{ti\}|)\} ctj=∑xi∈Rtj∣rti∣(1−∣rti∣)∑xi∈Rtjrti

(4)更新强学习器：  
 f t ( x ) = f t − 1 ( x ) + ∑ j = 1 J c t j I ( x ∈ R t j ) f\_t(x)=f\_\{t−1\}(x)+\\sum\_\{j=1\}^Jc\_\{tj\}I(x∈R\_\{tj\}) ft(x)=ft−1(x)\+j=1∑JctjI(x∈Rtj)

1.  得到最终的分类树，即强学习器 f ( x ) f(x) f(x)的表达式：  
     f ( x ) = f T ( x ) = f 0 ( x ) + ∑ t = 1 T ∑ j = 1 J c t j I ( x ∈ R t j ) f(x)=f\_T(x)=f\_0(x)+\\sum\_\{t=1\}^T\\sum\_\{j=1\}^Jc\_\{tj\}I(x∈R\_\{tj\}) f(x)=fT(x)=f0(x)\+t=1∑Tj=1∑JctjI(x∈Rtj)

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

由于我们用的是类别的预测概率值和真实概率值的差来拟合损失，所以最后还要将概率转换为类别，如下：

P ( y = 1 ∣ x ) = 1 1 + e x p ( − f ( x ) ) P(y=1|x)=\\frac\{1\}\{1+exp(−f(x))\} P(y=1∣x)=1\+exp(−f(x))1  
 P ( y = − 1 ∣ x ) = 1 1 + e x p ( f ( x ) ) P(y=−1|x)=\\frac\{1\}\{1+exp(f(x))\} P(y=−1∣x)=1\+exp(f(x))1

最终输出比较类别概率大小，概率大的就预测为该类别。

**3. 多元GBDT分类算法基本模型(log损失)：**

多元GBDT要比二元GBDT复杂一些，对应的是多元逻辑回归和二元逻辑回归的复杂度差别。

输入：训练数据集 T = \{ ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . ( x m , y m ) \} T=\\\{(x\_1,y\_1),(x\_2,y\_2),...(x\_m,y\_m)\\\} T=\{(x1,y1),(x2,y2),...(xm,ym)\}，假设类别数为 K K K，则对数似然损失函数为：  
 L ( y , f ( x ) ) = − ∑ k = 1 K y k log ⁡ p k ( x ) ， y k = \{ 0 , 1 \} L(y,f(x))=−\\sum\_\{k=1\}^Ky\_k\\log p\_k(x)，y\_k=\\\{0,1\\\} L(y,f(x))=−k=1∑Kyklogpk(x)，yk=\{ 0,1\}  
其中 y k = \{ 0 , 1 \} y\_k=\\\{0,1\\\} yk=\{ 0,1\}表示是否属于第 k k k类别，1表示是，0表示否。 k = 1 , 2 , . . . , K k=1,2,...,K k=1,2,...,K，表示共有多少分类的类别。

输出：分类树 f ( x ) f(x) f(x)

1.  初始化：  
     f k 0 ( x ) = 0 , k = 1 , 2 , . . . , K f\_\{k0\}(x)=0,k=1,2,...,K fk0(x)=0,k=1,2,...,K
2.  对迭代轮数 t = 1 , 2 , . . . , T t=1,2,...,T t=1,2,...,T 有：

对样本 i = 1 , 2 , . . . , m i=1,2,...,m i=1,2,...,m，计算样本点属于每个类别的概率(其中如果样本输出类别为 k k k，则 y k = 1 y\_k=1 yk=1。第 k k k类的概率)：

p k ( x ) = e x p ( f k ( x ) ) ∑ l = 1 K e x p ( f l ( x ) ) p\_k(x)=\\frac\{exp(f\_k(x))\}\{\\sum\_\{l=1\}^Kexp(f\_l(x))\} pk(x)=∑l=1Kexp(fl(x))exp(fk(x))  
(2.1) 对类别 k = 1 , 2 , . . . , K k=1,2,...,K k=1,2,...,K：

集合上两式(损失函数和第 k k k类的概率)，可以计算出第  t t t 轮的第  i i i 个样本对应类别l的负梯度误差为:

r t i l = − \[ ∂ L ( y i , f ( x i ) ) ) ∂ f ( x i ) \] f k ( x ) = f l , t − 1 ( x ) = y i l − p l , t − 1 ( x i ) r\_\{til\}=−\[\\frac\{∂L(y\_i,f(x\_i)))\}\{∂f(x\_i)\}\]\_\{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 i 对应类别l的真实概率和  t − 1 t−1 t−1 轮预测概率的差值。

(2.2) 对概率伪残差 \{ ( x 1 , r t 1 l ) , . . . , ( x i , r t i l ) \} \\\{(x\_1,r\_\{t1l\}),...,(x\_i,r\_\{til\})\\\} \{(x1,rt1l),...,(xi,rtil)\}拟合一个分类树。

(2.3) 对于生成的决策树，我们各个叶子节点的最佳负梯度拟合值为:  
 c t j l = arg ⁡ min ⁡ c j l ∑ i = 0 m ∑ k = 1 K L ( y k , f t − 1 , l ( x ) + ∑ j = 0 J c j l I ( x i ∈ R t j l ) ) c\_\{tjl\}=\\arg\\min\_\{c\_\{jl\}\}∑\_\{i=0\}^m∑\_\{k=1\}^KL(y\_k,f\_\{t−1,l\}(x)+∑\_\{j=0\}^Jc\_\{jl\}I(x\_i∈R\_\{tjl\})) ctjl=argcjlmini=0∑mk=1∑KL(yk,ft−1,l(x)\+j=0∑JcjlI(xi∈Rtjl))  
由于上式比较难优化，我们一般使用近似值代替:  
 c t j l = K − 1 K ∑ x i ∈ R t j l r t i l ∑ x i ∈ R t i l ∣ r t i l ∣ ( 1 − ∣ r t i l ∣ ) c\_\{tjl\}=\\frac\{K−1\}\{K\}\\frac\{∑\_\{x\_i∈R\_\{tjl\}\}r\_\{til\}\}\{∑\_\{x\_i∈R\_\{til\}\}|r\_\{til\}|(1−|r\_\{til\}|)\} ctjl=KK−1∑xi∈Rtil∣rtil∣(1−∣rtil∣)∑xi∈Rtjlrtil  
(2.4) 更新强学习器：  
 f t k ( x ) = f t − 1 , k ( x ) + ∑ j = 1 J c t k j I ( x ∈ R t k j ) f\_\{tk\}(x)=f\_\{t−1,k\}(x)+∑\_\{j=1\}^Jc\_\{tkj\}I(x∈R\_\{tkj\}) ftk(x)=ft−1,k(x)\+j=1∑JctkjI(x∈Rtkj)

1.  得到最终的分类树，即强学习器 f ( x ) f(x) f(x)的表达式：  
     f ( x ) = f T k ( x ) = f 0 ( x ) + ∑ t = 1 T ∑ j = 1 J c t k j I ( x ∈ R t k j ) f(x)=f\_\{Tk\}(x)=f\_0(x)+∑\_\{t=1\}^T∑\_\{j=1\}^Jc\_\{tkj\}I(x∈R\_\{tkj\}) f(x)=fTk(x)=f0(x)\+t=1∑Tj=1∑JctkjI(x∈Rtkj)  
    除了负梯度计算和叶子节点的最佳负梯度拟合的线性搜索，多元GBDT分类和二元GBDT分类以及GBDT回归算法过程相同。

### 六、GBDT的正则化 ###

和Adaboost一样，我们也需要对GBDT进行正则化，防止过拟合。GBDT的正则化主要有三种方式：

(1). Adaboost类似的正则化项，即步长(learning rate)。定义为 v v v，对于前面的弱学习器的迭代：  
 f k ( x ) = f k − 1 ( x ) + h k ( x ) f\_k(x)=f\_\{k−1\}(x)+h\_k(x) fk(x)=fk−1(x)\+hk(x)  
如果我们加上了正则化项，则有：  
 f k ( x ) = f k − 1 ( x ) + ν h k ( x ) f\_k(x)=f\_\{k−1\}(x)+νh\_k(x) fk(x)=fk−1(x)\+νhk(x)  
 ν ν ν的取值范围为0<  ν ν ν ≤1。对于同样的训练集学习效果，较小的  ν ν ν 意味着我们需要更多的弱学习器的迭代次数。通常我们用步长和迭代最大次数一起来决定算法的拟合效果。

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

(3). 对于弱学习器即CART回归树进行正则化剪枝。具体可参看决策树算法原理。

### 七、GBDT优缺点 ###

优点：

1.可以灵活处理各种类型的数据，包括连续值和离散值；

2.相对于SVM来说，较少的调参可以达到较好的预测效果；

3.使用健壮的损失函数时，模型鲁棒性非常强，受异常值影响小。

缺点：

1.由于弱学习器之间存在依赖关系，难以并行训练数据。不过可以通过自采样的SGBT来达到部分并行。

[1300f671e62a4e25800ca6a93dc482ab.png]: https://img-blog.csdnimg.cn/1300f671e62a4e25800ca6a93dc482ab.png
[1cfb3e40a4a44c92918e33cd6c7c689e.png]: https://img-blog.csdnimg.cn/1cfb3e40a4a44c92918e33cd6c7c689e.png
[70c88b802c24490fb5d43a7e39d89e65.png]: https://img-blog.csdnimg.cn/70c88b802c24490fb5d43a7e39d89e65.png
[76791aaa8e73444595d78ff447f27994.png]: https://img-blog.csdnimg.cn/76791aaa8e73444595d78ff447f27994.png