datawhale 10月学习——树模型与集成学习：AdaBoost

前情回顾

1. 决策树
2. CART树的实现
3. 集成模式
4. 两种并行集成的树模型

结论速递

本次学习了解了AdaBoost的常见方法：用于分类的SAMME和用于回归的Adaboost.R2，学习内容比较硬核，根据李航《统计学习方法》进行了一定的重新整理。

1 AdaBoost

1.1 概述

对提升方法来说，有两个问题需要回答：一是在每一轮如何改变训练数据的权值或概率分布；二是如何将弱分类器组合成一个强分类器。

关于第一个问题，AdaBoost的做法是，提高那些被前一轮弱分类器错误分类样本的全职，而降低那些被正确分类样本的权值；
对于第二个问题，采取加权多数表决的方法，具体地，加大分类误差率小的弱分类器的权值，使其在表决中起较大的作用，减小分类误差率大的弱分类器的权值，使其在表决中其较小的作用。

1.2 分类损失

AdaBoost所用的分类损失函数如下

对于$K$分类问题而言，当样本标签$\mathbf{y}=[y_1,...,y_K{]}^T$的类别$S(\mathbf{y})$为第$k$类（$k=1,...,K$）时，标签$\mathbf{y}$的第$i$个（$i=1,...,K$）元素$y_i$满足
$$y_i=\{\begin{array}{rlr}& 1,& \mathrm{i}\mathrm{f}i=k\\ & -\frac{1}{K-1},& \mathrm{i}\mathrm{f}i\ne k\end{array}$$
设模型的输出结果为$\mathbf{f}=[f_1,...,f_K{]}^T$，则记损失函数为
$$L(\mathbf{y},\mathbf{f})=\exp (-\frac{{\mathbf{y}}^T\mathbf{f}}{K})$$

【思考题】假设有一个3分类问题，标签类别为第2类，模型输出的类别标签为[-0.1,-0.3,0.4]，请计算对应的指数损失。
首先可以写出标签$\mathbf{y}=[-\frac{1}{2},1,-\frac{1}{2}]$，则损失函数为
$$\begin{array}{rl}L(\mathbf{y},\mathbf{f})& =\exp (-\frac{{\mathbf{y}}^T\mathbf{f}}{K})\\ & =\exp (-\frac{[-\frac{1}{2},1,-\frac{1}{2}{]}^T\times [-0.1,-0.3,0.4]}{3})\\ & =1.162\end{array}$$

2 SAMME

2.1 二分类AdaBoost

假定一个二分类的训练数据集
T = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . , ( x N , y N ) } T = \{ (x_1,y_1), (x_2,y_2), ... ,(x_N,y_N)\} T={(x1​,y1​),(x2​,y2​),...,(xN​,yN​)}
其中 y i ∈ { − 1 , + 1 } y_i \in \{ -1,+1\} yi​∈{−1,+1}

则流程如下

1. 初始化训练数据的权值分布
   $$D_1=(w_{11},...,w_{1i},...,w_{1N}),w_{1i}=\frac{1}{N},i=1,2,...,N$$
2. 对$m=1,2,...,M$
   1. 使用具有权值分布$D_m$的训练数据集学习，得到基本分类器
      G m ( x ) : → { − 1 , + 1 } G_m(x): \rightarrow \{ -1,+1\} Gm​(x):→{−1,+1}
   2. 计算$G_m(x)$在训练数据集上的分类误差率
      $$e_m=P(G_m(x_i)\ne y_i)=\sum _{i=1}^N{w}_{mi}I(G_m(x_i)\ne y_i)$$
   3. 计算$G_m(x)$的系数
      $${\alpha }_m=\frac{1}{2}\log \frac{1-e_m}{e_m}$$
      这里的对数是自然对数
   4. 更新训练数据集的权值分布
      $$D_{m+1}=(w_{m+1,1},...,w_{m+1,i},...,w_{m+1,N})$$
      $$w_{m+1,i}=\frac{w_{mi}}{Z_m}\exp (-{\alpha }_m{y}_i{G}_m(x_i)),i=1,2,...,N$$
      这里，$Z_m$是规范化因子
      $$Z_m=\sum _{i=1}^N{w}_{mi}\exp (-{\alpha }_m{y}_i{G}_m(x_i))$$
      它使$D_{m+1}$成为一个 概率分布
3. 构建基本分类器的线性组合
   $$f(x)=\sum _{m=1}^M{\alpha }_m{G}_m(x)$$
   得到最终分类器
   $$G(x)=sign(f(x))=sign(\sum _{m=1}^M{\alpha }_m{G}_m(x))$$

2.2 SAMME

SAMME算法的全称是$\text{S}\mathrm{t}\mathrm{a}\mathrm{g}\mathrm{e}\mathrm{w}\mathrm{i}\mathrm{s}\mathrm{e}\text{A}\mathrm{d}\mathrm{d}\mathrm{i}\mathrm{t}\mathrm{i}\mathrm{v}\mathrm{e}\text{M}\mathrm{o}\mathrm{d}\mathrm{e}\mathrm{l}\mathrm{i}\mathrm{n}\mathrm{g}\mathrm{u}\mathrm{s}\mathrm{i}\mathrm{n}\mathrm{g}\mathrm{a}\text{M}\mathrm{u}\mathrm{l}\mathrm{t}\mathrm{i}\mathrm{c}\mathrm{l}\mathrm{a}\mathrm{s}\mathrm{s}\text{E}\mathrm{x}\mathrm{p}\mathrm{o}\mathrm{n}\mathrm{e}\mathrm{n}\mathrm{t}\mathrm{i}\mathrm{a}\mathrm{l}\mathrm{l}\mathrm{o}\mathrm{s}\mathrm{s}\mathrm{f}\mathrm{u}\mathrm{n}\mathrm{c}\mathrm{t}\mathrm{i}\mathrm{o}\mathrm{n}$，它假定模型的总输出$\mathbf{f}$具有${\mathbf{f}}^{(M)}(\mathbf{x})={\sum }_{m=1}^M{\beta }^{(m)}{\mathbf{b}}^{(m)}(\mathbf{x})$的形式。其中，$M$是模型的总迭代轮数，${\beta }^{(m)}\in {\mathbb{R}}^{+}$是每轮模型的加权系数，${\mathbf{b}}^{(m)}(\mathbf{x})\in {\mathbb{R}}^K$是基模型$G$输出类别的标签向量。

