Boosting集成算法：Adaboost与Gradient Boosting

Boosting集成算法：Adaboost与Gradient Boosting

Boosting是一族可将弱学习器提升为强学习器的算法，这族算法的工作机制类似于：

• 先从初始训练集训练出一个基学习器，再根据基学习器的表现对训练样本分布进行调整，使得先前基学习器做错的训练样本在后续受到更多关注；
• 然后基于调整后的样本分布来训练下一个基学习器；
• 如此重复进行，直至基学习器数目达到事先指定的值 $T$，最终将这 $T$个基学习器进行加权结合；

Boosting族算法最著名的代表是自适应增强算法（Adaptive Boosting，简称Adaboost）算法；

Boosting算法之Adaboost：自适应增强算法

自适应增强算法（Adaptive Boosting，简称Adaboost），由Yoav Freund和Robert Schapire在1995年提出；它的自适应在于：前一个基本分类器分错的样本会得到加强，加权后的全体样本再次被用来训练下一个基本分类器；同时，在每一轮中加入一个新的弱分类器，直到达到某个预定的足够小的错误率或达到预先指定的最大迭代次数。

具体展开说，整个Adaboost迭代算法实则只有3步：

• 初始化训练数据的权值分布：如果有 $N$个样本，则每一个训练样本最开始时都被赋予相同的权值： $\displaystyle \frac {1}{N}$；

• 训练弱分类器：

  • 如果某个样本点已经被准确地分类，那么在构造下一个基学习器中，它的权值就被降低；
  • 反之，如果某个样本点没有被准确地分类，那么它的权值就会得到提高；

  随后，权值更新过的样本集被用于训练下一个分类器，整个训练过程如此迭代地进行下去；

• 将各个训练得到的弱分类器组合成强分类器：各个弱分类器的训练过程结束后，加大分类误差率小的弱分类器的权重，使其在最终的分类函数中起着较大的决定作用，而降低分类误差率大的弱分类器的权重，使其在最终的分类函数中起着较小的决定作用；

  换言之：

  • 误差率低的弱分类器在最终分类器中占比的权重则较高；
  • 误差率高的弱分类器在最终分类器中占比的权重则较低；

接下来给出详细的Adaboost算法流程推导；

Adaboost算法原理推导及流程分析

假设现给定一个训练集数据 $T=\{(x_1,y_1),(x_2,y_2),...,(x_n,y_n)\}$，若推导Adaboost算法，其实方法有很多，比较容易理解的是基于“加性模型”（additive model）的推导：

第一步，先初始化训练数据的权值分布：

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

每一个训练样本最开始时都被赋予相同的权值： $\displaystyle \frac {1}{N}$；

第二步，此时将开始多轮迭代步骤，此处用 $m=1,2,...,M$表示迭代到了第几轮；在每一轮的迭代步骤中，首先使用具有权值分布 $D_m$（ $m$表示第几轮迭代时所得的权值分布）的训练集训练弱分类器，得到基本分类器：

$$G_m(x):\chi \to \{-1,+1\}$$

这个过程中需要选取让误差率最低的阈值来设计基本分类器；其次，计算 $G_m(x)$在训练集上的分类误差率：

$$e_m = P(G_m(x_i)≠y_i) = \sum _{i=1}^Nw_{mi}I(G_m(x_i)≠y_i)$$

其中：

• $P(G_m(x_i)≠y_i)$表示：事件“分类器 $G_m(x)$分类结果不为 $y_i$”发生的概率，亦即表示分类误差率；
• $w_{mi}$表示权值分布中第 $m$次迭代时第 $i$个样本的权值；
• $I(G_m(x_i)≠y_i)$表示被分类器 $G_m(x)$分类错误的样本的数量；

整体表达式含义为： $e_m$表示被分类器 $G_m(x)$错分样本的加权平均，表示误差率；

第三步，接下来计算 $G_m(x)$的系数 $\alpha_m$，它表示 $G_m(x)$在最终分类器（自适应增强后的集成的分类器）中的重要程度，也就是得到基本分类器在最终分类器中所占据的权重：

