task10前向分步算法与梯度提升决策树

1. 前向分步算法

AdaBoost算法还有另一个解释，即可以认为AdaBoost算法是模型为加法模型、损失函数为指数函数、学习算法为前向分步算法时的二类分类学习方法。

1.1 加法模型

$$f(x)=\sum _{m=1}^M{\beta }_{m}b(x;{\gamma }_m)\text{\hspace{1em}(1.1)}$$
其中，$b(x;{\gamma }_m)$为基函数，${\gamma }_m$为基函数的参数，${\beta }_m$为基函数的系数。显然，AdaBoost的基分类器的线性组合$f(x)={\sum }_{m=1}^M{\alpha }_m{G}_m(x)$是一个加法模型。

在给定训练数据以及损失函数$L(y,f(x))$的条件下，学习加法模型$f(x)$成为经验风险极小化，即损失函数极小化问题：
$$mi{n}_{{\beta }_m,{\gamma }_m}\sum _{i=1}^{N}L(y_i,\sum _{m=1}^M{\beta }_{m}b(x_i;{\gamma }_m))\text{\hspace{1em}(1.2)}$$

通常这是一个复杂的优化问题。前向分步算法（forward stagwise algorithm）求解这一优化问题的思想是：因为学习的是加法模型，如果能够从前向后，每一步只学习一个基函数及其系数，逐步逼近优化目标函数式（1.2），那么就可以简化优化的复杂度。具体地，每步只需优化如下损失函数：
$$mi{n}_{{\beta }_m,{\gamma }_m}\sum _{i=1}^{N}L(y_i,\beta b(x_i;{\gamma }_m))\text{\hspace{1em}(1.3)}$$
可能这个式子还不是那么好理解，如果将其换成AdaBoost之后，就变为：
$$mi{n}_{{\beta }_m,{\gamma }_m}\sum _{i=1}^{N}L(y_i,{\alpha }_m{G}_m(x))$$

1.2 前向分步算法

给定训练集 T = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , … , ( x N , y n ) , } , x i ∈ X ⊆ R n T=\{ (x_1,y_1),(x_2,y_2), \dots,(x_N,y_n),\},x_{i} \in \mathcal{X} \subseteq \mathbf{R}^{n} T={(x1​,y1​),(x2​,y2​),…,(xN​,yn​),},xi​∈X⊆Rn， 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)$。

（1）初始化：$f_0(x)=0$
（2）对m = 1,2,…,M:
        (a) 极小化损失函数：
$$\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)\text{\hspace{1em}(1.4)}$$
得到参数${\beta }_m$与${\gamma }_m$
        (b) 更新：
$$f_m(x)=f_{m-1}(x)+{\beta }_{m}b\left(x;{\gamma }_m\right)\text{\hspace{1em}(1.5)}$$
（3）得到加法模型：
$$f(x)=f_M(x)=\sum _{m=1}^M{\beta }_{m}b\left(x;{\gamma }_m\right)\text{\hspace{1em}(1.6)}$$

这样，前向分步算法将同时求解从m=1到M的所有参数${\beta }_m$，${\gamma }_m$的优化问题简化为逐次求解各个${\beta }_m$，${\gamma }_m$的问题。

1.3 前向分步算法与Adaboost的关系：

由前向分步算法可以推导出AdaBoost，用定理叙述这一关系：

定理 AdaBoost算法是前向分步加法算法的特里。这时，模型是由基本分类器组成的加法模型，损失函数是指数函数。（《统计学习方法》 李航著 清华大学出版社）

2. 梯度提升决策树（GBDT）

2.1 提升树模型

