机器学习算法系列（十九）-自适应增强算法（Adaptive Boosting Algorithm）

Saisimon
1,249 阅读16分钟

阅读本文需要的背景知识点：集成学习、拉格朗日乘数法、一丢丢编程知识

一、引言

  前面一节我们学习了随机森林算法（Random Forest Algorithm），讲到了其中一种集成学习的方法——Bagging 算法，这一节我们来学习另一种集成学习的方法——提升算法1 （Boosting Algorithm），同时介绍其中比较常见的算法——自适应增强算法2（Adaptive Boosting Algorithm / AdaBoost Algorithm）

二、模型介绍

Boosting 算法

  Boosting 算法也是一种集成学习，与 Bagging 算法不同的是，每次训练更关注训练出的估计器中分类错误或者回归误差大的样本，即每次训练都是根据上次训练的结果调整不同的样本权重，直到最后的输出小于预设的阈值。

0.png

图2-1

  图 2-1 展示了提示算法的具体流程，其与 Bagging 算法的区别在于：其一，Bagging 算法的每个估计器相对独立且权重都相同，而 Boosting 算法的每个估计器都依赖于上一个估计器同时权重也不同。其二，一般情况下 Bagging 算法可以减小方差、而 Boosting 算法则是减小偏差。
  Boosting 算法中比较有代表性的算法就是自适应增强算法（Adaptive Boosting Algorithm / AdaBoost Algorithm）

AdaBoost 算法

  AdaBoost 算法是由 Yoav Freund 和 Robert E. Schapire 在 1995 年提出的，同时还提出了 AdaBoost.M1、AdaBoost.M2 算法用于多分类问题，AdaBoost.R 算法用于回归问题。后面陆续又有人提出了上述算法的变体 AdaBoost-SAMME、AdaBoost-SAMME.R、AdaBoost.R2 算法。
  AdaBoost 算法的基本步骤与 Boosting 算法一样，是 Boosting 算法的具体实现，其定义了每次循环如何更新样本权重以及最后如何将每个估计器结合起来。
  由于笔者能力所限，本文只会介绍基础的 AdaBoost 算法和现在 scikit-learn 中所实现的 AdaBoost-SAMME、AdaBoost-SAMME.R、AdaBoost.R2算法，其他的算法暂无法一一介绍，感兴趣的读者可以参考文末对应算法的论文原文。

三、算法步骤

  下面先给出每个算法的执行步骤，后面再一一说明这些算法步骤中公式的来源。

二分类

  假设训练集 T = { X_i, y_i }，i = 1，...，N，y_i 可取-1，+1，h(x) 为估计器，估计器的数量为 K。

AdaBoost 算法步骤如下：

初始化样本权重向量 ω_1

ω1,i=1Ni=1,...,N\begin{aligned} \omega_{1,i} &= \frac{1}{N} \quad i = 1,...,N \end{aligned}

遍历估计器的数量 K 次：
  在样本权重 ω_k 下训练估计器 h(x)
  计算第k次的误差率 e_k

ek=∑i=1Nωk,iI(yi≠hk(Xi))\begin{aligned} e_k &= \sum_{i = 1}^{N}\omega_{k,i} I(y_i \ne h_k(X_i)) \end{aligned}

  如果误差率 e_k 大于 0.5
    中断循环
  计算第k次的估计器权重 α_k

αk=12ln⁡1−ekek\begin{aligned} \alpha_k &= \frac{1}{2} \ln \frac{1 - e_k}{e_k}\\ \end{aligned}

  计算第 k+1 次的权重向量 ω_{k+1}

ωk+1,i=ωk,ie−yiαkhk(Xi)∑j=0N(ωk,je−yjαkhk(Xj))\begin{aligned} \omega_{k+1,i} &= \frac{\omega_{k,i} e^{-y_i\alpha_kh_k(X_i)}}{\sum_{j = 0}^N \left(\omega_{k,j} e^{-y_j\alpha_kh_k(X_j)}\right) } \end{aligned}

结束循环

  最后的结合策略，采用加权后的结果取 sign 函数，得到最终的强估计器：

H(x)=sign⁡(∑i=1Kαihi(x))\begin{aligned} H(x) &= \operatorname{sign} \left(\sum_{i = 1}^{K} \alpha_i h_i(x)\right) \end{aligned}

多分类

  假设训练集 T = { X_i, y_i }，i = 1，...，N，y 的取值有 M 种可能，h(x) 为估计器，估计器的数量为 K。

AdaBoost-SUMME 算法步骤如下：

初始化样本权重向量 ω_1

ω1,i=1Ni=1,...,N\begin{aligned} \omega_{1,i} &= \frac{1}{N} \quad i = 1,...,N \end{aligned}

遍历估计器的数量 K 次：
  在样本权重 ω_k 下训练估计器 h(x)
  计算第k次的误差率 e_k

ek=∑i=1Nωk,iI(yi≠hk(Xi))\begin{aligned} e_k &= \sum_{i = 1}^{N}\omega_{k,i} I(y_i \ne h_k(X_i)) \end{aligned}

  计算第 k 次的估计器权重 α_k

αk=ln⁡1−ekek+ln⁡(M−1)\begin{aligned} \alpha_k &= \ln \frac{1 - e_k}{e_k} + \ln (M - 1) \\ \end{aligned}

  计算第 k+1 次的权重向量 ω_{k+1}

ωk+1,iˉ=ωk,ieαkI(yi≠hk(Xi))\begin{aligned} \bar{\omega_{k+1,i}} &= \omega_{k,i}e^{\alpha_kI(y_i \ne h_k(X_i))} \end{aligned}

  对权重向量 ω_{k+1} 进行归一化

ωk+1,i=ωk+1,iˉ∑j=1Nωk+1,iˉ\begin{aligned} \omega_{k+1,i} &= \frac{\bar{\omega_{k + 1,i}}}{\sum_{j = 1}^N \bar{\omega_{k + 1,i}} } \end{aligned}

结束循环

  最后的结合策略，采用正确分类的结果加权后取值最大的分类，得到最终的强估计器：

H(x)=argmax⁡m(∑i=1KαiI(hi(x)=m))\begin{aligned} H(x) &= \underset{m}{\operatorname{argmax}} \left( \sum_{i = 1}^{K} \alpha_i I(h_i(x) = m) \right) \end{aligned}
AdaBoost-SUMME.R 算法步骤如下：

初始化样本权重向量 ω_1

ω1,i=1Ni=1,...,N\begin{aligned} \omega_{1,i} &= \frac{1}{N} \quad i = 1,...,N \end{aligned}

遍历估计器的数量 K 次：
  在样本权重 ω_k 下计算加权类概率估计向量 P_k

pkm(x)=P(y=m∣x)\begin{aligned} p_k^m(x) = P(y = m \mid x) \end{aligned}

   计算第 k+1 次的权重向量 ω_{k+1}

