AdaBoost算法超详细讲解

古城微笑少年丶 2023-09-28 21:53 22阅读 0赞

### 一、Boosting提升算法 ###

AdaBoost是典型的Boosting算法。

Boosting算法是将“弱学习算法“提升为“强学习算法”的过程，主要思想是“三个臭皮匠顶个诸葛亮”。

一般来说，找到弱学习算法要相对容易一些，然后通过反复学习得到一系列弱分类器，组合这些弱分类器得到一个强分类器。

Boosting算法要涉及到两个部分，加法模型和前向分步算法：

**1. 加法模型**

加法模型就是我们最终的强分类器是若干个弱分类器加权平均而得到的（弱分类器线性相加而成）。

**2. 前向分步算法**

前向分步就是我们在训练的过程中，下一轮迭代产生的分类器是在上一轮的基础上训练得来的。

我们的算法是通过一轮轮的弱学习器学习，利用前一个弱学习器的结果和当前弱学习器来更新当前的强学习器的模型。也就是说：

第 k − 1 k-1 k−1轮的强学习器为:  
 f k − 1 ( x ) = ∑ i = 1 k − 1 α i G i ( x ) f\_\{k−1\}(x)=∑\_\{i=1\}^\{k−1\}α\_iG\_i(x) fk−1(x)=i=1∑k−1αiGi(x)  
而第  k k k 轮的强学习器为：  
 f k ( x ) = ∑ i = 1 k α i G i ( x ) f\_k(x)=∑\_\{i=1\}^kα\_iG\_i(x) fk(x)=i=1∑kαiGi(x)  
上两式一比较可以得到：  
 f k ( x ) = f k − 1 ( x ) + α k G k ( x ) f\_k(x)=f\_\{k−1\}(x)+\\alpha\_kG\_k(x) fk(x)=fk−1(x)\+αkGk(x)  
可见强学习器的确是通过前向分步学习算法一步步而得到的。

### 二、AdaBoost算法 ###

Adaboost是一种迭代算法，其核心思想是针对同一个训练集训练不同的分类器(弱分类器)，然后把这些弱分类器集合起来，构成一个更强的最终分类器（强分类器）。

后一个模型的训练永远是在前一个模型的基础上完成！

这里的集合起来的策略是通过提高前一轮分类器分类错误的样本的权值，降低分类分类正确的样本权值，对于那些没有本分类正确的样本会得到后面分类器更多的关注。然后可以产生很多的弱分类器，通过多数加权投票组合这些弱分类器，加大误差率小的分类器，减少误差率大的分类器，使其在表决中起到较少的作用。

如下图所示：  
![09bffcc900d9475b8ba99d88514a4586.png][]  
**算法思想：**

（1）初始化训练样本的权值分布，每个样本具有相同权重；

（2）训练弱分类器，如果样本分类正确，则在构造下一个训练集中，它的权值就会被降低；反之提高。用更新过的样本集去训练下一个分类器；

（3）将所有弱分类组合成强分类器，各个弱分类器的训练过程结束后，加大分类误差率小的弱分类器的权重，降低分类误差率大的弱分类器的权重。

我们的步骤可以如下图表示：  
![1b7cf35f8bd84a9a88011e11e462b38e.png][]  
由Adaboost算法的描述过程可知，该算法在实现过程中根据训练集的大小初始化样本权值，使其满足均匀分布，在后续操作中通过公式来改变和规范化算法迭代后样本的权值。样本被错误分类导致权值增大，反之权值相应减小，这表示被错分的训练样本集包括一个更高的权重。这就会使在下轮时训练样本集更注重于难以识别的样本，针对被错分样本的进一步学习来得到下一个弱分类器，直到样本被正确分类。在达到规定的迭代次数或者预期的误差率时，则强分类器构建完成。

**boosting算法要解决的问题：**

1）如何计算学习误差率 e e e?

2）如何得到弱学习器权重系数 α α α?

3）如何更新样本权重 D D D?

4）使用何种结合策略？

### 三、Adaboost分类算法原理 ###

假设一个二分类训练样本集：  
 T = \{ ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . , ( x m , y m ) \} T=\\\{(x\_1,y\_1),(x\_2,y\_2),...,(x\_m,y\_m)\\\} T=\{(x1,y1),(x2,y2),...,(xm,ym)\}  
