【机器学习算法】集成学习之Stacking，Bagging，AdaBoost

1.模型融合（aggregation models）

  假如我们有多个模型，要怎么灵活运用将这些模型的结果呢？可以使用模型融合（aggregation models） 的方式，将n个模型的输出进一步融合成为一个输出，得到我们想要的结果，那么怎么融合多个模型呢？常见的方法有以下几种：

1.1 uniform blending

  核心思想：少数服从多数，民主投票
  如果知道n个模型的输出，每个模型有一票，则最终的输出：
$$H(x)=sign(\sum _{t=1}^T{h}_t(x))$$
  如果是多分类，则最终输出得票数最多的分类即可。
  如果是预测数值型输出，则最终的输出：
$$H(x)=\frac{1}{T}\sum _{t=1}^T{h}_t(x)$$
  可以证明融合之后的模型要比原先的效果好（更稳定）：
$$\begin{array}{rl}avg((h_t(x)-f(x){)}^2)& =avg(h_t^2-2h_{t}f+f^2)\\ & =avg(h_t^2)-2Hf+f^2\\ & =avg(h_t^2)-H^2+(H-f{)}^2\\ & =avg(h_t^2)-2H^2+H^2+(H-f{)}^2\\ & =avg(h_t^2-2h_{t}H+H^2)+(H-f{)}^2\\ & =avg((h_t-H{)}^2)+(H-f{)}^2\end{array}$$
  其中，$avg((h_t(x)-f(x){)}^2)$代表原始模型的均方误差，$(H-f{)}^2$表示融合模型的军方误差，它们之间相差了一个$avg((h_t-H{)}^2)$，因此有
$$avg((h_t(x)-f(x){)}^2)\ge (H-f{)}^2$$
  对于uniform blending，每个模型的输出要有所不同，这样融合之后的效果才有可能比单一的模型效果要好，否则平均下来得到的还是一样的结果。

1.2 Linear Bleading

  核心思想 ：让每个模型投票，但是给不同模型不同的票数，即给予它们不同的权重。最终的输出为：
$$H(x)=sign(\sum _{t=1}^T{\alpha }_t\cdot h_t(x))$$
此时要求解的目标为：
$$\underset{a_t\ge 0}{\min }\frac{1}{N}{\left(y_n-\sum _{t=1}^T{a}_t{h}_t(x_n)\right)}^2$$

1.3 Stacking (condition blending)

  核心思想 ：让每个模型投票，但是在不同的条件下给不同模型不同的的权重,采用非线性的方式将模型的输出融合。这种方式比较强大，有过拟合的风险。

  stacking是一种分层模型集成框架。以两层为例，第一层由多个基学习器组成，其输入为原始训练集，第二层的模型则是以第一层基学习器的输出作为训练集进行再训练，从而得到完整的stacking模型。
  通常使用K-fold来实现Stacking，假设我们使用5折交叉验证，有10000行训练集，2500行验证集，对于一个模型来说，5次交叉验证会将10000个训练集分成5份，每份2000个数据，每次以其中一份作为测试集，这样10000个数据都会被测试一次，最终我们可以得到$10000\times 1$的矩阵$A_1$，同时每次交叉验证的时候都会对验证集进行预测，每次都可以得到一个$2500\times 1$的矩阵，共得到5个。对于同一个样本的预测，我们使用平均的方式，最终5个矩阵合并为1个$2500\times 1$的矩阵$B_1$。由于我们是在融合多个模型，自然不止一个模型。假如我们还有模型$Mode{l}_2，Mode{l}_3，...，Mode{l}_n$，对于每一个模型重复上述步骤，我们可以得到$A_2,B_2,A_3,B_3,...A_n,B_n$。将所有的A，B矩阵按列合并起来，得到$A_{total},B_{total}$。以上步骤是Stacking第一层所完成的事情。
  将得到的$A_{total}$作为第二层的训练集，$B_{total}$作为第二层的测试集，使用Liner Regression来总结所有模型的效果，得到最终的预测效果。