$$\alpha_m = \frac {1}{2}\log \frac {1-e_m}{e_m}$$

由上式可知：当 $\displaystyle e_m \leq \frac {1}{2}$（为何？以2为底的对数，当 $x>1$时函数单调递增且函数值大于0）时， $\alpha_m>0$，且伴随 $e_m$逐步减小， $\alpha_m$逐步增大；这就意味着：

• 分类误差越小的基本分类器在最终分类器中的作用越大；

得出本轮迭代后基分类器 $G_m(x)$在线性组合中的系数之后，接下来就需要更新训练集的权值分布，目的是要得到样本的新的权值分布，用于下一轮迭代做准备：

$$D_{m+1} = (w_{m+1,1},w_{m+1,2},...,w_{m+1,N})$$

其中每个权值的重新计算公式为：

$$w_{m+1,i} = \frac {w_{mi}}{Z_m}\exp(-\alpha_my_iG_m(x_i)),i = 1,2,...,N$$

$w_{mi}$表示上一轮，即第 $m$次迭代时第 $i$个样本的权值，而 $Z_m$是一个规范化因子，它可以使得 $D_{m+1}$继续成为一个概率分布：

$$Z_m = \sum_{i=1}^N w_{mi}\exp (-\alpha_my_iG_m(x_i))$$

注意： $Z_m$即为Adaboost优化的损失函数；同时也可将其代入表示，即为：

$$\displaystyle w_{m+1,i} = \frac {w_{mi} \exp(-\alpha_my_iG_m(x_i))}{\sum\limits_{i=1}^N w_{mi}\exp (-\alpha_my_iG_m(x_i))},i = 1,2,...,N$$

那么：经过本次权值调整后，被基分类器 $G_m(x)$误分类的样本的权值将增大，而正确分类的样本的权值则降低；基于这种方式，Adaboost算法就能“重点关注”或“聚焦于”那些较难分类的样本（亦即 $m$次迭代中最少 $j$次被误分类的样本）；

继续进行下一次迭代，依据上一次迭代所调整的权值，并结合训练集数据后继续训练出一个新的弱分类器；

如此迭代下去，当经过 $m$次迭代，得到 $m$个弱分类器 $G_m(x)$后，利用加性模型线性组合这些弱分类器：

$$f(x)=\sum_{m=1}^M\alpha_mG_m(x)$$

从而得到最终分类器：

$$G(x)=sign(f(x))=sign(\sum_{m=1}^M\alpha_mG_m(x))$$

$sign$是符号函数，亦即分段函数，在这里表示分类器 $G(x)$的完整分类过程；

下面给出一个简易的Adaboost算法案例，来辅助各位彻底理解算法原理；假设给定下列训练样本，使用Adaboost算法学习一个强分类器：

序号	1	2	3	4	5	6	7	8	9	10
X	0	1	2	3	4	5	6	7	8	9
Y	1	1	1	-1	-1	-1	1	1	1	-1

求解过程：

• 第一步，初始化训练数据的权值分布，令每个权值 $\displaystyle w_{1i}=\frac {1}{N}=\frac {1}{10}=0.1$，其中 $N=10,i=1,2,...,10$；

拿到这10个数据的训练样本后，根据 $X$和 $Y$的对应关系，要把这10个数据分为两类，一类是“1”，一类是“-1”；根据数据的特点发现：

• “0 1 2”这3个数据对应的类是“1”；
• “3 4 5”这3个数据对应的类是“-1”；
• “6 7 8”这3个数据对应的类是“1”；
• 9是比较孤独的，对应类“-1”；抛开孤独的9不讲，“0 1 2”、“3 4 5”、“6 7 8”这是3类不同的数据，分别对应的类是1、-1、1，直观上推测可知，可以找到对应的数据分界点，比如2.5、5.5、8.5 将数据分成两类；

当然，这只是主观臆测，下面展示实际计算过程，开始 $m$次迭代（ $m=1,2,...$），设定一个阈值 $v$：

