引言

这是统计学习方法的读书笔记。主要讲了提升方法，这是一种常用的机器学习方法。在分类问题中，它通过改变训练样本的权重，学习多个分类器，并将这些分类器进行线性组合，可以提高分类的性能。

上周看了这一章，再不记录下来自己都要忘记了

首先介绍代表性的提升方法AdaBoost。

AdaBoost方法

提升方法的基本思路

提升方法基于这样一种思想：对于一个复杂任务来说，将多个专家的判断进行适当的综合所得出的判断，要比其中任何一个专家单独的判断好。

在概率近似正确学习的框架中，一个概念(一个类)，如果存在一个多项式的学习算法能够学习它，并且正确率很高，那么就称这个概念是强可学习的；如果学习的正确率只比随机猜测略好，那么就称这个概念是弱可学习的。后来证明强可学习与弱可学习是等价的。

这样一来，在机器学习中，如果已经发现了弱可学习算法，那么能否将它提升(boost)为强可学习算法。因为发现弱可学习算法要容易的多。

大多数的提升方法都是改变训练数据的概率分布(训练数据的权值分布)，针对不同的训练数据分布调用弱可学习算法学习一系列弱分类器，最终将这些弱分类器组合成一个强分类器。

AdaBoost算法

假设给定一个二分类的训练数据集
$T = \{(x_1,y_1),(x_2,y_2),\cdots,(x_N,y_N)\}$

其中，每个样本点由实例与标记组成。实例 $x_i \in X \subseteq R^n$ ，标记 $y_i \in Y = \{-1,+1\}$ 。

这里要注意的是 $Y$ 的取值不是 $\{1,0\}$ ，而是 $\{-1,+1\}$ 。

AdaBoost

输入：训练数据集 $T$ ;弱可学习算法；
输出：最终分类器 $G(x)$

初始化训练数据的权值分布(初始为同样的均值)
$D_1 = (w_{11},\cdots,w_{1i},\cdots,w_{1N}), w_{1i} = \frac{1}{N},i = 1,2,\cdots,N$
对于 $m=1,2,\cdots,M$ (对应于 $M$ 个模型)
a. 使用具有权值分布 $D_m$ 的训练数据集学习，得到基本分类器
$G_m(x) : X \rightarrow \{-1,+1\}$
b.计算 $G_m(x)$ 在训练数据集上的分类误差率
$e_m = \sum_{i=1}^N P(G_m(x_i) \neq y_i) = \sum_{i=1}^N w_{mi} I(G_m(x) \neq y_i) \tag{8.1}$

这里的 $I$ 是指示函数，里面的条件成立返回 $1$ ，否则返回 $0$ 。

分类误差率 = 判断结果不等于真实结果的概率，考虑权重的话，也就是计算分类错误的样本权重之和。一般我希望误差率要比随机猜测要好，可以去掉比随机猜测差的模型，或进行一些处理(下面的实例可以看到是如何处理的)，以保证 $e_m \leq 0.5$ 。
c. 计算 $G_m(x)$ 的系数(该模型的权重)
$\alpha_m = \frac{1}{2} log \frac{1 - e_m}{e_m} \tag{8.2}$
因为我们说 $e_m \leq 0.5$ ，所以权重必然是大于等于0的。这一点很重要，我们可以通过它的函数图像来验证

并且 $\alpha_m$ 随着 $e_m$ 的减小而增大，所以分类误差率越小的基本分类器在最终分类器中的作用越大。

d. 更新训练数据的权值分布(增大误分类点的权重)
$D_{m+1} = (w_{m+1,1},\cdots,w_{m+1,i},\cdots,w_{m+1,N}) \tag{8.3}$
$w_{m+1,i} = \frac{w_{mi}}{Z_m}exp(-\alpha_m y_iG_m(x_i)), i = 1,2,\cdots,N \tag{8.4}$
这里 $Z_m$ 是规范化因子
$Z_m = \sum_{i=1}^N w_{mi} exp(-\alpha_m y_iG_m(x_i)) \tag{8.5}$
它使 $D_{m+1}$ 成为一个概率分布。

