Adaboost分类算法原理及代码实例 python

一、Adaboost 简介

     集成学习(Ensemble Learning) 是机器学习领域表现最强的一大分支，主要原理是将多个弱机器学习器结合，构建一个有较强性能的机器学习器。集成学习方法可以分为两类：Boosting 和 Bagging。
     Bagging：它的特点是各个弱学习器是并行关系，相互之间没有依赖，如随机森林算法，是由多个独立决策树模型共同组成。
     Boosting, 也称为增强学习或提升法，特点是当前的弱学习器与上一弱学习器之间有依赖关系，且可以通过不断地构建多个“链式”弱学习器，最终形成一个强学习器。
     AdaBoost 属于Boosting算法的一种，英文全称"Adaptive Boosting"（自适应增强），它的自适应在于：前一个基本分类器被错误分类的样本的权值会增大，而正确分类的样本的权值会减小，并再次用来训练下一个基本分类器。同时，在每一轮迭代中，加入一个新的弱分类器，直到达到某个预定的足够小的错误率或达到预先指定的最大迭代次数才确定最终的强分类器。

一、Adaboost 算法过程

• 给定一个二分类数据集
  $$T=\{(x_1,y_1),(x_2,y_2),...,(x_N,y_N)\}$$
  其中， y i ∈ { − 1 , 1 } y_{i} \in \{ -1,1 \} yi​∈{−1,1}

• 算法流程：
  （1）初始化每条数据的权重
  $$D_1=(w_1,w_2,...,w_N)=(\frac{1}{N},\frac{1}{N},...,\frac{1}{N})$$

（2）进行迭代
    a. 选取一个误差率最低的弱分类器 $h$ 作为第 $t$ 个基分类器 $h_t$，并计算该基分类器的拟合误差率：