• $m=1$：第一次迭代，在权值分布为 $D_1$（此时的10个样本点各自权值均为0.1）的训练数据上，经过计算得：

  • 阈值 $v$取2.5时误差率为0.3（x < 2.5时取1，x > 2.5时取-1，则6 7 8分错，误差率为0.3）；
  • 阈值 $v$取5.5时误差率最低为0.4（x < 5.5时取1，x > 5.5时取-1，则3 4 5 6 7 8皆分错，误差率0.6大于0.5，不可取。故令x > 5.5时取1，x < 5.5时取-1，则0 1 2 9分错，误差率为0.4）；
  • 阈值 $v$取8.5时误差率为0.3（x < 8.5时取1，x > 8.5时取-1，则3 4 5分错，误差率为0.3）；

  可以看到：无论阈值 $v$取2.5还是8.5，总是至少分错3个样本，故可任取其中任意一个阈值，如2.5，构成第一个基本分类器为：

  $$G_1(x)=\begin{cases} 1,x<2.5 \\ -1,x>2.5 \end{cases}$$

  从而得到 $G_1(x)$在训练集上的误差率（被 $G_1(x)$错误分类的样本6 7 8的权值之和）为：

  $$e_1 = P(G_1(x_1)≠y_i) = 0.1 * 3 = 0.3 \\$$

  随后根据该误差率 $e_1$计算 $G_1$的系数 $\alpha_1$：

  $$\alpha_1 = \frac {1}{2}\log \frac {1-e_1}{e_1} \approx 0.4236$$

  系数 $\alpha_1$即代表 $G_1(x_1)$基分类器在最终集成的分类器上所占据的权重为0.4236；

  继续，接下来更新训练集数据的权值分布，用于下一次迭代：

  $$D_{m+1} = (w_{m+1,1},w_{m+1,2},...,w_{m+1,N}) \\ \displaystyle w_{m+1,i} = \frac {w_{mi} \exp(-\alpha_my_iG_m(x_i))}{\sum\limits_{i=1}^N w_{mi}\exp (-\alpha_my_iG_m(x_i))},i = 1,2,...,N$$

  由权值更新的公式可知：每个样本的新权值是变大还是变小，取决于它是分类出错还是分类正确：

  • 若某个训练样本分类出错，则 $y_iG_m(x_1)$为负， $-\alpha_my_iG_m(x_i)$因负负而得正，使得整个 $w_{m+1,i}$表达式结果增大；
  • 反之，则减小；

  故而，第一轮迭代完毕后，更新各个样本点的新权值分布为： $D_2 = (0.0715, 0.0715, 0.0715, 0.0715, 0.0715, 0.0715,0.1666, 0.1666, 0.1666, 0.0715)$（计算省略）；由此观察，发现：

  • 因为样本点6 7 8分错了，故而其权值由之前的0.1增大到0.1666；
  • 反之，其余样本点都分对了，所以他们的权值由之前的0.1降低到0.0715；

  最终，对应得到此时集成后的分类器仅包含第一个弱分类器：

  $$G(x)=sign(f(x))=sign(\sum_{m=1}^M\alpha_mG_m(x)) \\ sign(f_1(x)) = sign(\alpha_1G_1(x))=sign(0.4236G_1(x))$$

  此时也能看出：第一个弱分类器 $sign(0.4236G_1(x))$中，错误分类样本的权值之和即影响了误差率，而误差率即影响该弱分类器在集成中所占据的权重；

