集成学习-AdaBoost-(分类)

1. 概念

1.1 League of Legends 还是 AdaBoost？

LOL打团的思想是这样的：对面开团时，五个英雄各自有各自的作用，坦克要够肉，ADC要足够猥琐输出……所以，类型越全面，对面越容易团灭。
其实AdaBoost模型和LOL打团是一样一样的。面对数据集，每个基学习器（英雄）都有各自关注的部分，覆盖的越全面，学习效果越好。而且，有一定的先后顺序：先控再输出。。。

1.2 真正的AdaBoost

1.2.1 样本空间

假定给定一个二分类的训练数据集 T = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . , ( x N , y N ) } T=\{(\boldsymbol{x_1}, y_1),(\boldsymbol{x_2}, y_2),...,(\boldsymbol{x_N}, y_N)\} T={(x1​,y1​),(x2​,y2​),...,(xN​,yN​)}，其中${\mathbf{x}}_{\mathbf{i}}$是一个$1\ast d$维的向量，标签 y i ∈ Y = { − 1 , 1 } y_i \in Y=\{-1, 1\} yi​∈Y={−1,1}。

1.2.2 表达式

$$\begin{array}{r}{F}_T(\mathbf{x})=\sum _{t=1}^T{\alpha }_t{f}_t(\mathbf{x})\end{array}\text{\hspace{1em}(1.1)}$$
在公式$(1.1)$中，$f_t(\mathbf{x})$是弱学习器的计算结果，$f_t$是弱学习器模型，$T$是弱学习器的数量。
在每迭代过程中，每次迭代都会选择一个弱学习器，并且给其分配一个权重${\alpha }_t$，这样的话，对于第$i$个样本而言$(i\le N)$，整个AdaBoost模型在第$t$轮时的训练误差$E_t$可以表达为：
$$\begin{array}{r}{E}_t=\sum _{i=1}^{N}E[F_{t-1}({\mathbf{x}}_{\mathbf{i}})+{\alpha }_t{f}_t({\mathbf{x}}_{\mathbf{i}})]\end{array}\text{\hspace{1em}(1.2)}$$
在公式$(1.2)$中$F_{t-1}({\mathbf{x}}_{\mathbf{i}})$是根据之前$t-1$次迭代得到的模型，$f_t({\mathbf{x}}_{\mathbf{i}})$是本轮学习的弱学习器，在学习完成之后会添加到最终模型中。

1.2.3 AdaBoost的损失函数

函数表达式：
$$L(y,f(x))=e^{[-yf(x)]}\text{\hspace{1em}(1.3)}$$

这里多说一句：为什么损失函数是公式(1.3)的样子，而不是我们常见的$L(y,f(x))=\frac{1}{2}(y-f(x){)}^2$?

解答：在AdaBoost算法中，我们所关心的只是每一个弱分类器结果的符号，而真正影响模型最后输出结果的是那些离群值所对应的权重。

1.2.4 AdaBoost 的前生今世

