提升方法AdaBoost算法

进击的阿刚#

于 2024-04-14 22:31:51 发布

阅读量1.1k

点赞数 28

分类专栏：统计学习方法文章标签：算法人工智能机器学习

本文链接：https://blog.csdn.net/qq_47190374/article/details/137756206

版权

统计学习方法专栏收录该内容

8 篇文章 0 订阅

订阅专栏

文章目录

前言
一、AdaBoost是什么？
二、AdaBoost算法流程
三、 AdaBoost算法的解释
四、代码实现

前言

提升方法是一种常用的统计学习方法，应用广泛且有效。在分类问题中，通过改变训练样本的权重，学习多个分类器，并将这些分类器线性组合，提高分类的性能。

一、AdaBoost是什么？

标准AdaBoost关注二分类问题，AdaBoost通过训练一系列的弱分类器来组成一个强分类器，每一轮训练时会提高前一轮弱分类器错误分类样本的权值，而降低那些被正确分类的样本的权值。模型最后的预测结果为各弱分类器预测结果的加权多数表决结果。具体的，加大分类误差率小的弱分类器权值，使其在表决中起较大的作用。

二、AdaBoost算法流程

输入：训练数据集 $T={(x_1,y_1),(x_2,y_2),..,(x_N,y_N)}$ ，其中 $x_i\in \mathbb{R}^n$ ， $Y_i\in \{-1,1\}$ ；弱分类器算法（一般为树桩）
输出：最终分类器 $G (x)$ .
1. 初始化训练数据的权值分布为 $D_1=(w_{11},w_{12},...,w_{1N}),w_{1i}=\frac{1}{N}$
1. 对m=1,2,…,M（M为弱分类器数量）
- - 使用具有权值分布 $D_m$ 的训练数据学习，得到第m个基分类器 $G_m(x)$
- - 计算 $G_m(x)$ 的分类误差率：
    $e_m=\sum_{i=1}^Nw_{mi}I(G_m(x_i)\ne y_i)$
- - 计算 $G_m(x)$ 的系数（权重）
    $\alpha_m=\frac{1}{2}\ln \frac{1-e_m}{e_m}$
- - 更新训练集数据权值分布
    $D_{m+1}=(w_{m1},w_{m2},...,w_{mN}) \\ w_{mi}=\frac{w_{mi}e^{-\alpha_m y_iG(x_i)}}{Z_m} \\ Z_m=\sum_{i=1}^Nw_{mi}e^{-\alpha_m y_iG(x_i)}$
    — 最终分类器
    $G(x)=sign(\sum_{m=1}^M\alpha_mG_m(x))$

三、 AdaBoost算法的解释

AdaBoost算法可解释为模型是加法模型、损失函数为指数函数、学习算法为前向分步算法时的二分类学习算法。

