机器学习 6 GBDT(梯度提升决策树)

1. 基本概念

1. GBDT也是Boosting算法的一种，但是和Adaboost算法不同；如别如下：
   1. Adaboost算法是利用前一轮的弱学习器的预测误差率来更新样本权重，然后一轮一轮的迭代；
   2. GBDT也是迭代，但是GBDT要求的弱学习器必须是CART模型，而且GBDT在模型训练的时候，模型预测的样本损失尽可能小；
   3. GBDT底层只支持决策树，并且是回归决策树；
2. 别名：GBT(Gradient Boosting Tree),GTB(Gradient Tree Boosting)、GBRT(Gradient Boosting Regression Tree), GBDT(Gradient Boosting Decision Tree),
   MART(mutiple Additive Regression Tree)
3. 迭代过程：
   1. $f_{t-1}(x)->训练弱学习器h_t(x)->f_t(x)$
   2. $L(Y,f_{t-1})->训练弱学习器h_t(x)->L(y,f_{t-1}(x)+h_t(x))$
4. 在工作中用的比较少，实际在工作中用的比较多的是Xgboost和LightGBM
5. 思想理解

其实，就是每迭代一轮，减少误差。选择本轮迭代器的标准就是：使得本轮得到的误差比上一轮得到的误差最小；

6. 举例
   1. 例一
      
   2. 例二
7. 将每一轮的弱学习器在训练集上的残差作为下一轮学习的输入。
8. 当给定步长step0的时候，在构建下一棵树的时候使用step0*残差值作为输出值，这种情况可以减少过拟合的发生

2. 组成要素

1. GBDT由三部分组成：DT(Regression Decision Tree)、GB(Gradient Boosting)和shrink(衰减)；
2. 由多棵决策树组成，所有树的结果累加起来就是最终结果；
3. 迭代决策树和随机森林的区别：
   1. 随机森林抽取不同的样本，构建不同的子树；也就是说第m棵树和第m-1棵树之间没有必然的关系；
   2. 迭代决策树在构建子树的时候，使用之前的子树构建结果后形成的残差作为输入数据来构建下一个子树；然后最终预测的时候按照子树构建的顺序进行预测，并将模型结果相加；

3. GBDT算法原理

1. 给定输入向量X和输出变量Y组成若干训练样本$(X_1,Y_1),(X_2,Y_2)....(X_n,Y_n)$,目标是找到近似函数(弱学习器)，是的损失函数$(L(Y,F(X)))$尽可能小。
2. L损失函数一般采用最小二乘损失函数或者绝对值损失函数：[主要原因是构造回归树]
   1. $L(X,F(X))=\frac{1}{2}(y-f(x){)}^2$
   2. $L(X,F(X))=|y-F(X)|$
3. 需要寻找的最优弱学习器为：$F^{\ast }(X)=argmi{n}_{F}L(y,F(x))$
4. 假设F(x)是一族最优基函数$f_i(x)$的加权和：
   1. $F(X)={\sum }_{i=0}^M{f}_i(x)$
   2. 为了防止每一个基学习器学习能力过强，而导致过拟合，需要给定一个缩放系数：$F(X)=v{\sum }_{i=0}^M{f}_i(x)$
5. 按照贪心算法的思想得到$F_M(x)$,求解最优的f
   1. $F_M(x)=F_{M-1}(x)+argmi{n}_f{\sum }_{i=1}^{n}L(y_i,F_{M-1}(X_i)+fm(X_i))$
6. 按照贪心算法每次选择最优基函数时，仍然存在困难，使用梯度下降法近似计算[因为涉及到所有的样本]
7. 给定常数函数$F_0(X)$,使得$F_0(X)=argmi{n}_c{\sum }_{i=1}^{n}L(y_i,c)$
8. 根据梯度下降计算学习率：
   1. ${\alpha }_{im}=[\frac{\partial L(y_i,F(x_i))}{\partial F(x_i)}{]}_{F(x)=F_{m-1}(x)}$
9. 使用数据$(x_i,{\alpha }_{im})(i=1,2...n)$计算拟合残差，得到一个CART回归树，得到第m棵树：注意每次将$y_i变为{\alpha }_{im}$,${\alpha }_{im}$的变化就是梯度方向变化
   1. $c_{mj}=argmi{n}_x{\sum }_{x\in leaf}L(y_i,f_{m-1}(x_i)+c)$
   2. $h_m(x)={\sum }_{j=1}^{|leaf{|}_m}{c}_{mj}I(x\in lea{f}_{mj})$
