datawhale 10月学习——树模型与集成学习：梯度提升树

前情回顾

1. 决策树
2. CART树的实现
3. 集成模式
4. 两种并行集成的树模型
5. AdaBoost

结论速递

本次学习了GBDT，首先了解了用于回归的GBDT，将损失使用梯度下降法进行减小；用于分类的GBDT要稍微复杂一些，需要对分类损失进行定义。学习了助教提供的代码。

1 用于回归的GBDT

1.1 原理

与AdaBoost类似，对于每一轮集成来说，上一轮的集成输出都是常数。

设数据集为$D=\{(X_1,y_1),...,(X_N,y_N)\}$，模型的损失函数为$L(y,\hat{y})$，现希望利用多棵回归决策树来进行模型集成：设第$m$轮时，已知前$m-1$轮中对第$i$个样本的集成输出为$F_{m-1}(X_i)$，则本轮的集成输出${\hat{y}}_i$
$$F_m(X_i)=F_{m-1}(X_i)+h_m(X_i)$$
其中，$h_m$是使得当前轮损失${\sum }_{i=1}^{N}L(y_i,{\hat{y}}_i)$达到最小的决策树模型。
特别地，当$m=0$时，$F_0(X_i)=\arg {\min }_{\hat{y}}{\sum }_{i=1}^{N}L(y_i,\hat{y})$。

【思考题】对于均方损失函数和绝对值损失函数，请分别求出模型的初始预测$F_0$
$F_0=\arg {\min }_{\hat{y}}{\sum }_{i=1}^N(y_i-\hat{y}{)}^2$
$F_0=\arg {\min }_{\hat{y}}{\sum }_{i=1}^N|y_i-\hat{y}{|}^2$

则可以记第m轮的损失函数
$$G(h_m)=\sum _{i=1}^{N}L(y_i,F_{m-1}(X_i)+h_m(X_i))$$

学习一个决策树模型等价于对数据集$\tilde{D}=\{(X_1,h^{\ast }(X_1)),...,(X_N,h^{\ast }(X_N))\}$进行拟合，设$w_i=h^{\ast }(X_i)$，$\text{w}=[w_1,...,w_N]$，此时的损失函数可改记为
$$G(\text{w})=\sum _{i=1}^{N}L(y_i,F_{m-1}(X_i)+w_i)$$
由于只要我们获得最优的$\text{w}$，就能拟合出第$m$轮相应的回归树，此时一个函数空间的优化问题已经被转换为了参数空间的优化问题，即对于样本$i$而言，最优参数为
$$w_i=\arg \underset{w}{\min }L(y_i,F_{m-1}(X_i)+w)$$

接下来就可以用梯度下降，使损失最小，恰好是决策树要拟合的$h^{\ast }(X_i)$。

以损失函数$L(y,\hat{y})=\sqrt{|y-\hat{y}|}$为例，记残差为
$$r_i=y_i-F_{m-1}(X_i)$$
则实际损失为
$$L(w_i)=\sqrt{|r_i-w_i|}$$

【思考题】给定了上一轮的预测结果$F_{m-1}(X_i)$和样本标签$y_i$，请计算使用平方损失时需要拟合的$w_i^{\ast }$。
记残差为
$$r_i=y_i-F_{m-1}(X_i)$$
则损失为
$$L(w_i)=(r_i-w_i{)}^2$$

根据在零点处的梯度下降可知：
$$\begin{array}{rl}{w}_i^{\ast }& =0-{\frac{\partial L}{\partial w}|}_{w=0}\\ & =\frac{1}{2\sqrt{|r_i|}}sign(r_i)\end{array}$$

【思考题】当样本$i$计算得到的残差$r_i=0$时，本例中的函数在$w=0$处不可导，请问当前轮应当如何处理模型输出？
取比0大一些或者小一些的数？

接下来，可以引入学习率来缓解过拟合。

为了缓解模型的过拟合现象，我们需要引入学习率参数$\eta$来控制每轮的学习速度，即获得了由${\text{w}}^{\ast }$拟合的第m棵树$h^{\ast }$后，当前轮的输出结果
$${\hat{y}}_i=F_{m-1}(X_i)+\eta h_m^{\ast }(X_i)$$

另一种理解

