GBDT梯度提升树

前向分步算法框架

前向分步算法是在Adaboost基础上提出的算法框架。

• 研究对象：

  • 加法集成模型：$$f(x)=\sum _{m=1}^M{\beta }_{m}b\left(x;{\gamma }_m\right)$$
    其中，
    $b\left(x;{\gamma }_m\right)$为即基本分类器，
    ${\gamma }_m$为基本分类器的参数，
    ${\beta }_m$为基本分类器的权重
  • 损失函数：在给定训练数据以及损失函数$L(y,f(x))$的条件下，学习$f(x)$就是：
    $$\underset{{\beta }_m,{\gamma }_m}{\min }\sum _{i=1}^{N}L\left(y_i,\sum _{m=1}^M{\beta }_{m}b\left(x_i;{\gamma }_m\right)\right)$$

• 基本思路：将同时求解从m=1到M的所有参数${\beta }_m$，${\gamma }_m$的优化问题简化为逐次求解各个${\beta }_m$，${\gamma }_m$的问题。（并不一定是全局最优）

• 步骤
  给定数据集 T = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , ⋯   , ( x N , y N ) } T=\left\{\left(x_{1}, y_{1}\right),\left(x_{2}, y_{2}\right), \cdots,\left(x_{N}, y_{N}\right)\right\} T={(x1​,y1​),(x2​,y2​),⋯,(xN​,yN​)}，$x_i\in \mathcal{X}\subseteq {\mathbf{R}}^n$， y i ∈ Y = { + 1 , − 1 } y_{i} \in \mathcal{Y}=\{+1,-1\} yi​∈Y={+1,−1}。损失函数$L(y,f(x))$，基函数集合 { b ( x ; γ ) } \{b(x ; \gamma)\} {b(x;γ)}，输出加法模型$f(x)$。
  Step1 初始化 ： $f_0(x)=0$
  Step2 迭代极小化损失函数
  对m = 1,2,…,M:
  $$\left({\beta }_m,{\gamma }_m\right)=\arg \underset{\beta ,\gamma }{\min }\sum _{i=1}^{N}L\left(y_i,f_{m-1}\left(x_i\right)+\beta b\left(x_i;\gamma \right)\right)$$
  $$f_m(x)=f_{m-1}(x)+{\beta }_{m}b\left(x;{\gamma }_m\right)$$
  Step3 最终加法模型
  $$f(x)=f_M(x)=\sum _{m=1}^M{\beta }_{m}b\left(x;{\gamma }_m\right)$$

梯度提升树

梯度提升树（Gradient Boosting Decision Tree，GBDT）是在前向分布算法框架下，以决策树为基学习器，利用梯度下降法的集成模型。

回归问题

基本概念

设优化问题为：$$w_i=\arg \underset{w}{\min }L(y_i,F_{m-1}(X_i)+w)$$
对于可微损失函数，$w_i=0$处进行剃度下降即可得到损失更小的$w_i^{\ast }$。
记$$r_i=y_i-F_{m-1}(X_i)$$
则损失函数$L(y,\hat{y})$

• $L(y,\hat{y})=\sqrt{|y-\hat{y}|}$时：
  $$\begin{array}{rl}{w}_i^{\ast }& =0-{\frac{\partial L}{\partial w}|}_{w=0}\\ & =-{\frac{\partial \sqrt{|r_i-w_i|}}{\partial w}|}_{w=0}\\ & =\frac{1}{2\sqrt{|r_i|}}sign(r_i)\end{array}$$
  注：当$r_i=0$时，上轮结果与真实值无差异，令$w^{\ast }=0$即可。
• $L(y,\hat{y})=(y-\hat{y}{)}^2$时：
  $$\begin{array}{rl}{w}_i^{\ast }& =0-{\frac{\partial L}{\partial w}|}_{w=0}\\ & =-{\frac{\partial (r_i-w_i{)}^2}{\partial w}|}_{w=0}\\ & =2r_i\end{array}$$
  为了缓解模型的过拟合现象，我们需要引入学习率参数$\eta$来控制每轮的学习速度，即获得了由${\text{w}}^{\ast }$拟合的第m棵树$h^{\ast }$后，当前轮的输出结果为:$${\hat{y}}_i=F_{m-1}(X_i)+\eta h_m^{\ast }(X_i)$$