10. 更新模型
    1. $f_m(x)=f_{m-1}(x)+{\sum }_{j=1}^{|leaf{|}_m}{c}_{mj}I(x\in lea{f}_{mj})$
    2. $f(x)=f_0(x)+{\sum }_{m=1}^M{\sum }_{j=1}^{|leaf{|}_m}{c}_{mj}I(x\in lea{f}_{mj}$

4. GBDT回归算法和分类算法的区别

1. 两者唯一的区别就是选择不同的损失函数；
2. 回归算法选择的损失函数一般为：均方差(最小二乘)或者绝对值误差；而在分类算法中一般的损失函数选择对数函数来表示：
   1. $L(y,f(x))=\frac{1}{2}(y-f(x){)}^2$
   2. $L(y,f(x))=ln(1+e^{-y\ast f(x)});y\in (-1,+1)$
   3. $L(y,f(x))=-{\sum }_{k=1}^K{y}_{k}log(p_k(x))$; K分类中

5. GBDT API相关参数

参数	GradientBoostingClassifier	GradientBoostingRegressor
alpha	不支持	当使用huber或者quantile损失函数时，需要给定分位数的值，默认为0.9；如果噪音数据比较多，可以适当地降低改参数
loss	给定损失函数，可以选择对数似然函数diviance和指数损失函数exponential；默认为deviance，不建议修改	给定损失函数，可选均方差损失函数ls、绝对损失lad、Huber损失huber、分位数损失函数quantile；默认选择ls，如果噪音数据比较多，采用huber；如果是分段预测，推荐qutantile
n_estimators	最大迭代次数，值过小可能会导致欠拟合，值过大可能会导致过拟合，一般50~100比较合适，默认50
learning_rate	指定每个弱分类器的权重缩减系数v，默认为1；一般从一个较小的值进行调参；该值越小表示需要更多的弱分类器；
subsample	给定训练模型的时候，进行子采样的比例值，取值范围(0,1],默认为1，表示不采用子采样；给定小于1的值表示采用部分数据进行模型训练，可以降低模型的过拟合情况；推荐[0.5, 0.8]；采样的方式是不放回采用
init	给定初始化的模型，可以不给定

6. GBDT总结

1. GBDT的优点如下：
   1. 可以处理连续值和离散值；
   2. 在相对少的调参情况下，模型的预测效果也会不错；
   3. 模型的鲁棒性较强
2. GBDT的缺点
   1. 由于弱学习器之间存在关联关系，难以并行训练模型，也就是模型的训练速度很慢。

Bagging和Boosting的区别

1. 样本选择：Bagging算法是又放回的随机抽样(Bootstrap)；Boosting算法是每一轮的训练集不变，只是训练集中的每个样例在分类器中的权重发生变化(adaboost)或者目标属性发生变化(gbdt)，而权重根据上一轮的分类结果进行调整；
2. 样例权重：Bagging使用随机抽样，样例等权重；Boosting根据基分类器的错误率不断地调整样本的权重，错误率越大，权重越大；
3. 预测函数：Bagging所有预测模型的权重相等；Boosting算法对于误差小的分类器具有更大的权重；
4. 并行计算：Bagging算法可以并行生成各个模型；Boosting理论上只能顺序产生，因为后一个模型需要前一个模型的预测结果；
5. Bagging是减小模型的variance(方差)；Boosting时间小模型的Bias(偏差)。
6. Bagging里面每个分类模型都是强分类器，因为降低的是方差，方差过高需要降低的是过拟合；
   Boosting里面每个分类器模型是弱分类器，因为降低的是偏度，偏度过高时欠拟合；

方差和偏差

1. $error=Bias+Variance$
2. 图示
   

# demo
import numpy as np
from matplotlib import pyplot as plt
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import Ridge

x = np.arange(0, 5, 0.5)
fun_c = lambda x: -1 * np.square(x) + 6 * x
y_ = [fun_c(_) for _ in x]
noise = [0, 0.1, 0.1, 1, 0.2, 0, -1, 0.1, 0, -0.2]
y = []
for i, j in zip(y_, noise):
    y.append(i + j)

pf = PolynomialFeatures(degree=11)

p_x = pf.fit_transform(x.reshape(-1, 1))

lin1 = Ridge()
lin1.fit(p_x, y)
y_pred1 = lin1.predict(p_x)
# -- 直接线性回归
lin2 = Ridge()
lin2.fit(x.reshape(-1, 1), y)
y_pred2 = lin2.predict(x.reshape(-1, 1))
    
fig = plt.figure(figsize=(8, 6))
plt.scatter(x, y, Zorder=10, s=75, label='real points')
plt.plot(x, y_, color='r', label='Just Right')
plt.plot(x, y_pred1, color='g', label='overfit')
plt.plot(x, y_pred2, color='black', label='underfit')
plt.grid(True)
plt.xlabel('x')
plt.ylabel('y')
plt.legend()
plt.show()

3. Stacking

1. Stacking是指训练一个模型用于组合(combine)其他模型(基模型和基学习器)的技术。即首先训练处多个不同的模型，然后以之前训练的各个模型的输出作为输入来训练一个新的模型，从而得到一个最终模型，一般情况下，使用单层的Logistic回归作为组合模型；
2. 图例：