向前分步算法
加法模型：
$f(x)=\sum_{m=1}^M\beta_mb(x;\gamma_m)$
其中， $b(x;\gamma_m)$ 为基函数， $\gamma_m$ 为基函数参数， $\beta_m$ 为基函数的系数，M为基函数的个数。
学习加法模型 $f (x)$ 即对经验风险极小化：
$\min_{\beta_m,\gamma_m}\sum_{i=1}^NL(y_i,\sum_{m=1}^M\beta_mb(x;\gamma_m))$
通常这是一个复杂的优化问题，前向分布算法求解这一优化问题的想法是：从前往后每一步只学习一个基函数及其系数，逐步逼近最优解。具体地，每一步需要优化如下损失函数：
$\min_{\beta,\gamma}\sum_{i=1}^NL(y_i,f_{m-1}(x_i)+\beta b(x;\gamma))$
前向分布算法与AdaBoost
前向分步算法逐一学习基函数，这与AdaBoost算法逐一学习基本分类器的过程一致。
当前向分步算法的损失函数为指数损失函数，即：
$L(y,f(x))=e^{-yf(x)}$
时，其学习的具体操作等价于AdaBoost算法学习的具体操作。
假设经过m-1轮迭代前向分步算法已经得到：
$f_{m-1}(x)=\alpha_1G_1(x)+\alpha_2G_2(x)+...+\alpha_{m-1}G_{m-1}(x)$
在第m轮迭代得到 $\alpha_m,G_m(x)和f_m(x)=f_{m-1}(x)+\alpha_mG_m(x)$ ，目标是希望得到：
$(\alpha_m,G_m(x))=\arg\min_{\alpha_m,G_m(x)}\sum_{i=1}^Ne^{-y_i(f_{m-1}(x_i)+\alpha_mG_m(x_i))}$
令 $\overline w_{mi}=e^{-y_if_{m-1}(x_i)}$ ，则上式子可以化为：
$(\alpha_m,G_m)=\arg\min_{\alpha_m,G_m(x)}\sum_{i=1}^N\overline w_{mi}e^{-\alpha_my_iG_m(x_i)} \\ =\arg\min_{\alpha_m,G_m}e^{-\alpha_m}\sum_{y_i=G_m(x_i)}\overline w_{mi}+e^{\alpha_m}\sum_{y_i\ne G_m(x_i)}\overline w_{mi} \\ =\arg\min_{\alpha_m,G_m}e^{-\alpha_m}(\sum_{i=1}^N\overline w_{mi}-\sum_{y_i\ne G_m(x_i)}\overline w_{mi})+e^{\alpha_m}\sum_{y_i\ne G_m(x_i)}\overline w_{mi} \\ =\arg\min_{\alpha_m,G_m}e^{-\alpha_m}\sum_{i=1}^N\overline w_{mi}+(e^{\alpha_m}-e^{-\alpha_m})\sum_{y_i\ne G_m(x_i)}\overline w_{mi} \\ =\arg\min_{\alpha_m,G_m}e^{-\alpha_m}\sum_{i=1}^N\overline w_{mi}+(e^{\alpha_m}-e^{-\alpha_m})\sum_{i=1}^N\overline w_{mi}I(y_i\ne G_m(x_i))$
对于固定的 $\alpha_m$ ，上式中 $e^{-\alpha_m}\sum_{i=1}^N\overline w_{mi}$ 和 $e^{\alpha_m}-e^{-\alpha_m}$ 都是定值，则上式等价于：
$G_m^*=\arg\min_{G_m}\sum_{i=1}^N\overline w_{mi}I(y_i\ne G_m(x_i))$
这与AdaBoost中要寻找的基本分类器一致。
然后对 $\alpha_m$ 求导并使其等于0，得：
$\alpha_m^*=\frac{1}{2}\ln \frac{1-e_m}{e_m} \\ e_m=\frac{\sum_{i=1}^N\overline w_{mi}I(y_i\ne G_m(x_i))}{\sum_{i=1}^N\overline w_{mi}}$
令 $w_{mi}=\frac{\overline w_{mi}}{\sum_{i=1}^N\overline w_{mi}}$ ，得 $e_m=\sum_{i=1}^Nw_{mi}I(y_i\ne G_m(x_i))$ ，这与AdaBoost一致。特别地，当 $m = 0$ 时， $\overline w_{mi}=e^{-y_i*0}=1,w_{mi}=\frac{1}{N}=\frac{\overline w_{mi}}{\sum_{i=1}^N\overline w_{mi}}$ 。

由 $\overline w_{mi}=e^{-y_if_{m-1}(x_i)}$ 以及 $f_m(x_i)=f_{m-1}(x)+\alpha_mG_m(x_i)$ 得：
$\overline w_{m+1,i}=\overline w_{mi}e^{-y_i\alpha_mG_m(x_i)}$
由 $w_{m+1,i}=\frac{\overline w_{m+1,i}}{\sum_{i=1}^N\overline w_{m+1,i}}$ 以及上式得：
$w_{m+1,i}=\frac{\overline w_{mi}e^{-y_i\alpha_mG_m(x_i)}}{\sum_{i=1}^N\overline w_{mi}e^{-y_i\alpha_mG_m(x_i)}} \\ =\frac{\frac{\overline w_{mi}}{\sum_{i=1}^N\overline w_{mi}}e^{-y_i\alpha_mG_m(x_i)}}{\sum_{i=1}^N\frac{\overline w_{mi}}{\sum_{i=1}^N\overline w_{mi}}e^{-y_i\alpha_mG_m(x_i)}} \\ =\frac{w_{mi}e^{-y_i\alpha_mG_m(x_i)}}{\sum_{i=1}^Nw_{mi}e^{-y_i\alpha_mG_m(x_i)}}$
与AdaBoost一致。
综上，模型是加法模型、损失函数为指数函数、学习算法为前向分步算法时可以推导出AdaBoost。

四、代码实现

"""
AdaBoost 算法
"""

import numpy as np
from sklearn.datasets import load_digits
from tqdm import tqdm


