Adaboost算法

集成学习有两大类：bagging和boosting。随机森林是bagging的一个例子，而Adaboost是boosting的典型算法。

什么是boosting

    bagging算法是由多个学习器组成的，但是学习器之间是$并行$的，意思就是学习器之间互补干扰，各自训练各自的，各自测试各自的数据，然后通过整合每个学习器返回的数据最终得到结果。
    整合的方式有很多种：

1. 投票法，少数服从多数，比如：10个学习器，8个的结果是1，2个的结果是0，那么最终结果为1；
2. 平均法，最终的结果求平均或者给每个学习器加个权重；
3. 学习法，把每个学习器输出数据再学习一下得到最终结果，代表方法有stacking。

    boosting也是有多个学习器组成，但是学习器之间是有$串联$的。
    举个例子，从一批数据中抽样70%，第一个学习器训练这70%，训练完之后测试这批数据，标记出错的样本，第二个学习器再重点训练这些第一个学习器出错的样本，训练完之后测试这批数据，再标记出错的样本，第三个学习器再重点训练第一个学习器和第二个学习器都出错的样本。最后利用集成学习整合这些数据，第一个学习器和第二个学习器输出一致时那就输出他们的结果，不一致时就输出第三个学习器的结果。这样误差率就大大下降了。
    那么就刚刚的例子中，我们能够看到算法实现的时候需要$标记样本$，并且最后需要$整合$每个学习器的输出。
    那接下来我们来看一下Adaboost是如何标记样本和整合输出的吧。

Adaboost算法

Adaboost具体实现如下图：

其中，${ϵ}_t$是第$t$个学习器的误差率，${\alpha }_t$是第$t$个学习器的更新权重系数$(整合输出)$，$D_t(i)$是第$t$个学习器对第$i$个样本的权重$(标记样本)$。
    Adaboost算法有很好地数学特性，就是说它的误差率的收敛，更新权重的系数都是可以通过数学推导出来的，那我们就来看一下是如何推导出来的吧，在推导之前先明确一下几个定义：

• $h_t(x_i)$是第$i$个样本在第$t$个学习器的输出；
• $f(x_i)={\sum }_{t=1}^T{\alpha }_t{h}_t(x_i)$，$T$个学习器之后的输出，如果不加权重${\alpha }_t$，二分类最终输出结果相当于投票，这明显不可合理的，之前说过boost算法的学习器是串行的有针对性的（某个学习器它对某些样本的分类会准确些），所以引入了权重${\alpha }_t$，但是我们看到这个权重只和当前学习器的误差率有关，它也没用针对某个样本变化啊，这个就是Adaboost的局限性，RegionBoost算法会在这方面对其进行处理；
• $H(x_i)=sign(f(x_i))$是最后的输出结果；
• ${ϵ}_t={\sum }_{h_t(x_i)̸=y_i}{D}_t(i)$，第$t(t不等于T)$个学习器的误差率是误判样本的权重和。

${ϵ}_t$,${\alpha }_t$的推导

    误差率当然越小越好，但是这个误差率和什么有关呢，我们不知道啊，但是仔细想想boost的原理，这个误差率会不会和$学习器输出结果的整合方式$与$选取的训练的样本$有关呢？在Adaboost中难道和参数${\alpha }_t$和$D_t(i)$有关？算了，想那么多干嘛，先看看误差率长什么样吧！
$$\begin{array}{rl}误差率ϵ& =\frac{H(x_i)不等于y_i的个数}{样本总个数m}\\ & =\frac{1}{m}\sum _{i=1}^m[[H(x_i)̸=y_i]]\end{array}$$
其中，$a$成立，$[[a]]=1$，$a$不成立，$[[a]]=0$。
这个误差率表达式好像不怎么好处理，能不能转化一下。
我们看一下下面的式子
$$\begin{gathered} [[H(x_i)̸=y_i]]=1\Rightarrow y_{i}f(x_i)<0\Rightarrow e^{-y_{i}f(x_i)}>1 \\ [[H(x_i)̸=y_i]]=0\Rightarrow y_{i}f(x_i)>0\Rightarrow e^{-y_{i}f(x_i)}>0 \end{gathered}$$
好像有点意思，那我们整理一下不就可以得到：$[[H(x_i)̸=y_i]]\le e^{-y_{i}f(x_i)}$。那么$ϵ\le \frac{1}{m}{\sum }_{i=1}^m{e}^{-y_{i}f(x_i)}$，虽然误差率整理的好像有点样子了，但是接下来也不知道怎么处理，我们暂时放一下。刚刚猜测误差率和$D_t(i)$有关来着，我们先看看$D_t(i)$的表达吧！
    $D_t$是样本的权重，我们一开始初始化$D_t(i)$为$\frac{1}{m}$，接下来通过不同学习器的学习训练，每个样本的权重都会变化，具体怎么变化呢？

