14、集成学习——Adaboost算法

1 概述

• 定义：Adaboost ，“Adaptive Boosting”（自适应增强），是一种迭代算法，其核心思想是针对同一个训练集训练不同的分类器(弱分类器)，然后把这些弱分类器集合起来，构成一个更强的最终分类器（强分类器）。由Yoav Freund和Robert Schapire于1995年提出。

• 思想

  前面的模型对训练集预测后，在每个样本上都会产生一个不同损失，AdaBoost会为每个样本更新权重，分类错误的样本要提高权重，分类正确的样本要降低权重，下一个学习器会更加**“关注”权重大的样本；每一次得到一个模型后，根据模型在该轮数据上的表现给当前模型设置一个权重**，表现好的权重大，最终带权叠加得到最终集成模型。

  

2 分类算法流程

• 输入：训练集为 T={(x1,y1),(x2,y2),...,(xN,yN)},y∈{−1,+1}T=\{ (x_1,y_1),(x_2,y_2),...,(x_N,y_N) \},y∈\{−1,+1\}T={(x1​,y1​),(x2​,y2​),...,(xN​,yN​)},y∈{−1,+1}，训练弱学习器M个。

• 输出：最终的强学习器G(x)

1. 初始化样本集权重为 $D_1=(w_{11},w_{12},...,w_{1N})$，其中 $w_{1i}=\frac{1}{N},i=1,2,...,N$

2. 对每个弱学习器 $G_m(x),m=1,2,...,M$

   ​ a) 使用具有权值分布$D_m$的训练数据来训练模型，得到弱学习器$G_m(x)$

   ​ b) 定义第 $m$ 个弱分类器$G_m(x)$在训练集上的误差率 $e_m$
   $$e_m=\sum _{i=1}^{N}P(G_m(x_i)\ne y_i)=\sum _{i=1}^N{w}_{mi}I(G_m(x_i)\ne y_i)$$
   ​ c) 计算弱学习器的系数
   $${\alpha }_m=\frac{1}{2}\ln \frac{1-e_m}{e_m}$$
   ​ d) 更新训练集中样本的权重分布，使$D_{m+1}$成为一个概率分布，$Z_m$是规范化因子。
   $$\begin{gathered} D_{m+1}=(w_{m+1,1},...,w_{m+1,i,...,w_{m+1,N}}) \\ {Z}_m=\sum _{i=1}^N{w}_{m,i}\exp (-{\alpha }_m{y}_i{G}_m(x_i)) \\ {w}_{m+1,i}=\frac{w_{m,i}}{Z_m}\exp (-{\alpha }_m{y}_i{G}_m(x_i))，i=1,2,3,\dots ,N \end{gathered}$$

3. 最终学习器为：

