Adaboost原理

Adaboost介绍

AdaBoost算法与Boosting算法不同，它是使用整个训练集来训练弱学习器，其中训练样本在每次迭代的过程中都会重新被赋予一个权重，在上一个弱学习器错误的基础上进行学习来构建一个更加强大的分类器。下面通过一个图来了解AdaBoost算法的工作过程。

Adaboost算法分析

从图1.1中，我们可以看到adaboost的一个详细的算法过程。Adaboost是一种比较有特点的算法，可以总结如下：

每次迭代改变的是样本的分布，而不是重复采样（re weight)
样本分布的改变取决于样本是否被正确分类 总是分类正确的样本权值低；总是分类错误的样本权值高（通常是边界附近的样本）
最终的结果是弱分类器的加权组合（权值表示该弱分类器的性能）
简单来说，Adaboost有很多优点:

adaboost是一种有很高精度的分类器
可以使用各种方法构建子分类器，adaboost算法提供的是框架
当使用简单分类器时，计算出的结果是可以理解的。而且弱分类器构造极其简单
简单，不用做特征筛选
不用担心overfitting！
总之：adaboost是简单，有效。

Adaboost过程图示

下面我们举一个简单的例子来看看adaboost的实现过程：

图中，“+”和“-”分别表示两种类别，在这个过程中，我们使用水平或者垂直的直线作为分类器，来进行分类。
第一步：

根据分类的正确率，得到一个新的样本分布D2­，一个子分类器h1
其中划圈的样本表示被分错的。在右边的途中，比较大的“+”表示对该样本做了加权。

第二步：

​
根据分类的正确率，得到一个新的样本分布D3，一个子分类器h2

第三步：

得到一个子分类器h3

整合所有子分类器：

因此可以得到整合的结果，从结果中看，及时简单的分类器，组合起来也能获得很好的分类效果，在例子中所有的。

Adaboost算法的某些特性是非常好的，在我们的报告中，主要介绍adaboost的两个特性。一是训练的错误率上界，随着迭代次数的增加，会逐渐下降；二是adaboost算法即使训练次数很多，也不会出现过拟合的问题。

Adaboost算法流程

假设输入训练数据为：
T = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , ( x N , y N ) } T=\left\{\left(x_{1}, y_{1}\right),\left(x_{2}, y_{2}\right),\left(x_{N}, y_{N}\right)\right\} T={(x1​,y1​),(x2​,y2​),(xN​,yN​)}其中：$x_i\in X\subseteq R^n,y_i\in Y=-1,1$ ，迭代次数即若分类器个数为M.
1.初始化训练样本的权值分布为：
$$D_1=\left(w_{1,1},w_{1,2},\dots ,w_{1,i}\right),w_{1,i}=\frac{1}{N},i=1,2,\dots ,N$$2.对于$m=1,2,\dots ,M$

a）使用具有权值分布$D_m$的训练数据集进行学习，得到弱分类器$G_m(x)$
b）计算$G_m(x)$在训练数据集上的分类误差率：
$$e_m=\sum _{i=1}^N{w}_{m,i}I\left(G_m\left(x_i\right)\ne y_i\right)$$c）计算$G_m(x)$在强分类器中所占的权重：
$${\alpha }_m=\frac{1}{2}\log \frac{1-e_m}{e_m}$$d）更新训练数据集的权值分布（这里$z_m$是归一化因子，为了使样本的概率分布和为1）：
$$\begin{array}{c}{w}_{m+1,i}=\frac{w_{m,i}}{z_m}\exp \left(-{\alpha }_m{y}_i{G}_m\left(x_i\right)\right),i=1,2,\dots ,10\\ z_m={\sum }_{i=1}^N{w}_{m,i}\exp \left(-{\alpha }_m{y}_i{G}_m\left(x_i\right)\right)\end{array}$$

3.得到最终的分类器为：
$$F(x)=\mathrm{sign}\left(\sum _{i=1}^N{\alpha }_m{G}_m(x)\right)$$
整个流程中令人困惑的是：

• 分类器的权重的确定

下面我们进行证明

