AdaBoost算法详解及示例分析

1 引言

目前集成学习主要分为两类，一是基学习器之间存在强依赖关系、其必须串行生成的序列化方法，二是基学习器之间没有非常强的依赖关系、可同时生成的并行化方法。前者代表的算法为Boosting，后者则为Bagging和“随机森林”(Random Forest)，本文着重讲解有关Boosting算法的具体内容及算例分析。

2 Boosting

Boosting是指将一系列弱学习器经过某种组合的方法提升为强学习器的算法，其基本思路如下：先在原始数据上训练出一个弱学习器（也称基学习器），再根据生成的基学习器改变原始数据的分布，使得后续的训练可以进一步关注到该基学习器出错的样本集。继续在经过上述改变的数据上训练下一个基学习器，如此重复进行数据的改变和基学习器的训练，直到所训练好的基学习器组合后的学习器可以达到分类要求。而其中最具代表性的便是AdaBoost算法[1]，下面将着重介绍该算法的具体原理以及实际运用。

图1：Boosting具体流程示意图

3 AdaBoost算法

3.1 加性模型

AdaBoost算法所使用的基于加性模型(additive model)的强学习器生成方法，所谓加性模型即是各基学习器的线性组合

$$f(x) = \sum_{m=1}^{M}\beta_{m}b_{m}(x;\gamma_{m})\tag{1}$$
其中，$x$为输入数据，$\{\beta_{m},\gamma_{m}\}$为模型参数，$b_{m}(x;\gamma_{m})$为关于$x$的二分类器$G_{m}(x;\gamma_{m}):R^{K}\to\{-1,1\}$。而其中的$\{\beta_{m},\gamma_{m}\}$参数是由所定义的损失函数所确定，其计算表达式如下：

在给定训练数据以及所定义的损失函数后，求解强分类器的问题便变成了优化(2)式右边使得总体的损失误差达到最小。考虑到我们所使用的模型为加性模型，那么从前至后，我们每一步只需要学习一个基函数以及其相应的系数。那么在模型参数的确定过程中便可以使用前向分布算法(forward stagewise algorithm)思想，每一步只需优化使得单步的损失函数达到最小即可。
$$\min_{\beta,\gamma}\sum_{i=1}^{N}L(y_{i},\beta_{m} b_{m}(x_{i};\gamma))\tag{3}$$

3.2 损失函数

在这里我们使用指数损失函数(exponential loss function)[2]来进行上述的优化操作，其定义如下

$$L(y,f(x))=e^{-yf(x)}\tag{4}$$
所求得的强分类器$f(x)$需使得指数损失函数达到最小，考虑到式(4)对$f(x)$对偏导
$$\frac {\partial L(y(x),f(x))}{\partial f(x)}=-e^{f(x)}P(y(x)=1|x)+e^{f(x)}P(y(x)=-1|x)\tag{5}$$
令(5)式为0可得
$$f(x)=\frac{1}{2}\ln\frac{P(y(x)=1|x)}{P(y(x)=-1|x)}\tag{6}$$
故有
$$\begin{eqnarray*} sign(f(x))&=&sign(\frac{1}{2}\ln\frac{P(y(x)=1|x)}{P(y(x)=-1|x)})\\&=&\begin{cases}1,P(y(x)=1|x)>P(y(x)=-1|x)\\-1,P(y(x)=1|x)<P(y(x)=-1|x)\end{cases}\tag{7} \end{eqnarray*}$$
从上式便可以看出，若指数损失函数达到最小则分类错误率也将到达最小值。因此，由于指数损失函数具有更好的数学性质（例如是连续可微函数），我们将使用该损失函数代替0/1损失函数作为优化对象。

3.3 分类器参数更新

根据分类器的加性特征我们有