$$\begin{gathered} H(x)=sign(\sum _{m=1}^M{\alpha }_m{G}_m(x)) \\ sign(x)=\{\begin{array}{r}-1,x<0\\ 0,x=0\\ 1,x>0\end{array} \end{gathered}$$
这里Adaboost算法中引入了正则化，通过一个称为学习率的参数$v$对弱分类器的权重大小进行控制，即
$$H_m(x)=H_{m-1}(x)+v{\alpha }_m{G}_m(x)$$
第一次设置样本权重相同，通过错误率计算学习器权重，更新下一次样本权重。计算每个学习器权重和结果的乘积，计算最终结果。

3 分类案例详解

有如下的训练样本，我们需要构建强分类器对其进行分类。x是特征，y是标签

1）设置初始的样本权重值$1/N$

初始每个样本的权重为$w_{1,i}=0.1,i=1,2,\cdots ,10$

2）对于$m=1,2,...,M$:

初始第1个弱分类器，经过决策树分类原则，知道最佳阈值点为2，得到弱分类器：
$$G_1(x)=\{\begin{array}{r}1,x\le 2\\ -1,x>2\end{array}$$
通过误差率计算，可以计算出误差率为
$$e_1=\sum _{i=1}^N{w}_{1i}I(G_1(x)\ne y_i)=0.3$$
计算$G_1(x)$在强分类器中的权重系数
$${\alpha }_1=\frac{1}{2}\log \frac{1-e_1}{e_1}=0.4236$$
更新样本的权重分布，用于下一轮迭代：

$$\begin{gathered} Z_1=\sum _{i=1}^N(w_{1,i}\exp (-{\alpha }_1{y}_i{G}_1(x_i))) \\ {w}_{2,i}=\frac{w_{1,i}}{z_1}\exp (-{\alpha }_2{y}_i{G}_2(x_i))，i=1,2,3,\dots \end{gathered}$$
更新后的权重进行调整
$$w_2=(0.0715,0.0715,0.0715,0.0715,0.0715,0.0715,0.1666,0.1666,0.1666,0.0715)$$
得到第一轮迭代的强分类器
$$sign(F_1(x))=sign(0.4236G_1(x))$$
依此类推，经过多轮以后，得到如下强分类器：
$$sign(F_3(x))=sign(0.4236G_1(x)+0.6496G_2(x)+0.7514G_3(x))$$
分类误差率为0，结束迭代。

$F(x)=sign(F_3(x))$就是最终的强分类器。

4 回归算法流程

输入：训练集为$T=(x_1,y_1),(x_2,y_2),...,(x_N,y_N),y\in R$，训练弱学习器$M$个。

输出：最终的强学习器$G(x)$

1. 初始化训练集权重为

$$D_1=(w_{11},w_{12},...,w_{1N}),w_{1i}=\frac{1}{N},i=1,2,...,N$$

2. 对于$m=1,2,...,M$:

   a) 使用具有权值分布$D_m$的训练数据来训练模型，得到弱学习器$G_m(x)$

   b) 计算$G_m(x)$的在训练集T上的最大误差$E_m$和回归误差率$e_m$
   $$\begin{gathered} E_m=\max |y_i-G_m(x_i)|,i=1,2,...,N \\ {e}_m=\sum _{i=1}^N{w}_{mi}\frac{(y_i-G_m(x_i){)}^2}{E_m^2} \end{gathered}$$
   c) 计算${\alpha }_m$（用于计算弱学习器的系数）
   $${\alpha }_m=\frac{e_m}{1-e_m}$$
   d) 更新训练集中样本的权重

$$\begin{gathered} Z_m=\sum _{i=1}^N{w}_{m,i}\exp (-{\alpha }_m{y}_i{G}_m(x_i)) \\ {w}_{m+1,i}=\sum _{i=1}^N\frac{w_{m,i}}{Z_m}{\alpha }_m^{1-e_m} \end{gathered}$$

3. 最终学习器

   先对弱学习器进行加权，取中位数，再组成最终模型
   $$G(x)=[\sum _{m=1}^M(ln\frac{1}{{\alpha }_m})]g(x)，其中g(x)是所有{\alpha }_m{G}_m(x)的中位数，m=1,2,...,M$$

5 AdaBoost函数模型

5.1 AdaBoostingClassifier

class sklearn.ensemble. AdaBoostClassifier(base_estimator=None,*, n_estimators=50,learning_rate=1.0,algorithm='SAMME.R', random_state=None)