假设经过m-1轮迭代，得到弱分类器$F_{m-1}(x)$，根据前向分布，有：
$$F_m(x)=F_{m-1}(x)+{\alpha }_m{G}_m(x)$$AdaBoost的损失函数是指数损失，则有：
$$\text{ Loss }=\sum _{i=1}^N\exp \left(-y_i{F}_m\left(x_i\right)\right)=\sum _{i=1}^N\exp \left(-y_i\left(F_{m-1}\left(x_i\right)+{\alpha }_m{G}_m\left(x_i\right)\right)\right)$$因为$F_{m-1}(x)$是已知的，所以将其移到前面：
$$\mathrm{Loss}=\sum _{i=1}^N\widetilde{w_{m,i}}\exp \left(-y_i{\alpha }_m{G}_m\left(x_i\right)\right)$$其中，$\widetilde{w_{m,i}}=\exp \left(-y_i\left(F_{m-1}(x)\right)\right)$是每轮迭代的样本权重，证明化简如下：
$$\widetilde{w_{m,i}}=\exp \left(-y_i\left(F_{m-2}\left(x_i\right)+{\alpha }_{m-1}{G}_{m-1}\left(x_i\right)\right)\right)$$$$=\widetilde{w_{m-1,i}}\exp \left(-y_i{\alpha }_{m-1}{G}_{m-1}\left(x_i\right)\right)$$继续化简Loss：
$$Loss=\sum _{i=1}^N\widetilde{w_{m,i}}\exp \left(-y_i{\alpha }_m{G}_m\left(x_i\right)\right)$$$$=\sum _{y_i=G_m\left(x_i\right)}\widetilde{w_{m,i}}\exp \left(-{\alpha }_m\right)+\sum _{y_i\ne G_m\left(x_i\right)}\widetilde{w_{m,i}}\exp \left({\alpha }_m\right)$$$$=\sum _{i=1}^N\widetilde{w_{m,i}}\left(\frac{{\sum }_{y_i=G_m\left(x_i\right)}\widetilde{w_{m,i}}}{{\sum }_{i=1}^N\widetilde{w_{m,i}}}\exp \left(-{\alpha }_m\right)+\frac{{\sum }_{y_i\ne G_m\left(x_i\right)}\widetilde{w_{m,i}}}{{\sum }_{i=1}^N\widetilde{w_{m,i}}}\exp \left({\alpha }_m\right)\right)$$重写Loss：
$$\text{ Loss }=\sum _N^{i=1}{w}_{m,i}\left(\left(1-e_m\right)\exp \left(-{\alpha }_m\right)+e_m\exp \left({\alpha }_m\right)\right)$$对$a_m$求偏导，并令其为0，则有：
$${\alpha }_m=\frac{1}{2}\log \frac{1-e_m}{e_m}$$

Adaboost算法实例讲解

上表表示是10个一维样本的数据。第一列表示样本的编号，第二列表示样本特征的值，第三列表示样本对应的实际类别，第四列表示的是样本的权重值，第五列表示的是预测的样本，第六列表示预测的类标是否准确，第七列表示的是样本权重更新后的值。根据上面Adaboost的步骤，详细介绍权重的更新过程

（1）计算权重的错误率，预测类标与实际类标相等用0表示，否则用1表示，所以预测错误的样本有三个
$$\epsilon =\omega \ast (\hat{y}！=y)=0.1\ast \sum _{i=1}^{10}\left({\hat{y}}_i！=y_i\right)=0.1\ast 3=0.3$$
（2）计算相关系数
$${\alpha }_j=0.5\ast \log \frac{1-\epsilon }{\epsilon }=0.5\ast \log \frac{1-0.3}{0.3}=0.424$$
（3）更新权重
$$\omega \ast e^{\left(-{\alpha }_j\ast \hat{y}\ast y\right)}=\omega$$$$（\hat{y}表示预测值，y表示实际值）$$$$（\omega 、\hat{y}、y都表示一个所有样本的（10维）向量）$$

单个样本预测错误则更新后的权重为
$$\omega =0.1\ast e^{(-0.424\ast (-1)\ast 1)}=0.153或者\omega =0.1\ast e^{(-0.424\ast 1\ast (-1))}=0.153$$单个样本预测错误则更新后的权重为$$\omega =0.1\ast e^{(-0.424\ast 1\ast 1)}=0.066$$
（4）权重归一化
$$\sum _{i=1}^{10}{\omega }_i=7^{\ast }0.065+3^{\ast }0.153=0.914$$预测正确的权重，归一化后的权重为$$\frac{0.066}{0.914}=0.072$$预测错误的权重，归一化后的权重为$$\frac{0.153}{0.914}=0.167$$通过一轮权重的更新可以发现，之前预测正确的权重由0.1变成了0.072，预测错误的权重由0.1变成了0.167，所以说，权重更新的过程中，会增大预测错误样本的权重，同时也会减小预测正确样本的权重。

Adaboost原理案例举例

import numpy as np
from sklearn.ensemble import AdaBoostClassifier
from sklearn import tree
import matplotlib.pyplot as plt

X = np.arange(10).reshape(-1,1)
y = np.array([1,1,1,-1,-1,-1,1,1,1,-1])
display(X,y)
#array([[0],
#       [1],
#       [2],
#       [3],
#       [4],
#       [5],
#       [6],
#       [7],
#       [8],
#       [9]])
#array([ 1,  1,  1, -1, -1, -1,  1,  1,  1, -1])