这段比较长，先看下这个式子 $y_iG_m(x_i)$ ，当预测正确的时候，这个式子的结果是 $+1$ ，同号相乘得正数；预测错误的时候为 $-1$ 。所当预测正确的时候， $exp(-\alpha_m y_iG_m(x_i))$ 的结果就是 $exp(-\alpha_m)$ ；当预测错误的时候结果就是 $exp(\alpha_m)$ 。

$exp(-\alpha_m y_iG_m(x_i))= \left\{ \begin{array}{lr} exp(-\alpha_m) & : y_i = G_m(x_i)\\ exp(\alpha_m) & : y_i \neq G_m(x_i) \end{array} \right.$

上面我们说过 $e_m \leq 0.5$ ，当然 $e_m \geq 0$ 的。这里作为一个概率不能为负的。

在这里插入图片描述
而 $e^x$ 的图像是这样的：

当分类正确时 $exp(-\alpha_m) < 1$ ，根据 $w_{m+1,i} = \frac{w_{mi}}{Z_m}exp(-\alpha_m y_iG_m(x_i))$ ，也就是分类正确的样本权值会比之前的要小，反之，分类错误的样本权值要比之前要大。

那这里除以一个 $Z_m$ 是干嘛的呢？看这个 $Z_m$ 的式子，其实就是所有样本权值之和，让 $w_{mi} exp(-\alpha_m y_iG_m(x_i))$ 除以 $Z_m$ 就可以让

$\sum_{i=1}^N w_{m+1,i} = 1$

使得 $D_{m+1}$ 成为一个概率分布。

在构建好 $M$ 个基本分类器模型后，最终构建基本分类器的线性组合
$f(x) = \sum_{m=1}^M \alpha_m G_m(x) \tag{8.6}$
得到最终分类器
$\begin{aligned} G(x) &= sign(f(x)) \\ & = sign\left(\sum_{m=1}^M \alpha_m G_m(x)\right) \tag{8.7} \end{aligned}$
其中 $sign$ 是符号函数。

每个分类器误差率越小，权重越大。

如果上面的公式没看懂的话没关系，我们来看一个例子。

AdaBoost的例子(代码实现)

给定如表8.1所示训练数据，假设弱分类器由 $x < v$ 或 $x > v$ 产生，其阈值 $v$ 使该分类器在训练数据集上分类误差率最低。用AdaBoost算法学习一个强分类器。

在这里插入图片描述

这里根据书上的过程自己算一遍也很简单，不过要注意的是，当误差率大于 $0.5$ 时，这里直接取反即可。比如在 $x < v$ 的情况下，就是把 $x < v$ 改成 $x > v$ 。

这里把整个过程用代码实现了一遍

# -*- coding: utf-8 -*
import numpy as np
import math
import collections

Classifier = collections.namedtuple('Classifier', ['alpha', 'split', 'sign'])#当前分类器的权重 划分阈值 判断符号 


class AdaBoost:
    def __init__(self, M):
        self.M = M #迭代的次数，也就是训练基本分类器的个数
        self.f = [] # 保持最终的分类器
 
 	# 保持Gm新 sign表示符号 是 x < v 还是 x > 1
    def Gm(self, split, sign=1):
        r = self.x.copy()
        r[r < split] = 1 * sign
        r[r > split] = -1 * sign
        return r

	# 计算alpha
    def cal_alpha(self, error):
        return round(1 / 2 * math.log((1 - error) / error, math.e), 4)

	# 更新权重
    def update_weight(self, split, alpha, sign=1):
        g = self.Gm(split, sign)
        exp_result = np.exp(-1 * alpha * self.y * g)
        Z = np.sum(self.w * exp_result)
        return np.round(self.w * exp_result / Z, 5)

	# 计算错误次数，这里简单的用错误次数来代表错误率
    def cal_error_count(self):
        result = np.zeros((self.size,))
        for alpha, split, sign in self.f:
            result += alpha * self.Gm(split, sign)
        return sum(np.sign(result) != self.y)

	# 选择当前最好的阈值
    def choose_best_split(self):
        best_v, min_error, best_sign = -1, 1, 1
        # 尝试相连两个元素之间的均值作为阈值
        for i in range(1, self.size):
            v = (self.x[i - 1] + self.x[i]) / 2
            sign = 1
            error = sum(self.w[self.Gm(v) != self.y])
            # 如果错误率 > 0.5 ，则翻转符号，这样错误率就可以小于0.5
            if error > 0.5:
                error = 1 - error
                sign = -1

            if error < min_error:
                best_v = v
                min_error = error
                best_sign = sign
        print('best v:%s,best error :%s,error elements:%s' % (
            best_v, min_error, self.x[self.Gm(best_v, best_sign) != self.y]))
        return best_v, min_error, best_sign

    def fit(self, x, y):
        x.sort()
        self.x = x
        self.y = y
        self.size = len(x)
        self.w = np.ones((self.size,)) / self.size

	    # 最多迭代M次
        for m in range(self.M):
        	# 找到当前最好的划分
            split, error, sign = self.choose_best_split() 
            # 计算出alpha
            alpha = self.cal_alpha(error)
            # 更新权重
            self.w = self.update_weight(split, alpha, sign)
            # 保持得到的基本分类器
            self.f.append(Classifier(alpha, split, sign))
            # 计算错误次数
            error_count = self.cal_error_count()
            # 如果没有一个样本分类错误，则停止整个过程
            if error_count == 0:
                break
	# 预测
    def _predict(self, single_x):
        result = 0
        for alpha, split, sign in self.f:
            result += alpha * (sign if single_x < split else -1 * alpha)
        return np.sign(result)

    def predict(self, x_test):
        return np.array([self._predict(r) for r in x_test])

    def __repr__(self):
        lc = ''
        for c in self.f:
            lc = lc + '%.4fGm(x,%s,%d)' % (c.alpha, c.split, c.sign) + '+'
        lc = lc[:-1]
        return 'sign[%s](error count is %d)' % (lc, self.cal_error_count())


if __name__ == '__main__':
   # 进行训练
   x = np.arange(10)
   y = np.array([1,1,1,-1,-1,-1,1,1,1,-1])
   ab = AdaBoost(5)
   ab.fit(x,y)
   # 训练结束，打印信息
   print(ab)
   # 进行测试
   print(ab.predict(np.array([3,1,5]))) # [-1.  1. -1.]

这里只学习了3个模型就可以达到准确率为100%了。

best v:2.5,best error :0.30000000000000004,error elements:[6 7 8] #第一个模型阈值为2.5，分类错误的元素是 6 7 8
best v:8.5,best error :0.21428999999999998,error elements:[3 4 5] #第二个模型阈值为8.5，分类错误的元素是 3 4 5
best v:5.5,best error :0.1818399999999999,error elements:[0 1 2 9]

并且输出了最终分类器：

sign[0.4236Gm(x,2.5,1)+0.6496Gm(x,8.5,1)+0.7520Gm(x,5.5,-1)](error count is 0)

可以根据这个代码结合书上的讲解去理解AdaBoost的思想。

AdaBoost算法的训练误差分析

AdaBoost能在学习过程中不断减少训练误差，即在训练数据集上的分类误差率。
这个误差率可以用下面的公式来计算：
$\frac{1}{N}\sum_{i=1}^N I(G(x_i) \neq y_i)$

这里的 $G(x)$ 为

$G(x) = sign\left(\sum_{m=1}^M \alpha_m G_m(x)\right)$

定理8.1 AdaBoost的训练误差界

$\frac{1}{N}\sum_{i=1}^N I(G(x_i) \neq y_i) \leq \frac{1}{N}\sum_i exp(-y_if(x_i)) = \prod_m Z_m \tag{8.9}$

我们先看 $\frac{1}{N}\sum_{i=1}^N I(G(x_i) \neq y_i) \leq \frac{1}{N}\sum_i exp(-y_if(x_i))$

这里的 $I$ 是指示函数，里面的条件成立返回 $1$ ，否则返回 $0$ 。

首先对于正确分类的点来说(指示函数里面的条件不成立)， $I(G(x_i) \neq y_i) = 0 \leq exp(-y_if(x_i)) = e^{-1}$
对于错误分类的点来说(指示函数里面的条件成立)， $I(G(x_i) \neq y_i) 1 \leq exp(-y_if(x_i)) = e^1$

所以式 $(8.9)$ 第一个不等号是很好推的，接下来推右边的等式。

$Z_m$ 在 $(8.4)$ 和 $(8.5)$ 中出现。

在这里插入图片描述
先对 $(8.4)$ 进行一个变形，把分母上的 $Z_m$ 乘到左边去：

$Z_m \cdot w_{m+1,i} = w_{mi} exp(-\alpha_m y_iG_m(x_i))$
这里说的是样本下一轮的权重和本轮的权重之间的关系。
因为这里有个 $w_{m+1,1}$ ，我们可以想到

$Z_1\cdot w_{2,i} = w_{1,i} exp(-\alpha_1 y_iG_1(x_i)) \\ Z_2\cdot w_{3,i} = w_{2,i} exp(-\alpha_2 y_iG_2(x_i)) \\ \vdots \\ Z_{M-1}\cdot w_{M,i} = w_{M-1,i} exp(-\alpha_{M-1} y_iG_{M-1}(x_i)) \\$

如果把上面这很多个式子中，等式左边相乘，等式右边也相乘的话，可以约掉相同项，得：

$Z_1\cdot \bcancel{w_{2,i}} = w_{1,i} exp(-\alpha_1 y_iG_1(x_i)) \\ Z_2\cdot \bcancel{w_{3,i}} = \bcancel{w_{2,i}} exp(-\alpha_2 y_iG_2(x_i)) \\ \vdots \\ Z_{M-1}\cdot w_{M,i} = \bcancel{w_{M-1,i}} exp(-\alpha_{M-1} y_iG_{M-1}(x_i)) \\$

整理一下得(右边利用了 $e^a \cdot e^b = e^{a+b}$ )

$\prod_m^{M-1} Z_m \cdot W_{M,i} = w_{1,i} exp (-y_i \sum_{m=1}^{M-1} \alpha_mG_m(x_i))$

观察上式和 $(8.9)$ 式的区别可知上式中，左边少了个 $Z_M$ ，多了个 $W_{M,i}$ ；右边指数函数中少加了个 $\alpha_MG_M(x_i))$