提升方法实际采用加法模型（即基函数的线性组合）与前向分步算法。以决策树为基函数的提升方法称为提升树（boosting tree）。对分类问题决策树是二叉分类树，对回归问题决策树是二叉回归树。在之前的adaboost中，基本分类器$x<v$或$x>v$，可以看作是由一个根结点直接连接两个叶结点的两个简单决策树，即所谓的决策树桩（decision stump）。提升树模型可以表示为决策树的加法模型：
$$f_M(x)=\sum _{m=1}^{M}T(x;{\Theta }_m)\text{\hspace{1em}(2.1)}$$
其中，$T(x;{\Theta }_m)$表示决策树，${\Theta }_m$为决策树的参数，M为树的个数。

2.2 提升树算法

输入数据集 T = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , ⋯   , ( x N , y N ) } , x i ∈ X ⊆ R n , y i ∈ Y ⊆ R T=\left\{\left(x_{1}, y_{1}\right),\left(x_{2}, y_{2}\right), \cdots,\left(x_{N}, y_{N}\right)\right\}, x_{i} \in \mathcal{X} \subseteq \mathbf{R}^{n}, y_{i} \in \mathcal{Y} \subseteq \mathbf{R} T={(x1​,y1​),(x2​,y2​),⋯,(xN​,yN​)},xi​∈X⊆Rn,yi​∈Y⊆R，输出最终的提升树$f_M(x)$
（1）初始化$f_0(x)=0$
（2）对m = 1,2,…,M：
    （a）计算每个样本的残差:$$r_{mi}=y_i-f_{m-1}\left(x_i\right),i=1,2,\cdots ,N$$
    （b）拟合残差$r_{mi}$学习一棵回归树，得到$T\left(x;{\Theta }_m\right)$ 。
    （c）更新$f_m(x)=f_{m-1}(x)+T\left(x;{\Theta }_m\right)$。
（3）得到最终的回归问题的提升树：$$f_M(x)=\sum _{m=1}^{M}T\left(x;{\Theta }_m\right)$$

2.3 梯度提升

提升树利用加法模型与前向分步算法实现学习的优化过程。当损失函数是平方损失和指数损失函数时，每一步的优化是很简单的。但对于一般损失函数而言，往往每一步的优化并不容易。

针对这一问题，Freidman提出了梯度提升（gradient boosting）算法。这是利用最速下降法的近似方法，其关键是利用损失函数的负梯度在当前模型的值：
$$-{\left[\frac{\partial L(y,f(x_i))}{\partial f(x_i)}\right]}_{f(x)=f_{m-1}(x)}$$
作为回归问题提升算法中残差的近似值，拟合一个回归树。

梯度提升算法

输入：训练数据集 T = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , … , ( x N , y n ) , } , x i ∈ X ⊆ R n T=\{ (x_1,y_1),(x_2,y_2), \dots,(x_N,y_n),\},x_{i} \in \mathcal{X} \subseteq \mathbf{R}^{n} T={(x1​,y1​),(x2​,y2​),…,(xN​,yn​),},xi​∈X⊆Rn，$y_i\in \mathcal{Y}\subseteq \mathbf{R}$。损失函数$L(y,f(x))$;

输出：回归树$\hat{f}(x)$。

（1）初始化
$$f_0(x)=\arg \underset{c}{\min }\sum _{i=1}^{N}L\left(y_i,c\right)$$
（2）对于m=1,2,…,M：
    （a）对i = 1,2,…,N计算：$$r_{mi}=-{\left[\frac{\partial L\left(y_i,f\left(x_i\right)\right)}{\partial f\left(x_i\right)}\right]}_{f(x)=f_{m-1}(x)}$$
    （b）对$r_{mi}$拟合一个回归树，得到第m棵树的叶结点区域$R_{mj},j=1,2,\cdots ,J$。
    （c）对j=1,2,…J，计算：$$c_{mj}=\arg \underset{c}{\min }\sum _{x_i\in R_{mj}}L\left(y_i,f_{m-1}\left(x_i\right)+c\right)$$
    （d）更新$f_m(x)=f_{m-1}(x)+{\sum }_{j=1}^J{c}_{mj}I\left(x\in R_{mj}\right)$