• $m=2$：第二次迭代，在权值分布为 $D_2 = (0.0715, 0.0715, 0.0715, 0.0715, 0.0715, 0.0715,0.1666, 0.1666, 0.1666, 0.0715)$（此时的10个样本点各自权值来自上一轮迭代结束前更新完毕的权值分布）的训练数据上，经过计算得：

  • 阈值 $v$取2.5时误差率为 $0.1666*3$（x < 2.5时取1，x > 2.5时取-1，则6 7 8分错，误差率为 $0.1666*3$）；
  • 阈值 $v$取5.5时误差率最低为 $0.0715*4$（x > 5.5时取1，x < 5.5时取-1，则0 1 2 9分错，误差率为 $0.0715*3 + 0.0715$）；
  • 阈值 $v$取8.5时误差率为 $0.0715*3$（x < 8.5时取1，x > 8.5时取-1，则3 4 5分错，误差率为 $0.0715*3$）；

  故而，阈值 $v$取8.5时误差率最低，故第二个弱分类器为：

  $$G_2(x)=\begin{cases} 1,x<8.5 \\ -1,x>8.5 \end{cases}$$

  很明显， $G_2(x)$把样本3 4 5分错了，根据 $D_2$可知它们的权值均为0.0715，所以 $G_2(x)$在训练数据集上的误差率（被 $G_2(x)$错误分类的样本3 4 5的权值之和）为：

  $$e_2 = P(G_2(x_2)≠y_i) = 0.0715 * 3 = 0.2413 \\$$

  随后根据该误差率 $e_2$计算 $G_2$的系数 $\alpha_2$：

  $$\alpha_2 = \frac {1}{2}\log \frac {1-e_2}{e_2} \approx 0.6496$$

  系数 $\alpha_2$即代表 $G_2(x_1)$基分类器在最终集成的分类器上所占据的权重为0.6496；

  继续，接下来更新训练集数据的权值分布，用于下一次迭代：

  $$D_{m+1} = (w_{m+1,1},w_{m+1,2},...,w_{m+1,N}) \\ \displaystyle w_{m+1,i} = \frac {w_{mi} \exp(-\alpha_my_iG_m(x_i))}{\sum\limits_{i=1}^N w_{mi}\exp (-\alpha_my_iG_m(x_i))},i = 1,2,...,N$$

  故而，第二轮迭代完毕后，更新各个样本点的新权值分布为： $D_3 = (0.0455, 0.0455, 0.0455, 0.1667, 0.1667, 0.1667 , 0.1060, 0.1060, 0.1060, 0.0455)$（计算省略）；由此观察，发现：

  • 因为样本点3 4 5分错了，故而其权值由之前的0.0715增大到0.1667；
  • 反之，其余样本点都分对了，所以他们的权值相比之前均有所降低；

  最终，对应得到此时集成后的，包含第一、第二弱分类器的集成为：

  $$G(x)=sign(f(x))=sign(\sum_{m=1}^M\alpha_mG_m(x)) \\ sign(f_2(x)) =sign(0.4236G_1(x)+0.6496G_2(x))$$

• $m=3$：第三次迭代，在权值分布为 $D_3 = (0.0455, 0.0455, 0.0455, 0.1667, 0.1667, 0.01667 , 0.1060, 0.1060, 0.1060, 0.0455)$（此时的10个样本点各自权值来自上一轮迭代结束前更新完毕的权值分布）的训练数据上，经过计算得阈值 $v$应取5.5（计算过程不再重复），故而第三个弱分类器为：

  $$G_3(x)=\begin{cases} 1,x>5.5 \\ -1,x<5.5 \end{cases}$$

  此时分错的样本是0 1 2 9，且其目前对应权值均为0.0455，故而 $G_3(x)$在训练集上的误差率 $e_3 = P(G_3(x_3)≠y_i) = 0.0455 * 4 = 0.1820$，此时 $G_3$的系数 $\alpha_3$为：

  $$\alpha_3 = \frac {1}{2}\log \frac {1-e_3}{e_3} \approx 0.7514$$

  故而，第三轮迭代完毕后，更新各个样本点的新权值分布为： $D_4 = (0.125, 0.125, 0.125, 0.102, 0.102, 0.102, 0.065, 0.065, 0.065, 0.125)$（计算省略）；

  最终，对应得到此时集成后的，包含第一、第二、第三弱分类器的集成为：

  $$G(x)=sign(f(x))=sign(\sum_{m=1}^M\alpha_mG_m(x)) \\ sign(f_3(x)) =sign(0.4236G_1(x)+0.6496G_2(x)+0.7514G_3(x))$$

综上三步迭代过程，我们可以总结：