假设经过了$m-1$代之后（$m<T$），对于第$i$个样本而言，公示$(1.1)$可以表示为
$$\begin{array}{rl}{F}_{m-1}({\mathbf{x}}_{\mathbf{i}})=& {\alpha }_1{f}_1({\mathbf{x}}_{\mathbf{i}})+{\alpha }_2{f}_2({\mathbf{x}}_{\mathbf{i}})+...+{\alpha }_{m-1}{f}_{m-1}({\mathbf{x}}_{\mathbf{i}})\end{array}\text{\hspace{1em}(1.4)}$$
根据公式$(1.3)$有
$$\begin{array}{r}{F}_m({\mathbf{x}}_{\mathbf{i}})=F_{m-1}({\mathbf{x}}_{\mathbf{i}})+{\alpha }_m{f}_m({\mathbf{x}}_{\mathbf{i}})\end{array}\text{\hspace{1em}(1.5)}$$
当损失函数为Exponential loss的时候：
$$\begin{array}{rl}E=& \sum _{i=1}^N{e}^{-y_i{F}_m({\mathbf{x}}_{\mathbf{i}})}\\ =& \sum _{i=1}^N{e}^{-y_i(F_{m-1}({\mathbf{x}}_{\mathbf{i}})+{\alpha }_m{f}_m({\mathbf{x}}_{\mathbf{i}}))}\\ =& \sum _{i=1}^N{e}^{-y_i{F}_{m-1}({\mathbf{x}}_{\mathbf{i}})-y_i{\alpha }_m{f}_m({\mathbf{x}}_{\mathbf{i}})}\\ =& \sum _{i=1}^N{e}^{-y_i{F}_{m-1}({\mathbf{x}}_{\mathbf{i}})}{e}^{-y_i{\alpha }_m{f}_m({\mathbf{x}}_{\mathbf{i}})}\end{array}\text{\hspace{1em}(1.6)}$$
公式$(1.6)$中，由于$e^{-y_i{F}_{m-1}({\mathbf{x}}_{\mathbf{i}})}$是一个定值，记为$w_i$。所以，假设$w_i^{(1)}=1$，且当$m>1$时，有$w_i^{(m)}=e^{-y_i{F}_{m-1}({\mathbf{x}}_{\mathbf{i}})}$，则公式$(1.6)$可以记为：
$$\begin{array}{rl}E=& \sum _{i=1}^N{w}_i^{(m)}{e}^{-y_i{\alpha }_m{f}_m({\mathbf{x}}_{\mathbf{i}})}\end{array}\text{\hspace{1em}(1.7)}$$
如果在样本空间中，AdaBoost模型能够正确分类的情况下，有：$y_i{f}_m({\mathbf{x}}_{\mathbf{i}})=1$；当分类错误时：$y_i{f}_m({\mathbf{x}}_{\mathbf{i}})=-1$。因此，公式$(1.7)$可以写为：
$$\begin{array}{rl}E=& \sum _{y_i=f_m({\mathbf{x}}_{\mathbf{i}})}^N{w}_i^{(m)}{e}^{-{\alpha }_m}+\sum _{y_i\ne f_m({\mathbf{x}}_{\mathbf{i}})}^N{w}_i^{(m)}{e}^{{\alpha }_m}\\ =& \sum _{y_i=f_m({\mathbf{x}}_{\mathbf{i}})}^N{w}_i^{(m)}{e}^{-{\alpha }_m}+\sum _{y_i\ne f_m({\mathbf{x}}_{\mathbf{i}})}^N{w}_i^{(m)}{e}^{{\alpha }_m}-\sum _{y_i\ne f_m({\mathbf{x}}_{\mathbf{i}})}^N{w}_i^{(m)}{e}^{-{\alpha }_m}+\sum _{y_i\ne f_m({\mathbf{x}}_{\mathbf{i}})}^N{w}_i^{(m)}{e}^{-{\alpha }_m}\\ & \\ =& \sum _{i=1}^N{w}_i^{(m)}{e}^{-{\alpha }_m}+\sum _{y_i\ne f_m({\mathbf{x}}_{\mathbf{i}})}^N{w}_i^{(m)}{e}^{{\alpha }_m}-\sum _{y_i\ne f_m({\mathbf{x}}_{\mathbf{i}})}^N{w}_i^{(m)}{e}^{-{\alpha }_m}\\ & \\ =& \sum _{i=1}^N{w}_i^{(m)}{e}^{-{\alpha }_m}+\sum _{y_i\ne f_m({\mathbf{x}}_{\mathbf{i}})}^N{w}_i^{(m)}(e^{{\alpha }_m}-e^{-{\alpha }_m})\end{array}\text{\hspace{1em}(1.8)}$$
在公式$(1.8)$中，要使AdaBoost模型分类尽可能的正确，即要找到一个${\alpha }_m$使得${\sum }_{y_i\ne f_m({\mathbf{x}}_{\mathbf{i}})}^N{w}_i^{(m)}$项尽可能的小（假设${\alpha }_m>0$），因此对${\alpha }_m$求导有：
$$\begin{array}{rl}\partial E/\partial {\alpha }_m=& -\sum _{i=1}^N{w}_i^{(m)}{e}^{-{\alpha }_m}+\sum _{y_i\ne f_m({\mathbf{x}}_{\mathbf{i}})}^N{w}_i^{(m)}(e^{{\alpha }_m}+e^{-{\alpha }_m})\end{array}\text{\hspace{1em}(1.9)}$$
令公式$(1.9)$为$0$：
$$\begin{array}{r}0=-\sum _{i=1}^N{w}_i^{(m)}{e}^{-{\alpha }_m}+\sum _{y_i\ne f_m({\mathbf{x}}_{\mathbf{i}})}^N{w}_i^{(m)}(e^{{\alpha }_m}+e^{-{\alpha }_m})\\ e^{-{\alpha }_m}\sum _{y_i=f_m({\mathbf{x}}_{\mathbf{i}})}^N{w}_i^{(m)}=e^{{\alpha }_m}\sum _{y_i\ne f_m({\mathbf{x}}_{\mathbf{i}})}^N{w}_i^{(m)}\end{array}\text{\hspace{1em}(1.10)}$$
由于$e^{-{\alpha }_m}$与$i$无关，公式$(1.10)$左右同时取对数：
$$\begin{gathered} \begin{array}{rl} \\ -{\alpha }_m+In(\sum _{y_i=f_m({\mathbf{x}}_{\mathbf{i}})}^N{w}_i^{(m)})=& {\alpha }_m+In(\sum _{y_i\ne f_m({\mathbf{x}}_{\mathbf{i}})}^N{w}_i^{(m)})\\ 2{\alpha }_m=& In(\sum _{y_i=f_m({\mathbf{x}}_{\mathbf{i}})}^N{w}_i^{(m)})-In(\sum _{y_i\ne f_m({\mathbf{x}}_{\mathbf{i}})}^N{w}_i^{(m)})\\ {\alpha }_m=& \frac{1}{2}In(\frac{{\sum }_{y_i=f_m({\mathbf{x}}_{\mathbf{i}})}^N{w}_i^{(m)}}{{\sum }_{y_i\ne f_m({\mathbf{x}}_{\mathbf{i}})}^N{w}_i^{(m)}})\end{array}\text{\hspace{1em}(1.11)} \end{gathered}$$
又因$m$次之后，错误率${\epsilon }_m$为：
$$\begin{array}{r}{\epsilon }_m=\frac{{\sum }_{y_i\ne f_m({\mathbf{x}}_{\mathbf{i}})}^N{w}_i^{(m)}}{{\sum }_{i=1}^N{w}_i^{(m)}}\end{array}\text{\hspace{1em}(1.12)}$$
所以公式$(1.11)$为
$$\begin{gathered} \begin{array}{rl} \\ {\alpha }_m=& \frac{1}{2}In(\frac{1-{\epsilon }_m}{{\epsilon }_m})\end{array}\text{\hspace{1em}(1.11)} \end{gathered}$$
最终，通过更新$F_{m-1}$为$F_m({\mathbf{x}}_{\mathbf{i}})=F_{m-1}({\mathbf{x}}_{\mathbf{i}})+{\alpha }_m{f}_m({\mathbf{x}}_{\mathbf{i}})$即可提升AdaBoost模型的性能。