2. Bagging

  如果说，我们一开始并没有很多个模型，也就无法运用上面的技巧了。因此我们需要通过学习的方式来得到多个模型，一边决定怎么把它们合起来。其中，Bagging是一种通过Bootstraping学习得到多个模型并利用uniform blending来融合模型的方法。
  Bootstraping：从已有的样本中有放回地随机取n份样本。即同一个样本可能被取到多次。假如有10000个样本，可以迭代三千次，每次都取出一份bootstrap sample，每份bootstrap sample可以看做是新的数据，从而我们得到了3000个模型$h_t$。这是Bagging套袋法中一个重要的步骤。
  Bagging的算法过程如下：

1. 从原始样本集中按照Bootstraping方法抽取n个样本，共进行k次，得到k组训练集。
2. 使用k组训练集得到k个模型。
3. 对于分类问题使用投票的方式得到分类结果，对于回归问题使用均值作为最后的结果。

  如果我们的模型对数据的随机性比较敏感的话，采用BAGging的方式得到的融合模型往往很有效果。

3. AdaBoost(Adaptive Boosting)

  在Bagging的过程中，每次Boostraping取到的样本都是独立随机的。而在模型融合的算法中，我们认为每个基分类器如果越不一样的，则融合得到的效果是最好的。考虑这样一种情况，在当前一轮取到的样本得到的模型$h_{t1}$,如果让他在$h_{t2}$的表现变得和抛硬币的情况一样，那么在$h_{t2}$的样本就会使得$h_{t2}$跟$h_{t1}$的差别变大，也就是说两个分类器会得到很不一样的决策边界。
  而boostraping的过程其实就是在给样本赋予不同权重的过程，比如说，我们取到了3个样本1，,0个样本2,1个样本3，那么他们的权重就分别是3,0,1。要改变下一个模型的表现，其实只要修改它们的权重即可。令$ϵ$表示当前模型下分类错误的比例。则我们的权重优化操作为：

• 将正确分类的样本权重乘上$ϵ$
• 将错误分类的样本权重乘上$1-ϵ$

  或者我们进一步定义放缩因子$t=\sqrt{\frac{1-ϵ}{ϵ}}$，则权重优化操作变为：

• 将正确分类的样本权重除以$t$
• 将错误分类的样本权重乘上$t$

  在通常$ϵ$都要小于$\frac{1}{2}$，否则我们的基学习器就比抛硬币的概率还低了。此时$t\ge 1$，则上面的式子表现为增大错误分类的权重，缩小正确分类的权重。经过上面的修正，当前模型的表现就会变成五五开的情况。
  通常一开始的权重u初始化为$\frac{1}{N}$，即每个样本都取一次。
  那我们最终要怎么确定每个模型$h_t$在最终模型h中占用的权重呢？考虑模型有的可能变现较差，有的表现较好，那么给予不同的权重是一个合理的选择。对于一个表现良好的模型$h_t$，它的缩放因子t会更大，因此可以考虑使用$\ln t$。当t越大时，错误率$ϵ$越低，得到的权重越大，当t=1时，错误率$ϵ$为$\frac{1}{2}$，$\ln t$=0，即这样的模型不予考虑，因为他跟抛硬币没什么区别。
  对于权重更新的式子可以合并为
$$\begin{gathered} u_{m+1,i}=\frac{u_{m,i}}{Z_m}\cdot exp\left(-{\alpha }_m{y}_i{G}_m(x_i)\right),i=1,2...,N \\ {Z}_m=\sum _{i=1}^N{u}_{m,i}\exp (-{\alpha }_m{y}_i{G}_m(x_i)) \end{gathered}$$
  其中$Z_m$为规范化因子。构建基本分类器的线性组合
$$f(x)=\sum _{m=1}^M{\alpha }_m{G}_m(x)$$
  得到最终分类器
$$G(x)=sign(f(x))=sign\left(\sum _{m=1}^M{\alpha }_m{G}_m(x)\right)$$
  最终我们得到Adaptive Boosting的算法流程如下：

