机器学习 の04 梯度提升决策树GBDT
机器学习 の04 梯度提升决策树GBDT
- GBDT的背景知识
- 集成学习（ensemble learning）
- Bagging（Bootstrap Aggregating）算法
- Boosting提升算法
- Bagging和Boosting 的主要区别
- boosting系列算法之AdaBoost算法
- boosting系列算法之提升树
- 基学习器的常见问题
- GBDT的基本概念
- GBDT的算法描述
- GBDT回归树的基本模版
- GBDT回归算法描述
- GBDT分类算法描述
- GBDT与AdaBoost的区别与联系
- GBDT的Python实现
GBDT的背景知识
集成学习（ensemble learning）
基本概念：
集成学习：通过构建并结合多个学习器来完成学习任务。如何产生“好而不同”的个体学习器，是集成学习研究的核心。
集成学习方法：是指将多个学习模型组合，以获得更好的效果，使组合后的模型具有更强的泛化能力。
分类：
一般来说，集成学习可以分为三大类：
1、用于减少方差的 bagging，包括：随机森林；
2、用于减少偏差的 boosting，包括：Adaboosting，提升树（代表是GBDT）, XGBoost等 ；
3、用于提升预测结果的 stacking；
或者，根据个体学习器的生成方式不同，集成学习也分为两大类：
1、串行集成方法：个体学习器间存在强依赖关系、必须串行生成的序列化方法。可以通过给错分样本一个较大的权重来提升性能，比如：boosting算法。
2、并行集成方法：个体学习器之间不存在强依赖关系（彼此独立）、可同时生成的并行化方法。可以通过取平均来降低误差，比如bagging算法。
Bagging + 决策树 = 随机森林
AdaBoost + 决策树 = 提升树
gradient + 决策树 = GDBT
Bagging（Bootstrap Aggregating）算法
基本概念：
Bagging（套袋法）：对训练样本使用装袋采样来获取数据子集，在数据子集上分别训练基础学习器，最后合并每一个学习器的结果，作为最终的学习结果。通常分类任务使用投票的方式集成，而回归任务通过平均的方式集成。
备注：Bagging算法在采样时，可以取全部特征进行训练，也可以随机选取部分特征进行训练（例如：随机森林）。
算法的具体过程：
1、从原始样本集中抽取训练集。每轮从原始样本集中使用Bootstraping（也称 自助法，它是一种有放回的抽样方法）的方法抽取n个训练样本（在训练集中，有些样本可能被多次抽取到，而有些样本可能一次都没有被抽中）。共进行k轮抽取，得到k个训练集。（假设k个训练集之间是相互独立的，事实上不是完全独立）
2、每次使用一个训练集得到一个模型，k个训练集共得到k个模型。（注：这里并没有具体的分类或回归方法，我们可以根据具体问题采用不同的分类或回归方法，如决策树、感知器等）；
3、对分类问题：将上步得到的k个模型采用投票的方式得到分类结果；对回归问题，计算上述模型的均值作为最后的结果。（所有模型的重要性相同）
Bagging方法的具体过程如下图所示：
优缺点：
Bagging的优势在于当原始样本中有噪声数据时，通过bagging抽样，那么就有1/3的噪声样本不会被训练。对于受噪声影响的分类器，bagging对模型是有帮助的。所以说bagging可以降低模型的方差，不容易受噪声的影响，广泛应用在不稳定的模型，或者倾向于过拟合的模型。
Boosting提升算法
基本概念：
Boosting算法：是将弱学习算法组合成强学习算法，它是一个不断迭代提升的过程，整体是串行执行的（XGBoost在建立回归树的过程中可以实现并行化）。
基本思想：
不同的训练集是通过调整每个样本对应的权重 W i W_i Wi实现的，不同的权重对应不同的样本分布，而这个权重为分类器不断增加对错分样本的重视程度。
分类：
Boosting主要的代表算法有Adaboost，GBDT，XGBoost。
Boosting的两个核心问题：
1、如何改变每一轮中训练数据的权值或概率分布？
Answer：通过提高那些在前一轮被弱分类器分错样例的权值，减小前一轮分对样例的权值，来使得分类器对误分的数据有较好的效果。
2、如何将多个弱分类器组合成一个强分类器？
Answer：通过加法模型将弱分类器进行线性组合。
算法的具体过程：
1、首先赋予每个训练样本相同的初始化权重，在此训练样本分布下训练出一个弱分类器（基学习器）；
2、再根据基学习器的表现对训练样本分布进行调整（数据加权），使得先前基学习器做错的训练样本在后续受到更多关注；
3、基于调整后的样本分布来训练下一个基学习器，并且更新样本权重；
4、重复进行上述步骤，直至基学习器数目达到事先指定的值 T T T，最终将这 T T T 个基学习器进行加权结合。
Boosting方法的具体过程如下图所示（图片来源）：
弱分类器：
Boosting处理过程：
缺点：
由于Boosting将注意力集中在难分的样本上，使得它对训练样本的噪声非常敏感，主要任务集中在噪声样本上，从而影响最终的分类性能。
Bagging和Boosting 的主要区别
1、样本选择上：Bagging采用随机有放回取样（Bootstraping）；Boosting每一轮的训练样本是固定的，改变的是每个样本的权重。
2、样本权重上：Bagging采取的是均匀取样，且每个样本的权重相同；Boosting根据错误率调整样本权重，错误率越大的样本权重也越大。
3、预测函数上：Bagging所有预测函数的权值相同，Boosting中误差越小的预测函数权值越大。
4、集成方式上：Bagging 的各个预测函数可以并行生成；Boosting的各个预测函数必须按照顺序迭代生成。
5、改善误差上：Bagging通过降低基分类器的方差，改善了泛化误差；Boosting通过降低基分类器的偏差，改善了泛化误差。
6、基分类器选择上：Bagging中所有的弱分类器必须是同种模型；Boosting中所有的弱分类器可以是不同类的。
boosting系列算法之AdaBoost算法
解决主要问题：
Boosting算法存在一个重大缺陷：该分类算法要求预先知道弱分类器识别准确率的下限。与Boosting分类算法相比，AdaBoost算法不需要预先获得弱分类算法识别准确率的下限(弱分类器的误差)，只需关注于所有弱分类算法的分类精度(分类准确率略大于50％)。
基本概念：
AdaBoost（Adaptive boosting）算法：是一种自适应提升的方法，由于训练的过程是重复使用相同的训练集，因而不要求数据集很大，其自身就可以组合任意数量的基分类器。算法过程简述为：前一个分类器改变权重w后，成为后一个新的分类器。
基本特点：
1、AdaBoost算法每一轮都要判断当前基学习器是否满足条件，一旦条件不满足，则当前学习器被抛弃，且学习过程停止。
2、AdaBoost算法中的个体学习器存在着强依赖关系，应用的是串行生成的序列化方法。每一个基生成器的目标，都是为了最小化损失函数。所以，可以说AdaBoost算法注重减小偏差。
3、由于属于boosting算法族，采用的是加性模型，对每个基学习器的输出结果加权处理，只会得到一个输出预测结果。所以标准的AdaBoost只适用于二分类任务。
4、AdaBoost算法，通过每一次迭代改变训练数据的权值分布，使得数据在每一个基本分类器的学习中起到不同作用，从而使不同数据发挥各自不同的作用，因此不易发生过拟合。
5、相关的训练误差分析表明，每一次迭代后构建的分类器，其分类误差率随着迭代次数增加而稳定下降。
详细算法流程：
Given: ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . , ( x m , y m ) (x_1,y_1),(x_2,y_2),...,(x_m,y_m) (x1,y1),(x2,y2),...,(xm,ym) where x i ∈ X , y i ∈ Y = { − 1 , + 1 } x_i∈X,y_i∈Y=\{-1,+1\} xi∈X,yi∈Y={−1,+1}
Initialize: D 1 ( i ) = 1 m , i = 1 , . . . , m . D_1(i)=\frac{1}{m}, i=1,...,m. D1(i)=m1,i=1,...,m.
For t = 1 , 2 , . . . , T : t=1,2,...,T: t=1,2,...,T:
- Train weak learner using distribution D t . D_t. Dt.
- Get weak hypothesis h t : X → { − 1 , + 1 } h_t:X\rightarrow\{-1,+1\} ht:X→{−1,+1}which minimizes error wrt D t D_t Dt,i.e., h t = a r g m i n h j ε j w h e r e ε j = ∑ i = 1 m D t ( i ) [ h j ( x i ) ≠ y i ] . h_t=arg \underset{{h_j}}{min}ε_j \quad where \quad ε_j=\sum_{i=1}^{m}D_t(i)[h_j(x_i)≠y_i]. ht=arghjminεjwhereεj=i=1∑mDt(i)[hj(xi)̸=yi].
- Choose α t = 1 2 l n ( 1 − ε t ε t ) . α_t=\frac{1}{2}ln\Big(\frac{1-ε_t}{ε_t}\Big). αt=21ln(εt1−εt).
- Update:
D t + 1 ( i ) = D t ( i ) Z t × { e − α t i f h t ( x i ) = y i e − α t i f h t ( x i ) ≠ y i = D t ( i ) e x p ( − α t y i h t ( x ) ) Z t D_{t+1}(i)=\frac{D_t(i)}{Z_t}×\begin{cases} \mathbf e^{-α_t} & &if \quad h_t(x_i)=y_i\\ \mathbf e^{-α_t} & &if \quad h_t(x_i)≠y_i\\ \end{cases}\\ \\ \quad \\=\frac{D_t(i)exp(-α_ty_ih_t(x))}{Z_t} Dt+1(i)=ZtDt(i)×{e−αte−αtifht(xi)=yiifht(xi)̸=yi=ZtDt(i)exp(−αtyiht(x))
where Z t Z_t Zt is a normalization factor(chosen so that D t + 1 D_{t+1} Dt+1 will be a distribution).Output the final hypothesis:
H ( x ) = s i g n ( ∑ t = 1 T α t h t ( x ) ) . H(x)=sign\Big(\sum_{t=1}^{T}α_th_t(x)\Big). H(x)=sign(t=1∑Tαtht(x)).
参数说明：
D t ( i ) D_t(i) Dt(i): 样本 x i x_i xi 在第 t t t 次迭代的权重， D 1 ( i ) = 1 / m D_1(i)=1/m D1(i)=1/m；
h t ( X ) h_t(X) ht(X)：使用具有权值分布 D m D_m Dm的训练数据集学习，得到的基本分类器： h t : X → { − 1 , + 1 } h_t:X\rightarrow\{-1,+1\} ht:X→{−1,+1}；
ε t ε_t εt：基本分类器 h t ( X ) h_t(X) ht(X)的错误率，加权分类误差（weighted error）；
α t α_t αt：分类器的系数，根据误差计算，误差越小，权重越大；
备注：上面权重 D t + 1 ( i ) D_{t+1}(i) Dt+1(i)的更新是基于前一步的权重 D t ( i ) D_t(i) Dt(i)，而非局域全局更新。
过程简述如下：
输入：
1）训练数据集T= { ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . , ( x m , y m ) } \{(x_1,y_1),(x_2,y_2),...,(x_m,y_m)\} {(x1,y1),(x2,y2),...,(xm,ym)}，其中 x i x_i xi表示训练数据， y i = { − 1 , + 1 } y_i=\{-1,+1\} yi={−1,+1}表示标签；
2）弱分类器输出：
最终分类器 H ( x ) H(x) H(x)
执行过程：
（1）初始化训练数据的权值分布：
训练数据的权重分布为 D 1 ( i ) = 1 / m , i = 1 , . . . , m . D_1(i)=1/m,\quad i=1,...,m. D1(i)=1/m,i=1,...,m.（即：平均分配）
（2）选择基本分类器 ：
例如：选择最简单的线性分类器 y = a X + b y=aX+b y=aX+b ，分类器选定之后，使用具有权值分布 D m D_m Dm的训练数据集学习，得到基本分类器： h t ( x ) ： X → { − 1 , + 1 } h_t(x)：X\rightarrow\{-1,+1\} ht(x)：X→{−1,+1}，最小化分类误差可以求得参数。
（3）计算分类器的系数和更新数据权重：
误差率 ε t ε_t εt可以求出来，同时可以求出分类器的系数 α t = 1 2 l n ( 1 − ε t ε t ) α_t=\frac{1}{2}ln\Big(\frac{1-ε_t}{ε_t}\Big) αt=21ln(εt1−εt)，更新数据权重 D t + 1 ( i ) = D t ( i ) Z t e x p ( − α t y i h t ( x ) ) D_{t+1}(i)=\frac{D_t(i)}{Z_t}exp(-α_ty_ih_t(x)) Dt+1(i)=ZtDt(i)exp(−αtyiht(x))
（4）构建基本分类器的线性组合，得到最终分类器：
H ( x ) = s i g n ( ∑ t = 1 T α t h t ( x ) ) . H(x)=sign\Big(\sum_{t=1}^{T}α_th_t(x)\Big). H(x)=sign(t=1∑Tαtht(x)).
优缺点：
AdaBoost的主要优点：
1、是一种有高精度的分类器
2、可以使用各种方法构建子分类器，adaboost算法提供的是一种框架
3、基本分类器构建简单，易于理解
4、算法过程简单，不用做特征筛选
5、不易发生过拟合
AdaBoost的主要缺点：
1、提升的过程对噪声和离群点的干扰尤为明显。
boosting系列算法之提升树
基本概念：
提升树(boosted tree)：是以决策树（分类树或回归树）为 基分类器 ，采用 加法模型 与 前向分布算法 的提升方法。由于树的线性组合可以很好地拟合训练数据，即使数据中的输入与输出之间的关系很复杂也是如此，所以提升树是一个高功能的学习算法。
提升树模型可以表示为决策树的加法模型：
f m ( x ) = ∑ m = 1 M T ( x ; θ m ) f_m(x)= ∑_{m=1}^MT(x;θ_m) fm(x)=m=1∑MT(x;θm)
其中， T ( x ; θ m ) T(x;θ_m) T(x;θm)表示决策树； θ m θ_m θm为决策树的参数； M M M为树的个数。
回归问题的提升树算法：
输入：训练数据集 T = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , ⋅ ⋅ ⋅ , ( x N , y N ) } , x i ∈ χ = R n , y i ∈ γ , i = 1 , 2 , ⋅ ⋅ ⋅ , N T=\{(x_1,y_1),(x_2,y_2),⋅⋅⋅,(x_N,y_N)\},x_i∈χ=R_n,\quad y_i∈γ,\quad i=1,2,⋅⋅⋅,N T={(x1,y1),(x2,y2),⋅⋅⋅,(xN,yN)},xi∈χ=Rn,yi∈γ,i=1,2,⋅⋅⋅,N， γ γ γ 为输出空间。
输出：提升树 f M ( x ) f_M(x) fM(x)
执行过程：
（1）初始化 f 0 ( x ) = 0 f_0(x)=0 f0(x)=0
（2）对于 m = 1 , 2 , . . . M m=1,2,...M m=1,2,...M：
- 计算残差（后一棵树拟合前一颗树残差）： r m i = y i − f m − 1 ( x i ) r_{mi}=y_i−f_{m−1}(x_i) rmi=yi−fm−1(xi)；
- 拟合残差学习一个回归树，得到 T ( x ; θ m ) T(x;θ_m) T(x;θm)
- 更新 f m ( x ) = f m − 1 ( x ) + T ( x ; θ m ) f_m(x)=f_{m−1}(x)+T(x;θ_m) fm(x)=fm−1(x)+T(x;θm)
\quad（3）M次迭代之后得到提升树：
f M ( x ) = ∑ m = 1 M T ( x ; θ m ) f_M(x)=∑_{m=1}^{M}T(x;θ_m) fM(x)=m=1∑MT(x;θm)
boosted tree优势：
1.使用不同类型自变量数据时，不需要做特征归一化/标准化/最大最小化
2.可输出特征变量的相对重要程度，作为特征选择方法
3.模型可解释性好
4.对数据字段缺失不敏感
5.能自动做多组特征变量间的interaction，具有良好的非线性性
6.容易平衡运行时效率和精度，如使用boosted tree做的在线预测模型在机器资源紧张时可截断参与预测的决策树数量从而提高预测效率
基学习器的常见问题
1、为什么使用决策树作为基学习器/ 基学习器有什么特点？
1、决策树的表达能力和泛化能力，可以通过剪枝快速调整；
2、决策树可以方便地将样本的权重整合到训练过程中；
3、决策树是一种不稳定的学习器；
2、为什么不稳定的学习器更适合作为基学习器？
1、所谓不稳定，指的是数据样本的扰动会对学习器的结果产生较大的影响；
2、不稳定的学习器容易受到样本分布的影响（方差大），很好的引入了随机性；这有助于在集成学习（特别是采用 Bagging 策略）中提升模型的泛化能力。
3、为了更好的引入随机性，有时会随机选择一个属性子集中的最优分裂属性，而不是全局最优（随机森林）。
3、还有哪些模型也适合作为基学习器？
神经网络也属于不稳定的学习器，通过调整神经元的数量、网络层数，连接方式初始权重也能很好的引入随机性和改变模型的表达能力和泛化能力。
GBDT的基本概念
基本概念：
梯度提升决策树（GBDT）：是一种迭代的决策树算法，由多颗决策树组成。GBDT中的决策树都是回归树(非分类树)，所有决策树结论累加起来做最终分类预测，是集成学习boosting家族中的一员。
适用范围：
GBDT是一个应用很广泛的算法，可以用于：
（1） 分类：例如，二分类问题（设定阈值，大于阈值为正例，反之为负例）；
（2） 回归 ：几乎可用于所有回归问题（线性/非线性）；
（3）特征选择：根据Friedman在GBM论文中提出的方法：特征 j j j 的全局重要度是通过 j j j在单颗树中的重要度取平均值来衡量。
（4） 和其他算法进行模型融合 ：例如，logistic+GBDT，该算法在很多数据上都有不错的效果。
特征重要度的计算公式和代码实现：
J ^ 2 = 1 M ∑ m = 1 M J ^ 2 ( T m ) \hat{J}^2=\frac{1}{M}\sum_{m=1}^{M}\hat{J}^2(T_m) J^2=M1m=1∑MJ^2(Tm)
其中， M M M为树的数量，特征 j j j 在单棵树中的重要性度量为：
J ^ j 2 ( T ) = ∑ t = 1 L − 1 i ^ t 2 ( ν t = j ) \hat{J}_j^2(T)=\sum_{t=1}^{L-1}\hat{i}_t^2(\nu_t=j) J^j2(T)=t=1∑L−1i^t2(νt=j)
其中， L L L为叶节点数， L − 1 L-1 L−1是非叶子节点数（根节点+枝节点，二叉树）， ν t \nu_t νt是与节点 t t t 相关的特征， i ^ t 2 \hat{i}_t^2 i^t2是枝节点分裂后均方误差的减少量。
\quad# feature_importances_属性的计算方法 def feature_importances_(self):total_sum = np.zeros((self.n_features,),dtype=np.float64)for tree in self.estimators_:total_sum += tree.feature_importances_ importances = total_sum / len(self.estimators_)return importances #self.estimators_是算法构建出的决策树数组，tree.feature_importances_ 是单棵树的特征重要度向量
为什么GBDT中的决策树只能是回归树？：
决策树分为两大类，回归树和分类树。前者用于预测实数值，如明天的温度、用户的年龄、网页的相关程度；后者用于分类标签值，如晴天/阴天/雾/雨、用户性别、网页是否是垃圾页面。这里要强调的是，前者的结果加减是有意义的，如10岁+5岁-3岁=12岁，后者则无意义，如男+男+女=到底是男是女？GBDT的核心 在于 累加所有树的结果作为最终结果，比如：对年龄的累加来预测年龄，而分类树的结果显然是没办法累加的，所以GBDT中的树是回归树，不是分类树。这点对理解GBDT相当重要（尽管GBDT调整后也可用于分类但不代表GBDT的树是分类树）。
GBDT（Gradient Boost Decision Tree)，每一次的计算是为了减少上一次的残差，GBDT在残差减少（负梯度）的方向上建立一个新的模型。
优缺点：
GBDT的优点：
1、可灵活处理各种类型数据，包括：连续型和离散型；
2、在相对少的调参时间下，预测准确率也比较高（相对SVM
）；
3、使用一些健壮损失函数，对异常值的鲁棒性非常强。比如Huber损失函数和Quantile分位数损失函数。
GBDT的缺点：
1、由于弱学习器间存在依赖关系，难以并行训练数据。不过，可通过自采样的SGBT来达到部分并行；
GBDT是如何拟合残差来学习弱学习器的?：
（1）当GBDT的 损失函数 是平方损失时，损失函数负梯度的方向就是残差。（即： L ( y , f ( x ) ) = 1 2 ( y − f ( x ) 2 ) L(y,f(x))=\frac{1}{2}(y-f(x)^2) L(y,f(x))=21(y−f(x)2)时，负梯度为： − ∂ L ∂ f ( x ) = y − f ( x ) -\frac {∂L}{∂f(x)}=y-f(x) −∂f(x)∂L=y−f(x)，此时 y − f ( x ) y-f(x) y−f(x)即为我们所说的残差。）GBDT的思想就是在每次迭代中拟合残差来学习一个弱学习器。而残差的方向即为我们全局最优的方向。
（2）当GBDT的 损失函数 不是平方损失时，使用损失函数负梯度的方向代替残差方向。我们称损失函数负梯度为伪残差，而伪残差的方向即为我们局部最优的方向。此时，用每次迭代的局部最优方向代替全局最优方向。
GBDT工作过程实例：
基本原理：
GBDT算法中，每一棵树学的是之前所有树结论和的残差，这个残差就是一个加预测值后能得真实值的累加量。
过程简述：
比如：A的真实年龄是18岁，但第一棵树的预测年龄是12岁，差了6岁，即残差为6岁。那么在第二棵树里我们把A的年龄设为6岁去学习。
（1）如果第二棵树真的能把A分到6岁的叶子节点，那累加两棵树的结论就是A的真实年龄，学习结束；
（2）如果第二棵树的结论是5岁，则A仍然存在1岁的残差，第三棵树里A的年龄就变成1岁，继续学习。
应用实例：
训练集是4个人，A，B，C，D年龄分别是14，16，24，26。样本中有购物金额、上网时长、经常到百度知道提问等特征。提升树的过程如下：
从上图可以看出，第一棵树建立的时候使用的是原始数据，而后每一棵树建立使用的是前 n − 1 n-1 n−1次的残差来拟合弱学习器。
\quad
我们可以证明（相关证明见链接附录部分）：
（1）当损失函数为 平方损失 时，叶节点中使平方损失误差达到最小值的是叶节点中所有值的 均值 ；
（2）当损失函数为 绝对值损失 时，叶节点中使绝对损失误差达到最小值的是叶节点中所有值的 中位数。
GBDT的算法描述
GBDT回归树的基本模版
GBDT回归树的基本模版：
输入：训练数据集 T = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . , ( x N , y N ) } T=\left \{ (x{_{1},y{_{1}}}),(x{_{2}},y{_{2}}),...,(x{_{N}},y{_{N}}) \right \} T={(x1,y1),(x2,y2),...,(xN,yN)}， x i ∈ χ = R n ， x i ∈ χ = R n ， y i ∈ γ = { − 1 , + 1 } , i = 1 , 2 , ⋅ ⋅ ⋅ , N x_i∈χ=R^n，x_i∈χ=R^n ，y_i∈γ=\{−1,+1\}, i=1,2,⋅⋅⋅,N xi∈χ=Rn，xi∈χ=Rn，yi∈γ={−1,+1},i=1,2,⋅⋅⋅,N，损失函数为 L ( y , f ( x ) ) L(y,f(x)) L(y,f(x))
输出：回归树 F ( x ) F(x) F(x)
执行过程：
（1）初始化弱学习器：估计使损失函数极小化的常数值，它是只有一个根节点的树。一般，平方损失函数取节点的均值，而绝对损失函数取节点样本的中位数。
f 0 ( x ) = a r g m i n c ∑ i = 1 N L ( y i , c ) f_0(x)=arg\underset{c}{min}\sum_{i=1}^{N}L(y_i,c) f0(x)=argcmini=1∑NL(yi,c)
（2）对 m = 1 , 2 , . . . , M m=1,2,...,M m=1,2,...,M（ M M M表示迭代次数，即生成的弱学习器个数）：
对样本 i = 1 , 2 , . . . N i=1,2,...N i=1,2,...N，计算损失函数的负梯度在当前模型的值，将它作为残差的估计，对于平方损失函数而言，它就是通常所说的残差；而对于一般损失函数，它就是残差的近似值（伪残差）：
r m i = − [ ∂ L ( y i , f ( x i ) ) ∂ f ( x i ) ] f ( x ) = f m − 1 ( x ) r_{mi}=-\Big[\frac{∂L(y_i,f(x_i))}{∂f(x_i)}\Big]_{f(x)=f_{m-1}(x)} rmi=−[∂f(xi)∂L(yi,f(xi))]f(x)=fm−1(x)对 { ( x 1 , r m 1 ) , . . . , ( x N , r m N ) } \left \{ (x{_{1}},r{_{m1}}),..., (x{_{N}},r{_{mN}})\right \} {(x1,rm1),...,(xN,rmN)}拟合一个回归树，得到第 m m m棵树的叶节点区域 R m j ， j = 1 , 2 , . . . , J R{_{mj}}，j=1,2,...,J Rmj，j=1,2,...,J（ J J J表示每棵树的叶节点个数）
对 j = 1 , 2 , . . . , J j=1,2,...,J j=1,2,...,J，利用线性搜索，估计叶节点区域的值，使损失函数最小化，计算每个叶子节点的最佳负梯度拟合值为：
c m j = a r g m i n c ∑ x i ∈ R m j L ( y i , f m − 1 ( x i ) + c ) c{_{mj}}=arg\underset{c}{min}\sum_{x{_{i}}\in R{_{mj}}}L(y{_{i}},f{_{m-1}}(x{_{i}})+c) cmj=argcminxi∈Rmj∑L(yi,fm−1(xi)+c)更新强学习器：
f m ( x ) = f m − 1 ( x ) + ∑ j = 1 J c m j I ( x ∈ R m j ) f{_{m}}(x)=f{_{m-1}}(x)+\sum^{J}_{j=1}c{_{mj}}I(x\in R{_{mj}}) fm(x)=fm−1(x)+j=1∑JcmjI(x∈Rmj)（3）得到最终的回归树（强学习器）
F ( x ) = ∑ m = 1 M f m ( x ) = ∑ m = 1 M ∑ j = 1 J c m j I ( x ∈ R m j ) F(x)=∑_{m=1}^{M}f_m(x)=\sum_{m=1}^{M}\sum_{j=1}^{J}c{_{mj}}I(x\in R{_{mj}}) F(x)=m=1∑Mfm(x)=m=1∑Mj=1∑JcmjI(x∈Rmj)
GBDT的损失函数：
1、在sklearn中 梯度提升回归树 有四种可选的损失函数：分别为’ls：平方损失’，‘lad：绝对损失’，‘huber：huber损失’，‘quantile：分位数损失’；
梯度提升回归树的损失函数
（1） ls：平方损失函数 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） lad：绝对损失函数 L ( y , f ( x ) ) = ∣ y − f ( x ) ∣ L(y,f(x))=|y-f(x)| L(y,f(x))=∣y−f(x)∣，这个损失函数也很常见，对应负梯度为： r ( y i , f ( x i ) ) = s i g n ( y i − f ( x i ) ) r(y{_{i}},f(x{_{i}}))=sign(y{_{i}}-f(x{_{i}})) r(yi,f(xi))=sign(yi−f(xi))；
（3）huber：huber损失 ，它是平方损失和绝对损失的这种产物，对于远离中心的异常点采用绝对损失，而中心附近的点采用平方损失。这个界限一般用分位数点度量。损失函数如下：
L ( y , f ( x ) ) = { 1 2 ( y − f ( x ) ) 2 if ∣ y − f ( x ) ∣ ≤ δ δ ( ∣ y − f ( x ) ∣ − δ 2 ) if ∣ y − f ( x ) ∣ > δ L(y,f(x))=\begin{cases} \frac{1}{2}(y-f(x))^2 & \text{ if } |y-f(x)|\leq \delta \\ \delta (|y-f(x)|-\frac{\delta }{2})& \text{ if } |y-f(x)|> \delta \end{cases} L(y,f(x))={21(y−f(x))2δ(∣y−f(x)∣−2δ) if ∣y−f(x)∣≤δ if ∣y−f(x)∣>δ
对应的负梯度为：
r ( y i , f ( x i ) ) = { y i − f ( x i ) if ∣ y i − f ( x i ) ∣ ≤ δ δ s i g n ( y i − f ( x i ) ) if ∣ y i − f ( x i ) ∣ > δ r(y{_{i}},f(x{_{i}}))=\begin{cases} y{_{i}}-f(x{_{i}}) & \text{ if }|y{_{i}}-f(x{_{i}})|\leq \delta \\ \delta sign(y{_{i}}-f(x{_{i}})) & \text{ if } |y{_{i}}-f(x{_{i}})|> \delta \end{cases} r(yi,f(xi))={yi−f(xi)δsign(yi−f(xi)) if ∣yi−f(xi)∣≤δ if ∣yi−f(xi)∣>δ
（4）quantile：分位数损失 ，它对应的是分位数回归的损失函数，表达式如下：
L ( y , f ( x ) ) = ∑ y ≥ f ( x ) θ ∣ y − f ( x ) ∣ + ∑ y < f ( x ) ( 1 − θ ) ∣ y − f ( x ) ∣ L(y,f(x))=\sum_{y\geq f(x)}\theta |y-f(x)|+\sum_{y<f(x)}(1-\theta )|y-f(x)| L(y,f(x))=y≥f(x)∑θ∣y−f(x)∣+y<f(x)∑(1−θ)∣y−f(x)∣
其中 θ θ θ为分位数，需要我们在回归前指定。对应的负梯度为：
r ( y i , f ( x i ) ) = { θ if y i ≥ f ( x i ) θ − 1 if y i < f ( x i ) r(y{_{i}},f(x{_{i}}))=\begin{cases} \theta & \text{ if } y{_{i}}\geq f(x{_{i}}) \\\theta-1 &\text{ if } y{_{i}}< f(x{_{i}}) \end{cases} r(yi,f(xi))={θθ−1 if yi≥f(xi) if yi<f(xi)
备注：对于huber损失和分位数损失的主要作用就是减少异常点对损失函数的影响。
2、在sklearn中 梯度提升分类树 有两种可选的损失函数：一种是‘exponential：指数损失’，一种是‘deviance：对数损失’。
梯度提升分类树的损失函数
（1） exponential：指数损失 ，表达式如下：
L ( y , f ( x ) ) = e x p ( − y f ( x ) ) L(y,f(x))=exp(-yf(x)) L(y,f(x))=exp(−yf(x))
（2） deviance：对数损失 ，类似于logistic回归的损失函数，输出的是类别的概率，表达式如下：
L ( y , f ( x ) ) = l n ( 1 + e x p ( − 2 y f ( x ) ) ) L(y,f(x))=ln(1+exp(-2yf(x))) L(y,f(x))=ln(1+exp(−2yf(x)))
GBDT回归算法描述
01 平方损失的GBDT算法描述
输入：训练数据集 T = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . , ( x N , y N ) } T=\left \{ (x{_{1},y{_{1}}}),(x{_{2}},y{_{2}}),...,(x{_{N}},y{_{N}}) \right \} T={(x1,y1),(x2,y2),...,(xN,yN)}，损失函数为 L ( y , f ( x ) ) = ( y − f ( x ) ) 2 L(y,f(x))=(y-f(x))^2 L(y,f(x))=(y−f(x))2
输出：回归树 F ( x ) F(x) F(x)
执行过程：
（1）初始化： f 0 ( x ) = y ˉ f{_{0}}(x)=\bar{y} f0(x)=yˉ（当损失函数为平方损失时，节点的平均值即为该节点中使损失函数达到最小值的最优预测值）
（2）对 m = 1 , 2 , . . . , M m=1,2,...,M m=1,2,...,M：
- 对样本 i = 1 , 2 , . . . N i=1,2,...N i=1,2,...N，计算伪残差（对于平方损失来说，伪残差就是真残差）
r m i = − [ ∂ L ( y i , f ( x i ) ) ∂ f ( ( x i ) ) ] f ( x ) = f m − 1 ( x ) = y − f ( x i ) r{_{mi}}=-[\frac{\partial L(y{_{i}},f(x{_{i}}))}{\partial f((x{_{i}}))}]_{f(x)=f{_{m-1}}(x)}=y-f(x{_{i}}) rmi=−[∂f((xi))∂L(yi,f(xi))]f(x)=fm−1(x)=y−f(xi)- 对 { ( x 1 , r m 1 ) , . . . , ( x N , r m N ) } \left \{ (x{_{1}},r{_{m1}}),..., (x{_{N}},r{_{mN}})\right \} {(x1,rm1),...,(xN,rmN)}拟合一个回归树，得到第 m m m棵树的叶节点区域 R m j ， j = 1 , 2 , . . . , J R{_{mj}}，j=1,2,...,J Rmj，j=1,2,...,J
- 对 j = 1 , 2 , . . . , J j=1,2,...,J j=1,2,...,J，利用线性搜索，估计叶节点区域的值，使损失函数最小化，计算 c m j = 1 K ∑ x i ∈ R m j ( y i − f ( x i ) ) c{_{mj}}=\frac{1}{K}\underset{{{x{_{i}}\in R{_{mj}}}}}{\sum}(y{_{i}}-f(x{_{i}})) cmj=K1xi∈Rmj∑(yi−f(xi))， K K K表示第 m m m棵树的第 j j j个节点中的样本数量，上式表示 c m j c{_{mj}} cmj的取值为第 m m m棵树的第 j j j个叶节点中伪残差的平均数。
- 更新 f m ( x ) = f m − 1 ( x ) + ∑ J j = 1 c m j I ( x ∈ R m j ) f{_{m}}(x)=f{_{m-1}}(x)+\sum_{J}^{j=1}c{_{mj}}I(x\in R{_{mj}}) fm(x)=fm−1(x)+∑Jj=1cmjI(x∈Rmj)
\quad（3）得到最终的回归树 F ( x ) = ∑ m = 1 M ∑ j = 1 J c m j I ( x ∈ R m j ) F(x)=\sum_{m=1}^{M}\sum_{j=1}^{J}c{_{mj}}I(x\in R{_{mj}}) F(x)=∑m=1M∑j=1JcmjI(x∈Rmj)
\quad
02 绝对损失GBDT算法描述
输入：训练数据集 T = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . , ( x N , y N ) } T=\left \{ (x{_{1},y{_{1}}}),(x{_{2}},y{_{2}}),...,(x{_{N}},y{_{N}}) \right \} T={(x1,y1),(x2,y2),...,(xN,yN)}，损失函数为 L ( y , f ( x ) ) = ∣ y − f ( x ) ∣ L(y,f(x))=|y-f(x)| L(y,f(x))=∣y−f(x)∣
输出：回归树 F ( x ) F(x) F(x)
执行过程：
（1）初始化： f 0 ( x ) = m e d i a n { y } f{_{0}}(x)=median\left \{ y \right \} f0(x)=median{y}（当损失函数为绝对损失时，节点中样本的中位数即为该节点中使损失函数达到最小值的最优预测值）
（2）对 m = 1 , 2 , . . . , M m=1,2,...,M m=1,2,...,M：
- 对样本 i = 1 , 2 , . . . N i=1,2,...N i=1,2,...N，计算伪残差 r m i = − [ ∂ L ( y i , f ( x i ) ) ∂ f ( ( x i ) ) ] f ( x ) = f m − 1 ( x ) = s i g n ( y i − f ( x i ) ) r{_{mi}}=-[\frac{\partial L(y{_{i}},f(x{_{i}}))}{\partial f((x{_{i}}))}]_{f(x)=f{_{m-1}}(x)}=sign(y{_{i}}-f(x{_{i}})) rmi=−[∂f((xi))∂L(yi,f(xi))]f(x)=fm−1(x)=sign(yi−f(xi))
- 对 { ( x 1 , r m 1 ) , . . . , ( x N , r m N ) } \left \{ (x{_{1}},r{_{m1}}),..., (x{_{N}},r{_{mN}})\right \} {(x1,rm1),...,(xN,rmN)}拟合一个回归树，得到第 m m m棵树的叶节点区域 R m j , j = 1 , 2 , . . . , J R{_{mj}},j=1,2,...,J Rmj,j=1,2,...,J
- 对 j = 1 , 2 , . . . , J ， i = 1 , 2 , . . . , N j=1,2,...,J，i=1,2,...,N j=1,2,...,J，i=1,2,...,N，计算 c m j = m e d i a n x i ∈ R m j { y i − f m − 1 ( x i ) } c{_{mj}}=\underset{{x{_{i}}\in R{_{mj}}}}{median}\left \{ y{_{i}}-f{_{m-1}(x{_{i}})} \right \} cmj=xi∈Rmjmedian{yi−fm−1(xi)},式表示 c m j c{_{mj}} cmj的取值为第 m m m棵树的第 j j j个叶节点中伪残差的中位数。
- 更新 f m ( x ) = f m − 1 ( x ) + ∑ J j = 1 c m j I ( x ∈ R m j ) f{_{m}}(x)=f{_{m-1}}(x)+\sum_{J}^{j=1}c{_{mj}}I(x\in R{_{mj}}) fm(x)=fm−1(x)+∑Jj=1cmjI(x∈Rmj)
\quad（3）得到最终的回归树 F ( x ) = ∑ m = 1 M ∑ j = 1 J c m j I ( x ∈ R m j ) F(x)=\sum_{m=1}^{M}\sum_{j=1}^{J}c{_{mj}}I(x\in R{_{mj}}) F(x)=∑m=1M∑j=1JcmjI(x∈Rmj)
\quad03 huber损失GBDT算法描述
输入：训练数据集 T = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . , ( x N , y N ) } T=\left \{ (x{_{1},y{_{1}}}),(x{_{2}},y{_{2}}),...,(x{_{N}},y{_{N}}) \right \} T={(x1,y1),(x2,y2),...,(xN,yN)}，损失函数为 L ( y , f ( x ) ) = { 1 2 ( y − f ( x ) ) 2 if ∣ y − f ( x ) ∣ ≤ δ δ ( ∣ y − f ( x ) ∣ − δ 2 ) if ∣ y − f ( x ) ∣ > δ L(y,f(x))=\begin{cases} \frac{1}{2}(y-f(x))^2 & \text{ if } |y-f(x)|\leq \delta \\ \delta (|y-f(x)|-\frac{\delta }{2})& \text{ if } |y-f(x)|> \delta \end{cases} L(y,f(x))={21(y−f(x))2δ(∣y−f(x)∣−2δ) if ∣y−f(x)∣≤δ if ∣y−f(x)∣>δ
输出：回归树 F ( x ) F(x) F(x)
执行过程：
（1）初始化： f 0 ( x ) = m e d i a n { y } f{_{0}}(x)=median\left \{ y \right \} f0(x)=median{y}
（2）对 m = 1 , 2 , . . . , M m=1,2,...,M m=1,2,...,M：
- 对样本 i = 1 , 2 , . . . N i=1,2,...N i=1,2,...N，计算
δ m = q u a n t i l e α { y i − f m − 1 ( x i ) } \delta {_{m}}=\underset{\alpha }{quantile}\left \{ y{_{i}}-f{_{m-1}(x{_{i}})} \right \} δm=αquantile{yi−fm−1(xi)}。其中， δ m \delta {_{m}} δm表示分位数； α \alpha α表示将伪残差的百分之多少设为分位数，在sklearn中是需要我们自己设置的，默认为 α = 0.9 \alpha=0.9 α=0.9。
计算伪残差 r m j = { y i − f ( x i ) if ∣ y i − f ( x i ) ∣ ≤ δ m δ m s i g n ( y i − f ( x i ) ) if ∣ y i − f ( x i ) ∣ > δ m r{_{mj}}=\begin{cases} y{_{i}}-f(x{_{i}}) & \text{ if }|y{_{i}}-f(x{_{i}})|\leq \delta{_{m}} \\ \delta{_{m}} sign(y{_{i}}-f(x{_{i}})) & \text{ if } |y{_{i}}-f(x{_{i}})|> \delta{_{m}} \end{cases} rmj={yi−f(xi)δmsign(yi−f(xi)) if ∣yi−f(xi)∣≤δm if ∣yi−f(xi)∣>δm- 对 { ( x 1 , r m 1 ) , . . . , ( x N , r m N ) } \left \{ (x{_{1}},r{_{m1}}),..., (x{_{N}},r{_{mN}})\right \} {(x1,rm1),...,(xN,rmN)}拟合一个回归树，得到第 m m m棵树的叶节点区域 R m j ， j = 1 , 2 , . . . , J R{_{mj}}，j=1,2,...,J Rmj，j=1,2,...,J
- 对 j = 1 , 2 , . . . , J ， i = 1 , 2 , . . . , N j=1,2,...,J，i=1,2,...,N j=1,2,...,J，i=1,2,...,N，计算
r ˉ m j = m e d i a n x i ∈ R m j { y i − f m − 1 ( x i ) } \bar{r}{_{mj}}=\underset{x{_{i}}\in R{_{mj}}}{median}\left \{y{_{i}}-f{_{m-1}}(x{_{i}}) \right \} rˉmj=xi∈Rmjmedian{yi−fm−1(xi)} c m j = r ˉ m j + 1 N m j ∑ x i ∈ R m j s i g n ( y i − f m − 1 ( x i ) − r ˉ m j ) ∗ m i n ( δ m , a b s ( y i − f m − 1 ( x i ) − r ˉ m j ) ) \tiny c{_{mj}}=\bar{r}{_{mj}}+\frac{1}{N{_{mj}}}\sum_{x{_{i}}\in R{_{mj}}}sign(y{_{i}}-f{_{m-1}(x{_{i}})}-\bar{r}{_{mj}})*min(\delta {_{m}},abs(y{_{i}}-f{_{m-1}(x{_{i}})}-\bar{r}{_{mj}})) cmj=rˉmj+Nmj1xi∈Rmj∑sign(yi−fm−1(xi)−rˉmj)∗min(δm,abs(yi−fm−1(xi)−rˉmj))- 更新： f m ( x ) = f m − 1 ( x ) + ∑ J j = 1 c m j I ( x ∈ R m j ) f{_{m}}(x)=f{_{m-1}}(x)+\sum_{J}^{j=1}c{_{mj}}I(x\in R{_{mj}}) fm(x)=fm−1(x)+∑Jj=1cmjI(x∈Rmj)
\quad（3）得到最终的回归树 F ( x ) = ∑ m = 1 M ∑ j = 1 J c m j I ( x ∈ R m j ) F(x)=\sum_{m=1}^{M}\sum_{j=1}^{J}c{_{mj}}I(x\in R{_{mj}}) F(x)=∑m=1M∑j=1JcmjI(x∈Rmj)
GBDT分类算法描述
GBDT分类算法思想上和GBDT的回归算法没有什么区别，但是由于样本输出不是连续值，而是离散类别，导致我们无法直接从输出类别去拟合类别输出误差。为了解决这个问题，主要有两种方法。一是用 指数损失函数，此时GBDT算法退化为AdaBoost算法。另一种方法是用类似于逻辑回归的 对数似然损失函数。也就是说，我们 利用类别的预测概率值和真实概率值的差来拟合损失。
当损失函数为指数函数时，类似于AdaBoost算法，此时，指数损失函数为： J ( w ) = λ R ( w ) + ∑ i e x p ( − y i f w ( x i ) ) J(w)=λR(w)+\underset{i}{\sum} exp(-y_if_w(x_i)) J(w)=λR(w)+i∑exp(−yifw(xi))，这里暂不做介绍。
下面介绍损失函数为log函数时的 GBDT二分类 和 GBDT多分类算法。
对数损失的GBDT二分类算法描述
输入：训练数据集 T = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . , ( x N , y N ) } T=\left \{ (x{_{1},y{_{1}}}),(x{_{2}},y{_{2}}),...,(x{_{N}},y{_{N}}) \right \} T={(x1,y1),(x2,y2),...,(xN,yN)}，损失函数为 L ( y , f ( x ) ) = l n ( 1 + e x p ( − 2 y f ( x ) ) ) ， y = { − 1 ， 1 } L(y,f(x))=ln(1+exp(-2yf(x)))，y= \{-1，1\} L(y,f(x))=ln(1+exp(−2yf(x)))，y={−1，1}
输出：分类树 F ( x ) F(x) F(x)
执行过程：
（1）初始化： f 0 ( x ) = 1 2 l n P ( y = 1 ∣ x ) P ( y = − 1 ∣ x ) f{_{0}}(x)=\frac{1}{2}ln\frac{P(y=1|x)}{P(y=-1|x)} f0(x)=21lnP(y=−1∣x)P(y=1∣x)
（2）对 m = 1 , 2 , . . . , M m=1,2,...,M m=1,2,...,M：
- 对样本 i = 1 , 2 , . . . N i=1,2,...N i=1,2,...N，计算伪残差 r m i = 2 y i 1 + e x p ( 2 y i f m − 1 ( x i ) ) r{_{mi}}=\frac{2y{_{i}}}{1+exp(2y{_{i}}f{_{m-1}}(x{_{i}}))} rmi=1+exp(2yifm−1(xi))2yi
- 对概率残差 { ( x 1 , r m 1 ) , . . . , ( x N , r m N ) } \left \{ (x{_{1}},r{_{m1}}),..., (x{_{N}},r{_{mN}})\right \} {(x1,rm1),...,(xN,rmN)}拟合一个分类树，得到第 m m m棵树的叶节点区域 R m j ， j = 1 , 2 , . . . , J R{_{mj}}，j=1,2,...,J Rmj，j=1,2,...,J
- 对 j = 1 , 2 , . . . , J ， i = 1 , 2 , . . . , N j=1,2,...,J，i=1,2,...,N j=1,2,...,J，i=1,2,...,N，计算 c m j = ∑ x i ∈ R m j r m j ∑ x i ∈ R m j ∣ r m j ∣ ( 2 − ∣ r m j ∣ ) c{_{mj}}=\frac{\sum_{x{_{i}}\in R{_{mj}}}r{_{mj}}}{\sum_{x{_{i}}\in R{_{mj}}}|r{_{mj}}|(2-|r{_{mj}}|)} cmj=∑xi∈Rmj∣rmj∣(2−∣rmj∣)∑xi∈Rmjrmj
- 更新 f m ( x ) = f m − 1 ( x ) + ∑ J j = 1 c m j I ( x ∈ R m j ) f{_{m}}(x)=f{_{m-1}}(x)+\sum_{J}^{j=1}c{_{mj}}I(x\in R{_{mj}}) fm(x)=fm−1(x)+∑Jj=1cmjI(x∈Rmj)
\quad（3）得到最终的分类树 F ( x ) = ∑ m = 1 M ∑ j = 1 J c m j I ( x ∈ R m j ) F(x)=\sum_{m=1}^{M}\sum_{j=1}^{J}c{_{mj}}I(x\in R{_{mj}}) F(x)=∑m=1M∑j=1JcmjI(x∈Rmj)
（4）由于我们是通过 类别的预测概率值和真实概率值的差来拟合损失，所以最后还需要将概率转换为类别，如下：
P ( y = 1 ∣ x ) = 1 1 + e x p ( − 2 F ( x ) ) P(y=1|x)=\frac{1}{1+exp(-2F(x))} P(y=1∣x)=1+exp(−2F(x))1 P ( y = − 1 ∣ x ) = 1 1 + e x p ( 2 F ( x ) ) P(y=-1|x)=\frac{1}{1+exp(2F(x))} P(y=−1∣x)=1+exp(2F(x))1
最终输出比较类别的概率大小，概率大的就预测为该类别。
\quad对数损失的GBDT多分类算法描述
输入：训练数据集 T = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . , ( x N , y N ) } T=\left \{ (x{_{1},y{_{1}}}),(x{_{2}},y{_{2}}),...,(x{_{N}},y{_{N}}) \right \} T={(x1,y1),(x2,y2),...,(xN,yN)}，损失函数为 L ( y k , f k ( x ) ) = − ∑ k = 1 K y k l n P k ( x ) ， y k = { 0 , 1 } L(y{_{k}},f{_{k}}(x))=-\sum_{k=1}^{K}y{_{k}}lnP{_{k}}(x)，y{_{k}}=\{0,1\} L(yk,fk(x))=−∑k=1KyklnPk(x)，yk={0,1}表示是否属于第 k k k 类别， 1 1 1表示是， 0 0 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）对 m = 1 , 2 , . . . , M m=1,2,...,M m=1,2,...,M：
- 计算样本点属于每个类别的概率： P k ( x ) = e x p ( f k ( x ) ) / ∑ l = 1 K e x p ( f l ( x ) ) P{_{k}}(x)=exp(f{_{k}}(x))/\sum_{l=1}^{K}exp(f{_{l}}(x)) Pk(x)=exp(fk(x))/∑l=1Kexp(fl(x))
- 对 k = 1 , 2 , . . . , K k=1,2,...,K k=1,2,...,K：
1）计算伪残差 r k i = y k i − P k ( x i ) ， i = 1 , 2 , . . . , N r{_{ki}}=y{_{ki}}-P{_{k}}(x{_{i}})，i=1,2,...,N rki=yki−Pk(xi)，i=1,2,...,N
2）对概率伪残差 { ( x 1 , r k 1 ) , . . . , ( x N , r k N ) } \left \{ (x{_{1}},r{_{k1}}),..., (x{_{N}},r{_{kN}})\right \} {(x1,rk1),...,(xN,rkN)}，拟合一个分类树
3）计算： c m k j = K − 1 K ∑ x i ∈ R m k j r k i ∑ x i ∈ R m k j ∣ c k i ∣ ( 1 − ∣ c k i ∣ ) c{_{mkj}}=\frac{K-1}{K}\frac{\sum_{x{_{i}}\in R{_{mkj}}}r{_{ki}}}{\sum_{x{_{i}}\in R{_{mkj}}}|c{_{ki}}|(1-|c{_{ki}}|)} cmkj=KK−1∑xi∈Rmkj∣cki∣(1−∣cki∣)∑xi∈Rmkjrki
4）更新： f m k ( x ) = f k , m − 1 ( x ) + ∑ j = 1 J c m k j I ( x ∈ R m k j ) f{_{mk}}(x)=f{_{k,m-1}}(x)+\sum_{j=1}^{J}c{_{mkj}}I(x\in R{_{mkj}}) fmk(x)=fk,m−1(x)+∑j=1JcmkjI(x∈Rmkj)
\quad（3）得到最终的分类树 F M k ( x ) = ∑ m = 1 M ∑ j = 1 J c m k j I ( x ∈ R m k j ) F{_{Mk}}(x)=\sum_{m=1}^{M}\sum_{j=1}^{J}c{_{mkj}}I(x\in R{_{mkj}}) FMk(x)=∑m=1M∑j=1JcmkjI(x∈Rmkj)
（4）最后得到的 F M k ( x ) F{_{Mk}}(x) FMk(x)可以被用于求解分为第k类的相应概率 P M k ( x ) P{_{Mk}}(x) PMk(x)，计算如下：
P M k = e x p ( F M k ( x ) ) / ∑ l = 1 K e x p ( F M l ( x ) ) P{_{Mk}}=exp(F{_{Mk}}(x))/\sum_{l=1}^{K}exp(F{_{Ml}}(x)) PMk=exp(FMk(x))/l=1∑Kexp(FMl(x))
由于我们是通过 类别的预测概率值和真实概率值的差来拟合损失，所以最后还要将概率转换为类别，如下：
k ^ ( x ) = a r g m i n 1 ≤ k ≤ K ∑ k ′ = 1 K [ c ( k , k ′ ) P M k ′ ( x ) ] \hat{k}(x)=arg\underset{1\leq k\leq K}{min}\sum_{{k}'=1}^{K}[c(k,{k}')P{_{M{k}'}(x)}] k^(x)=arg1≤k≤Kmink′=1∑K[c(k,k′)PMk′(x)]
其中， k ^ ( x ) \hat{k}(x) k^(x)为最终的输出类别， c ( k , k ′ ) c(k,{k}') c(k,k′)为当真实值为 k ′ {k}' k′时，预测为第 k k k 类时的联合代价，即：概率最大的类别即为我们所预测的类别。当 K = 2 K=2 K=2 时，该算法等价于为二分类算法。
GBDT与AdaBoost的区别与联系
Table1 GBDT与AdaBoost 的 联系 与 区别
| 模型 | 学习算法 | 损失函数 | 处理问题 | 改进措施（针对基学习器的不足） | |
| AdaBoost算法 | 加法模型 | 前向分步算法 | 指数函数 | 分类问题 | 通过提升错分数据点的权重来定位模型的不足 |
| GBDT算法 | 加法模型 | 前向分步算法 | 平方损失函数 | 回归问题 | 通过算梯度来定位模型的不足 |
| 指数函数 | 分类问题 | ||||
| 一般损失函数 | 一般决策问题 |
GBDT的Python实现
GBDT分类
每一棵树拟合当前模型损失函数的负梯度，构建新的树加入当前模型中形成新模型，下一棵树拟合新模型损失函数的负梯度。
from sklearn.ensemble import GradientBoostingClassifierGradientBoostingClassifier(criterion='friedman_mse', init=None, learning_rate=0.1, loss='deviance', max_depth=3, max_features=None, max_leaf_nodes=None, min_impurity_decrease=0.0, min_impurity_split=None, min_samples_leaf=1, min_samples_split=2, min_weight_fraction_leaf=0.0, n_estimators=100, presort='auto', random_state=None, subsample=1.0, verbose=0, warm_start=False)gbc = GradientBoostingClassifier()
gbc.fit(x_train,y_train) #训练数据y_pred_5=gbc.predict(X_test_new) #预测数据
#probability of 1
y_pred_6=gbc.predict_proba(X_test_new)[:,1]
y_pred_6=gbc.predict_proba(X_test_new)[:,0]
GBDT回归
每一棵树拟合当前模型的残差，构建新树加入到当前模型中形成新模型，下一棵树拟合新模型残差。
from sklearn import ensemble
clf = ensemble.GradientBoostingRegressor()
gbdt_model = clf.fit(X_train, y_train) #训练数据
y_upper = gbdt_model.predict(x_test) #预测数据
GBDT运用正则化技巧-调参
gbc=GradientBoostingClassifier(init=None,learning_rate=0.1,loss='deviance',max_depth=3,max_features=None,max_leaf_nodes=None,min_samples_leaf=1,min_samples_split=2,min_weight_fraction_leaf=0.0,n_estimators=100,random_state=None,subsample=1.0,verbose=0,warm_start=False)
#参数说明：
#learning_rate:学习速率
#loss:损失函数,ls最小二乘法,deviance
#max_depth:每棵树深度(通常4-6)
#n_estimators:回归树数量
#max_features:在找到最佳分隔节点前对所有特征取样(需要有充足特征>30个)
GBDT的常用调参技巧：
1、early stoping：是机器学习迭代式模型训练中很常见的防过拟合技巧。具体做法是：选择一部分样本作为验证集，在迭代拟合训练集过程中，如果模型在验证集中的错误率不再下降就停止训练，也就是说空值迭代轮数（树个数），对应参数monitor=None。
2、shrinkage缩减：将当前每棵树的输出结果（即：使得损失函数极小化的叶节点预测值）乘一个因子 ν \nu ν（ 0 < ν < 1 0<\nu<1 0<ν<1），update： f m ( x ) = f m − 1 ( x ) + ν ⋅ ∑ j = 1 J c m j I ( x ∈ R m j ) f_m(x)=f_{m−1}(x)+\nu \cdot ∑_{j=1}^{J}c_{mj}I(x∈R_{mj}) fm(x)=fm−1(x)+ν⋅∑j=1JcmjI(x∈Rmj)， ν \nu ν与树个数 M M M呈反比例关系（ ν \nu ν设置小点（learning_rate默认值0.1，类型float），M（n_estimators默认值100，类型int）就设置大些），这样一般能有较好地准确率，代价是训练时长变长；
Shrinkage缩减
基本思想：
每次走一小步逐渐逼近结果的效果，要比每次迈一大步很快逼近结果的方式更容易避免过拟合。即：它不完全信任每一个棵残差树，它认为每棵树只学到了真理的一小部分，所以，累加的时候只累加一小部分，通过多学几棵树来弥补不足。
公式对比：
之前： f m ( x ) = f m − 1 ( x ) + ∑ j = 1 J c m j I ( x ∈ R m j ) f_m(x)=f_{m−1}(x)+∑_{j=1}^{J}c_{mj}I(x∈R_{mj}) fm(x)=fm−1(x)+j=1∑JcmjI(x∈Rmj)
Shrinkage： f m ( x ) = f m − 1 ( x ) + s t e p ∗ ∑ j = 1 J c m j I ( x ∈ R m j ) f_m(x)=f_{m−1}(x)+step∗∑_{j=1}^{J}c_{mj}I(x∈R_{mj}) fm(x)=fm−1(x)+step∗j=1∑JcmjI(x∈Rmj)
Shrinkage仍然以残差作为学习目标，但对于残差学习的结果，只累加一小部分， s t e p step step一般取值 0.001 − 0.01 0.001-0.01 0.001−0.01（非gradient的step），使得各个树的残差是渐变而不是陡变的，即将大步切成了小步。Shrinkage能减少过拟合发生也是经验证明的，目前还没有看到从理论的证明。
3、subsampling：子采样比例，源于booststrap averaging思想，GBDT中每一轮建树时，样本室从训练集中无放回随机抽样 η η η部分（默认1.0，若subsample<1.0将导致方差减少，偏差增加），这样做既能对模型起到正则作用，又能减少计算时间，建议设置 η ∈ [ 0.5 , 0.8 ] η∈[0.5,0.8] η∈[0.5,0.8]之间；
4、min_samples_leaf：叶节点的样例数量使用稍微较低的边界，可避免不均衡的划分，同时也可控制树的深度。
参考链接：https://blog.csdn.net/qq_24519677/article/details/82020863
机器学习 の04 梯度提升决策树GBDT相关推荐
- 简单易学的机器学习算法——梯度提升决策树GBDT
梯度提升决策树(Gradient Boosting Decision Tree,GBDT)算法是近年来被提及比较多的一个算法,这主要得益于其算法的性能,以及该算法在各类数据挖掘以及机器学习比赛中的卓越 ...
- 机器学习之梯度提升决策树(GBDT)
1.GBDT算法简介 GBDT(Gradient Boosting Decision Tree)是一种迭代的决策树算法,由多棵决策树组成,所有树的结论累加起来作为最终答案,我们根据其名字(Gradie ...
- [机器学习]梯度提升决策树--GBDT
概述 GBDT(Gradient Boosting Decision Tree) 又叫 MART(Multiple Additive Regression Tree),是一种迭代的决策树算法,该算法由 ...
- 【机器学习】深入剖析梯度提升决策树(GBDT)分类与回归
1. 梯度提升决策树概述 梯度提升决策树(Gradient Boosting Decision Tree,GBDT)是以决策树为基学习器的一种Boosting算法,它在每一轮迭代中建立一个决策树,使当 ...
- 梯度提升决策树GBDT及其优秀改进XGBoost的浅析
梯度提升决策树 英文是Gradient Boosting Decision Tree (GBDT).是一种迭代的决策树算法,由多棵决策树组成,将所有树的结论累加起来做最终答案.值得注意的是,GBDT中 ...
- 【机器学习】梯度提升树(GBDT)的原理小结
在集成学习之Adaboost算法原理小结中,我们对Boosting家族的Adaboost算法做了总结,本文就对Boosting家族中另一个重要的算法梯度提升树(Gradient Boosting De ...
- 3. 梯度提升决策树（GBDT）详解
一.提升树 以决策树为基函数的提升方法称为提升树.其中,分类问题采用二叉分类树,回归问题采用二叉回归树.sklearn中的提升树采用的是CART树.模型可以表示为决策树的加法模型: 其中,表示决策树, ...
- 梯度提升决策树（GBDT）与XGBoost、LightGBM
20211224 [机器学习算法总结]XGBoost_yyy430的博客-CSDN博客_xgboost xgboost参数 默认:auto.XGBoost中使用的树构造算法.可选项:auto,exac ...
- 机器学习-集成学习-梯度提升决策树（GBDT）
目录 1. GBDT算法的过程 1.1 Boosting思想 1.2 GBDT原理 需要多少颗树 2. 梯度提升和梯度下降的区别和联系是什么? 3. GBDT的优点和局限性有哪些? 3.1 优点 3. ...
最新文章
- 最新 macOS Sierra 10.12.3 安装CocoaPods及使用详解
- 免费的文本分析 文本挖掘软件工具
- 阿里巴巴在应用性能测试场景设计和实现上的实践
- WMS学习笔记：1.尝试加载WMS
- 详谈java类和对象的生命周期
- Codeforces Round #224 (Div. 2): C. Arithmetic Progression（模拟）
- 适用于苹果Mac的 4 个好用的 CAD 软件
- UL电子线标准规格说明书
- 3dmax如何建模（二）
- SharePoint常用CAML查询语法及举例
- 使用腾讯云OCR文字识别
- 自制力差？!教你强迫自己学习
- 程序员新电脑常用软件安装
- mysql 5.1 limit_mysql5 limit使用表达式的问题
- SpringCloud项目搭建(六) —elastic-job的使用，以及consul的配置使用（衔接上篇）
- VsCode超实用插件推荐，让你的开发效率火力全开
- 曾经是亚洲第一大学，如今靠野猪上热搜？这所985实在是太委屈了！！
- 基金的选择方法及MATLAB实现
- 实现一个方法，给定一个输入字符串，能够删除所有连续同样字母（大小写不敏感）。例如，输入为ABBCCCCCBBAB，输出就是 ABCBAB
- hevc_nvenc 详细分析2 ——preset分析