1.2.5 基本流程

---

2. AdaBoost的另一种理解

---

3. 提升树(Boosting Tree)

其实提升树并没有那么高大上，就是采用了决策树作为上述AdaBoost模型中的弱学习器，而且严格意义上来说，是决策树桩，下面通过一个栗子来说明，基于分类的提升树是怎么构建出来的。

3.1 数据

假定我们有数据集如图1所示。目标：用boosting tree去预测是否有心脏病（绿色列），三个特征（Chest Pain, Blocked Arteries, Patient Weight）。

1. 给每一个样本同样的权重，表示他们一开始对于分类器是同等重要的。
   $$w=\frac{1}{dat{a}_{s}ize}=\frac{1}{8}$$
2. 计算不同特征值下正确与错误分类的数量，并计算其基尼系数。
   
   由于特征Patient Weight的基尼系数最小，因此，选择该特征所构成的决策树桩作为第一个分类器。

以特征Patient Weight作为决策树桩时，在整个训练集上仅$1$个错误，即${\epsilon }_1=\frac{1}{8}$。根据公式$(1.11)$，可以计算出该分类器的权重为：
$$\begin{gathered} \begin{array}{rl} \\ {\alpha }_1=& \frac{1}{2}In(\frac{1-{\epsilon }_1}{{\epsilon }_1})\\ =& \frac{1}{2}In(\frac{1-\frac{1}{8}}{\frac{1}{8}})\\ =& 0.97\end{array} \end{gathered}$$