1. 初始化权重$u_1=[\frac{1}{N},\frac{1}{N},...,\frac{1}{N}]$
2. 根据当前权重$u$学习基本分类器$G_m(x)$
3. 获得当前错误率${ϵ}_m=P(G_m(x_i)̸=y_i)=\sum _{G_m(x_i)̸=y_i}{w}_{m,i}$
4. 计算当前模型在融合模型中的权重${\alpha }_m=\frac{1}{2}\ln \frac{1-{ϵ}_m}{{ϵ}_m}$
5. 计算缩放因子$t=\sqrt{\frac{1-{ϵ}_m}{{ϵ}_m}}$
6. 更新$u_{m+1,i}=\{\begin{array}{ll}\frac{u_{m,i}}{Z_m}{e}^{-{\alpha }_m}& G_m(x_i)=y_i\\ \frac{u_{m,i}}{Z_m}{e}^{{\alpha }_m}& G_m(x_i)̸=y_i\end{array}$，即将正确分类样本的权重降低，将错误分类样本的权重提高。
7. 重复步骤2-6 M次。
8. 得到最终模型$G(x)$。

4.AdaBoost误差分析

  当$G(x_i)̸=y_i$时，$y_{i}f(x_i)<0$，因而$\exp (-y_{i}f(x_i))\ge 1$。则有$$\frac{1}{N}\sum _{i=1}^{N}I(G(x_i)̸=y_i)\le \frac{1}{N}\sum _i\exp (-y_{i}f(x_i))$$
  又
$$\begin{array}{rl}& \frac{1}{N}\sum _i\exp (-y_{i}f(x_i))\\ & =\frac{1}{N}\sum _i\exp \left(-\sum _{m=1}^M{\alpha }_m{y}_i{G}_m(x_i)\right)\\ & =\sum _i{u}_{1,i}\prod _{m=1}^M\exp (-{\alpha }_m{y}_i{G}_m(x_i))\\ & =Z_1\sum _i{u}_{2,i}\prod _{m=2}^M\exp (-{\alpha }_m{y}_i{G}_m(x_i))\\ & =Z_1{Z}_2\sum _i{u}_{3,i}\prod _{m=3}^M\exp (-{\alpha }_m{y}_i{G}_m(x_i))\\ & =...\\ & =Z_1{Z}_2...Z_{M-1}\sum _i{u}_{M,i}\exp (-{\alpha }_m{y}_i{G}_m(x_i))\\ & =\prod _{m=1}^M{Z}_m\end{array}$$
  因此AdaBoost最终分类器的训练误差界为
$$\frac{1}{N}\sum _{i=1}^{N}I(G(x_i)̸=y_i)\le \frac{1}{N}\sum _i\exp (-y_{i}f(x_i))=\prod _m{Z}_m$$
  结论：每一轮可以选取适当的$G_m$使得$Z_m$最小，从而使得训练误差下降最快。
  在二分类问题里，令${\gamma }_m=\frac{1}{2}-{ϵ}_m$,有
$$\begin{array}{rl}{Z}_m& =\sum _{i=1}^N{u}_{m,i}\exp (-{\alpha }_m{y}_i{G}_m(x_i))\\ & =\sum _{y_i=G_m(x_i)}{u}_{m,i}{e}^{-a_m}+\sum _{y_i̸=G_m(x_i)}{u}_{m,i}{e}^{a_m}\\ & =(1-{ϵ}_m)e^{-a_m}+{ϵ}_m{e}^{a_m}\\ & =2\sqrt{{ϵ}_m(1-{ϵ}_m)}\\ & =\sqrt{1-4{\gamma }_m^2}\end{array}$$
  再由$e^x$和$\sqrt{1-x}$在点x=0处的泰勒展开式推出不等式$\sqrt{(1-4{\gamma }_m^2)}\le \exp (-2{\gamma }_m^2)$，从而有
$$\prod _{m=1}^M\sqrt{(1-4{\gamma }_m^2)}\le \exp (-2\sum _{m=1}^M{\gamma }_m^2)$$
  则二分类的训练误差界为
$$\prod _{m=1}^M{Z}_m=\prod _{m=1}^M\sqrt{1-4{\gamma }_m^2}\le \exp (-2\sum _{m=1}^M{\gamma }_m^2)$$
  如果存在$\gamma >0$，对所有m有${\gamma }_m\ge \gamma$，则
$$\frac{1}{N}\sum _{i=1}^{N}I(G(x_i)̸=y_i)\le \exp (-2M{\gamma }^2)$$
  这表明在此条件下Adaboost的训练误差是以指数速率下降的！

5.AdaBoost与前向分步算法

  其实AdaBoost是当前向分步算法损失函数为指数损失时的特例。 前向分步算法如下：

1. 初始化$f_0(x)=0$
2. 对m=1,2,…,M，极小化损失函数$$({\beta }_m,{\gamma }_m)=\arg \underset{\beta ,\gamma }{\min }\sum _{i=1}^{N}L(y_i,f_{m-1}(x_i)+\beta b(x_i;y))$$得到参数${\beta }_m,{\gamma }_m$。然后更新$$f_m(x)=f_{m-1}(x)+{\beta }_{m}b(x;y_m)$$
3. 得到加法模型$$f(x)=\sum _{m=1}^M{\beta }_{m}b(x;y_m)$$

  前向分步算法将同时求解M个模型的参数${\beta }_m,{\gamma }_m$的优化问题简化为逐次求解各个${\beta }_m,{\gamma }_m$。这与AdaBoost的步骤一致。
  当前向分步算法的损失函数是
$$L(y,f(x))=\exp [-yf(x)]$$
时，等价于AdaBoost算法学习的具体步骤。
  假设经过m-1轮迭代后已经得到$f_{m-1}(x)$，在第m轮时，需要迭代得到$a_m,G_m(x)和f_m(x)$，有
$$f_m(x)=f_{m-1}(x)+a_m{G}_m(x)$$
  目标是让前向分步算法中得到的$a_m$和$G_m(x)$使$f_m(x)$在训练集T上的指数损失最小，即
$$\begin{gathered} (a_m,G_m(x))=\arg \underset{a,G}{\min }\sum _{i=1}^N\exp [-y_i(f_{m-1}(x_i)+aG(x_i))] \\ =\arg \underset{a,G}{\min }\sum _{i=1}^N{\bar{u}}_{m,i}\exp [-y_{i}aG(x_i)]..........(1) \end{gathered}$$
  其中${\bar{u}}_{m,i}=\exp [-y_i{f}_{m-1}(x_i)]$，为当前已知量，与最小化无关。
  使式子1最小的G(x)为
$$G_m^{\ast }(x)=\arg \underset{G}{\min }\sum _{i=1}^N{\bar{u}}_{m,i}I(y_i̸=G(x_i))$$
  此分类器即为AdaBoost算法学习的基本分类器$G_m(x)$，它是使第m轮数据分类误差率最小的分类器。
$$\begin{array}{rl}& \sum _{i=1}^N{\bar{u}}_{m,i}\exp [-y_{i}aG(x_i)]\\ & =\sum _{y_i=G_m(x_i)}{\bar{u}}_{m,i}{e}^{-a}+\sum _{y_i̸=G_m(x_i)}{\bar{u}}_{m,i}{e}^a\\ & =\sum _{y_i=G_m(x_i)}{\bar{u}}_{m,i}{e}^{-a}+\sum _{y_i̸=G_m(x_i)}{\bar{u}}_{m,i}{e}^a+\sum _{y_i̸=G_m(x_i)}{\bar{u}}_{m,i}{e}^{-a}-\sum _{y_i̸=G_m(x_i)}{\bar{u}}_{m,i}{e}^{-a}\\ & =(e^a-e^{-a})\sum _{i=1}^N{\bar{u}}_{m,i}I(y_i̸=G(x_i))+e^{-a}\sum _{i=1}^N{\bar{u}}_{m,i}\end{array}$$
  由于已经求出$G_m(x)$，我们将其带入，对a求导并使其导数为0，得到
$$a_m^{\ast }=\frac{1}{2}\log \frac{1-{ϵ}_m}{{ϵ}_m}$$
  其中
$${ϵ}_m=\frac{{\sum }_{i=1}^N{\bar{u}}_{m,i}I(y_i̸=G_m(x_i))}{{\sum }_{i=1}^N{\bar{u}}_{m,i}}$$
  跟AdaBoost中的$a_m$完全一致。
  而权重的更新由 $f_m=f_{m-1}+a_m{G}_m(x)$以及${\bar{u}}_{m,i}=\exp [-y_i{f}_{m-1}(x_i)]$得
$${\bar{u}}_{m+1,i}={\bar{u}}_{m,i}\exp [-y_i{a}_m{G}_m(x)]$$
  添上规范化因子$Z_m$就与AdaBoost中的权值更新公式等价。