训练集的在第  k k k 个弱学习器的输出权重为：  
 D ( k ) = ( w k 1 , w k 2 , . . . , w k m ) ; w 1 i = 1 m ; i = 1 , 2 , . . . , m D(k)=(w\_\{k1\},w\_\{k2\},...,w\_\{km\});w\_\{1i\}=\\frac1m;i=1,2,...,m D(k)=(wk1,wk2,...,wkm);w1i=m1;i=1,2,...,m  
第  k k k 个弱分类器  G k ( x ) G\_k(x) Gk(x) 在训练集上的加权误差率为：  
 e k = P ( G k ( x i ) ≠ y i ) = ∑ i = 1 m w k i I ( G k ( x i ) ≠ y i ) e\_k=P(G\_k(x\_i)≠y\_i)=∑\_\{i=1\}^mw\_\{ki\}I(G\_k(x\_i)≠y\_i) ek=P(Gk(xi)=yi)=i=1∑mwkiI(Gk(xi)=yi)  
第  k k k 个弱分类器  G k ( x ) G\_k(x) Gk(x) 的权重系数为：  
 α k = 1 2 log ⁡ 1 − e k e k α\_k=\\frac\{1\}\{2\}\\log\\frac\{1−e\_k\}\{e\_k\} αk=21logek1−ek  
为什么这样计算弱学习器权重系数？

从上式可以看出，如果分类误差率  e k e\_k ek 越大，则对应的弱分类器权重系数  α k α\_k αk 越小。也就是说，误差率小的弱分类器权重系数越大。具体为什么采用这个权重系数公式，我们在讲Adaboost的损失函数优化时再讲。

更新样本权重  D D D 。假设第  k k k 个弱分类器的样本集权重系数为  D ( k ) = ( w k 1 , w k 2 , . . . w k m ) D(k)=(w\_\{k1\},w\_\{k2\},...w\_\{km\}) D(k)=(wk1,wk2,...wkm)，则对应的第  k + 1 k+1 k\+1 个弱分类器的样本集权重系数为：  
 w k + 1 , i = w k i Z K e x p ( − α k y i G k ( x i ) ) w\_\{k+1,i\}=\\frac\{w\_\{ki\}\}\{Z\_K\}exp(−α\_ky\_iG\_k(x\_i)) wk\+1,i=ZKwkiexp(−αkyiGk(xi))  
这里  Z k Z\_k Zk 是规范化因子：  
 Z k = ∑ i = 1 m w k i e x p ( − α k y i G k ( x i ) ) Z\_k=∑\_\{i=1\}^mw\_\{ki\}exp(−α\_ky\_iG\_k(x\_i)) Zk=i=1∑mwkiexp(−αkyiGk(xi))  
从  w k + 1 , i w\_\{k+1,i\} wk\+1,i 计算公式可以看出，如果第  i i i 个样本分类错误，则  y i G k ( x i ) < 0 y\_iG\_k(x\_i)<0 yiGk(xi)<0 ，导致样本的权重在第  k + 1 k+1 k\+1 个弱分类器中增大，如果分类正确，则权重在第  k + 1 k+1 k\+1 个弱分类器中减少。具体为什么采用样本权重更新公式，我们在讲Adaboost的损失函数优化时再讲。

最后是集合策略。Adaboost分类采用的是加权表决法，构建基本分类器的线性组合：  
 f ( x ) = ∑ k = 1 K α k G k ( x ) f(x)=∑\_\{k=1\}^Kα\_kG\_k(x) f(x)=k=1∑KαkGk(x)  
最终的强分类器为：  
 G ( x ) = s i g n ( f ( x ) ) = s i g n ( ∑ k = 1 K α k G k ( x ) ) G(x)=sign(f(x))=sign(∑\_\{k=1\}^Kα\_kG\_k(x)) G(x)=sign(f(x))=sign(k=1∑KαkGk(x))

### 四、AdaBoost分类问题的损失函数优化 ###

分类问题的Adaboost的弱学习器权重系数公式和样本权重更新公式，可以从Adaboost的损失函数推导出来。