• 如果某些样本被分错，它们在下一轮迭代中的权值将被增大；
• 反之，其它被分对的样本在下一轮迭代中的权值将被减小；
• 这样，分错样本权值不断增大，分对样本权值不断减小，在下一轮迭代中，总是选取让误差率最低的阈值来设计新的弱分类器，所以误差率 $e$（所有被 $G_m(x)$错误分类样本的权值之和）就不断降低；

最终所得的分类器即为：

$$G(x)=sign(f_3(x)) =sign(0.4236G_1(x)+0.6496G_2(x)+0.7514G_3(x))$$

Adaboost的误差界

通过上面的例子可知：

• Adaboost在学习的过程中不断减少训练误差 $e$，直到各个弱分类器组合成最终分类器；

那这个最终分类器的误差界到底是多少呢？在这里先直接给出Adaboost集成的训练误差上界为：

$$\frac {1}{N}\sum_{i=1}^NI(G(x_i)≠y_i) \leq \frac {1}{N}\sum_i \exp (-y_if(x_i))=\prod_{m}Z_m \qquad ①$$

接下来给出证明：

$$\because w_{m+1,i} = \frac {w_{mi}}{Z_m}\exp(-\alpha_my_iG_m(x_i)),i = 1,2,...,N \\ \therefore Z_m w_{m+1,i} = w_{mi}\exp(-\alpha_my_iG_m(x_i)) \qquad (1)\\ 又\because f(x)=\sum_{m=1}^M\alpha_mG_m(x) \\ \therefore 原式=\frac {1}{N}\sum_i \exp (-y_if(x_i)) \\ =\frac {1}{N}\sum_i \exp (-\sum_{m=1}^M\alpha_my_iG_m(x_i)) \qquad (初始时w_{1i}=\frac {1}{N})\\ =w_{1i}\sum_i \exp (-\sum_{m=1}^M\alpha_my_iG_m(x_i)) \qquad (利用对数运算法则\log^{(a+b)}=\log^a*\log^b)\\ =w_{1i}\prod_{m=1}^M\exp (-\alpha_my_iG_m(x_i)) \qquad (利用(1)式带入连乘计算)\\ =Z_1\sum_iw_{2i}\prod_{m=2}^M\exp (-\alpha_my_iG_m(x_i)) \\ =Z_1Z_2\sum_iw_{3i}\prod_{m=3}^M\exp (-\alpha_my_iG_m(x_i)) \qquad (不断的从连乘式中拆解出一个合适的G_m进行化简)\\ =Z_1Z_2...Z_{M-1}\sum_iw_{Mi}\exp (-\alpha_M y_i G_M(x_i)) \\ =Z_1Z_2...Z_{M-1}Z_M \\ =\prod_{m}Z_m$$

这个结果说明，可以在每一轮选取适当的 $G_m$使得 $Z_m$最小，从而使训练误差下降最快；

但此时： $\displaystyle \prod_{m}Z_m$并不是最终的上界表达式，要视问题情况具体进一步推导；比如这里给出的案例就是一个典型的二分类问题，那么二分类问题下Adaboost的误差上界为：

$$\prod_{m}Z_m = \prod_{m}^M(2\sqrt {e_m(1-e_m)})=\prod_{m}^M\sqrt {1-4\gamma_m^2} \leq \exp (-2\sum_{m=1}^M\gamma_m^2),其中\gamma_m=\frac {1}{2}-e_m$$

也可简单推导，由给出的 $Z_m$以及误差上界一般化表达式①式可得：

$$Z_m = \sum_{i=1}^N w_{mi}\exp (-\alpha_my_iG_m(x_i)) \\ =\sum_{y_i=G_M(x_i)}w_{mi}e^{-\alpha_m}+\sum_{y_i≠G_M(x_i)}w_{mi}e^{\alpha_m} \qquad (其中\alpha_m = \frac {1}{2}\log \frac {1-e_m}{e_m})\\ =(1-e_m)e^{-\alpha_m}+e_me^{\alpha_m} \\ =2\sqrt{e_m(1-e_m)} \\ =\sqrt{1-4\gamma_m^2} \qquad (其中\gamma_m=\frac {1}{2}-e_m)\\ (后续连乘计算不再展示，连乘需要依据表达式在点x处的泰勒展开进行推导，故计算过程不重要，看结果即可)$$