3. 通过权重重新调整数据分布。

• 对于错误的样本，增加权重。
  
  $w_3=\frac{1}{8}\ast e^{-0.97\ast (1\ast -1)}=0.33$

• 对于分类正确的样本，减少权重。
  
  $w_0=w_1=w_2=\frac{1}{8}\ast e^{-0.97\ast (1\ast 1)}=0.05$
  $w_4=w_5=w_6=w_7=\frac{1}{8}\ast e^{-0.97\ast (-1\ast -1)}=0.05$

• 正则化权重.
  $w_i=\frac{w_i}{{\sum }_{j=0}^7{w}_j}=\frac{w_i}{0.68}$
  

4. 创建新的数据分布（要与原数据具有同样的shape）
   此时，将图3.5中的数据当成概率分布。随机选择一个$(0,1)$内的数字$n$:

• 若$n_1\in (0,0.07]$，则将第0条数据（Yes, Yes, 205, Yes）添加进新数据集；
• 若$n\in (0.07,0.14]$，则将第2条数据（No, Yes, 180, Yes）添加进新数据集；
• 若$n\in (0.21,0.7]$，则将第2条数据（Yes, Yes, 167, Yes）添加进新数据集；
  … 以此类推

很明显，被第一个分类器分错的数据很入选新数据集的概率极大，可能有多条。假设新数据集是这样的：

跳转步骤1 。直到模型中有指定数量的分类器后结束。

---

4. 代码

源代码