$$f_{m}(x)=f_{m-1}(x)+\beta_{m}G(x;\gamma_{m})\tag{8}$$
其中，$\beta_{m}$为第$m$个基分类器的加性系数，$\gamma_{m}$为第$m$个基分类器的二分类阈值。
我们将指数损失函数代入式(3)并结合(8)式可得
$$<\beta_{m},G_{m}>=\arg\min_{\beta_{m},G}\sum_{i}^{N}e^{-y(x_{i})(f_{m-1}(x)+\beta_{m}G(x_{i};\gamma_{m}))}\tag{9}$$
上式即我们最终需要优化的表达式，可以发现对于数据在每一步的分类器上训练的分布不一样的，其都需要乘上相应的系数，即训练数据各自的权重。
我们定义第$m$个训练器的训练数据各自权重如下
$$w_{i}^{m}=e^{-y(x_{i})f_{m-1}(x_{i})}\tag{10}$$
找出第$m+1$个基训练器和第$m$个基训练器训练数据权重的关系便可以对训练数据对于每一个基训练器的分布进行确定，其推导如下：
$$\begin{eqnarray*} w_{i}^{m+1} &=& e^{-y(x_{i})f_{m}(x_{i})} \\ &=& e^{-y(x_{i})(f_{m-1}(x_{i})+\beta_{m}G_{m}(x_{i}))} \\ &=& w_{i}^{m}e^{-\beta_{m}y(x_{i})G_{m}(x_{i})}\tag{11} \end{eqnarray*}$$
这里，为了满足权重的分布特点，我们引进一个规范化因子$Z_{m}$
$$Z_{m}=\sum_{i=1}^{N}w_{i}^{m}e^{-\beta_{m}y(x_{i})G_{m}(x_{i})}\tag{12}$$
因此，得到最终的训练数据分布权重更新公式
$$w_{i}^{m+1}=\frac{w_{i}^{m}}{Z_{m}}e^{-\beta_{m}y(x_{i})G_{m}(x_{i})}\tag{13}$$
接下来我们再考虑对基分类器加性系数的求解，将训练数据可分解为两个子集为$\{y(x_{i})=G(x_{i})\}$和$\{y(x_{i})\ne G(x_{i})\}$,则对指数损失函数进行整理有
$$L(y,f(x))= e^{(-\beta_{m})}\sum_{i=1}^{N}w_{i}^{m}I(y(x_{i})=G(x_{i}))+e^{\beta_{m}}\sum_{i=1}^{N}w_{i=1}^{m}I(y(x_{i})\ne G(x_{i}))\tag{14}$$
$L(y,f(x))$对$\beta_{m}$进行求解偏导，并使其为0，可解得
$$\beta_{m}=\frac {1}{2}\ln(\frac {1-err_{m}}{err_{m}})\tag{15}$$
$$err_{m}=\frac {\sum_{i=1}^{N}w_{i}^{m}I(y(x_{i})\ne G(x_{i}))}{\sum_{i}^{N}w_{i}^{m}}\tag{16}$$
式(15)即为各基分类器的加性系数的求解等式，而基分类器的确定是由式(16)达到最小所确定，
$$\hat{G}_{m}=\arg \min_{G}\sum_{i=1}^{N}w_{i}^{m}I(y(x_{i})\ne G(x_{i}))\tag{17}$$
那么，最终AdaBoost算法所确定的基于诸多弱分类器加性为的强分类器为
$$f(x)=sign(\sum_{m=1}^{M}\beta_{m}G_{m}(x))\tag{18}$$
这便是AdaBoost算法的整体推导过程以及流程。

4 AdaBoost算例[3]

表1：训练数据表
$$\begin{array}{lcr} \hline \text{序号} & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 & 10\\ \hline x & 0 & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9\\ y & 1 & 1 & 1 & -1 & -1 & -1 & 1 & 1 & 1 & -1\\ \hline \end{array}$$