此时若取 $\gamma_1,\gamma_2,...$的最大值，记作 $\gamma$，则：

$$\frac {1}{N}\sum_{i=1}^NI(G(x_i)≠y_i) \leq \exp(-2M\gamma^2)$$

这个结论很重要，它表明Adaboost的训练误差是以指数速率下降的；

综上完整的理论推导，关于Adaboost算法，我们可以给出另外一种解释：

Adaboost是一种遵循加性模型的、损失函数为指数函数的、学习算法为前向分步算法的二分类集成学习算法。

Adaboost分类器的SCIKIT-LEARN实现

前文讲解随机森林时已统一作了API的介绍，这里不再赘述，直接展示Adaboost分类器的文档解释：

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

其中关键参数的含义为：

• base_estimator：指定基学习器；
• n_estimators：boosting（提升）过程被终止的最大的基学习器数量；
• learning_rate：boosting（提升）的学习率，表示梯度收敛速度，默认为1；
  • 如果该值过大，容易错过最优值；
  • 如果该值过小，则收敛速度会很慢；
  • 该值需要和n_estimators进行一个权衡：当分类器迭代次数较少时，学习率可以小一些，当迭代次数较多时，学习率可以适当放大；
• algorithm：指定boosting（提升）算法；

下述为Adaboost的sklearn基本实现流程：

第一步，先导入包和模块：

import numpy as np
import pandas as pd

# 导入鸢尾花数据集
from sklearn.datasets import load_iris

# 导入Adaboost对象
from sklearn.ensemble import AdaBoostClassifier

# 导入CART分类树对象
from sklearn.tree import DecisionTreeClassifier

# 导入数据集划分对象
from sklearn.model_selection import train_test_split

# 导入预测准确率计算对象accuracy_score
from sklearn.metrics import accuracy_score
import matplotlib.pyplot as plt
%matplotlib inline

第二步，加载数据集，并完成数据集划分：

# 加载数据集,并完成数据集划分
iris = load_iris()

# 数据集划分
Xtrain,Xtest,Ytrain,Ytest = train_test_split(iris.data,iris.target,test_size = 0.3)

第三步，定义弱分类器，这里采用的是CART分类决策树对象，并且评估其分类预测的准确率：

# 定义一个弱分类器对象 - 这里我们采用的就是CART分类树模型，建立该模型并完成训练，同时评估其分类预测的准确率

# 实例化CART分类树模型对象并完成模型训练
weakClassifier = DecisionTreeClassifier(max_depth = 5).fit(Xtrain,Ytrain)

# 获取预测结果
dtc_y_pred = weakClassifier.predict(Xtest)
print('CART分类树预测的准确率：{}'.format(accuracy_score(Ytest,dtc_y_pred)))

# ====output====
CART分类决策树的准确率：0.9333333333333333

第四步，构建Adaboost分类模型并完成训练，获取预测结果：

# 构建Adaboost自适应增强分类器模型，并完成训练，且获取预测结果
clf = AdaBoostClassifier(
    base_estimator = weakClassifier,
    algorithm = 'SAMME.R',
    n_estimators = 300,
    learning_rate = 0.4
).fit(Xtrain,Ytrain)

# 获取预测结果
clf_y_pred = clf.predict(Xtest)
print('Adaboost自适应增强分类模型预测的准确率：{}'.format(accuracy_score(Ytest,clf_y_pred)))
clf.feature_importances_
clf.estimator_weights_ 

# ====output====
Adaboost的准确率：0.9555555555555556

接下来绘制n_estimators超参数学习曲线观察该值对Adaboost整体性能的影响：

x = list(range(2, 20, 2))
y = []