当损失函数为绝对值时，$F_0$为y中位数；当损失函数为均方值时，$F_0$为y均值。

代码

• python库：sklearn.ensemble.GradientBoostingRegressor

from sklearn.tree import DecisionTreeRegressor as DT
from sklearn.datasets import make_regression
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split
import numpy as np

class GBDTRegressor:

    def __init__(self, max_depth=4, n_estimator=100, lr=0.1):
        self.max_depth = max_depth
        self.n_estimator = n_estimator
        self.lr = lr
        self.booster = []
        self.best_round = None

    def record_score(self, y_train, y_val, train_predict, val_predict, i):
        mse_val = mean_squared_error(y_val, val_predict)
        if (i+1)%10==0:
            mse_train = mean_squared_error(y_train, train_predict)
            print("第%d轮\t训练集： %.4f\t"
                "验证集： %.4f"%(i+1, mse_train, mse_val))
        return mse_val

    def fit(self, X, y):
        # 在数据集中划分训练集和验证集
        X_train, X_val, y_train, y_val = train_test_split(
            X, y, test_size=0.25, random_state=0)
        train_predict, val_predict = 0, 0
        #损失函数为均方损失
        next_fit_val = np.full(X_train.shape[0], np.mean(y_train))
        # 为early_stop做记录准备
        last_val_score = np.infty
        for i in range(self.n_estimator):
            cur_booster = DT(max_depth=self.max_depth)
            cur_booster.fit(X_train, next_fit_val)
            train_predict += cur_booster.predict(X_train) * self.lr
            val_predict += cur_booster.predict(X_val) * self.lr
            next_fit_val = y_train - train_predict
            self.booster.append(cur_booster)
            cur_val_score = self.record_score(
                y_train, y_val, train_predict, val_predict, i)
            if cur_val_score > last_val_score:
                self.best_round = i
                print("\n训练结束！最佳轮数为%d"%(i+1))#为防止过拟合，所以选择验证集最佳
                break
            last_val_score = cur_val_score

    def predict(self, X):
        cur_predict = 0
        # 在最佳验证集得分的轮数停止，防止过拟合
        for i in range(self.best_round):
            cur_predict += self.lr * self.booster[i].predict(X)
        return cur_predict

分类问题

基本概念

GBDT用回归树处理分类问题。

• 利用Softmax处理类别，得到样本属于类别的概率$$P=\frac{e^{F_{ki}}}{{\sum }_{c=1}^K{e}^{F_{ci}}}$$
• 对类别进行one-hot编码
• 损失函数用交叉熵表示为$$L({\text{y}}_i,{\text{F}}_i)=-\sum _{c=1}^K{y}_{ci}\log \frac{e^{F_{ci}}}{{\sum }_{\tilde{c}=1}^K{e}^{F_{\tilde{c}i}}}$$
• 学习目标为$$\begin{array}{rl}{\text{h}}_i^{\ast (m)}& ={\text{F}}_i^{\ast (m)}-{\text{F}}_i^{(m-1)}\\ & =-{\frac{\partial L}{\partial {\text{F}}_i}|}_{{\text{F}}_i={\text{F}}_i^{(m-1)}}\\ & =[y_{1i}-\frac{e^{F_{1i}^{(m-1)}}}{{\sum }_{c=1}^K{e}^{F_{ci}^{(m-1)}}},...,y_{Ki}-\frac{e^{F_{Ki}^{(m-1)}}}{{\sum }_{c=1}^K{e}^{F_{ci}^{(m-1)}}}]\end{array}$$
• 引入学习率后$${\text{F}}_i^{\ast (m)}={\text{F}}_i^{(m-1)}+\eta {\text{h}}_i^{\ast (m)}$$

算法简化