• 当前学习器$t$对于样本$x_i$如果预测正确了，即$y_i{\alpha }_t{h}_t(x_i)>0$，那下一个学习器对这个样本的权重应该减小；
• 当前学习器$t$对于样本$x_i$如果预测错误了，即$y_i{\alpha }_t{h}_t(x_i)<0$，那下一个学习器对这个样本的权重应该增大。

综上，样本的权重为$D_t(i)e^{-y_{i}f(x_i)}$，但是考虑每个样本的权重和应该为1，需要将权重标准化，最终权重：$D_{t+1}(i)=D_t(i)\frac{e^{-y_i{\alpha }_t{h}_t(x_i)}}{Z_t}$，其中，$Z_t={\sum }_i{D}_t(i)e^{-y_i{\alpha }_t{h}_t(x_i)}$。
最后求解，
$$\begin{array}{rl}{D}_{T+1}(i)& =D_1(i)\prod _{t=1}^T\frac{e^{-y_i{\alpha }_t{h}_t(x_i)}}{Z_t}\\ & =\frac{1}{m}\frac{e^{-y_{i}f(x_i)}}{{\prod }_{t=1}^T{Z}_t}\end{array}$$
    不知不觉出现了$e^{-y_{i}f(x_i)}$，且$e^{-y_{i}f(x_i)}=m{D}_{T+1}(i){\prod }_{t=1}^T{Z}_t$，那么代入上面误差率的公式中，
$$\begin{array}{rl}ϵ& \le \sum _{i=1}^m{D}_{T+1}(i)\prod _{t=1}^T{Z}_t\\ & =\prod _{t=1}^T{Z}_t\end{array}$$
    误差率出现了上界，仔细观察这个上界，里面的$Z_t$好像和参数$D_t(i),{\alpha }_t$有关耶，是不是和我们一开始的猜想一样。我们的目标是最小化误差率，可最小化$\prod$有点困难，我们退而求其次，即求解$\min Z_t$。
    那么我们先处理一下$Z_t$，观察$y_i{h}_t(i)$这项的值不是1就是-1，那么就好办了。
$$\begin{array}{rl}{Z}_t& =\sum _i{D}_t(i)e^{-y_i{\alpha }_t{h}_t(x_i)}\\ & =\sum _{y_i̸=h_t(x_i)}{D}_t(i)e^{{\alpha }_t}+\sum _{y_i=h_t(x_i)}{D}_t(i)e^{-{\alpha }_t}\\ & =e^{{\alpha }_t}{ϵ}_t+e^{-{\alpha }_t}\left(1-{ϵ}_t\right)\end{array}$$
那么$Z_t$对${\alpha }_t$求导，领导数等于0，得${\alpha }_t=\frac{1}{2}\ln \frac{1-{ϵ}_t}{{ϵ}_t}$。
    我们这边看一下，权重更新之后对当前学习器的误差率有什么影响，那我们就要计算${ϵ}_t^{\ast }={\sum }_{h_t(x_i)̸=y_i}{D}_{t+1}(i)$，