给定表1训练数据，假设基分类器是由$x<\gamma_{m}$或者$x>\gamma_{m}$生成，而其基分类器的阈值大小是由该分类器在训练数据集上误差率达到最小。
(1)首先，初始化训练数据集权重分布
$$D_{1}=(w_{11},w_{12},...,w_{10}),w_{1i}=0.1,i=1,2,...,10\tag{19}$$
(2)在权重分布为$D_{1}$的训练数据上，借助公式(16)使得其$err_{m}$达到最小可以确定此时的$\gamma_{1}$为2.5，故第一个基分类器为
$$G_{1}(x)=\begin{cases} 1,\quad x<2.5\\ -1,\ \ x>2.5 \end{cases}\tag{20}$$
$G_{1}(x)$在训练数据集上的误差率$err_{1}=0.3$(式16),计算$G_{1}(x)$的系数$\beta_{1}=0.4236$(式15)，那么即有
$$f_{1}(x)=0.4236G_{1}(x)\tag{21}$$ 更新训练数据集的权重分布有(式13)，
$$D_{2}=(0.07143,0.07143,0.07143,0.07143,0.07143,0.007143,0.16667,0.16667,0.16667,0.07143)\tag{22}$$
而分类器$sign[f_{1}(x)]$在训练数据集上有3个误分类点。
(3)对于$m=2$,在权重分布为$D_{2}$的训练数据上，阈值$\gamma_{2}$为8.5时分类误差率最低，第二个基分类器为
$$G_{2}(x)=\begin{cases} 1,\quad x<8.5\\ -1,\ \ x>8.5 \end{cases}\tag{23}$$
$G_{2}(x)$在训练数据集上的误差率$err_{2}=0.2143$，计算$G_{2}(x)$的系数$\beta_{2}=0.6496$，那么即有 $$f_{2}(x)=0.4236G_{1}(x)+0.6496G_{2}(x)\tag{24}$$ 更新训练数据集的权重分布有，
$$D_{3}=(0.0455,0.0455,0.0455,0.1667,0.1667,0.1667,0.1060,0.1060,0.1060,0.0455)\tag{25}$$
而分类器$sign[f_{2}(x)]$在训练数据集上有3个误分类点。
(4)对于$m=3$在权重分布为D_{3}的训练数据集上，阈值$\gamma_{3}$为5.5时分类误差率最低，第三个基分类器为
$$G_{3}(x)=\begin{cases} 1,\quad x>5.5\\ -1,\ \ x<5.5 \end{cases}\tag{26}$$
$G_{3}(x)$在训练数据集上的误差率$err_{3}=0.1820$，计算$G_{3}$的系数$\beta_{3}=0.7514$，那么有
$$f_{3}(x)=0.4236G_{1}(x)+0.6496G_{2}(x)+0.7514G_{3}(x)\tag{27}$$
更新训练数据集的权重分布有
$$D_{4}=(0.125,0.125,0.125,0.102,0.102,0.102,0.065,0.065,0.065,0.125)\tag{28}$$
而分类器$sign[f_{3}(x)]$在训练数据集上的误分类点个数为0，那么最终得到的强分类器为
$$G(x)=sign[f_{3}(x)]=sign[0.4236G_{1}(x)+0.6496G_{2}(x)+0.7514G_{3}(x)]\tag{29}$$
那么经过三个基分类器的加性组合得到一个强分类器，最终的分类结果从有三个分类误差点优化到分类器在训练数据集上误分类点个数为0.

5 AdaBoost算法

下面给出AdaBoost算法的具体流程
输入：训练数据集$T=\{(x_{1},y_{1}),(x_{2},y_{2}),...,(x_{N},y_{N})\}$,其中$x_{i}\in\chi\subseteq R^{n}$,$y_{i}\in\Upsilon=\{-1,+1\}$;
输出：最终的强分类器 $f(x)$
步骤1：初始化训练数据集的权重分布

$$D_{1}=\{w_{11},...,w_{1i},...,w_{1N}\},w_{1i}=\frac {1}{N},i=1,2,...,N\tag{30}$$
步骤2：对于$m=1,2,...,M$

• 使用具有$D_{m}$分布的训练数据集进行分类器学习，得到相应的基分类器 $$G_{m}(x):\chi\to\{-1,+1\}\tag{31}$$
• 根据得到的基分类器计算相应的误差率(式16)和加性系数(式15)
• 更新到$D_{m+1}$的权重分布(式12和式13)

步骤3：基分类器进行线性组合(式1)以及得到最终的强分类器(式18)
以上便是AdaBoost算法的具体流程，下面给出其算法框架[4]