在这里插入图片描述
我们让左右两边同时乘以 $exp(-y_i\alpha_MG_M(x_i))$ ,
$\prod_m^{M-1} Z_m \cdot W_{M,i} \cdot exp(-y_i\alpha_MG_M(x_i))= \frac{1}{N}exp (-y_i \sum_{m=1}^{M-1} \alpha_mG_m(x_i)) \cdot exp(-y_i\alpha_MG_M(x_i))$

因为 $w_{1,i}$ 是首轮的权值，为 $\frac{1}{N}$ ，把上式左边整理一下得：

$\prod_m^{M-1} Z_m \cdot W_{M,i} \cdot exp(-y_i\alpha_MG_M(x_i))= \frac{1}{N}exp (-y_i \sum_{m=1}^{M} \alpha_mG_m(x_i))$

上面得到的式子是针对单个样本点 $i$ 的，而 $(8.9)$ 是针对所有样本点的，所以两边都对所有样本点求和得：
$\prod_m^{M-1} Z_m \cdot \sum_{i=1}^N W_{M,i} \cdot exp(-y_i\alpha_MG_M(x_i))= \frac{1}{N} \sum_{i=1}^N\left(exp (-y_i \sum_{m=1}^{M} \alpha_mG_m(x_i))\right)$
根据公式 $(8.5)$ 和公式 $(8.6)$ ，得