$$\begin{array}{rl}{ϵ}_t^{\ast }& =\sum _{h_t(x_i)̸=y_i}{D}_{t+1}(i)\\ & =\frac{{\sum }_{h_t(x_i)̸=y_i}{D}_t(i)e^{-y_i{\alpha }_t{h}_t(x_i)}}{Z_t}\\ & =\frac{{\sum }_{h_t(x_i)̸=y_i}{D}_t(i)e^{{\alpha }_t}}{{\sum }_{h_t(x_i)̸=y_i}{D}_t(i)e^{{\alpha }_t}+{\sum }_{h_t(x_i)=y_i}{D}_t(i)e^{-{\alpha }_t}}\\ & =\frac{{ϵ}_t{e}^{{\alpha }_t}}{{ϵ}_t{e}^{{\alpha }_t}+(1-{ϵ}_t)e^{-{\alpha }_t}},{\alpha }_t=\frac{1}{2}\ln \frac{1-{ϵ}_t}{{ϵ}_t}\\ & =0.5\end{array}$$
    结果是0.5，对于误差率来说应该是最坏的结果了（大于0.5的只要输出翻转一下就小于0.5了），那意思就是当前学习器训练完，$权重会调整到使当前学习器效果最差的状态$，然后再给下一个学习器训练，这是Adaboost一个重要的思想！
    到这里，Adaboost算法里面公式的推导结束了，那接下来我们使用刚刚推导的结果看一下最终的误差率吧。

误差率上界

将${\alpha }_t=\frac{1}{2}\ln \frac{1-{ϵ}_t}{{ϵ}_t}$代入$Z_t$得
$$\begin{array}{rl}{Z}_t& =\sum _i{D}_t(i)e^{-\frac{1}{2}{y}_i{h}_t(x_i)\ln \frac{1-{ϵ}_t}{{ϵ}_t}}\\ & =\sum _i{D}_t(i)\left[\sqrt{\frac{1-{ϵ}_t}{{ϵ}_t}}\mathrm{Pr}(y_i̸=h_t(i))+\sqrt{\frac{{ϵ}_t}{1-{ϵ}_t}}\mathrm{Pr}(y_i=h_t(i))\right]\\ & =2\sum _i{D}_t(i)\sqrt{{ϵ}_t(1-{ϵ}_t)}\\ & =2\sqrt{{ϵ}_t(1-{ϵ}_t)}\end{array}$$
令${ϵ}_t=\frac{1-r_t}{2}$，在上面的算法中，我们可以看到${ϵ}_t>0.5$，所以这边的$r_t\in (0,1)$。
上式$2\sqrt{{ϵ}_t(1-{ϵ}_t)}=\sqrt{1-r_t^2},r_t\in (0,1)$
所以最终的误差率$ϵ\le {\prod }_t{Z}_t={\prod }_t\sqrt{1-r_t^2},r_t\in (0,1)$，可以看出误差率上界是$T$个小于1的数相乘，明显是趋于0的。

附简单的程序：

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

X1, y1 = make_gaussian_quantiles(cov=2., n_samples=200, n_features=2, n_classes=2, random_state=1)
X2, y2 = make_gaussian_quantiles((3, 3), cov=1.5, n_samples=300, n_features=2, n_classes=2, random_state=1)
X = np.concatenate((X1, X2))
y = np.concatenate((y1, -y2+1))

plt.scatter(X[:,0], X[:,1], marker='o', c=y)

bdt = AdaBoostClassifier(DecisionTreeClassifier(
    max_depth=2
    , min_samples_split=20
    , min_samples_leaf=5
)
                         , algorithm='SAMME'
                         , n_estimators=200
                         , learning_rate=1
                        )
bdt.fit(X, y)
bdt.score(X, y)

附初音程序

初音程序结果参考
初音图片下载地址miku.zip

import pandas as pd
import numpy as np
from PIL import Image
from sklearn.ensemble import AdaBoostClassifier
from sklearn.tree import DecisionTreeClassifier

miku = pd.read_csv(r'miku.csv')
miku = np.array(miku.values)
# print(miku.shape)
# miku_grayscale = miku[:, 2]
# miku_grayscale = miku_grayscale.reshape((500, 500))
# miku_grayscale = miku_grayscale.transpose()
# image = Image.fromarray(miku_grayscale*255)
# image.show()

miku_data = miku[:, 0:2]
miku_target = miku[:, 2]

# n_estimators参数为上文讲到的T，修改参数看效果。
clf = AdaBoostClassifier(DecisionTreeClassifier(max_depth=5), n_estimators=50) 
clf.fit(miku_data, miku_target)

predict = clf.predict(miku_data)
predict = predict.reshape((500, 500))
predict = predict.transpose()
image = Image.fromarray(predict*255)
image.show()

AdaBoost补充

https://blog.csdn.net/zhisuihen6347/article/details/100582880