1. 参数

   • base_estimator： 对象类型，默认值为None
     该参数设置为None时，使用默认基学习器DecisionTreeClassifier(max_depth=1),即默认使用深度为1的CART树。

   • algorithm：
     可选参数，默认为SAMME.R。scikit-learn实现了两种Adaboost分类算法：SAMME和SAMME.R。两者的主要区别在于基学习器权重的度量方法：

     • SAMME使用对数据集的分类效果作为基学习器的权重（上述流程是二分类，此算法为多分类，改变权重系数计算${\alpha }_m，{\alpha }_m=\frac{1}{2}\ln (\frac{1-e_m}{e_m})+\ln (|Y|-1)$，$|Y|$是分类数，加$\ln (|Y|-1)$可以增大使${\alpha }_m$为0时的$e_m$）；
     • SAMME.R使用对数据集分类的预测概率大小来作为基学习器的权重。

     由于SAMME.R使用了概率度量的连续值，迭代速度一般比SAMME快，因此AdaBoostClassifier的algorithm参数默认值也设置为SAMME.R。注意：若使用的是SAMME.R算法，则base_estimator参数必须限制使用支持概率预测的分类器，SAMME算法则没有这个限制。

   • n_estimators： 整型，默认值为50
     基学习器的最大迭代次数（即最大的基学习器个数）。AdaBoost的分类效果对n_estimators取值的敏感性较高：

     • n_estimator太小，基学习器数量太少，容易造成欠拟合；
     • n_estimators太大，基学习器数量太多，容易造成过拟合；

     所以，在实际使用中，n_estimators的值不宜过大，也不能太小，需要通过调参找到一个合适的取值。在实际调参的过程中，常常将n_estimators和下面要介绍到的参数learning_rate一起考虑。

   • learning_rate： 浮点型，默认为1.0
     表示每个基学习器的权重缩减系数（公式中的${\alpha }_m$）。该参数对AdaBoost分类效果的影响也很大，所以在实际使用中，需要通过调参，在n_estimators和learning_rate这两个参数之间找到平衡。在实例2中将会对这一过程做详细的探索。

   • random_state： 整型，默认为None
     为每个基学习器设置相同的随机数种子，确保多次运行所生成的随机数状态均一致，便于调参与观察。

2. 属性
   AdaBoostingClassifier类有很多属性，如下：

   • base_estimator_：返回基学习器（包括种类、详细参数等信息）。
   • estimators_：返回对数据集进行拟合之后的所有基学习器所组成的列表。
   • classes_：返回所有类别的标签。
   • n_class：返回总类别数。
   • estimator_weights_：返回每个基学习器所对应权重所组成的列表。
   • estimator_errors_：返回每个基学习器的分类错误率所组成的列表。