class BasicClassifier(object):
    def __init__(self, train_xs, train_ys, weights, attr_type, split_cnt=10):
        """
        :param train_xs: 特征
        :param train_ys: 标签
        :param weights: 权重
        :param attr_type: 属性的类别（离散或者连续）
        :param split_cnt: 对于连续属性划分区域个数
        """
        self.train_xs = train_xs
        self.train_ys = train_ys
        self.m, self.n = self.train_xs.shape
        assert len(weights) == self.m
        assert len(attr_type) == self.n
        self.weights = weights
        self.attr_type = attr_type
        self.split_cnt = split_cnt

    def build(self):
        """
        建立一个基本的分类器
        :return:
        """
        min_em = float('inf')  # 最小误差率
        attr_index = -1
        attr_value = -1
        predict_ys = None

        # 对于连续属性为选取属性哪边预测为-1，lt为左侧，gt为右侧
        # 对于离散属性为选中类别的选中取值预测为1还是-1，'eq'为选中取值预测为-1，'neq'为选中取值预测为1
        side = None

        for i in range(len(self.attr_type)):
            if self.attr_type[i] == 0:  # 该属性为离散的
                uniques = np.unique(self.train_xs[:, i])
                for j in range(len(uniques)):
                    for ineq in ['eq', 'neq']:
                        _predict_ys = np.ones((self.m,))
                        if ineq == 'eq':
                            _predict_ys[self.train_xs[:, i] == uniques[j]] = -1
                        else:
                            _predict_ys[self.train_xs[:, i] != uniques[j]] = -1
                        em = self.weights[_predict_ys != self.train_ys].sum()  # 计算出误差率

                        if em < min_em:
                            min_em = em
                            attr_index = i
                            attr_value = uniques[j]
                            predict_ys = _predict_ys
                            side = ineq

            else:  # 该属性为连续的
                _min, _max = np.min(self.train_xs[:, i]), np.max(self.train_xs[:, i])
                step = (_max - _min) / self.split_cnt
                for j in range(self.split_cnt+1):
                    split_value = _min + step * j
                    for ineq in ['lt', 'gt']:
                        _predict_ys = np.ones((self.m,))
                        if ineq == 'lt':
                            _predict_ys[self.train_xs[:, i] < split_value] = -1
                        else:
                            _predict_ys[self.train_xs[:, i] >= split_value] = -1
                        em = self.weights[_predict_ys != self.train_ys].sum()  # 计算出误差率

                        if em < min_em:
                            min_em = em
                            attr_index = i
                            attr_value = split_value
                            predict_ys = _predict_ys
                            side = ineq

        return min_em, attr_index, attr_value, predict_ys, side


class AdaBoost(object):
    """
    提升方法AdaBoost方法
    """
    def __init__(self) -> None:
        self.classifers = []

    def train(self, train_xs, train_ys, test_xs, test_ys, attr_type, iters=500, test_freq=50):
        m, n = train_xs.shape
        weights = (1. / m) * np.ones((m,))

        for i in tqdm(range(iters)):
            basicclassifier = BasicClassifier(train_xs, train_ys, weights, attr_type)
            min_em, attr_index, attr_value, predict_ys, side = basicclassifier.build()

            am = 0.5 * np.log((1 - min_em) / min_em)
            weights = weights * np.exp(-am * train_ys.reshape((m,)) * predict_ys)
            weights /= np.sum(weights)

            self.classifers.append((am, attr_index, attr_value, side))

            if test_xs is not None and test_ys is not None and (i+1) % test_freq == 0:
                accuracy = self.test(test_xs, test_ys, attr_type)
                print("iters:%d, accuracy is %.4f" % (i+1, accuracy))

    def test(self, test_xs, test_ys, attr_type):
        """
        测试函数
        """
        predict_ys = np.zeros((test_xs.shape[0]))
        for am, attr_index, attr_value, side in self.classifers:
            if attr_type[attr_index] == 0:  # 属性为离散时
                if side == 'eq':
                    predict_ys[test_xs[:, attr_index] == attr_value] += -am
                    predict_ys[test_xs[:, attr_index] != attr_value] += am
                else:
                    predict_ys[test_xs[:, attr_index] == attr_value] += am
                    predict_ys[test_xs[:, attr_index] != attr_value] += -am

            else:   # 属性为连续时
                if side == 'lt':
                    predict_ys[test_xs[:, attr_index] < attr_value] += -am
                    predict_ys[test_xs[:, attr_index] >= attr_value] += am
                else:
                    predict_ys[test_xs[:, attr_index] < attr_value] += am
                    predict_ys[test_xs[:, attr_index] >= attr_value] += -am

        predict_ys[predict_ys > 0] = 1
        predict_ys[predict_ys < 0] = -1

        accuracy = (predict_ys == test_ys).sum() / test_xs.shape[0]
        return accuracy


if __name__ == '__main__':

    # 加载sklearn自带的手写数字识别数据集
    digits = load_digits()
    features = digits.data
    targets = (digits.target > 4).astype(int)
    targets[targets == 0] = -1

    # 随机打乱数据
    shuffle_indices = np.random.permutation(features.shape[0])
    features = features[shuffle_indices]
    targets = targets[shuffle_indices]

    # 划分训练、测试集
    train_count = int(len(features)*0.8)
    train_xs, train_ys = features[:train_count], targets[:train_count]
    test_xs, test_ys = features[train_count:], targets[train_count:]

    attr_type = [1] * train_xs.shape[1]
    adaboost = AdaBoost()
    adaboost.train(train_xs, train_ys, test_xs, test_ys, attr_type)