$\prod_m^{M} Z_m = \frac{1}{N} \sum_{i=1}^N exp (-y_i f(x_i))$

证明完毕。

这个定理告诉我们，训练误差可以表示为 $Z_m$ 的连乘。我们要让训练误差比较小的话，只要最小化每个 $Z_m$ 就可以了。

$Z_m = \sum_{i=1}^N w_{mi} exp(-\alpha_m y_iG_m(x_i))$

再来看下 $Z_m$ 的式子，我们再每个循环里面， $w_{mi}$ 是上一轮循环里面得到的， $G_m$ 是本轮训练得到的。未知的是 $\alpha_m$ ，我们就可以通过最小化 $Z_m$ 来求 $\alpha_m$ 。

令 $\frac{\partial Z_m}{\partial \alpha_m} = 0$ ,这样可以求得最小的 $\alpha_m$ 为下式：
$\alpha_m = \frac{1}{2} log \frac{1 - e_m}{e_m}$

这也是书上为我们提供的计算方法。

定义8.2 二分类问题AdaBoost的训练误差界

$\begin{aligned} \prod_{m=1}^M Z_m &= \prod_{m=1}^M [2\sqrt{e_m(1-e_m)}]\\ & = \prod_{m=1}^M \sqrt{1 - 4\gamma^2_m} \\ &\leq exp \left(-2 \sum_{m=1}^M \gamma^2_m\right) \tag{8.10} \end{aligned}$