3. 常用方法
   AdaBoostingClassifier类有很多方法，常用的方法如下：

   • decision_function(X)：得到分类器对数据集$X$中各个样本的计算结果，分为如下两种情况：
     • 若数据集只有两个类别，则返回的计算结果的尺寸为 $shape=(样本数,1)$；
     • 若数据集有$k(k>2)$个类别，则返回的计算结果的尺寸为$shape=(样本数,k)$。

   以二分类为例，假设AdaBoost分类器abt对样本$x$的计算结果
   abt.decision_functiuon(x)=[-0.009] ，由于-0.009到0的距离比到1的距离更近，所以分类器预测$x$属于类别0；
   假设abt对样本$x$的计算结果 abt.decision_functiuon(x)=[0.999] ，由于0.999到1的距离比到0的距离更近，所以分类器预测$x$属于类别1。多分类任务也同理。

   • fit(X,y,[,sample_weight]：拟合数据集。
   • get_params([deep])：$deep$参数指定为$True$ 时，返回集成分类器的各项参数值。
   • predict(X)：对样本进行预测。
   • predict_proba(X)：计算出样本$X$属于各个类别的概率。
   • predict_log_proba(X)：预测结果以概率值的自然对数值返回。
     ( 这里简单介绍一下上面两种方法的区别。比如在一个二分类任务中，AdaBoost分类器abt对一个样本$x$的预测结果为[[0.8, 0.2]]，即 abt.predict_proba(x)= [[0.8,0.2]] ，表示该分类器预测出$x$属于类别0的概率为0.8、属于类别1的概率为0.2​；然后再对这两个值分别取自然对数，返回的结果为[[-0.2231, -1.6094]]，即 abt.predict_log_proba(x)=[[-0.2231, -1.6094]] )

5.2 AdaBoostRegressor

class sklearn.ensemble.AdaBoostRegressor(base_estimator=None, *, n_estimators=50, learning_rate=1.0, loss='linear', random_state=None)

1. 参数

   • base_estimator： 对象类型，默认值为None
     该参数不指定时，使用DecisionTreeRegressor(max_depth=3)作为基学习器，即默认使用深度为3的回归决策树。

   • n_estimators： 整型，默认值为50 基学习器的最大迭代次数（即最大的基学习器个数）。

   • learning_rate： 浮点型，默认为1.0 表示每个基学习器的权重缩减系数。

   • loss：可选项为 {‘linear’, ‘square’, ‘exponential’}，默认为‘linear’。
     定义误差函数，各个选项的含义如下：

     ‘linear’：线性损失函数， ‘square’：平方损失函数， ‘exponential’：指数损失函数

   • random_state： 整型，默认为None
     为每个基学习器设置相同的随机数种子，确保多次运行所生成的随机数状态均一致，便于调参与观察。

2. 属性
   AdaBoostingRegressor类的全部属性只有5个，比AdaBoostingClassifier类少。如下：
   base_estimator_：返回基学习器（包括种类、详细参数等信息）。
   estimators_：返回对数据集进行拟合之后的所有基学习器所组成的列表。
   estimator_weights_：返回每个基学习器所对应权重所组成的列表。
   estimator_errors_：返回每个基学习器的回归损失所组成的列表。
   feature_importances_：返回数据集中每个特征的权重的组成的列表。

3. 常用方法
   AdaBoostingRegressor类的常用方法如下：
   fit(X,y,[,sample_weight]：拟合数据集。
   get_params([deep])：$deep$参数指定为$True$时，返回集成回归器的各项参数值。
   predict(X)：对样本数据集$X$进行回归预测，返回预测出的数值。
   staged_predict(X)：获取对数据集$X$的阶梯测试准确率。
   staged_score(X)：获取对数据集$X$的阶梯训练准确率。
   set_params(**params)：以字典的形式传入参数**params，设置集成学习器的各项参数。

6 Adaboost代码实战

import pandas as pd
import numpy as np
from sklearn.ensemble import AdaBoostClassifier
df = pd.DataFrame([[0,1],[1,1],[2,1],[3,-1],[4,-1],
                   [5,-1],[6,1],[7,1],[8,1],[9,-1]])
X = df.iloc[:,[0]]
Y = df.iloc[:,-1]

model = AdaBoostClassifier(n_estimators=10,).fit(X,Y)
model.predict(X)

import pandas as pd
import numpy as np
from sklearn.ensemble import AdaBoostRegressor
from sklearn.tree import DecisionTreeRegressor

df = pd.DataFrame([[1,5.56],[2,5.7],[3,5.91],[4,6.4],[5,6.8],
                   [6,7.05],[7,8.9],[8,8.7111],[9,9.0],[10,9.05]])
X = df.iloc[:,[0]]
Y = df.iloc[:,-1]

model = DecisionTreeRegressor(max_depth=3)
model = AdaBoostRegressor(n_estimators=5,base_estimator=model,learning_rate=0.01).fit(X,Y)
model.predict(X)

7 Adaboost小结

• 优点：

  • 可以使用各种回归分类模型来构建弱学习器，非常灵活
  • Sklearn中对AdaBoost的实现是从带权学习视角出发的，思想朴素，易于理解
  • 控制迭代次数可以一定程度防止发生过拟合

• 缺点：对异常样本敏感，异常样本在迭代中可能会获得较高的权重，影响最终预测准确性。

• 提升树：AdaBoost思想结合决策树的基学习器，就得到提升树模型。提升树做分类时，基学习器选CART分类树；回归时选CART回归树

• 两个视角：带权学习视角、前向分布学习视角

  在前向分步学习视角下，当提升树的损失函数是平方损失和指数损失时，优化是简单的，但对一般损失函数而言优化难度大，即没有通用的求解方案

  因此2001年，Friedman提出了一个通用方案——梯度提升，起名为GBDT