对于上述的梯度下降过程，还可以从另一个等价的角度来观察：若设当前轮模型预测的输出值为${\tilde{w}}_i=F_{m-1}(X_i)+w_i$，求解的问题即为
$${\tilde{w}}_i=\arg \underset{\tilde{w}}{\min }L(y_i,\tilde{w})$$
从而当前轮学习器$h$需要拟合的目标值$w_i^{\ast }$为
$$\begin{array}{rl}{w}_i^{\ast }& ={\tilde{w}}_i-F_{m-1}(X_i)\\ & =0-\frac{\partial L}{\partial w}{\frac{\partial w}{\partial \tilde{w}}|}_{\tilde{w}=F_{m-1}(X_i)}\\ & =0-{\frac{\partial L}{\partial w}|}_{\tilde{w}=F_{m-1}(X_i)}\\ & =0-{\frac{\partial L}{\partial w}|}_{w=0}\end{array}$$

上述的结果与先前的梯度下降结果完全一致，事实上这两种观点在本质上没有任何区别，只是损失函数本身进行了平移

1.2 代码实现

基础库及函数导入

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

类分为几个主要方法，核心是fit部分，record_score部分用来支持早停机制。

class GBDTRegressor:
    def __init__(self, max_depth=4, n_estimator=1000, lr=0.2):
        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_absolute_error(y_val, val_predict)
        if (i+1)%10==0:
            mse_train = mean_absolute_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.median(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
            # 平方损失为((y - (F_{m-1} + w)^2)/2，若记残差为r
            # 即为((r - w)^2)/2，此时关于w在0点处的负梯度求得恰好为r
            # 因此拟合的值就是y_train - train_predict
            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

运行结果如下

2 用于分类的GBDT

2.1 原理

用于分类的GBDT最大的问题在于，不能够直接的拿类别嘉禾处理，需要引入损失。

在GBDT中，我们仍然使用回归树来处理分类问题，那此时拟合的对象和流程又是什么呢？
对于$K$分类问题，我们假设得到了$K$个得分$F_{1i},...,F_{Ki}$来代表样本$i$属于对应类别的相对可能性，那么在进行Softmax归一化后，就能够得到该样本属于这些类别的概率大小。其中，属于类别k的概率即为$\frac{e^{F_{ki}}}{{\sum }_{c=1}^K{e}^{F_{ci}}}$。此时，我们就能够使用多分类的交叉熵函数来计算模型损失，设${\text{y}}_i=[y_{1i},...,y_{Ki}]$为第$i$个样本的类别独热编码，记${\text{F}}_i=[F_{1i},...,F_{Ki}]$，则该样本的损失为
$$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}}}$$
上述的$K$个得分可以由$K$棵回归树通过集成学习得到，树的生长目标正是使得上述的损失最小化。记第$m$轮中$K$棵树对第$i$个样本输出的得分为${\text{h}}_i^{(m)}=[h_{1i}^{(m)},...,h_{Ki}^{(m)}]$，则此时${\text{F}}_i^{(m)}={\text{F}}_i^{(m-1)}+{\text{h}}_i^{(m)}$。与GBDT处理回归问题的思路同理，只需要令损失函数$L({\text{y}}_i,{\text{F}}_i)$在${\text{F}}_i={\text{F}}_i^{(m-1)}$处梯度下降即可：
$${\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)}}$$
$K$棵回归树的学习目标为：
$$\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}$$

同样需要引入学习率，以减少过拟合。

除此之外，可以利用概率和为1的性质，减少拟合次数，提升计算效率。

具体来说，此时我们需要$K-1$个得分，记为$F_{1i},...,F_{(K-1)i}$，则样本相应属于$K$个类别的概率值可表示为
$$[\frac{e^{F_{1i}}}{1+{\sum }_{c=1}^{K-1}{e}^{F_{ci}}},...,\frac{e^{F_{(K-1)i}}}{1+{\sum }_{c=1}^{K-1}{e}^{F_{ci}}},\frac{1}{1+{\sum }_{c=1}^{K-1}{e}^{F_{ci}}}]$$
当$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}}}$$

类似地记${\text{F}}_i=[F_{1i},...,F_{(K-1)i}]$，我们可以求出负梯度：
$$-{\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}$$
当$K=2$时，不妨规定$y_i\in \{0,1\}$，此时损失函数可简化为
$$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}}$$

2.2 代码实现

导入库及函数

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

同样，核心方法为fit

class GBDTClassifier:
    def __init__(self, max_depth=4, n_estimator=1000, lr=0.2):
        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))

运行结果如下