算法流程如下图

【思考题】对公式进行化简，写出$K=2$时的SAMME算法流程，并与李航《统计学习方法》一书中所述的Adaboost二分类算法对比是否一致。

就是将含K的项可以去掉，因为$\frac{(K-1{)}^2}{K}$在$K=2$时为1，而$\log (K-1)$在$K=2$时为0。化简结果和二分类一致，具体见2.1。

2.3 SAMME的代码实现

导入基础库

import numpy as np
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_classification

定义类

class AdaBoost:
    def __init__(self, n_estimators=100):
        self.clf_num = n_estimators
        self.classes = None
        
    def init_args(self, X, y):
    #初始化参数
        self.X = X
        self.y = y
        
        M, _ = X.shape
        
        self.models = []
        self.alphas = []
        self.weights = np.repeat(1/X.shape[0],X.shape[0])
        
        self.classes = np.unique(y.reshape(-1)).shape[0]
        
    def fit(self, X, y):
        self.init_args(X, y)
        output = 0
        
        for n in range(self.clf_num):
            #基础分类器
            clf = DecisionTreeClassifier(max_depth=1)
            clf.fit(X, y, sample_weight=self.weights)
            P = clf.predict(X)
            
            #误差计算
            err = (self.weights*(P!=y)).sum()
            #误差权重计算
            alpha = np.log((1-err)/err)+np.log(self.classes-1)
            
            #生成输出结果，对应于argmax形式
            temp_output = np.full((X.shape[0],self.classes),
                                  -1/(self.classes-1))
            temp_output[np.arange(X.shape[0]),P] = 1
            
            self.models.append(clf)
            self.alphas.append(alpha)
            
            #更新权重
            self.weights *= np.exp(alpha * (y != P))
            self.weights /= self.weights.sum()
            
            #更新输出
            output += temp_output * alpha
        
        #acc = accuracy_score(y,np.argmax(output, axis = 1))
        #print(acc)
        
    def predict(self,X):
    #预测过程不需要计算误差，只需要不断更新输出即可
        result = 0
        for n in range(self.clf_num):
            cur_pred = self.models[n].predict(X)
            temp_output = np.full((X.shape[0],self.classes),
                                  -1/(self.classes-1))
            temp_output[np.arange(X.shape[0]),cur_pred] = 1
            
            result += self.alphas[n] * temp_output
            
        return np.argmax(result,axis=1)

随后进行测试，与sklearn自带的进行对比。

X, y = make_classification(
        n_samples=10000, n_features=10,
        n_informative=5, random_state=0, n_classes=2
    )

X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.3, random_state=0
    )

from sklearn.ensemble import AdaBoostClassifier as ABC
clf = ABC(
        DecisionTreeClassifier(max_depth=1),
        n_estimators=20, algorithm="SAMME"
    )
clf.fit(X_train, y_train)
result = clf.predict(X_test)
print("sklearn中SAMME的验证集得分为: ", accuracy_score(y_test, result))

clf = AdaBoost(20)
clf.fit(X_train, y_train)
result = clf.predict(X_test)
print("SAMME的验证集得分为: ", accuracy_score(y_test, result))

预测结果

3 Adaboost.R2

这是用于处理回归问题的最常使用的AdaBoost方法。
需要重新定义误差的表达形式

设训练集特征和目标分别为$\mathbf{X}=({\mathbf{x}}_1,...,{\mathbf{x}}_n)$和$\mathbf{y}=(y_1,...,y_n)$，权重$\mathbf{w}$初始化为$(w_1,...,w_n)$。在第$m$轮时，根据权重训练基预测器得到$G^{\ast }$，计算每个样本的相对误差
$$e_i=\frac{|y_i-G^{\ast }({\mathbf{x}}_i)|}{{\max }_i|y_i-G^{\ast }({\mathbf{x}}_i)|}$$
设样本的加权相对误差率为$E^{(m)}={\sum }_{i=1}^n{w}_i{e}_i$，则相对误差率与正确率的比值为${\beta }^{(m)}=\frac{E^{(m)}}{1-E^{(m)}}$，即预测器权重${\alpha }^{(m)}=\log \frac{1}{{\beta }^{(m)}}$。

训练算法如下

4 知识回顾

1. 二分类问题下，AdaBoost算法如何调节样本权重？
   根据分类误差，每一轮训练都放大错误预测样本的权重。
2. 样本A在当轮分类错误，且样本B在当轮分类正确，请问在权重调整后，样本A的权重一定大于样本B吗？
   不是，因为样本权重是一个累积值，在整个boosting的过程中不断累积，由于未知样本A和样本B在本轮开始前的权重情况，因此不能知道该轮分类正确与否对样本权重的影响。
3. 在处理分类问题时，Adaboost的损失函数是什么？请叙述其设计的合理性。
   AdaBoost选用的损失函数是$L(\mathbf{y},\mathbf{f})=\exp (-\frac{{\mathbf{y}}^T\mathbf{f}}{K})$

参考文献

1. 机器学习算法之Boosting