class AdaBoost(object):
    def __init__(self, n_estimator, weaker_learner, column_type):
        '''
        AdaBoost 模型初始化
        :param n_estimator: 选取n_estimator个弱学习器
        '''
        # 弱学习器的数量
        self.n_estimator = n_estimator
        # 每一列数据的类型（连续/离散）
        self.column_type = column_type
        # 初始化每个学习器权重
        self.alpha = [1] * n_estimator
        # 初始弱学习器数组
        self.weaker_learners = []

        # 初始化样本数据集大小以及特征数量
        self.data_size, self.feature_size = 0, 0

        # 特征的索引值
        self.feature_indices = []

        # 初始化弱学习器
        self.weaker_learner = weaker_learner
        # 初始化训练集的权值分布
        self.w = None

    def __initArgs__(self, _X, _Y):
        '''
        相关参数初始化
        :param _X: 训练集特征值
        :param _Y: 训练集标签值
        :return:
        '''
        self.train_x = _X
        self.train_y = _Y
        self.data_size, self.feature_size = _X.shape
        self.feature_indices = [_ for _ in range(self.feature_size)]

    def getErrorRate(self, true_y, fake_y):
        '''
        计算第ith_estimator个弱学习器的误差
        :param fake_y: 弱学习器的编号
        :return: 弱学习器的错误率
        '''
        aggErrors = np.multiply(np.mat(true_y) != np.mat(fake_y), np.ones(fake_y.shape))
        return aggErrors.sum() / true_y.shape[0]

    def getAlpha(self, error_rate):
        '''
        计算第ith_estimator个弱学习器的权重
        :param error_rate: 错误率
        :return: 弱学习器对应的权重
        '''

        return 0.5 * np.log((1-error_rate)/error_rate)

    def fit(self, _X, _Y):
        '''
        AdaBoost 模型训练
        :param _X: 特征值
        :param _Y: 标签值
        :return:
        '''
        self.__initArgs__(_X, _Y)
        for ith_estimator in range(self.n_estimator):
            print('%d\'s estimator:' % ith_estimator)

            # 初始化分布
            self.w = 1 / self.data_size * np.ones((self.data_size, 1))

            # 新建一个弱学习器
            # 寻找最优的划分节点
            weaker_learner = self.weaker_learner(ith_estimator, self.column_type)

            weaker_learner.fit(_X, _Y)

            weaker_learner_result = weaker_learner.predict(_X)

            self.weaker_learners.append((weaker_learner.__root__.feature_index, weaker_learner))

            # 计算错误率
            error_rate = self.getErrorRate(self.train_y, weaker_learner_result)
            print('error_rate:', error_rate)

            # 计算该弱学习器的权重
            ith_alpha = self.getAlpha(error_rate)
            print('alpha:', ith_alpha)
            self.alpha[ith_estimator] = ith_alpha

            print(self.train_y)
            print(weaker_learner_result)

            # 更新w
            w_tmp = - ith_alpha * np.multiply(self.train_y, weaker_learner_result)
            self.w = np.multiply(self.w, np.exp(w_tmp))
            print('update weights:', self.w)
            # 规范化w
            self.w /= self.w.sum()
            print('normal weights:', self.w)

            # 如果错误率比随机猜还差，那就停止
            if error_rate > 0.5:
                break
            else:
                _X, _Y = self.resampleData()
                print('resample data')
                print(_X)
                print(_Y)

        print('train done')

    def resampleData(self):
        '''
        数据重采样，先计算每个样本需要被抽取的次数，
        然后列索引按照抽取次数从大到小排序（注意是列）
        :return:
        '''
        # 确定每个样本需要抽取的次数

        nums = list(np.multiply(self.w.T[0], self.data_size))

        # 将权重的索引按 权重的大小排序（从大到小）
        idx = list(np.argsort(self.w.T[0]))
        idx.reverse()


        new_index = []
        for id in idx:
            num_arr = (int(nums[id]) + 1) * [id]
            new_index.extend(num_arr)
            if len(new_index) == self.data_size:
                break
        return self.train_x[new_index], self.train_y[new_index]

    def predict(self, X):
        '''
        预测
        :param x: 1*d 维的特征值
        :return: 预测结果
        '''
        print('predict')
        result = []
        for x in X:
            res = 0
            for index, weaker_learner in enumerate(self.weaker_learners):
                res += self.alpha[index] * weaker_learner[1].predict(
                    np.array([x])
                )
            result.append(1 if res > 0 else -1)
        return np.array([result]).T

---

5. 小结

机器学习中最大的问题在于要面临数据集中维度灾难的问题，一般来说，减少了特征数量之后，虽然计算速度有所提升，但是鬼知道你去掉特征之后模型拟合优度有没有下降。AdaBoost模型不同于SVM和神经网络这两大算法，在AdaBoost模型中，你只要选择你认为有用的特征就好了，只要够小弟（基学习器）够多，啥样的模型都能画出来（当然这种过拟合的模型不要也罢）。

PS：用惯了pandas的行列索引之后，再使用Numpy简直就是个坑。

---

6. 参考文献

• 维基百科比大多数博主讲的要好！
• 一文读懂机器学习常用损失函数(Loss Function)
• 西瓜书
• 统计学习方法