输入：训练集$T=\{(x_{1},y_{1}),(x_{2},y_{2}),...,(x_{N},y_{N})\};$
$\quad\quad$基训练器$G_{m}(x)$
$\quad\quad$训练次数M
过程：
1：$D_{1}=\frac {1}{N}$
2：for m=1,2,…,M do
3：$\hat{G}_{m}=\arg \min\sum_{i=1}^{N}w_{i}^{m}I(y(x_{i})\ne G(x_{i}))$
4：$err_{m}=\frac {\sum_{i=1}^{N}w_{i=1}^{m}I(y(x_{i})\ne G(x_{i}))}{\sum_{i}^{N}w_{i}^{m}}$
5：if $err_{m}>0.5$ then break;
6：$\beta_{m}=\frac {1}{2}\ln(\frac {1-err_{m}}{err_{m}})$
7：$Z_{m}=\sum_{i=1}^{N}w_{i}^{m}e^{-\beta_{m}y(x_{i})G_{m}{(x_{i})}}$
8：$w_{i}^{m+1}=\frac {w_{i}^{m}}{Z_{m}}e^{-\beta_{m}y(x_{i})G_{m}(x_{i})}$
9：end for
输出：$f(x)=sign[\sum_{m=1}^{M}\beta_{m}G_{m}(x)]$

6 算例代码

下面给出第5部分AdaBoost算例的matlab相应代码，值得注意的是虽然上述算例中经过计算得到基学习器的个数达到3个的时候误分类的个数为0，但是实际情况下并不确定基学习器个数是多少。因此，往往在实际应用当中是需要额外引入限制因素来保证代码的执行效率以及结果的利好性。

clc
clear all
%%
%--------------------------------------------------------------------------
%初始化
%--------------------------------------------------------------------------
%训练数据
data = [0:1:9;1,1,1,-1,-1,-1,1,1,1,-1];
%初始化权值
D(1,:) = 0.1 * ones(1,10);
%基学习器
f = @(t,x) (x < t) - (x > t);
%基学习器阈值集合
T = (min(data(1,:)) + 0.5):1:(max(data(1,:)) + 0.5);
%训练次数
N = 3;
%错误率
err_i = ones(N,length(T));
%基学习器阈值
t = zeros(1,N);
%基学习器权重
a = zeros(1,N);
%基学习器判决结果
result_b = zeros(N,length(data));
i = 1;
%组合后的学习器误分类的个数
err_classification = -1 * ones(1,N);
%%
%基学习器权重生成以及数据权重更新
while(err_classification(i) ~= 0)
    f1 = @(t,w) w * [f(t,data(1,:)) ~= data(2,:);f(t,data(1,:)) == data(2,:)]';
    err_i_cell_all(i,:) = arrayfun(@(x)f1(x,D(i,:)),T,'UniformOutput',0);
    err_i_num_all(i,:) = cell2mat(err_i_cell_all(i,:));
    [min_err(i),indx(i)] = min(err_i_num_all(i,:));
    if min_err(i) > 0.5                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       
        break;
    end
    if rem(indx(i),2) == 0
        Type_base(i) = 2;
    else
        Type_base(i) = 1;
    end
    indx(i) = ceil(indx(i) / 2);
    t(i) = T(indx(i));
    a(i) = 1 / 2 * log((1 - min_err(i)) / min_err(i));
    result_b(i,:) = f(t(i),data(1,:));
    z = D(i,:) * (exp(-a(i) .* data(2,:) .* result_b(i,:)))';
    D(i+1,:) = D(i,:) .* (exp(-a(i) .* data(2,:) .* result_b(i,:))) / z;
    additive_learner = 0;
    for j = 1:1:i
        additive_learner = additive_learner + a(j) * f(t(j),data(1,:)) * (-1).^(Type_base(j) - 1);
    end
    result_additive_learner = sign(additive_learner);
    err_classification(i) = length(find((result_additive_learner - data(2,:)) ~= 0));
    i = i + 1;
end

[1] Yoav Freund, Robert E Schapire. A Decision-Theoretic Generalization of On-Line Learning and an Application to Boosting[M]// Computational Learning Theory. Springer Berlin Heidelberg, 1995:119-139.
[2] Friedman J, Hastie T, Tibshirani R. Special Invited Paper. Additive Logistic Regression: A Statistical View of Boosting[J]. Annals of Statistics, 2000, 28(2):337-374.
[3] 李航. 统计学习方法[M]. 北京:清华大学出版社, 2012. 140-142
[4] 周志华. 机器学习[M]. 北京:清华大学出版社, 2016. 174