Adaboost是模型为加法模型，学习算法为前向分步学习算法，损失函数为指数函数的分类问题。

首先AdaBoost算法的最终模型表达式为：  
 f ( x ) = ∑ m = 1 M α k G k ( x ) f(x)=∑\_\{m=1\}^Mα\_kG\_k(x) f(x)=m=1∑MαkGk(x)  
可以看到这是一个“加性模型(additive model)”。我们希望这个模型在训练集上的经验误差最小，即：  
 min ⁡ ∑ i = 1 N L ( y i , f ( x ) ) < = > min ⁡ ∑ i = 1 N L ( y i , ∑ i = 1 M α m G m ( x ) ) \\min∑\_\{i=1\}^NL(y\_i,f(x))<=>\\min∑\_\{i=1\}^NL(y\_i,∑\_\{i=1\}^Mα\_mG\_m(x)) mini=1∑NL(yi,f(x))<=>mini=1∑NL(yi,i=1∑MαmGm(x))  
通常这是一个复杂的优化问题。前向分步算法求解这一优化问题的思想就是: 因为最终模型是一个加性模型，如果能从前往后，每一步只学习一个基学习器  G m ( x ) G\_m(x) Gm(x) 及其权重  α m α\_m αm , 不断迭代得到最终的模型，那么就可以简化问题复杂度。具体的，当我们经过  m − 1 m−1 m−1 轮迭代得到了最优模型  f m − 1 ( x ) f\_\{m−1\}(x) fm−1(x) 时，由前向分步算法可知：  
 f m ( x ) = f m − 1 ( x ) + α m G m ( x ) f\_m(x)=f\_\{m−1\}(x)+α\_mG\_m(x) fm(x)=fm−1(x)\+αmGm(x)  
所以此轮优化目标就为：  
 min ⁡ ∑ i = 1 N L ( y i , f m − 1 ( x ) + α m G m ( x ) ) \\min∑\_\{i=1\}^NL(y\_i,f\_\{m−1\}(x)+α\_mG\_m(x)) mini=1∑NL(yi,fm−1(x)\+αmGm(x))  
求解上式即可得到第  m m m 个基分类器  G m ( x ) G\_m(x) Gm(x) 及其权重  α m α\_m αm。

这样，前向分步算法就通过不断迭代求得了从 m = 1 m=1 m=1到 m = M m=M m=M的所有基分类器及其权重，问题得到了解决。

上面主要介绍了前向分步算法逐一学习基学习器，这一过程也即AdaBoost算法逐一学习基学习器的过程。下面将证明前向分步算法的损失函数是指数损失函数(exponential loss function)时，AdaBoost学习的具体步骤。

首先指数损失函数即 L ( y , f ( x ) ) = e x p ( − y f ( x ) ) L(y,f(x))=exp(−yf(x)) L(y,f(x))=exp(−yf(x))，指数损失函数是分类任务原本0/1损失函数的一致(consistent)替代损失函数，由于指数损失函数有更好的数学性质，例如处处可微，所以我们用它替代0/1损失作为优化目标。

AdaBoost是采用指数损失，由此可以得到损失函数：  
 L o s s = ∑ i = 1 N e x p ( − y i f m ( x i ) ) = ∑ i = 1 N ( − y i ( f m − 1 ( x i ) + α m G m ( x ) ) ) Loss=∑\_\{i=1\}^Nexp(−y\_if\_m(x\_i))=∑\_\{i=1\}^N(−y\_i(f\_\{m−1\}(x\_i)+α\_mG\_m(x))) Loss=i=1∑Nexp(−yifm(xi))=i=1∑N(−yi(fm−1(xi)\+αmGm(x)))  
因为 y i f m − 1 ( x ) y\_if\_\{m−1\}(x) yifm−1(x)与优化变量  α α α 和  G G G 无关，所以令 w m , i = e x p ( − y i f m ( x ) ) w\_\{m,i\}=exp(−y\_if\_m(x)) wm,i=exp(−yifm(x))，这里  y i f m − 1 ( x ) y\_if\_\{m−1\}(x) yifm−1(x) 是已知的，相当于可以作为常量移到前面去：  
 L o s s = ∑ i = 1 N w m , i e x p ( − y i α m G m ( x ) ) ) Loss=∑\_\{i=1\}^Nw\_\{m,i\}exp(−y\_iα\_mG\_m(x))) Loss=i=1∑Nwm,iexp(−yiαmGm(x)))  