这里 $\gamma = \frac{1}{2} - e_m$

在这里插入图片描述

证明，由式 $(8.5)$ 和 $(8.8)$ 得

$\begin{aligned} Z_m &= \sum_{i=1}^N w_{mi} exp(-\alpha_m y_i G_m(x_i)) \\ &= \sum_{y_i=G_m(x_i)} w_{mi} e^{-\alpha_m} +\sum_{y_i\neq G_m(x_i)} w_{mi} e^{\alpha_m} \end{aligned}$
这一步就是根据 $y_i G_m(x_i)$ 在判断正确的情况下为 $+1$ ，错误的情况下为 $-1$ 得到的。

$\begin{aligned} Z_m &= \sum_{i=1}^N w_{mi} exp(-\alpha_m y_i G_m(x_i)) \\ &= \sum_{y_i=G_m(x_i)} w_{mi} e^{-\alpha_m} +\sum_{y_i\neq G_m(x_i)} w_{mi} e^{\alpha_m} \\ &= (1 - e_m) e^{-\alpha_m} + e_m e^{\alpha_m} \end{aligned}$
这一步是当 $y_i=G_m(x_i)$ 时，对判断结果求乘以一个 $-1$ 。

$\begin{aligned} Z_m &= \sum_{i=1}^N w_{mi} exp(-\alpha_m y_i G_m(x_i)) \\ &= \sum_{y_i=G_m(x_i)} w_{mi} e^{-\alpha_m} +\sum_{y_i\neq G_m(x_i)} w_{mi} e^{\alpha_m} \\ &= (1 - e_m) e^{-\alpha_m} + e_m e^{\alpha_m} \\ &= 2\sqrt{e_m(1-e_m)} \\ &= \sqrt{1 - 4\gamma_m^2} \end{aligned}$

那么不等式
$\prod_{m=1}^M \sqrt{1 - 4\gamma_m^2} \leq exp\left(-2\sum_{m=1}^M \gamma_m^2\right)$
是怎么证明的呢，书上给出了提示，用泰勒展开式。

我们先去掉连乘符号。

右边有
$exp\left(-2\sum_{m=1}^M \gamma_m^2\right) = \prod_{m=1}^M exp(-2 \gamma_m^2)$

也就是只要证明 $\sqrt{1 - 4\gamma^2} \leq exp(-2\gamma^2)$

关于泰勒公式，可以参阅人工智能数学基础之高等数学