$$e_t=P(h_t(x_i)\ne y_i)=\sum _{i=1}^N{w}_{ti}I(h_t(x_i)\ne y_i)$$
其中，$I(h_t(x_i)\ne y_i)=\{\begin{array}{ll}0,& h_t(x_i)=y_i\\ 1,& h_t(x_i)\ne y_i\end{array}$
不难看出，拟合误差率其实就是误分类样本的权值之和。

    b. 计算基分类器$h_t$在最终分类器$H$中所占的权重
$${\alpha }_t=\frac{1}{2}ln(\frac{1-e_t}{e_t})$$

    c. 更新样本权重$D_{t+1}$
$$D_{t+1}=\frac{D_{t}exp(-{\alpha }_t{y}_i{h}_t(x_i))}{Z_t}$$
其中，$Z_t$是归一化常数，$Z_t=2\sqrt{e_t(1-e_t)}$
    从样本权重更新公式可以看出，权重更新依赖于${\alpha }_t$，且${\alpha }_t$依赖于$e_t$，所以更新公式可以简化成：
    当样本分类错误时，$y_i{h}_t(x_i)=-1$
$$D_{t+1}=\frac{D_t}{2e_t}$$
    当样本分类正确时，$y_i{h}_t(x_i)=-1$
$$D_{t+1}=\frac{D_t}{2(1-e_t)}$$
关于$Z_t$与$D_{t+1}$的推导说明参考：Adaboost算法原理分析和实例+代码（简明易懂）

（3）最后，让每个弱分类器$h_t$与权重${\alpha }_t$进行组合
$$f(x)=\sum {\alpha }_{t{h}_t}$$
通过符号函数$sign()$，可以得到最终的强分类器
$$H=sign(f(x))$$

• 综上所述，构建最终的分类器迭代过程可以写成
  $$H_t=H_{t-1}+{\alpha }_t{h}_t$$

我们可以加一个迭代速率$\beta$，控制迭代快慢
$$H_t=H_{t-1}+\beta {\alpha }_t{h}_t$$

二、简单实例

• 给定一个简单的二分类数据集
  
• 算法过程
  （1）初始化每条数据的权重
  此处N=10.
  $$D_1=(w_1,w_2,...,w_{10})=(\frac{1}{10},\frac{1}{10},...,\frac{1}{10})$$

（2）迭代第1次
    a. 选取一个误差率最低的弱分类器 $h$ 作为第 $1$ 个基分类器 $h_1$，并计算该基分类器的拟合误差率：$h_1=\{\begin{array}{ll}1,& x<2.5\\ -1& x>=2.5\end{array}$ ，得到的结果是[ 1,1,1,-1, -1,-1,-1,-1,-1,-1]，能够发现x为6,7,8的数据结果分类错误，计算得到其错误率为：
$$e_1=0.1+0.1+0.1=0.3$$

    b. 计算基分类器$h_1$在最终分类器$H$中所占的权重
$${\alpha }_1=\frac{1}{2}ln(\frac{1-e_1}{e_1})=0.4236$$

    c. 更新样本权重$D_2$
    当样本分类错误时，$D_2=\frac{D_1}{2e_1}=0.071$；当样本分类正确时，$D_2=\frac{D_1}{2(1-e_1)}=0.167$。

    d. 得到第一次迭代的分类器H为
$$H=sign({\alpha }_1{h}_1)=sign(0.4236h_1)$$
    其中，$h_1=\{\begin{array}{ll}1,& x<2.5\\ -1& x>=2.5\end{array}$

（2）迭代第2次
    a. 选取第 $2$ 个基分类器 $h_2=\{\begin{array}{ll}1,& x<8.5\\ -1& x>=8.5\end{array}$ ，得到的拟合结果是[ 1,1,1,1, 1,1,1,1,-1,-1]，能够发现x为3,4,5的数据结果分类错误，计算得到其错误率为：
$$e_2=0.071+0.071+0.071=0.213$$

    b. 计算基分类器$h_2$在最终分类器$H$中所占的权重
$${\alpha }_2=\frac{1}{2}ln(\frac{1-e_2}{e_2})=0.653$$

    c. 更新样本权重$D_3$
    当样本分类错误时，$D_3=\frac{D_2}{2e_2}=0.168$；当样本分类正确时，$D_3=\frac{D_3}{2(1-e_3)}=0.045$。

    d. 得到第二次迭代的分类器H为
$$H=sign({\alpha }_1{h}_1+{\alpha }_2{h}_2)=sign(0.4236h_1+0.653h_2)$$
    其中，$h_1=\{\begin{array}{ll}1,& x<2.5\\ -1& x>=2.5\end{array}$ ，$h_2=\{\begin{array}{ll}1,& x<8.5\\ -1& x>=8.5\end{array}$

（2）迭代第3次
    a. 选取第 $3$ 个基分类器 $h_3=\{\begin{array}{ll}1,& x<5.5\\ -1& x>=5.5\end{array}$ ，得到的拟合结果是[ 1,1,1,1, 1,1,-1,-1,-1,-1]，能够发现x为0,1,2,9的数据结果分类错误，计算得到其错误率为：
$$e_3=0.045+0.045+0.045+0.045=0.184$$

    b. 计算基分类器$h_2$在最终分类器$H$中所占的权重
$${\alpha }_3=\frac{1}{2}ln(\frac{1-e_3}{e_3})=0.745$$

    c. 得到第三次迭代后的分类器H为
$$\begin{array}{rl}H& =sign({\alpha }_1{h}_1+{\alpha }_2{h}_2+{\alpha }_3{h}_3)\\ & =sign(0.4236h_1+0.653h_2+0.745h_3)\end{array}$$
    其中，
        $h_1=\{\begin{array}{ll}1,& x<2.5\\ -1& x>=2.5\end{array}$ ，

        $h_2=\{\begin{array}{ll}1,& x<8.5\\ -1& x>=8.5\end{array}$ ，

        $h_3=\{\begin{array}{ll}1,& x<5.5\\ -1& x>=5.5\end{array}$

迭代3次后的分类器能够100%拟合原始数据集，详情看下图

三、python 实现

3.1 sklearn.AdaBoostClassifier 参数说明

sklearn.AdaBoostClassifier(
    base_estimator=None, # 模型分类器
    *,
    n_estimators=50,     # 最大的弱学习器的个数
    learning_rate=1.0,   # 权重缩减系数
    algorithm='SAMME.R', # {'SAMME', 'SAMME.R'}, optional (default='SAMME.R')
                         # AdaBoost两种分类算法'SAMME', 'SAMME.R' ，两者的主要区别是弱学习器权重的度量。
                         # 'SAMME'使用了对样本集分类效果作为弱学习器权重。
                         # 'SAMME.R'使用了对样本集分类的预测概率大小作为弱学习器权重。
                         # 'SAMME.R'使用了概率度量的连续值，迭代一般比'SAMME'快。但其要求弱分类学习器参数
    random_state=None,   # 随机种子
)

3.2 导入相关库与数据集

import pandas as pd

from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import AdaBoostClassifier
from sklearn.model_selection import train_test_split,GridSearchCV
from sklearn.metrics import confusion_matrix,accuracy_score, recall_score, f1_score, precision_score

iris = load_iris() # skelarn自带的莺尾花数据集

3.3 划分训练集、预测集

# 划分训练集、预测集
x_train, x_test, y_train, y_test = train_test_split(
    iris.data, 
    iris.target, 
    test_size = 0.3, 
    random_state = 0
)

3.4 Adaboost模型训练

abc = AdaBoostClassifier(base_estimator=DecisionTreeClassifier(max_depth=5)) # 初始化
abc.fit(x_train,y_train)     # 模型训练

print("建立的弱分类器：",abc.estimators_)
print("分类误差：",abc.estimator_errors_)
print("分类器权重：",abc.estimator_weights_)
print("迭代速率：",abc.learning_rate)

3.5 模型预测与评价

y_pred = abc.predict(x_test) # 模型预测

print("\n---------- 模型评价 ----------")
cm = confusion_matrix(y_test, y_pred) # 混淆矩阵
df_cm = pd.DataFrame(cm)              # 构建DataFrame
print("ConfusionMatrix",df_cm)      
print('Accuracy score:', accuracy_score(y_test, y_pred))                       # 准确率
print('Recall:', recall_score(y_test, y_pred, average='weighted'))             # 召回率
print('F1-score:', f1_score(y_test, y_pred, average='weighted'))               # F1分数
print('Precision score:', precision_score(y_test, y_pred, average='weighted')) # 精确度

参考：Adaboost算法原理分析和实例+代码（简明易懂）