接下来就是求解上式的优化问题的最优解 α m ^ \\hat\{\\alpha\_m\} αm^和 G m ( x ) ^ \\hat\{G\_m(x)\} Gm(x)^。

首先我们求 G m ( x ) ^ \\hat\{G\_m(x)\} Gm(x)^，可以得到：  
 G m ( x ) = arg ⁡ min ⁡ G ∑ i = 1 m w m i I ( y i ≠ G m ( x i ) ) G\_m(x)=\\arg\\min\_\{G\}∑\_\{i=1\}^mw\_\{mi\}I(y\_i≠G\_m(x\_i)) Gm(x)=argGmini=1∑mwmiI(yi=Gm(xi))  
上式将指数函数换成指示函数是因为前面说的指数损失函数和0/1损失函数是一致等价的。

式子中所示的优化问题其实就是AdaBoost算法的基学习器的学习过程，即计算数据集的分类误差率，得到的 G m ( x ) ^ \\hat\{G\_m(x)\} Gm(x)^是使第  m m m 轮加权训练数据分类误差最小的基分类器。

然后求 α m ^ \\hat\{α\_m\} αm^，将  G m ( x ) G\_m(x) Gm(x)带入损失函数，并对  α α α 求导，使其等于0，即可得到：  
 α m = 1 2 log ⁡ 1 − e m e m α\_m=\\frac\{1\}\{2\}\\log \\frac\{1−e\_m\}\{e\_m\} αm=21logem1−em  
其中， e m e\_m em 即为我们前面的分类误差率：  
 e m = ∑ i = 1 m w m i I ( y i ≠ G ( x i ) ) ∑ i = 1 m w m i = ∑ i = 1 m w m i I ( y i ≠ G ( x i ) ) e\_m=\\frac\{∑\_\{i=1\}^mw\_\{mi\}I(y\_i≠G(x\_i))\}\{∑\_\{i=1\}^mw\_\{mi\}\}=∑\_\{i=1\}^mw\_\{mi\}I(y\_i≠G(x\_i)) em=∑i=1mwmi∑i=1mwmiI(yi=G(xi))=i=1∑mwmiI(yi=G(xi))  
最后看样本权重的更新：利用 f m ( x ) = f m − 1 ( x ) + α m G m ( x ) f\_m(x)=f\_\{m−1\}(x)+α\_mG\_m(x) fm(x)=fm−1(x)\+αmGm(x) 和  w m i = e x p ( − y i f m − 1 ( x ) ) w\_\{mi\}=exp(−y\_if\_\{m−1\}(x)) wmi=exp(−yifm−1(x))，即可得：  
 w m + 1 , i = w m i e x p \[ − y i α m G m ( x ) \] w\_\{m+1,i\}=w\_\{mi\}exp\[−y\_iα\_mG\_m(x)\] wm\+1,i=wmiexp\[−yiαmGm(x)\]  
到此AdaBoost二分类算法推导结束。

### 五、AdaBoost二元分类问题算法流程总结 ###

输入：训练数据集 T = \{ ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . , ( x m , y m ) \} T=\\\{(x\_1,y\_1),(x\_2,y\_2),...,(x\_m,y\_m)\\\} T=\{(x1,y1),(x2,y2),...,(xm,ym)\}，输出为\{-1, +1\}，弱分类器算法, 弱分类器迭代次数  K K K；

输出：为最终的强分类器  f ( x ) f(x) f(x)。

1.  初始化样本集权重为：  
     D ( 1 ) = ( w 11 , w 12 , . . . w 1 m ) ; w 1 i = 1 m ; i = 1 , 2... m D(1)=(w\_\{11\},w\_\{12\},...w\_\{1m\});w\_\{1i\}=\\frac\{1\}\{m\};i=1,2...m D(1)=(w11,w12,...w1m);w1i=m1;i=1,2...m
2.  对于  k = 1 , 2 , . . . K k=1,2,...K k=1,2,...K：