下面用泰勒展开来证明，利用点 $x=0$ 的泰勒展开式，
首先看 $\sqrt{1 - 4\gamma^2}$ 的泰勒展开，可以令 $4\gamma^2 =x$ ，也就是 $f(x) = \sqrt{1 - x} = (1-x)^{\frac{1}{2}}$ 。我们要求泰勒展开，就是要求 $f(x)$ 的导数，这里只要求前两阶导数就够了。

$f(x) = (1-x)^{\frac{1}{2}} \\ f^\prime(x) = - \frac{1}{2} (1-x) ^{-\frac{1}{2}} \\ f^{\prime\prime}(x) = - \frac{1}{4} (1-x) ^{-\frac{3}{2}} \\$

那么

$\begin{aligned} f(x) &= f(0) + xf^\prime(0) + \frac{1}{2}x^2f^{\prime\prime}(0) + \cdots \\ &\approx 1 - \frac{1}{2}x - \frac{1}{8}x^2 \end{aligned}$

把 $4\gamma^2$ 代入上式中 $x$ 得

$f(4\gamma^2) \approx 1 - 2\gamma^2 - 2\gamma^4$

接下来来看 $exp(-2 \gamma^2)$ ，令 $-2\gamma^2 =x$ ，得 $g(x) = e^x$

$g(x) = e^x\\ g^\prime(x) = e^x\\ g^{\prime\prime}(x) =e^x\\$

那么

$\begin{aligned} g(x) &=g(0) + xg^\prime(0) + \frac{1}{2}x^2g^{\prime\prime}(0) + \cdots \\ &\approx 1 + \frac{1}{2}x + \frac{1}{2}x^2 \end{aligned}$

$g(-2\gamma^2) \approx 1 - 2 \gamma^2 + 2 \gamma^4$

这里 $\gamma = \frac{1}{2} - e_m$ ，因此 $\gamma$ 的取值范围是 $[0,\frac{1}{2}]$ ，因为 $e_m \leq \frac{1}{2}$

所以当更高阶出现的时候，后面的高阶项约等于0了。

所以只要判断 $f(4\gamma^2) \approx 1 - 2\gamma^2 - 2\gamma^4$
和 $g(-2\gamma^2) \approx 1 - 2 \gamma^2 + 2 \gamma^4$ 的大小即可。

显然 $1 - 2\gamma^2 - 2\gamma^4 \leq 1 - 2 \gamma^2 + 2 \gamma^4$ ，当 $e_m = \frac{1}{2}$ 时， $\gamma=0$ ，不等式两边相等。

证明完毕。

$\prod_{m=1}^M Z_m \leq exp \left(-2 \sum_{m=1}^M \gamma^2_m\right)$

这个式子有什么意义了呢，因为 $\gamma$ 的取值范围是 $[0,\frac{1}{2}]$ ，说明训练误差会随着训练论轮数的增加而减少；同时训练误差是以指数速率下降的。

AdaBoost算法的解释

AdabBoost算法还有另一个解释，即可以认为AdaBoost算法是模型为加法模型、损失函数为指数函数、学习算法为前向分布算法时的二分类学习方法。

前向分步算法

考虑加法模型(additive model)
$f(x) = \sum_{m=1}^M \beta_mb(x;\gamma_m) \tag{8.13}$

其中， $b(x;\gamma_m)$ 为基函数， $\gamma_m$ 为基函数的参数。显然式 $(8.6)$ 是一个加法模型。

前向分布算分的步骤如下：

初始化 $f_0(x)=0$
对 $m=1,2,\cdots,M$
1. 极小化损失函数
  $(\beta_m,\gamma_m) = \arg\,\min_{\beta,\gamma}\sum_{i=1}^N L(y_i,f_{m-1}(x_i) + \beta b(x_i;\gamma)) \tag{8.16}$
  得到参数 $\beta_m,\gamma_m$
2. 更新
  $f_m(x) = f_{m-1}(x) + \beta_mb(x;\gamma_m) \tag{8.17}$
得到加法模型
$f(x) = f_M(x) = \sum_{m-1}^M\beta_mb(x;\gamma_m) \tag{8.18}$