y^={1y=m−1M−1y≠mm=1,…,M\hat{y} = \left\{ \begin{array}{c} 1 & y =m\\ -\frac{1}{M-1} & y \ne m \end{array}\right. \quad m = 1,\dots,M
ωk+1,iˉ=ωk,ie−M−1Myi^Tln⁡pk(x)\begin{aligned} \bar{\omega_{k+1,i}} &= \omega_{k,i}e^{-\frac{M-1}{M} \hat{y_i}^T \ln p_k(x) } \end{aligned}

  对权重向量 ω_{k+1} 进行归一化

ωk+1,i=ωk+1,iˉ∑j=1Nωk+1,iˉ\begin{aligned} \omega_{k+1,i} &= \frac{\bar{\omega_{k + 1,i}}}{\sum_{j = 1}^N \bar{\omega_{k + 1,i}} } \end{aligned}

结束循环

  最后的结合策略，采用概率估计计算结果取值最大的分类，得到最终的强估计器：

hk(x)=(M−1)(ln⁡pkm(x)−1M∑i=1Mln⁡pki(x))H(x)=argmax⁡m(∑i=1Khi(x))\begin{aligned} h_k(x) &= (M - 1) \left( \ln p_k^m(x) - \frac{1}{M} \sum_{i = 1}^{M} \ln p_k^i(x) \right) \\ H(x) &= \underset{m}{\operatorname{argmax}} \left( \sum_{i = 1}^{K} h_i(x)\right) \end{aligned}

回归

  假设训练集 T = { X_i, y_i }，i = 1，...，N，h(x) 为估计器，估计器的数量为 K

AdaBoost.R2 算法步骤如下：

初始化样本权重向量 ω_1

ω1,i=1Ni=1,...,N\begin{aligned} \omega_{1,i} &= \frac{1}{N} \quad i = 1,...,N \end{aligned}

遍历估计器的数量 K 次：
  在样本权重 ω_k 下训练估计器 h(x)
  计算最大误差 E_k

Ek=max⁡∣yi−hk(Xi)∣\begin{aligned} E_k &= \max \mid y_i - h_k(X_i) \mid \end{aligned}

  计算第 k 次的误差率 e_k

ek,i=∣yi−hk(Xi)∣Ek线性误差ek,i=(yi−hk(Xi))2Ek2平方误差ek,i=1−e−∣yi−hk(Xi)∣Ek指数误差ek=∑i=1Nωk,iek,i\begin{aligned} e_{k,i} &= \frac{\mid y_i - h_k(X_i) \mid}{E_k} & 线性误差 \\ e_{k,i} &= \frac{\left( y_i - h_k(X_i) \right)^2}{E_k^2} & 平方误差 \\ e_{k,i} &= 1 - e^{-\frac{\mid y_i - h_k(X_i) \mid}{E_k} } & 指数误差 \\ e_k & = \sum_{i = 1}^{N}\omega_{k,i} e_{k,i} \end{aligned}

  如果误差率 e_k 大于 0.5
    中断循环
  计算第 k 次的估计器权重 α_k

αk=ek1−ek\begin{aligned} \alpha_k &= \frac{e_k}{1 - e_k} \end{aligned}

  计算第 k+1 次的权重向量 ω_{k+1}

ωk+1,iˉ=ωk,iαk1−ek,i\begin{aligned} \bar{\omega_{k+1,i}} &= \omega_{k,i}\alpha_k^{1 - e_{k,i}} \end{aligned}

  对权重向量 ω_{k+1} 进行归一化

ωk+1,i=ωk+1,iˉ∑j=1Nωk+1,iˉ\begin{aligned} \omega_{k+1,i} &= \frac{\bar{\omega_{k + 1,i}}}{\sum_{j = 1}^N \bar{\omega_{k + 1,i}} } \end{aligned}

结束循环

  最后的结合策略，采用估计器权重的中位数对应的估计器的结果，得到最终的强估计器：

H(x)=inf⁡{y∈A:∑hi(x)≤yln⁡(1αi)≥12∑i=1Kln⁡(1αi)}\begin{aligned} H(x) &= \inf \left\{ y \in A: \sum_{h_i(x) \le y } \ln \left(\frac{1}{\alpha_i}\right) \ge \frac{1}{2} \sum_{i = 1}^{K} \ln \left(\frac{1}{\alpha_i}\right) \right\} \end{aligned}

四、原理证明

AdaBoost 算法推导

  同算法步骤中的前提条件一样，假设训练集 T = { X_i, y_i }，i = 1，...，N，y_i 可取-1，+1，h(x) 为估计器，估计器的数量为 K。

  AdaBoost 算法的一种解释是加法模型，通过多个估计器 h(x) 加权以后得到最后的强估计器 H(x)，如下所示：
（1）第 k-1 轮的强估计器表达式
（2）第 k 轮的强估计器表达式
（3）第 k 轮的强估计器可以由第 k-1 轮的强估计器和第 k 轮的加权估计器来表示

Hk−1(x)=∑i=1k−1αihi(x)(1)Hk(x)=∑i=1kαihi(x)(2)Hk(x)=Hk−1(x)+αkhk(x)(3)\begin{aligned} H_{k-1}(x) &= \sum_{i = 1}^{k-1} \alpha_i h_i(x) & (1) \\ H_k(x) &= \sum_{i = 1}^{k} \alpha_i h_i(x) & (2) \\ H_k(x) &= H_{k-1}(x) + \alpha_k h_k(x) & (3) \\ \end{aligned}
式4-1

  接下来我们来定义最后强估计器的代价函数，AdaBoost 算法选用的是指数函数，相比于0/1 函数具有更好的数学性质。
（1）指数代价函数
（2）带入式 4-1中的（3）式
（3）我们的目标就是找到最优的估计器权重 α 和估计器 h(x)
（4）定义一个新的变量 ω，包含前一轮的强估计器等与 α 、h(x)无关的值
（5）替换 ω

Cost(H(x))=∑i=1Ne−yiH(Xi)(1)Cost(α,h(x))=∑i=1Ne−yi(Hk−1(Xi)+αh(Xi))(2)αk,hk(x)=argmin⁡α,h(x)∑i=1Ne−yi(Hk−1(Xi)+αh(Xi))(3)ωk,iˉ=e−yiHk−1(Xi)(4)αk,hk(x)=argmin⁡α,h(x)∑i=1Nωk,iˉe−yiαh(Xi)(5)\begin{aligned} Cost(H(x)) &= \sum_{i = 1}^{N} e^{-y_iH(X_i)} & (1) \\ Cost(\alpha, h(x)) &= \sum_{i = 1}^{N} e^{-y_i(H_{k-1}(X_i) + \alpha h(X_i))} & (2) \\ \alpha_k, h_k(x) &= \underset{\alpha, h(x)}{\operatorname{argmin} } \sum_{i = 1}^{N} e^{-y_i(H_{k-1}(X_i) + \alpha h(X_i))} & (3) \\ \bar{\omega_{k,i}} &= e^{-y_iH_{k-1}(X_i)} & (4) \\ \alpha_k, h_k(x) &= \underset{\alpha, h(x)}{\operatorname{argmin} } \sum_{i = 1}^{N} \bar{\omega_{k,i}} e^{-y_i\alpha h(X_i)} & (5) \\ \end{aligned}
式4-2

  我们先来看下估计器 h(x)，在每次训练估计器后，估计器已经确定下来了，所以我们现在只需要关心每个估计器的权重 α 即可。
（1）找到最优的估计器权重 α 使得代价函数的取值最小
（2）代价函数 Cost(α)
（3）由于标签值可取正负 1，根据预测值与标签值是否相同拆为两项
（4）增加第二、三两项，不影响最后的结果
（5）将（4）式中前两项和后两项分别合并得到

αk=argmin⁡α∑i=1Nωk,iˉe−yiαhk(Xi)(1)Cost(α)=∑i=1Nωk,iˉe−yiαhk(Xi)(2)=∑yi=hk(Xi)Nωk,iˉe−α+∑yi≠hk(Xi)Nωk,iˉeα(3)=∑yi=hk(Xi)Nωk,iˉe−α+∑yi≠hk(Xi)Nωk,iˉe−α−∑yi≠hk(Xi)Nωk,iˉe−α+∑yi≠hk(Xi)Nωk,iˉeα(4)=e−α∑i=1Nωk,iˉ+(eα−e−α)∑i=1Nωk,iˉI(yi≠hk(Xi))(5)\begin{aligned} \alpha_k &= \underset{\alpha}{\operatorname{argmin} } \sum_{i = 1}^{N} \bar{\omega_{k,i}} e^{-y_i\alpha h_k(X_i)} & (1) \\ Cost(\alpha) &= \sum_{i = 1}^{N} \bar{\omega_{k,i}} e^{-y_i\alpha h_k(X_i)} & (2) \\ &= \sum_{y_i = h_k(X_i)}^{N} \bar{\omega_{k,i}} e^{-\alpha} + \sum_{y_i \ne h_k(X_i)}^{N} \bar{\omega_{k,i}} e^{\alpha} & (3) \\ &= \sum_{y_i = h_k(X_i)}^{N} \bar{\omega_{k,i}} e^{-\alpha} + \sum_{y_i \ne h_k(X_i)}^{N} \bar{\omega_{k,i}} e^{-\alpha} - \sum_{y_i \ne h_k(X_i)}^{N} \bar{\omega_{k,i}} e^{-\alpha} + \sum_{y_i \ne h_k(X_i)}^{N} \bar{\omega_{k,i}} e^{\alpha} & (4) \\ &= e^{-\alpha} \sum_{i = 1}^{N} \bar{\omega_{k,i}} + (e^{\alpha} - e^{-\alpha}) \sum_{i = 1}^{N} \bar{\omega_{k,i}} I(y_i \ne h_k(X_i)) & (5) \\ \end{aligned}
式4-3

（1）对代价函数求导数并令其为零
（2）定义错误率 e_k 的表达式
（3）将错误率 e_k 带入（2）式
（4）两边同时乘以 exp(α)
（5）移项后整理得
（6）求得最后的估计器权重 α 的表达式

∂Cost(α)∂α=−e−α∑i=1Nωk,iˉ+(eα+e−α)∑i=1Nωk,iˉI(yi≠hk(Xi))=0(1)ek=∑i=1Nωk,iˉI(yi≠hk(Xi))∑i=1Nωk,iˉ(2)0=−e−α+(eα+e−α)ek(3)0=−1+(e2α+1)ek(4)e2α=1−ekek(5)α=12ln⁡1−ekek(6)\begin{aligned} \frac{\partial Cost(\alpha )}{\partial \alpha } &= -e^{-\alpha} \sum_{i = 1}^{N} \bar{\omega_{k,i}} + (e^{\alpha} + e^{-\alpha}) \sum_{i = 1}^{N} \bar{\omega_{k,i}} I(y_i \ne h_k(X_i)) = 0& (1) \\ e_k &= \frac{\sum_{i = 1}^{N}\bar{\omega_{k,i}} I(y_i \ne h_k(X_i))}{\sum_{i = 1}^{N}\bar{\omega_{k,i}}} & (2) \\ 0 &= -e^{-\alpha} + (e^\alpha + e^{-\alpha}) e_k & (3) \\ 0 &= -1 + (e^{2\alpha } + 1)e_k & (4) \\ e^{2\alpha } &= \frac{1 - e_k}{e_k} & (5) \\ \alpha &= \frac{1}{2} \ln \frac{1 - e_k}{e_k} & (6) \\ \end{aligned}
式4-4

（1）错误率 e_k 的定义
（2）定义 ω_k
（3）得到错误率 e_k 的表达式

ek=∑i=1Nωk,iˉI(yi≠hk(Xi))∑i=1Nωk,iˉ(1)ωk,i=ωk,iˉ∑i=1Nωk,iˉ(2)ek=∑i=1Nωk,iI(yi≠hk(Xi))(3)\begin{aligned} e_k &= \frac{\sum_{i = 1}^{N}\bar{\omega_{k,i}} I(y_i \ne h_k(X_i))}{\sum_{i = 1}^{N}\bar{\omega_{k,i}}} & (1) \\ \omega_{k,i} &= \frac{\bar{\omega_{k,i}}}{\sum_{i = 1}^{N}\bar{\omega_{k,i}}} & (2) \\ e_k &= \sum_{i = 1}^{N}\omega_{k,i} I(y_i \ne h_k(X_i)) & (3) \\ \end{aligned}
式4-5

  接下来是 ω 的更新方法：
（1） ω_{k+1} 的定义
（2）带入式 4-1中的（3）式
（3）替换为 ω_k

ωk+1,iˉ=e−yiHk(Xi)(1)=e−yi(Hk−1(Xi)+αkhk(Xi))(2)=ωk,iˉe−yiαkhk(Xi)(3)\begin{aligned} \bar{\omega_{k+1,i}} &= e^{-y_iH_{k}(X_i)} & (1) \\ &= e^{-y_i(H_{k-1}(X_i) + \alpha_kh_k(X_i))} & (2) \\ &= \bar{\omega_{k,i}}e^{-y_i\alpha_kh_k(X_i)} & (3) \end{aligned}
式4-6

（1）式 4-6中的（3）
（2）两边同时除以归一化参数
（3）分子按照式 4-5中（2）式的定义替换，分母用式 4-7中（1）式替换
（4）分母再按照式 4-5中（2）式的定义替换
（5）由于 ω 的和为一个常数 C
（6）分子分母的常数 C 可以消除，得到 ω 的更新方表达式

ωk+1,iˉ=ωk,iˉe−yiαkhk(Xi)(1)ωk+1,i=ωk,iˉe−yiαkhk(Xi)∑j=0Nωk+1,jˉ(2)=ωk,i∑j=0N(ωk,jˉ)e−yiαkhk(Xi)∑j=0N(ωk,jˉe−yjαkhk(Xj))(3)=ωk,i∑j=0N(ωk,jˉ)e−yiαkhk(Xi)∑j=0N(ωk,j(∑l=0Nωk,lˉ)e−yjαkhk(Xj))(4)=ωk,iCe−yiαkhk(Xi)∑j=0N(ωk,jCe−yjαkhk(Xj))(5)=ωk,ie−yiαkhk(Xi)∑j=0N(ωk,je−yjαkhk(Xj))(6)\begin{aligned} \bar{\omega_{k+1,i}} &= \bar{\omega_{k,i}}e^{-y_i\alpha_kh_k(X_i)} & (1) \\ \omega_{k+1,i} &= \frac{ \bar{\omega_{k,i}}e^{-y_i\alpha_kh_k(X_i)} }{\sum_{j = 0}^N \bar{\omega_{k+1,j}}} & (2) \\ &= \frac{\omega_{k,i} \sum_{j = 0}^N \left(\bar{\omega_{k,j}}\right) e^{-y_i\alpha_kh_k(X_i)} }{\sum_{j = 0}^N \left(\bar{\omega_{k,j}} e^{-y_j\alpha_kh_k(X_j)} \right) } & (3) \\ &= \frac{\omega_{k,i} \sum_{j = 0}^N \left(\bar{\omega_{k,j}}\right) e^{-y_i\alpha_kh_k(X_i)}}{\sum_{j = 0}^N \left(\omega_{k,j} \left(\sum_{l = 0}^N \bar{\omega_{k,l}}\right) e^{-y_j\alpha_kh_k(X_j)}\right) } & (4) \\ &= \frac{\omega_{k,i} C e^{-y_i\alpha_kh_k(X_i)}}{\sum_{j = 0}^N \left(\omega_{k,j} C e^{-y_j\alpha_kh_k(X_j)}\right) } & (5) \\ &= \frac{\omega_{k,i} e^{-y_i\alpha_kh_k(X_i)}}{\sum_{j = 0}^N \left(\omega_{k,j} e^{-y_j\alpha_kh_k(X_j)}\right) } & (6) \\ \end{aligned}
式4-7

  综合式 4-1～式 4-7 可以得到 AdaBoost 算法的表达式：

ek=∑i=1Nωk,iI(yi≠hk(Xi))(1)αk=12ln⁡1−ekek(2)ωk+1,i=ωk,ie−yiαkhk(Xi)∑j=0N(ωk,je−yjαkhk(Xj))(3)H(x)=sign⁡(∑i=1Kαihi(x))(4)\begin{aligned} e_k &= \sum_{i = 1}^{N}\omega_{k,i} I(y_i \ne h_k(X_i)) & (1) \\ \alpha_k &= \frac{1}{2} \ln \frac{1 - e_k}{e_k} & (2) \\ \omega_{k+1,i} &= \frac{\omega_{k,i} e^{-y_i\alpha_kh_k(X_i)}}{\sum_{j = 0}^N \left(\omega_{k,j} e^{-y_j\alpha_kh_k(X_j)}\right) } & (3) \\ H(x) &= \operatorname{sign} \left(\sum_{i = 1}^{K} \alpha_i h_i(x)\right) & (4) \\ \end{aligned}
式4-8

AdaBoost-SAMME 算法推导

  同算法步骤中的前提条件一样，假设训练集 T = { X_i, y_i }，i = 1，...，N，y 的取值有 M 种可能，h(x) 为估计器，估计器的数量为 K。
  为了适应多分类问题，AdaBoost-SAMME 算法将原本为数值的标签 y 转化成一个向量的形式，如式 4-9 所示：

y^={1y=m−1M−1y≠mm=1,…,M\hat{y} = \left\{ \begin{array}{c} 1 & y =m\\ -\frac{1}{M-1} & y \ne m \end{array}\right. \quad m = 1,\dots,M
式4-9

  下面用一个例子来说明式 4-9 的含义，假设标签 y 可取 1，2，3，标签集 y = { 2，1，2，3 }，这时根据式 4-9 可以得到对应的转换后的标签集如式 4-10 所示：

y∈{1,2,3}y={2,1,2,3}y^i={1yi=m−12yi≠mm=1,2,3y^=[−121−121−12−12−121−12−12−121]\begin{array}{c} y \in \{1,2,3\} \\ y = \{2,1,2,3\} \\ \hat{y}_i = \left\{ \begin{array}{c} 1 & y_i =m\\ -\frac{1}{2} & y_i \ne m \end{array}\right. \quad m = 1,2,3 \\ \hat{y} = \begin{bmatrix} -\frac{1}{2} & 1 & -\frac{1}{2} \\ 1 & -\frac{1}{2} & -\frac{1}{2} \\ -\frac{1}{2} & 1 & -\frac{1}{2} \\ -\frac{1}{2} & -\frac{1}{2} & 1 \end{bmatrix} \end{array}
式4-10

  同样将算法解释为加法模型，通过多个估计器 h(x) 加权以后得到最后的强估计器 H(x)，代价函数使用指数函数
（1）代价函数，这里比原始算法多了一个 1 / M，是为了后面计算方便，同时 H(X_i) 也是一个向量
（2）带入式 4-1 中的（3）式
（3）同样定义一个 ω，包含前一轮的强估计器等与 α 无关的值
（4）带入 ω 得到代价函数的表达式
（5）目标为找到最优的估计器权重 α 使得代价函数的取值最小

Cost(H(x))=∑i=1Ne−1My^iH(Xi)(1)Cost(α)=∑i=1Ne−1My^i(Hk−1(Xi)+αhk(Xi))(2)ωk,iˉ=e−1My^iHk−1(Xi)(3)Cost(α)=∑i=1Nωk,iˉe−1My^iαhk(Xi)(4)αk=argmin⁡α∑i=1Nωk,iˉe−1My^iαhk(Xi)(5)\begin{aligned} Cost(H(x)) &= \sum_{i = 1}^{N} e^{-\frac{1}{M} \hat{y}_iH(X_i)} & (1) \\ Cost(\alpha) &= \sum_{i = 1}^{N} e^{-\frac{1}{M}\hat{y}_i(H_{k-1}(X_i) + \alpha h_k(X_i))} & (2) \\ \bar{\omega_{k,i}} &= e^{-\frac{1}{M}\hat{y}_iH_{k-1}(X_i)} & (3) \\ Cost(\alpha) &= \sum_{i = 1}^{N} \bar{\omega_{k,i}} e^{-\frac{1}{M}\hat{y}_i\alpha h_k(X_i)} & (4) \\ \alpha_k &= \underset{\alpha}{\operatorname{argmin} } \sum_{i = 1}^{N} \bar{\omega_{k,i}} e^{-\frac{1}{M}\hat{y}_i\alpha h_k(X_i)} & (5) \\ \end{aligned}
式4-11

  我们先来看下代价函数中指数的部分，即预测值与标签值的点积，下面分两种情况讨论：
  当预测值与标签值相同的时候，向量中 1 的位置一致，-1 / (M - 1) 一共有 M - 1 个，得到如下的点积结果：

1+(M−1)(−1M−1)(−1M−1)=MM−1\begin{aligned} 1 + \left(M - 1\right)\left(-\frac{1}{M-1}\right)\left(-\frac{1}{M-1}\right) = \frac{M}{M-1}\\ \end{aligned}
式4-12

  当预测值与标签值不相同的时候，向量中 1 的位置不一致，-1 / (M - 1) 一共有 M - 2 个，得到如下的点积结果：

(−1M−1)+(−1M−1)+(M−2)(−1M−1)(−1M−1)=−M(M−1)2\begin{aligned} \left(-\frac{1}{M-1}\right) + \left(-\frac{1}{M-1}\right) + \left(M - 2\right) \left(-\frac{1}{M-1}\right)\left(-\frac{1}{M-1}\right) = -\frac{M}{(M-1)^2} \end{aligned}
式4-13

  综合上面两种情况，得到如下的结果：

y^ihk(Xi)={MM−1y^i=hk(Xi)−M(M−1)2y^i≠hk(Xi)\hat{y}_ih_k(X_i) = \left\{ \begin{aligned} &\frac{M}{M-1} & \hat{y}_i = h_k(X_i) \\ &-\frac{M}{(M-1)^2} & \hat{y}_i \ne h_k(X_i) \end{aligned} \right.
式4-14

（1）代价函数 Cost(α)
（2）分两种情况带入式 4-14
（3）增加第二、三两项，不影响最后的结果
（4）将（3）式中前两项和后两项分别合并得到

Cost(α)=∑i=1Nωk,iˉe−1My^iαhk(Xi)(1)=∑y^i=hk(Xi)Nωk,iˉe−αM−1+∑y^i≠hk(Xi)Nωk,iˉeα(M−1)2(2)=∑y^i=hk(Xi)Nωk,iˉe−αM−1+∑y^i≠hk(Xi)Nωk,iˉe−αM−1−∑y^i≠hk(Xi)Nωk,iˉe−αM−1+∑y^i≠hk(Xi)Nωk,iˉeα(M−1)2(3)=e−αM−1∑i=1Nωk,iˉ+(eα(M−1)2−e−αM−1)∑i=1Nωk,iˉI(y^i≠hk(Xi))(4)\begin{aligned} Cost(\alpha) &= \sum_{i = 1}^{N} \bar{\omega_{k,i}} e^{-\frac{1}{M}\hat{y}_i\alpha h_k(X_i)} & (1) \\ &= \sum_{\hat{y}_i = h_k(X_i)}^{N} \bar{\omega_{k,i}} e^{-\frac{\alpha}{M-1} } + \sum_{\hat{y}_i \ne h_k(X_i)}^{N} \bar{\omega_{k,i}} e^{\frac{\alpha}{(M-1)^2}} & (2) \\ &= \sum_{\hat{y}_i = h_k(X_i)}^{N} \bar{\omega_{k,i}} e^{-\frac{\alpha}{M-1} } + \sum_{\hat{y}_i \ne h_k(X_i)}^{N} \bar{\omega_{k,i}} e^{-\frac{\alpha}{M-1}} - \sum_{\hat{y}_i \ne h_k(X_i)}^{N} \bar{\omega_{k,i}} e^{-\frac{\alpha}{M-1}} + \sum_{\hat{y}_i \ne h_k(X_i)}^{N} \bar{\omega_{k,i}} e^{\frac{\alpha}{(M-1)^2}} & (3) \\ &= e^{-\frac{\alpha}{M-1} } \sum_{i = 1}^{N} \bar{\omega_{k,i}} + (e^{\frac{\alpha}{(M-1)^2}} - e^{-\frac{\alpha}{M-1}}) \sum_{i = 1}^{N} \bar{\omega_{k,i}} I(\hat{y}_i \ne h_k(X_i)) & (4) \\ \end{aligned}
式4-15

（1）对代价函数求导数并令其为零
（2）定义错误率 e_k 的表达式
（3）将错误率 e_k 带入（2）式
（4）两边同时乘以 exp(α / (M - 1))
（5）移项后整理得
（6）求得最后的估计器权重 α 的表达式

∂Cost(α)∂α=(−1M−1)e−αM−1∑i=1Nωk,iˉ+((1(M−1)2)eα(M−1)2+(1(M−1))e−αM−1)∑i=1Nωk,iˉI(yi≠hk(Xi))=0(1)ek=∑i=1Nωk,iˉI(yi≠hk(Xi))∑i=1Nωk,iˉ(2)e−αM−1=((1M−1)eα(M−1)2+e−αM−1)ek(3)1=((1M−1)eα(M−1)2+αM−1+1)ek(4)1−ekek=(1M−1)eMα(M−1)2(5)α=(M−1)2M(ln⁡(1−ekek)+ln⁡(M−1))(6)\begin{aligned} \frac{\partial Cost(\alpha )}{\partial \alpha } &= \left(-\frac{1}{M-1}\right)e^{-\frac{\alpha}{M-1}} \sum_{i = 1}^{N} \bar{\omega_{k,i}} + \left(\left(\frac{1}{(M-1)^2}\right)e^{\frac{\alpha}{(M-1)^2}} + \left(\frac{1}{(M-1)}\right)e^{-\frac{\alpha}{M-1}}\right) \sum_{i = 1}^{N} \bar{\omega_{k,i}} I(y_i \ne h_k(X_i)) = 0& (1) \\ e_k &= \frac{\sum_{i = 1}^{N}\bar{\omega_{k,i}} I(y_i \ne h_k(X_i))}{\sum_{i = 1}^{N}\bar{\omega_{k,i}}} & (2) \\ e^{-\frac{\alpha}{M-1}} &= \left(\left(\frac{1}{M-1}\right)e^{\frac{\alpha}{(M-1)^2}} + e^{-\frac{\alpha}{M-1}}\right) e_k & (3) \\ 1 &= \left(\left(\frac{1}{M-1}\right)e^{\frac{\alpha}{(M-1)^2} + \frac{\alpha}{M-1}} + 1\right) e_k & (4) \\ \frac{1 - e_k}{e_k} &= \left(\frac{1}{M-1}\right)e^{\frac{M\alpha}{(M-1)^2}} & (5) \\ \alpha &= \frac{(M-1)^2}{M}\left( \ln \left(\frac{1 - e_k}{e_k}\right) + \ln (M - 1) \right) & (6) \end{aligned}
式4-16

  式 4-16 中估计器权重 α 的表达式前面的常数在进过归一化后对结果没有影响，后面的样本权重更新的公式一样也是简化后的结果。更多详细的算法说明请参考原始论文——Multi-class AdaBoost7

AdaBoost-SAMME.R 算法推导

  AdaBoost-SAMME.R 算法是 AdaBoost-SAMME 算法的变体，该算法是使用加权概率估计来更新加法模型，如式 4-17 所示：

Hk(x)=Hk−1(x)+hk(x)\begin{aligned} H_k(x) = H_{k - 1}(x) + h_k(x) \end{aligned}
式4-17

  代价函数使用的依然是指数函数，不同的是已经没有了估计器权重或者说每一个估计器的权重都为 1，且改成了期望的形式，其中 h(x) 返回的是 M 维的向量，同时为保证求出的 h(x) 唯一，加上了向量的各个元素之和为 0 的限制条件。

hk(x)=argmax⁡h(x)E(e−1My^i(Hk−1(x)+h(x))∣x)s.t.hk1(x)+hk2(x)+⋯+hkM(x)=0\begin{array}{c} h_k(x) = \underset{h(x)}{\operatorname{argmax}} E(e^{-\frac{1}{M} \hat{y}_i (H_{k-1}(x) + h(x)) } \mid x) \\ s.t. \quad h_k^1(x) + h_k^2(x) + \cdots + h_k^M(x) = 0 \end{array}
式4-18

  代价函数可以拆分成对每一类分别求期望后再相加：

Cost(h(x))=E(e−1My^i(Hk−1(x)+h(x))∣x)(1)=E(e−1My^iHk−1(x)e−1My^ih(x)∣x)(2)=E(e−1My^iHk−1(x)e−1My^ih(x)I(y=1)∣x)+⋯+E(e−1My^iHk−1(x)e−1My^ih(x)I(y=M)∣x)(3)\begin{aligned} Cost(h(x)) &= E(e^{-\frac{1}{M} \hat{y}_i (H_{k-1}(x) + h(x)) } \mid x) & (1) \\ &= E(e^{-\frac{1}{M} \hat{y}_i H_{k-1}(x)}e^{-\frac{1}{M}\hat{y}_ih(x) } \mid x) & (2) \\ &= E(e^{-\frac{1}{M} \hat{y}_i H_{k-1}(x)}e^{-\frac{1}{M}\hat{y}_ih(x) } I(y = 1) \mid x) + \cdots + E(e^{-\frac{1}{M} \hat{y}_i H_{k-1}(x)}e^{-\frac{1}{M}\hat{y}_ih(x) } I(y = M) \mid x) & (3) \\ \end{aligned}
式4-19

  先来看看当 y = 1 时，y * h(x) 的结果：
（1）当 y = 1 时，转换后 y 的向量形式
（2）计算点积的结果
（3）合并最后的项
（4）根据限制条件替换
（5）得到化简后的结果

y^=[1,−1M−1,⋯ ,−1M−1](1)y^ih(x)=h1(x)+(−1M−1)h2(x)+⋯+(−1M−1)hM(x)(2)=h1(x)−h2(x)+⋯+hM(x)M−1(3)=h1(x)−−h1(x)M−1(4)=Mh1(x)M−1(5)\begin{aligned} \hat{y} &= [1, -\frac{1}{M - 1}, \cdots, -\frac{1}{M - 1} ] & (1) \\ \hat{y}_ih(x) &= h^1(x) + (-\frac{1}{M - 1})h^2(x) + \cdots + (-\frac{1}{M - 1})h^M(x) & (2) \\ &= h^1(x) - \frac{h^2(x) + \cdots + h^M(x)}{M - 1} & (3) \\ &= h^1(x) - \frac{-h^1(x)}{M - 1} & (4) \\ &= \frac{Mh^1(x)}{M - 1} & (5) \\ \end{aligned}
式4-20

（1）带入式 4-20
（2）提出与期望无关的项
（3）另后面的期望为 P(y = 1 | x)
（4）同理可以得每一类的期望结果

E(e−1My^iHk−1(x)e−1My^ih(x)I(y=1)∣x)=E(e−1My^iHk−1(x)e−h1(x)M−1I(y=1)∣x)(1)=e−h1(x)M−1E(e−1My^iHk−1(x)I(y=1)∣x)(2)P(y=1∣x)=E(e−1My^iHk−1(x)I(y=1)∣x)(3)E(e−1My^iHk−1(x)e−1My^ih(x)I(y=m)∣x)=e−hm(x)M−1P(y=m∣x)(4)\begin{aligned} E(e^{-\frac{1}{M} \hat{y}_i H_{k-1}(x)}e^{-\frac{1}{M}\hat{y}_ih(x) } I(y = 1) \mid x) &= E(e^{-\frac{1}{M} \hat{y}_i H_{k-1}(x)}e^{-\frac{h^1(x)}{M-1} } I(y = 1) \mid x) & (1) \\ &= e^{-\frac{h^1(x)}{M-1}} E(e^{-\frac{1}{M} \hat{y}_i H_{k-1}(x)} I(y = 1) \mid x) & (2) \\ P(y = 1 | x) &= E(e^{-\frac{1}{M} \hat{y}_i H_{k-1}(x)} I(y = 1) \mid x) & (3) \\ E(e^{-\frac{1}{M} \hat{y}_i H_{k-1}(x)}e^{-\frac{1}{M}\hat{y}_ih(x) } I(y = m) \mid x) &= e^{-\frac{h^m(x)}{M-1}} P(y = m | x) & (4) \\ \end{aligned}
式4-21

  将上面的结果带入代价函数得：

Cost(h(x))=e−h1(x)M−1P(y=1∣x)+⋯+e−hM(x)M−1P(y=M∣x)(1)=∑m=1Me−hm(x)M−1P(y=m∣x)(2)\begin{aligned} Cost(h(x)) &= e^{-\frac{h^1(x)}{M-1}} P(y = 1 | x) + \cdots + e^{-\frac{h^M(x)}{M-1}} P(y = M | x) & (1) \\ &= \sum_{m = 1}^{M} e^{-\frac{h^m(x)}{M-1}} P(y = m | x) & (2) \\ \end{aligned}
式4-22

  这时可以使用拉格朗日乘数法来求解上述问题，其拉格朗日函数 L 如下：

L(h(x),λ)=∑m=1Me−hm(x)M−1P(y=m∣x)−λ∑m=1Mhm(x)\begin{aligned} L(h(x), \lambda ) &= \sum_{m = 1}^{M} e^{-\frac{h^m(x)}{M-1}} P(y = m | x) - \lambda \sum_{m = 1}^{M} h^m(x)\\ \end{aligned}
式4-23

  拉格朗日函数分别对 h(x) 的各个分量求导数：

∂L(h(x),λ)∂h1(x)=−1M−1e−h1(x)M−1P(y=1∣x)−λ=0∂L(h(x),λ)∂h2(x)=−1M−1e−h2(x)M−1P(y=2∣x)−λ=0⋯∂L(h(x),λ)∂hM(x)=−1M−1e−hM(x)M−1P(y=M∣x)−λ=0\begin{aligned} \frac{\partial L(h(x), \lambda)}{\partial h^1(x)} &= -\frac{1}{M-1} e^{-\frac{h^1(x)}{M-1}} P(y = 1 | x) - \lambda = 0 \\ \frac{\partial L(h(x), \lambda)}{\partial h^2(x)} &= -\frac{1}{M-1} e^{-\frac{h^2(x)}{M-1}} P(y = 2 | x) - \lambda = 0 \\ & \cdots \\ \frac{\partial L(h(x), \lambda)}{\partial h^M(x)} &= -\frac{1}{M-1} e^{-\frac{h^M(x)}{M-1}} P(y = M | x) - \lambda = 0 \\ \end{aligned}
式4-24

  两两联立式 4-24 ，分别求出各个分量的结果，下面以第一个为例：
（1）联立导数中的第 1，2 式子
（2）消掉相同的常数项再两边同时取对数
（3）移项化简后得

−1M−1e−h1(x)M−1P(y=1∣x)=−1M−1e−h2(x)M−1P(y=2∣x)(1)−h1(x)M−1+ln⁡P(y=1∣x)=−h2(x)M−1+ln⁡P(y=2∣x)(2)h1(x)−h2(x)=(M−1)(ln⁡P(y=1∣x)−ln⁡P(y=2∣x))(3)\begin{aligned} -\frac{1}{M-1} e^{-\frac{h^1(x)}{M-1}} P(y = 1 | x) &= -\frac{1}{M-1} e^{-\frac{h^2(x)}{M-1}} P(y = 2 | x) & (1)\\ -\frac{h^1(x)}{M-1} + \ln P(y = 1 | x) &= -\frac{h^2(x)}{M-1} + \ln P(y = 2 | x) & (2) \\ h^1(x) - h^2(x) &= (M - 1) (\ln P(y = 1 | x) - \ln P(y = 2 | x)) & (3) \\ \end{aligned}
式4-25

（1）～（3）同理可得
（4）将（1）～（3）式累加起来根据限制条件化简
（5）将最后一项补充完整
（6）得到第一个分量的结果

h1(x)−h2(x)=(M−1)(ln⁡P(y=1∣x)−ln⁡P(y=2∣x))(1)h1(x)−h3(x)=(M−1)(ln⁡P(y=1∣x)−ln⁡P(y=3∣x))(2)⋯h1(x)−hM(x)=(M−1)(ln⁡P(y=1∣x)−ln⁡P(y=M∣x))(3)(M−1)h1(x)−(−h1(x))=(M−1)((M−1)ln⁡P(y=1∣x)−∑m≠1ln⁡P(y=m∣x)))(4)Mh1(x)=(M−1)(Mln⁡P(y=1∣x)−∑m=1Mln⁡P(y=m∣x))(5)h1(x)=(M−1)(ln⁡P(y=1∣x)−1M∑m=1Mln⁡P(y=m∣x))(6)\begin{aligned} h^1(x) - h^2(x) &= (M - 1) (\ln P(y = 1 | x) - \ln P(y = 2 | x)) & (1) \\ h^1(x) - h^3(x) &= (M - 1) (\ln P(y = 1 | x) - \ln P(y = 3 | x)) & (2) \\ & \cdots \\ h^1(x) - h^M(x) &= (M - 1) (\ln P(y = 1 | x) - \ln P(y = M | x)) & (3) \\ (M - 1) h^1(x) - (-h^1(x)) &= (M - 1)((M - 1)\ln P(y = 1 | x) - \sum_{m \ne 1} \ln P(y = m | x))) & (4) \\ Mh^1(x) &= (M - 1)(M\ln P(y = 1 | x) - \sum_{m = 1}^{M} \ln P(y = m | x)) & (5) \\ h^1(x) &= (M - 1)(\ln P(y = 1 | x) - \frac{1}{M} \sum_{m = 1}^{M} \ln P(y = m | x)) & (6) \\ \end{aligned}
式4-26

  同理可得 h(x) 各个分量的结果

hm(x)=(M−1)(ln⁡P(y=m∣x)−1M∑m′=1Mln⁡P(y=m′∣x))\begin{aligned} h^m(x) &= (M - 1)(\ln P(y = m | x) - \frac{1}{M} \sum_{m^{'} = 1}^{M} \ln P(y = m^{'} | x)) \\ \end{aligned}
式4-27

  样本权重的更新如下，将 h(x) 带入更新方法中，可以看到更新方法只保留了前面一项，因为后面一项为每一类的 p(x) 求和，可以认为是一个常数，归一化以后不影响最后的结果。

ωk,iˉ=e−1My^iHk−1(Xi)(1)ωk+1,iˉ=ωk,iˉe−1My^ihk(Xi)(2)=ωk,iˉe−M−1My^iln⁡pk(Xi)(3)\begin{aligned} \bar{\omega_{k,i}} &= e^{-\frac{1}{M}\hat{y}_iH_{k-1}(X_i)} & (1) \\ \bar{\omega_{k+1,i}} &= \bar{\omega_{k,i}} e^{-\frac{1}{M}\hat{y}_ih_{k}(X_i)} & (2) \\ &= \bar{\omega_{k,i}} e^{-\frac{M - 1}{M}\hat{y}_i\ln p_k(X_i)} & (3) \\ \end{aligned}
式4-28

  这样就得到了算法步骤中的样本权重的更新公式，更多详细的算法说明也请参考原始论文——Multi-class AdaBoost7

五、代码实现

使用 Python 实现 AdaBoost 算法

import numpy as np
from sklearn.tree import DecisionTreeClassifier

class adaboostc():
    """
    AdaBoost 分类算法
    """

    def __init__(self, n_estimators = 100):
        # AdaBoost弱学习器数量
        self.n_estimators = n_estimators

    def fit(self, X, y):
        """
        AdaBoost 分类算法拟合
        """
        # 初始化样本权重向量
        sample_weights = np.ones(X.shape[0]) / X.shape[0]
        # 估计器数组
        estimators = []
        # 估计器权重数组
        weights = []
        # 遍历估计器
        for i in range(self.n_estimators):
            # 初始化最大深度为1的决策树估计器
            estimator = DecisionTreeClassifier(max_depth = 1)
            # 按照样本权重拟合训练集
            estimator.fit(X, y, sample_weight=sample_weights)
            # 预测训练集
            y_predict = estimator.predict(X)
            # 计算误差率
            e = np.sum(sample_weights[y_predict != y])
            # 当误差率大于等于0.5时跳出循环
            if e >= 0.5:
                self.n_estimators = i
                break
            # 计算估计器权重
            weight = 0.5 * np.log((1 - e) / e)
            # 计算样本权重
            temp_weights = np.multiply(sample_weights, np.exp(- weight * np.multiply(y, y_predict)))
            # 归一化样本权重
            sample_weights = temp_weights / np.sum(temp_weights)
            weights.append(weight)
            estimators.append(estimator)
        self.weights = weights
        self.estimators = estimators

    def predict(self, X):
        """
        AdaBoost 分类算法预测
        """
        y = np.zeros(X.shape[0])
        # 遍历估计器
        for i in range(self.n_estimators):
            estimator = self.estimators[i]
            weight = self.weights[i]
            # 预测结果
            predicts = estimator.predict(X)
            # 按照估计器的权重累加
            y += weight * predicts
        # 根据权重的正负号返回结果
        return np.sign(y)

使用 Python 实现 AdaBoost-SAMME 算法

import numpy as np
from sklearn.tree import DecisionTreeClassifier

class adaboostmc():
    """
    AdaBoost 多分类SAMME算法
    """

    def __init__(self, n_estimators = 100):
        # AdaBoost弱学习器数量
        self.n_estimators = n_estimators

    def fit(self, X, y):
        """
        AdaBoost 多分类SAMME算法拟合
        """
        # 标签分类
        self.classes = np.unique(y)
        # 标签分类数
        self.n_classes = len(self.classes)
        # 初始化样本权重向量
        sample_weights = np.ones(X.shape[0]) / X.shape[0]
        # 估计器数组
        estimators = []
        # 估计器权重数组
        weights = []
        # 遍历估计器
        for i in range(self.n_estimators):
            # 初始化最大深度为1的决策树估计器
            estimator = DecisionTreeClassifier(max_depth = 1)
            # 按照样本权重拟合训练集
            estimator.fit(X, y, sample_weight=sample_weights)
            # 训练集预测结果
            y_predict = estimator.predict(X)
            incorrect = y_predict != y
            # 计算误差率
            e = np.sum(sample_weights[incorrect])
            # 计算估计器权重
            weight = np.log((1 - e) / e) + np.log(self.n_classes - 1)
            # 计算样本权重
            temp_weights = np.multiply(sample_weights, np.exp(weight * incorrect))
            # 归一化样本权重
            sample_weights = temp_weights / np.sum(temp_weights)
            weights.append(weight)
            estimators.append(estimator)
        self.weights = weights
        self.estimators = estimators

    def predict(self, X):
        """
        AdaBoost 多分类SAMME算法预测
        """
        # 加权结果集合
        results = np.zeros((X.shape[0], self.n_classes))
        # 遍历估计器
        for i in range(self.n_estimators):
            estimator = self.estimators[i]
            weight = self.weights[i]
            # 预测结果
            predicts = estimator.predict(X)
            # 遍历标签分类
            for j in range(self.n_classes):
                # 对应标签分类的权重累加
                results[predicts == self.classes[j], j] += weight
        # 取加权最大对应的分类作为最后的结果
        return self.classes.take(np.argmax(results, axis=1), axis=0)

使用 Python 实现 AdaBoost-SAMME.R 算法

import numpy as np
from sklearn.tree import DecisionTreeClassifier

class adaboostmcr():
    """
    AdaBoost 多分类SAMME.R算法
    """

    def __init__(self, n_estimators = 100):
        # AdaBoost弱学习器数量
        self.n_estimators = n_estimators

    def fit(self, X, y):
        """
        AdaBoost 多分类SAMME.R算法拟合
        """
        # 标签分类
        self.classes = np.unique(y)
        # 标签分类数
        self.n_classes = len(self.classes)
        # 初始化样本权重
        sample_weights = np.ones(X.shape[0]) / X.shape[0]
        # 估计器数组
        estimators = []
        # 论文中对 y 的定义
        y_codes = np.array([-1. / (self.n_classes - 1), 1.])
        # 将训练集中的标签值转换成论文中的矩阵形式
        y_coding = y_codes.take(self.classes == y[:, np.newaxis])
        # 遍历估计器
        for i in range(self.n_estimators):
            # 初始化最大深度为1的决策树估计器
            estimator = DecisionTreeClassifier(max_depth = 1)
            # 根据样本权重拟合训练集
            estimator.fit(X, y, sample_weight=sample_weights)
            # 预测训练集标签值的概率
            y_predict_proba = estimator.predict_proba(X)
            # 处理概率为0的结果，避免取对数是结果为负无穷大的问题
            np.clip(y_predict_proba, np.finfo(y_predict_proba.dtype).eps, None, out=y_predict_proba)
            # 计算样本权重
            temp_weights = sample_weights * np.exp(- ((self.n_classes - 1) / self.n_classes) * np.sum(np.multiply(y_coding, np.log(y_predict_proba)), axis=1))
            # 归一化样本权重
            sample_weights = temp_weights / np.sum(temp_weights)
            estimators.append(estimator)
        self.estimators = estimators

    def predict(self, X):
        """
        AdaBoost 多分类SAMME.R算法预测
        """
        # 结果集合
        results = np.zeros((X.shape[0], self.n_classes))
        # 遍历估计器
        for i in range(self.n_estimators):
            estimator = self.estimators[i]
            # 预测标签值的概率
            y_predict_proba = estimator.predict_proba(X)
            # 同样需要处理零概率的问题
            np.clip(y_predict_proba, np.finfo(y_predict_proba.dtype).eps, None, out=y_predict_proba)
            # 对概率取对数
            y_predict_proba_log = np.log(y_predict_proba)
            # 计算 h(x)
            h = (self.n_classes - 1) * (y_predict_proba_log - (1 / self.n_classes) * np.sum(y_predict_proba_log, axis=1)[:, np.newaxis])
            # 累加
            results += h
        # 取累加最大对应的分类作为最后的结果
        return self.classes.take(np.argmax(results, axis=1), axis=0)

使用 Python 实现 AdaBoost.R2 算法

import numpy as np
from sklearn.tree import DecisionTreeRegressor

class adaboostr():
    """
    AdaBoost 回归算法
    """

    def __init__(self, n_estimators = 100):
        # AdaBoost弱学习器数量
        self.n_estimators = n_estimators

    def fit(self, X, y):
        """
        AdaBoost 回归算法拟合
        """
        # 初始化样本权重向量
        sample_weights = np.ones(X.shape[0]) / X.shape[0]
        # 估计器数组
        estimators = []
        # 估计器权重数组
        weights = []
        # 遍历估计器
        for i in range(self.n_estimators):
            # 初始化最大深度为3的决策树估计器
            estimator = DecisionTreeRegressor(max_depth = 3)
            # 根据样本权重拟合训练集
            estimator.fit(X, y, sample_weight=sample_weights)
            # 预测结果
            y_predict = estimator.predict(X)
            # 计算误差向量（线性误差）
            errors = np.abs(y_predict - y)
            errors = errors / np.max(errors)
            # 计算误差率
            e = np.sum(np.multiply(errors, sample_weights))
            # 当误差率大于等于0.5时跳出循环
            if e >= 0.5:
                self.n_estimators = i
                break
            # 计算估计器权重
            weight = e / (1 - e)
            # 计算样本权重
            temp_weights = np.multiply(sample_weights, np.power(weight, 1 - errors))
            # 归一化样本权重
            sample_weights = temp_weights / np.sum(temp_weights)
            weights.append(weight)
            estimators.append(estimator)
        self.weights = np.array(weights)
        self.estimators = np.array(estimators)

    def predict(self, X):
        """
        AdaBoost 回归算法预测
        """
        # 论文中权重的定义
        weights = np.log(1 / self.weights)
        # 预测结果矩阵
        predictions = np.array([self.estimators[i].predict(X) for i in range(self.n_estimators)]).T
        # 根据预测结果排序后的下标
        sorted_idx = np.argsort(predictions, axis=1)
        # 根据排序结果依次累加估计器权重，得到新的累积权重矩阵，类似累积分布函数的定义
        weight_cdf = np.cumsum(weights[sorted_idx], axis=1, dtype=np.float64)
        # 累积权重矩阵中大于其中中位数的结果
        median_or_above = weight_cdf >= 0.5 * weight_cdf[:, -1][:, np.newaxis]
        # 中位数结果对应的下标
        median_idx = median_or_above.argmax(axis=1)
        # 对应的估计器
        median_estimators = sorted_idx[np.arange(X.shape[0]), median_idx]
        # 取对应的估计器的预测结果作为最后的结果
        return predictions[np.arange(X.shape[0]), median_estimators]

六、第三方库实现

scikit-learn3 实现自适应增强分类

from sklearn.ensemble import AdaBoostClassifier

# 自适应增强分类器 SAMME 算法
clf = AdaBoostClassifier(n_estimators = 50, random_state = 0, algorithm = "SAMME")
# 自适应增强分类器 SAMME.R 算法
clf = AdaBoostClassifier(n_estimators = 50, random_state = 0, algorithm = "SAMME.R")
# 拟合数据集
clf = clf.fit(X, y)

scikit-learn4 实现自适应增强回归

from sklearn.ensemble import AdaBoostRegressor

# 自适应增强回归器
clf = AdaBoostRegressor(n_estimators = 50, random_state = 0)
# 拟合数据集
clf = clf.fit(X, y)

七、示例演示

  图 7-1 展示了使用自适应增强算法进行二分类的结果，红色表示标签值为 -1 的样本点，蓝色代表标签值为 1 的样本点。浅红色的区域为预测值为 -1 的部分，浅蓝色的区域则为预测值为 1 的部分

1.png

图7-1

  图 7-2 、图 7-3 分别展示了使用 SAMME 和 SAMME.R 算法进行多分类的结果，红色表示标签值为 0 的样本点，蓝色代表标签值为 1 的样本点，绿色代表标签值为 2 的样本点。浅红色的区域为预测值为 0 的部分，浅蓝色的区域则为预测值为 1 的部分，浅绿色的区域则为预测值为 1 的部分

2.png

图7-2

3.png

图7-3

  图 7-4 展示了使用自适应增强算法进行回归的结果

4.png

图7-4

八、思维导图

5.jpeg

图8-1

九、参考文献

  1. en.wikipedia.org/wiki/Boosti…
  2. en.wikipedia.org/wiki/AdaBoo…
  3. scikit-learn.org/stable/modu…
  4. scikit-learn.org/stable/modu…
  5. www.face-rec.org/algorithms/…
  6. citeseer.ist.psu.edu/viewdoc/dow…
  7. hastie.su.domains/Papers/samm…

完整演示请点击这里

注：本文力求准确并通俗易懂，但由于笔者也是初学者，水平有限，如文中存在错误或遗漏之处，恳请读者通过留言的方式批评指正
本文首发于——AI导图，欢迎关注

avatar
文章
阅读
粉丝
相关推荐
可视化大屏：autofit.js 一行搞定自适应
109k阅读
 · 
2.2k点赞
睡后收入（无人直播）
148k阅读
 · 
2.0k点赞
面试官问我按钮级别权限怎么控制，我说v-if，面试官说再见
255k阅读
 · 
2.7k点赞
2023高频前端面试题合集之Vue（上篇）
200k阅读
 · 
1.3k点赞
迄今为止我写过最复杂的算法
38k阅读
 · 
553点赞
总是跳转到国内版(cn.bing.com)？New Bing使用全攻略
473k阅读
 · 
146点赞
2023前端面试系列-- Vue 篇
106k阅读
 · 
1.5k点赞
为什么我们正在放弃 CSS-in-JS
221k阅读
 · 
193点赞
React CSS-In-JS 方案 : Linaria Vs Styled-Components
212k阅读
 · 
131点赞
数据大屏最简单自适应方案，无需适配rem单位
94k阅读
 · 
1.9k点赞

友情链接：