a) 使用具有权重 D k D\_k Dk的样本集来训练数据，得到弱分类器 G k ( x ) : χ → \{ − 1 , + 1 \} G\_k(x): \\chi→\\\{−1,+1\\\} Gk(x):χ→\{ −1,\+1\}

b) 计算 G k ( x ) G\_k(x) Gk(x)的分类误差率：  
 e k = P ( G k ( x i ) ≠ y i ) = ∑ i = 1 m w k i I ( G k ( x i ) ≠ y i ) e\_k=P(G\_k(x\_i)≠y\_i)=∑\_\{i=1\}^mw\_\{ki\}I(G\_k(x\_i)≠y\_i) ek=P(Gk(xi)=yi)=i=1∑mwkiI(Gk(xi)=yi)  
c) 计算弱分类器的系数：  
 α k = 1 2 log ⁡ 1 − e k e k α\_k=\\frac\{1\}\{2\}\\log \\frac\{1−e\_k\}\{e\_k\} αk=21logek1−ek  
d) 更新样本集的权重分布：  
 w k + 1 , i = w k i Z K e x p ( − α k y i G k ( x i ) )        , i = 1 , 2 , . . . m w\_\{k+1,i\}=w\_\{ki\}Z\_Kexp(−α\_ky\_iG\_k(x\_i))\\;\\;\\;,i=1,2,...m wk\+1,i=wkiZKexp(−αkyiGk(xi)),i=1,2,...m  
这里 Z k Z\_k Zk是规范化因子：  
 Z k = ∑ i = 1 m w k i e x p ( − α k y i G k ( x i ) ) Z\_k=∑\_\{i=1\}^mw\_\{ki\}exp(−α\_ky\_iG\_k(x\_i)) Zk=i=1∑mwkiexp(−αkyiGk(xi))

1.  构建最终分类器为：  
     f ( x ) = s i g n ( ∑ k = 1 K α k G k ( x ) ) f(x)=sign(∑\_\{k=1\}^Kα\_kG\_k(x)) f(x)=sign(k=1∑KαkGk(x))

对于Adaboost多元分类算法，其实原理和二元分类类似，最主要区别在弱分类器的系数上。比如Adaboost SAMME算法，它的弱分类器的系数：  
 α k = 1 2 log ⁡ 1 − e k e k + log ⁡ ( R − 1 ) α\_k=\\frac\{1\}\{2\}\\log \\frac\{1−e\_k\}\{e\_k\}+\\log(R−1) αk=21logek1−ek\+log(R−1)  
其中R为类别数。

从上式可以看出，如果是二元分类，R=2，则上式和我们的二元分类算法中的弱分类器的系数一致。

### 六、Adaboost回归算法原理 ###

由于Adaboost的回归问题有很多变种，这里我们以Adaboost R2算法为准。

假设一个回归训练集样本是：  
 T = \{ ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . ( x m , y m ) \} T=\\\{(x\_1,y\_1),(x\_2,y\_2),...(x\_m,y\_m)\\\} T=\{(x1,y1),(x2,y2),...(xm,ym)\}  
训练集的在第  k k k 个弱学习器的输出权重为：  
 D ( k ) = ( w k 1 , w k 2 , . . . w k m )      ; w 1 i = 1 m      ; i = 1 , 2... m D(k)=(w\_\{k1\},w\_\{k2\},...w\_\{km\})\\;\\;;w\_\{1i\}=1m\\;\\;;i=1,2...m D(k)=(wk1,wk2,...wkm);w1i=1m;i=1,2...m  
**回归问题的误差率**

对于第  k k k 个弱学习器，计算它在训练集上的最大误差：  
 E k = max ⁡ ∣ y i − G k ( x i ) ∣    ;    i = 1 , 2... m E\_k=\\max|y\_i−G\_k(x\_i)|\\;;\\;i=1,2...m Ek=max∣yi−Gk(xi)∣;i=1,2...m  
然后计算每个样本的相对误差：  
 e k i = ∣ y i − G k ( x i ) ∣ E k e\_\{ki\}=|y\_i−G\_k(x\_i)|E\_k eki=∣yi−Gk(xi)∣Ek  