for i in x:
  model = AdaBoostClassifier(
      base_estimator=weakClassifier,
      n_estimators=i,
      learning_rate=0.5,
      algorithm='SAMME.R',
      random_state=1
  ).fit(Xtrain,Ytrain)
  
  y.append(accuracy_score(Ytest, model.predict(Xtest)))

plt.style.use('ggplot')
plt.title("Effect of n_estimators", pad=20)
plt.xlabel("Number of base estimators")
plt.ylabel("Test accuracy of AdaBoost")
plt.plot(x, y)
plt.show()

接下来绘制learning_rate学习率超参数学习曲线观察该值对Adaboost整体性能的影响：

x = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1]
y = []

for i in x:
  model = AdaBoostClassifier(
      base_estimator=weakClassifier,
      n_estimators=50,
      learning_rate=i,
      algorithm='SAMME.R',
      random_state=1
  ).fit(Xtrain,Ytrain)
  
  y.append(accuracy_score(Ytest, model.predict(Xtest)))

plt.title("Effect of learning_rate", pad=20)
plt.xlabel("Learning rate")
plt.ylabel("Test accuracy of AdaBoost")
plt.plot(x, y)
plt.show()

重要属性、方法、接口、参数

• feature_importances_：查看样本每个特征的权重；

  # 查看样本每个特征的权重
  [*zip(pd.DataFrame(Xtrain).columns,clf.feature_importances_)]
  
  # ====output====
  [(0, 0.11172974014002672),
   (1, 0.17037184013571008),
   (2, 0.3692624049702443),
   (3, 0.3486360147540191)]
  

• estimator_weights_：查看所有基学习器的权重；

  # 查看每个基学习器的权重
  clf.estimator_weights_
  
  # ====output====
  array([3.13757867, 1.97283824, 2.60686223, 2.31186429, 1.82837079,
         1.65777319, 2.22170483, 2.22343172, 1.6475453 , 1.39016209,
         1.53223984, 2.05014314, 2.04086687, 2.15492762, 2.31784063,
         ...
  

Adaboost回归器的SCIKIT-LEARN实现

第一步，导包：

import numpy as np
import pandas as pd

# 导入波士顿房价数据集
from sklearn.datasets import load_boston

# 导入Adaboost回归器对象
from sklearn.ensemble import AdaBoostRegressor

# 数据集划分
from sklearn.model_selection import train_test_split

# 导入均方误差
from sklearn.metrics import mean_squared_error

# 导入CART回归树对象
from sklearn.tree import DecisionTreeRegressor
import matplotlib.pyplot as plt
%matplotlib inline

第二步，加载以及划分数据集：

boston = load_boston()

# 划分数据集为训练集和测试集
Xtrain,Xtest,Ytrain,Ytest = train_test_split(boston.data,boston.target,test_size = 0.3)

第三步，构建单棵CART回归树对象：

# 构建单棵CART回归树对象
clf = DecisionTreeRegressor(max_depth = 5)
clf.fit(Xtrain,Ytrain)
y_pred = clf.predict(Xtest)
print("单棵回归树结果如下：")
print("训练集分数：",clf.score(Xtrain,Ytrain))
print("验证集分数：",clf.score(Xtest,Ytest))
print("均方误差：",mean_squared_error(Ytest,y_pred))

第四步，构建Adaboost回归器对象，使用多棵回归树作为基学习器：

# Adaboost回归学习器（多棵回归树）
clf = AdaBoostRegressor(DecisionTreeRegressor(max_depth = 5),n_estimators = 40)
clf.fit(Xtrain,Ytrain)
y_pred = clf.predict(Xtest)
print("Adaboost回归学习器（多棵回归树）结果如下：")
print("训练集分数：",clf.score(Xtrain,Ytrain))
print("验证集分数：",clf.score(Xtest,Ytest))
print("均方误差：",mean_squared_error(Ytest,y_pred))

总结

还有一个遗漏的问题没有说到：关于Adaboost中弱学习器的类型问题；理论上来说，任何学习器都可以用于Adaboost，但一般而言，使用最广泛的Adaboost弱学习器仍然是决策树和神经网络；