提升算法AdaBoost原理以及python实现

提升算法的主要思想就是从弱分类器出发，反复学习，得到一系列弱分类器（也称为基本分类器），然后组合这些弱分类器，构成一个强分类器。大多数提升方法都是改变训练数据的概率分布（也就是训练数据的权值分布），之后针对不同的训练数据分布调用弱学习算法学习一系列弱分类器。
因此，提升方法需要解决两个问题：1、在每一轮如何改变训练样本数据的权值；2、如何将弱分类器组合成为一个强分类器。

AdaBoost的做法是：1、提高那些被前一轮弱分类器错误分类样本的权值，而降低那些正确分类样本的权值；2、采取加权多数表决的方法，加大分类误差率小的弱分类器的权值，使其在表决中起到较大的作用。减少分类误差率大的弱分类器的权值，使其在表决中起到较小的作用。

AdaBoost 算法

给定一个二分类数据集：
T = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , ⋯   , ( x N , y N ) } T=\{(x_1,y_1),(x_2,y_2),\cdots,(x_N,y_N)\} T={(x1​,y1​),(x2​,y2​),⋯,(xN​,yN​)}
每个实例点由实例与标记组成，其中 x i ∈ R n , y i ∈ { − 1 , + 1 } x_i\in\textbf{R}^n,y_i\in\{-1, +1\} xi​∈Rn,yi​∈{−1,+1}
(1)初始化训练数据的权值分布
$$D_1=(w_{11},\cdots ,w_{1i},\cdots ,w_{1N}),w_{1i}=\frac{1}{N},i=1,2,\cdots ,N$$
(2)对$m=1,2,\cdots ,M$
(a)使用具有权值分布$D_m$的训练数据集学习，得到基本分类器
G m ( x ) : X → { − 1 , + 1 } G_m(x):X\rightarrow\{-1,+1\} Gm​(x):X→{−1,+1}
(b)计算$G_m(x)$在训练数据集上的分类误差率
$$e_m=\sum _{i=1}^{N}P(G_m(x_i)\ne y_i)=\sum _{i=1}^N{w}_{mi}I(G_m(x_i)\ne y_i)$$
(c )计算$G_m(x)$的系数
$${\alpha }_m=\frac{1}{2}\log \frac{1-e_m}{e_m}$$
这里的对数的自然对数。
(d)更新训练数据集的权值分布
$$D_{m+1}=(w_{m+1,1},\cdots ,w_{m+1,i},\cdots ,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,\cdots ,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))$$

注意：$G_m(x)$在加权的训练数据集上的分类误差率是被$G_m(x)$误分类样本的权值之和。

下面展示代码：

import numpy as np
from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression

X, y = make_classification(n_samples=400, n_features=2, n_redundant=0, n_clusters_per_class=1, n_classes=2, random_state=2)
T1 = X.copy()
T2 = y.copy()

class AdaBoost:
    def __init__(self, X, y, m):
        self.X = X
        self.y = y
        self.m = m
        self.N = X.shape[0]
        self.w = np.ones(self.N)/self.N
        self.M_list = []
        self.clf_list = []

    def select_samples(self):
        t = []
        for i in range(self.N):
            t.append(np.random.random())
        t.sort()
        cum_list = []
        w = 0
        for i in range(self.N):
            w += self.w[i]
            cum_list.append(w/np.sum(self.w))
        new = 0
        old = 0
        T1 = self.X.copy()
        T2 = self.y.copy()
        while new < self.N:
            if t[new] < cum_list[old]:
                self.X[new] = T1[old]
                self.y[new] = T2[old]
                new += 1
            else:
                old += 1
        self.w = np.ones(self.N)/self.N

    def define(self, p):
        p = LogisticRegression(solver='liblinear')
        return p

    def calculate(self):
        for i in range(self.m):
            clf = self.define('p{}'.format(i))
            clf.fit(self.X, self.y)
            self.clf_list.append(clf)
            e = 1 - clf.score(self.X, self.y)
            a = 0.5*np.log((1 - e)/e)
            self.M_list.append(a)
            t = 0
            for j in range(self.N):
                t += self.w[j]*np.exp(-a*self.y[j]*(clf.predict([self.X[j]])-0.5)*2)
            for j in range(self.N):
                self.w[j] = (self.w[j]/t)*np.exp(-a*self.y[j]*(clf.predict([self.X[j]])-0.5)*2)
            self.select_samples()

    def score(self, X, y):
        r = 0
        Y = []
        self.M_list = self.M_list/sum(self.M_list)
        for i in self.clf_list:
            y_pre = i.predict(X)
            Y.append(y_pre)
        Y = np.array(Y)
        a = np.array(self.M_list)
        for i in range(self.N):
            if np.dot(Y[:, i], a) > 0.5 and y[i] == 1:
                r += 1
            elif np.dot(Y[:, i], a) < 0.5 and y[i] == 0:
                r += 1
        print(r/self.N)


A = AdaBoost(X, y, 10)
A.calculate()
A.score(T1, T2)

最终运行结果为：

表示算法的精度为90.75%.