这里是误差损失为线性时的情况，如果我们用平方误差，则:  
 e k i = ( y i − G k ( x i ) ) 2 E k 2 e\_\{ki\}=\\frac\{(y\_i−G\_k(x\_i))^2\}\{E\_k^2\} eki=Ek2(yi−Gk(xi))2  
如果我们用的是指数误差，则:  
 e k i = 1 − e x p （ − y i + G k ( x i ) ) E k ） e\_\{ki\}=1−exp（\\frac\{−y\_i+G\_k(x\_i))\}\{E\_k\}） eki=1−exp（Ek−yi\+Gk(xi))）  
最终得到第  k k k 个弱学习器的误差率：  
 e k = ∑ i = 1 m w k i e k i e\_k=∑\_\{i=1\}^mw\_\{ki\}e\_\{ki\} ek=i=1∑mwkieki  
**弱学习器权重系数 α α α**

接下来计算弱学习器权重系数 α α α：  
 α k = e k 1 − e k α\_k=\\frac\{e\_k\}\{1−e\_k\} αk=1−ekek  
计算更新样本权重  D D D，第  k + 1 k+1 k\+1 个弱学习器的样本集权重系数为：  
 w k + 1 , i = w k i Z k α k 1 − e k i w\_\{k+1,i\}=\\frac\{w\_\{ki\}\}\{Z\_k\}α\_k^\{1−e\_\{ki\}\} wk\+1,i=Zkwkiαk1−eki  
这里  Z k Z\_k Zk 是规范化因子：  
 Z k = ∑ i = 1 m w k i α k 1 − e k i Z\_k=∑\_\{i=1\}^mw\_\{ki\}α\_k^\{1−e\_\{ki\}\} Zk=i=1∑mwkiαk1−eki  
最后是结合策略，和分类问题稍有不同，采用的是对加权的弱学习器取权重中位数对应的弱学习器作为强学习器的方法，最终的强回归器为：  
 f ( x ) = G k ∗ ( x ) f(x)=G\_k^∗(x) f(x)=Gk∗(x)  
其中， G k ∗ ( x ) G\_k^∗(x) Gk∗(x) 是所有  l n 1 α k    ,    k = 1 , 2 , . . . . K ln\\frac\{1\}\{α\_k\}\\;,\\;k=1,2,....K lnαk1,k=1,2,....K 的中位数值对应序号 k ∗ k^\* k∗对应的弱学习器。

### 七、Adaboost回归问题算法流程总结 ###

这里再对AdaBoost回归问题算法流程做一个总结，AdaBoost回归算法变种很多，下面的算法为Adaboost R2回归算法过程。

输入为样本集： T = \{ ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . , ( x m , y m ) \} T=\\\{(x\_1,y\_1),(x\_2,y\_2),...,(x\_m,y\_m)\\\} T=\{(x1,y1),(x2,y2),...,(xm,ym)\}，弱学习器算法, 弱学习器迭代次数  K K K；

输出为最终的强学习器： f ( x ) f(x) f(x)。

1.  初始化样本集权重为:  
     D ( 1 ) = ( w 11 , w 12 , . . . , w 1 m )    ,    w 1 i = 1 m    ,    i = 1 , 2... m D(1)=(w\_\{11\},w\_\{12\},...,w\_\{1m\})\\;,\\;w\_\{1i\}=1m\\;,\\;i=1,2...m D(1)=(w11,w12,...,w1m),w1i=1m,i=1,2...m
2.  对于  k = 1 , 2 , . . . , K k=1,2,...,K k=1,2,...,K：

a) 使用具有权重  D k D\_k Dk 的样本集来训练数据，得到弱学习器： G k ( x ) G\_k(x) Gk(x)

b) 计算训练集上的最大误差：  
 E k = max ⁡ ∣ y i − G k ( x i ) ∣    ,    i = 1 , 2... m E\_k=\\max|y\_i−G\_k(x\_i)|\\;,\\;i=1,2...m Ek=max∣yi−Gk(xi)∣,i=1,2...m  
c) 计算每个样本的相对误差：

如果是线性误差，则:  
 e k i = ∣ y i − G k ( x i ) ∣ E k e\_\{ki\}=\\frac\{|y\_i−G\_k(x\_i)|\}\{E\_k\} eki=Ek∣yi−Gk(xi)∣  