（3）得到回归树：$$\hat{f}(x)=f_M(x)=\sum _{m=1}^M\sum _{j=1}^J{c}_{mj}I\left(x\in R_{mj}\right)$$

算法第一步初始化，估计使损失函数极小化的常数值，它是只有一个根节点的树，第2（a）步计算损失函数的负梯度在当前模型的值，将它作为残差的估计。对于平方损失函数，它就是通常所说的残差；对于一般损失函数，它就是残差的近似值。第2（b）步回归树叶节点区域，以拟合残差的近似值。第2（c）步利用线性搜索估计叶结点区域的值，使损失函数极小化。第2（d）步更新回归树。第3步得到输出的最终模型$\hat{f}(x)$。

2.4 代码实现

sklearn手册：

• https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.GradientBoostingRegressor.html#sklearn.ensemble.GradientBoostingRegressor
• https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.GradientBoostingClassifier.html?highlight=gra#sklearn.ensemble.GradientBoostingClassifier

from sklearn.metrics import mean_squared_error
from sklearn.datasets import make_friedman1
from sklearn.ensemble import GradientBoostingRegressor

'''
GradientBoostingRegressor参数解释：
loss：{‘ls’, ‘lad’, ‘huber’, ‘quantile’}, default=’ls’：‘ls’ 指最小二乘回归. ‘lad’ (最小绝对偏差) 是仅基于输入变量的顺序信息的高度鲁棒的损失函数。. ‘huber’ 是两者的结合. ‘quantile’允许分位数回归（用于alpha指定分位数）
learning_rate：学习率缩小了每棵树的贡献learning_rate。在learning_rate和n_estimators之间需要权衡。
n_estimators：要执行的提升次数。
subsample：用于拟合各个基础学习者的样本比例。如果小于1.0，则将导致随机梯度增强。subsample与参数n_estimators。选择会导致方差减少和偏差增加。subsample < 1.0
criterion：{'friedman_mse'，'mse'，'mae'}，默认='friedman_mse'：“ mse”是均方误差，“ mae”是平均绝对误差。默认值“ friedman_mse”通常是最好的，因为在某些情况下它可以提供更好的近似值。
min_samples_split：拆分内部节点所需的最少样本数
min_samples_leaf：在叶节点处需要的最小样本数。
min_weight_fraction_leaf：在所有叶节点处（所有输入样本）的权重总和中的最小加权分数。如果未提供sample_weight，则样本的权重相等。
max_depth：各个回归模型的最大深度。最大深度限制了树中节点的数量。调整此参数以获得最佳性能；最佳值取决于输入变量的相互作用。
min_impurity_decrease：如果节点分裂会导致杂质的减少大于或等于该值，则该节点将被分裂。
min_impurity_split：提前停止树木生长的阈值。如果节点的杂质高于阈值，则该节点将分裂
max_features{‘auto’, ‘sqrt’, ‘log2’}，int或float：寻找最佳分割时要考虑的功能数量：

如果为int，则max_features在每个分割处考虑特征。

如果为float，max_features则为小数，并 在每次拆分时考虑要素。int(max_features * n_features)

如果“auto”，则max_features=n_features。

如果是“ sqrt”，则max_features=sqrt(n_features)。

如果为“ log2”，则为max_features=log2(n_features)。

如果没有，则max_features=n_features。
'''

X, y = make_friedman1(n_samples=1200, random_state=0, noise=1.0)
X_train, X_test = X[:200], X[200:]
y_train, y_test = y[:200], y[200:]
est = GradientBoostingRegressor(n_estimators=100, learning_rate=0.1,
    max_depth=1, random_state=0, loss='ls').fit(X_train, y_train)
mean_squared_error(y_test, est.predict(X_test))

from sklearn.datasets import make_regression
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.model_selection import train_test_split
X, y = make_regression(random_state=0)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, random_state=0)
reg = GradientBoostingRegressor(random_state=0)
reg.fit(X_train, y_train)
reg.score(X_test, y_test)