因为K分类每种分类概率和为1，利用此性质，所以可以将K次拟合减少为K-1次，这在处理类别数较少的分类问题时（特别二分类问题）非常有用。

• 当$K\ge 3$ 时

  • 损失函数$$L(F_{1i},...,F_{(K-1)i})=y_{Ki}\log [1+\sum _{c=1}^{K-1}{e}^{F_{ci}}]-\sum _{c=1}^{K-1}{y}_{ci}\log \frac{e^{F_{ci}}}{1+{\sum }_{c=1}^{K-1}{e}^{F_{ci}}}$$
  • 负梯度$$-{\frac{\partial L}{\partial F_{ki}}|}_{{\text{F}}_i={\text{F}}_i^{(m-1)}}=\{\begin{array}{rl}-\frac{e^{F_{ki}^{(m-1)}}}{1+{\sum }_{c=1}^{K-1}{e}^{F_{ci}^{(m-1)}}}& y_{Ki}=1\\ y_{ki}-\frac{e^{F_{ki}^{(m-1)}}}{1+{\sum }_{c=1}^{K-1}{e}^{F_{ci}^{(m-1)}}}& y_{Ki}=0\end{array}$$
  • 初始值$$[\frac{e^{F_{1i}^{(0)}}}{1+{\sum }_{c=1}^{K-1}{e}^{F_{ci}^{(0)}}},...,\frac{e^{F_{(K-1)i}^{(0)}}}{1+{\sum }_{c=1}^{K-1}{e}^{F_{ci}^{(0)}}},\frac{1}{1+{\sum }_{c=1}^{K-1}{e}^{F_{ci}^{(0)}}}]=[p_1,...,p_{K-1},p_K]$$

• 当$K=2$ 时

  • 损失函数$$L(F_i)=-y_i\log \frac{e^{F_i}}{1+e^{F_i}}-(1-y_i)\log \frac{1}{1+e^{F_i}}$$
  • 负梯度$$-{\frac{\partial L}{\partial F_i}|}_{F_i=F_i^{(m-1)}}=y_i-\frac{e^{F_i}}{1+e^{F_i}}$$
  • 初始值$$[\frac{1}{1+e^{F_i^{(0)}}},\frac{e^{F_i^{(0)}}}{1+e^{F_i^{(0)}}}]=[p_0,p_1]$$
    例：设二分类数据集中正样本比例为10%（即$p_1=\frac{1}{10}$），则$\frac{e^{F^{(0)}}}{1+e^{F^{(0)}}}=\frac{1}{10}$，$F^{(0)}=-\ln 9$。

代码

• python库：sklearn.ensemble.GradientBoostingClassifier

from sklearn.tree import DecisionTreeRegressor as DT
from sklearn.datasets import make_classification
from sklearn.metrics import roc_auc_score
from sklearn.model_selection import train_test_split
import numpy as np

class GBDTClassifier:

    def __init__(self, max_depth=4, n_estimator=100, lr=0.1):
        self.max_depth = max_depth
        self.n_estimator = n_estimator
        self.lr = lr
        self.booster = []

        self.best_round = None

    def record_score(self, y_train, y_val, train_predict, val_predict, i):
        train_predict = np.exp(train_predict) / (1 + np.exp(train_predict))
        val_predict = np.exp(val_predict) / (1 + np.exp(val_predict))
        auc_val = roc_auc_score(y_val, val_predict)
        if (i+1)%10==0:
            auc_train = roc_auc_score(y_train, train_predict)
            print("第%d轮\t训练集： %.4f\t"
                "验证集： %.4f"%(i+1, auc_train, auc_val))
        return auc_val

    def fit(self, X, y):
        X_train, X_val, y_train, y_val = train_test_split(
            X, y, test_size=0.25, random_state=0)
        train_predict, val_predict = 0, 0
        fit_val = np.log(y_train.mean() / (1 - y_train.mean()))
        next_fit_val = np.full(X_train.shape[0], fit_val)
        last_val_score = - np.infty
        for i in range(self.n_estimator):
            cur_booster = DT(max_depth=self.max_depth)
            cur_booster.fit(X_train, next_fit_val)
            train_predict += cur_booster.predict(X_train) * self.lr
            val_predict += cur_booster.predict(X_val) * self.lr
            next_fit_val = y_train - np.exp(
                train_predict) / (1 + np.exp(train_predict))
            self.booster.append(cur_booster)
            cur_val_score = self.record_score(
                y_train, y_val, train_predict, val_predict, i)
            if cur_val_score < last_val_score:
                self.best_round = i
                print("\n训练结束！最佳轮数为%d"%(i+1))
                break
            last_val_score = cur_val_score

    def predict(self, X):
        cur_predict = 0
        for i in range(self.best_round):
            cur_predict += self.lr * self.booster[i].predict(X)
        return np.exp(cur_predict) / (1 + np.exp(cur_predict))

XGBoost

项目	GBDT	XGBoost
损失函数	$G(h_m)={\sum }_{i=1}^{N}L(y_i,F_{m-1}(X_i)+h_m(X_i))$	$L^{(m)}(F_i^{(m)})=\gamma T+\frac{1}{2}\lambda {\sum }_{j=1}^T{w}_j+{\sum }_{i=1}^{N}L(y_i,F_i^{(m)})$ 补充了两个正则项控制树生长以及拟合效果
优化方法	依赖于损失函数一阶导数	选择二次函数近似方法求目标值（对各类损失函数更有自适应性）
分裂依据	信息增益	近似损失$G=\frac{1}{2}[\frac{({\sum }_{i\in I_L}{p}_i{)}^2}{{\sum }_{i\in I_L}{q}_i+\lambda }+\frac{({\sum }_{i\in I_R}{p}_i{)}^2}{{\sum }_{i\in I_R}{q}_i+\lambda }-\frac{({\sum }_{i\in I}{p}_i{)}^2}{{\sum }_{i\in I}{q}_i+\lambda }]-\gamma$

其中，$p_i={\frac{\partial L}{\partial h_i}|}_{h_i=0}$，$q_i={\frac{{\partial }^{2}L}{\partial h_i^2}|}_{h_i=0}$。

注：为保证二次函数开口向上（即 $q_i>0$）。损失函数应当选取在整个定义域上或在𝑦𝑖临域上二阶导数恒正的损失函数，例如平方损失。均方根误差$\sqrt{|y-\hat{y}|}$、log平方误差$\frac{1}{2}[\log (\frac{y+1}{\hat{y}+1}){]}^2$不能满足该要求。Pseudo Huber Error ${\delta }^2(\sqrt{1+(\frac{y-\hat{y}}{\delta }{)}^2}-1)$则可以满足。

LightGBM

LightGBM在XGBoost的二阶近似基础上提出了两个新算法：单边梯度采样（GOSS）和互斥特征绑定（EFB）。

单边提督采样

• 目的：使梯度绝对值越小
• 思路：对梯度绝对值小的样本进行抽样
• 方法：对样本梯度绝对值排序后，先选出前𝑎%梯度绝对值对应的样本，再从剩下(1−𝑎)的样本中抽取𝑏%的样本（此处𝑏%是对于总样本的百分比），然后计算信息增益：$$\widetilde{Gain}(F,d)=\frac{1}{N}[\frac{({\sum }_{i\in A_L}{g}_i+\frac{1-a}{b}{\sum }_{i\in B_L}{g}_i{)}^2}{N_L}+\frac{({\sum }_{i\in A_R}{g}_i+\frac{1-a}{b}{\sum }_{i\in B_R}{g}_i{)}^2}{N_R}]$$

互斥特征绑定

• 目的：绑定互斥特征，减少稀疏特征
• 互斥特征：任意两个特征都不同时取非零值的特征集合
• 等效问题：图着色问题
• 几乎互斥：若存在一个样本使得两个特征同时为非零值则记它们存在一次冲突，特征之间的冲突总数不超过给定的最大冲突数𝐾，则近似为互斥（更符合实际情况）。

[参考]：
DataWhale集成学习