如果是平方误差，则:  
 e k i = ( y i − G k ( x i ) ) 2 E k 2 e\_\{ki\}=\\frac\{(y\_i−G\_k(x\_i))^2\}\{E\_k^2\} eki=Ek2(yi−Gk(xi))2  
如果是指数误差，则:  
 e k i = 1 − e x p ( − ∣ y i − G k ( x i ) ∣ E k ) e\_\{ki\}=1−exp(\\frac\{−|y\_i−G\_k(x\_i)|\}\{E\_k\}) eki=1−exp(Ek−∣yi−Gk(xi)∣)  
d) 计算回归误差率：  
 e k = ∑ i = 1 m w k i e k i e\_k=∑\_\{i=1\}^mw\_\{ki\}e\_\{ki\} ek=i=1∑mwkieki  
e) 计算弱学习器的系数：  
 α k = e k 1 − e k α\_k=\\frac\{e\_k\}\{1−e\_k\} αk=1−ekek  
f) 更新样本集的权重分布为：  
 w k + 1 , i = w k i Z k α k 1 − e k i w\_\{k+1,i\}=\\frac\{w\_ki\}\{Z\_k\}α\_k^\{1−e\_ki\} wk\+1,i=Zkwkiαk1−eki  
这里  Z k Z\_k Zk 是规范化因子：  
 Z k = ∑ i = 1 m w k i α k 1 − e k i Z\_k=∑\_\{i=1\}^mw\_\{ki\}α\_k^\{1−e\_\{ki\}\} Zk=i=1∑mwkiαk1−eki

1.  构建最终强学习器为：  
     f ( x ) = G k ∗ ( x ) f(x)=G\_k^∗(x) f(x)=Gk∗(x)  
    其中， G k ∗ ( x ) G\_k^∗(x) Gk∗(x) 是所有 ln ⁡ 1 α k    ,    k = 1 , 2 , ⋯   , K \\ln \\frac\{1\}\{\\alpha\_k\}\\;,\\;k=1,2,\\cdots,K lnαk1,k=1,2,⋯,K的中位数值对应序号  k ∗ k^∗ k∗对应的弱学习器。

### 八、Adaboost算法的正则化 ###

为了防止Adaboost过拟合，我们通常也会加入正则化项，这个正则化项我们通常称为步长(learning rate)。定义为  ν ν ν,对于前面的弱学习器的迭代：  
 f k ( x ) = f k − 1 ( x ) + α k G k ( x ) f\_k(x)=f\_\{k−1\}(x)+α\_kG\_k(x) fk(x)=fk−1(x)\+αkGk(x)  
如果我们加上了正则化项，则有：  
 f k ( x ) = f k − 1 ( x ) + ν α k G k ( x ) f\_k(x)=f\_\{k−1\}(x)+να\_kG\_k(x) fk(x)=fk−1(x)\+ναkGk(x)  
 ν ν ν 的取值范围为 0 < ν ≤ 1 0<ν≤1 0<ν≤1。对于同样的训练集学习效果，较小的  ν ν ν 意味着我们需要更多的弱学习器的迭代次数。通常我们用步长和迭代最大次数一起来决定算法的拟合效果。

### 九、Adaboost算法优缺点 ###

**Adaboost的优点：**

1）Adaboost作为分类器时，分类精度很高；

2）在Adaboost的框架下，可以使用各种回归分类模型来构建弱学习器，非常灵活；

3）作为简单的二元分类器时，构造简单，容易实施，结果可理解；

4）不容易发生过拟合。

**Adaboost的缺点：**

1）对异常样本敏感，异常样本在迭代中可能会获得较高的权重，影响最终的强学习器的预测准确性；

2）训练时间过长，每次一个分类器都要用全部样本学习，对于弱分类器学习来讲，时间及速度上影响不大，强分类器的学习时间会就会比较大。

### 参考文章 ###

https://www.cnblogs.com/bonheur/p/12666332.html

[09bffcc900d9475b8ba99d88514a4586.png]: https://img-blog.csdnimg.cn/09bffcc900d9475b8ba99d88514a4586.png
[1b7cf35f8bd84a9a88011e11e462b38e.png]: https://img-blog.csdnimg.cn/1b7cf35f8bd84a9a88011e11e462b38e.png