ada = AdaBoostClassifier(n_estimators=3,algorithm="SAMME)
ada.fit(X,y)

迭代过程1

plt.figure(figsize=(9,6))
tree.plot_tree(ada[0])

对于m=1，在权值分布为D1（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{array}{ll}1,& x<2.5\\ -1,& x>2.5\end{array}$$

y_ = ada[0].predict(X)
y_
#array([ 1,  1,  1, -1, -1, -1, -1, -1, -1, -1])
#真实标签y = array([ 1,  1,  1, -1, -1, -1,  1,  1,  1, -1])

#误差率
e1 = np.round(0.1*(y != y_).sum(),4)
e1
#0.3

#计算第一棵树的权重
#随机森林中每棵树的权重是一样的
#adaboost提升树中每棵树的权重不同
a1 = np.round(1/2*np.log((1-e1)/e1),4)
a1
#0.4236

#样本预测准确：更新的权重
w2 = 0.1*np.e**(-a1*y*y_)
w2 = w2/w2.sum()
np.round(w2,4)
#array([0.0714, 0.0714, 0.0714, 0.0714, 0.0714, 0.0714, 0.1667, 0.1667,
#       0.1667, 0.0714])

从上述第一轮的整个迭代过程可以看出：被误分类样本的权值之和影响误差率，误差率影响基本分类器在最终分类器中所占的权重

分类函数f1(x)= a1*G1(x)= 0.4236G1(x)

迭代过程2

plt.figure(figsize=(9,6))
tree.plot_tree(ada[1])

对于m=2，在权值分布为D2 = (0.0715, 0.0715, 0.0715, 0.0715, 0.0715, 0.0715, 0.1666, 0.1666, 0.1666, 0.0715)的训练数据上，经过计算可得：

• 阈值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{array}{ll}1,& x<8.5\\ -1,& x>8.5\end{array}$$

ada[1].predict(X)
#array([ 1,  1,  1,  1,  1,  1,  1,  1,  1, -1])
#真实标签y = array([ 1,  1,  1, -1, -1, -1,  1,  1,  1, -1])

e2 = 0.0714*3
e2
#0.2142

a2 = np.round(1/2*np.log((1-e2)/e2),4)
a2
#0.6499

y_ = ada[1].predict(X)
#样本预测准确：更新的权重
w3 = w2*np.e**(-a2*y*y_)
w3 = w3/w3.sum()
np.round(w3,4)
#array([0.0454, 0.0454, 0.0454, 0.1667, 0.1667, 0.1667, 0.106 , 0.106 ,
#       0.106 , 0.0454])

被分错的样本“ 3 4 5 ”的权值变大，其它被分对的样本的权值变小。

f2(x)=0.4236G1(x) + 0.6496G2(x)

迭代过程3

plt.figure(figsize=(9,6))
tree.plot_tree(ada[2])

对于m=3，在权值分布为D3 = (0.0455, 0.0455, 0.0455, 0.1667, 0.1667, 0.01667, 0.1060, 0.1060, 0.1060, 0.0455)的训练数据上，经过计算可得：

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

所以阈值v取5.5时误差率最低，故第三个基本分类器为：
$$G_3(x)=\{\begin{array}{cc}1,& x>5.5\\ -1,& x<5.5\end{array}$$

ada[2].predict(X)
#array([-1, -1, -1, -1, -1, -1,  1,  1,  1,  1])
#真实标签y = array([ 1,  1,  1, -1, -1, -1,  1,  1,  1, -1])

e3 = (w3*(y_ != y)).sum()
e3
#0.182

a3 = 1/2*np.log((1-e3)/e3)
a3
#0.7514

#样本预测准确：更新的权重
y_ = ada[2].predict(X)
w4 = w3*np.e**(-a3*y*y_)
w4 = w4/w4.sum()
np.round(w4,4)
#array([0.125 , 0.125 , 0.125 , 0.1019, 0.1019, 0.1019, 0.0648, 0.0648,
#       0.0648, 0.125 ])

弱分类器合并成强分类器

综上，将上面计算得到的a1、a2、a3各值代入G(x)中，G(x) = sign[f3(x)] = sign[ a1 * G1(x) + a2 * G2(x) + a3 * G3(x) ]，得到最终的分类器为：

G(x) = sign[f3(x)] = sign[ 0.4236G1(x) + 0.6496G2(x)+0.7514G3(x) ]

ada.predict(X)
#array([ 1,  1,  1, -1, -1, -1,  1,  1,  1, -1])

y_predict = a1*ada[0].predict(X) +  a2*ada[1].predict(X) +a3*ada[2].predict(X)
y_predict
np.sign(y_predict).astype(np.int)
#array([ 1,  1,  1, -1, -1, -1,  1,  1,  1, -1])