task9 集成学习之boosting的思路与adaboost算法

Boosting的思路与Adaboost算法
前向分步算法与梯度提升决策树(GBDT)
XGBoost算法与xgboost库的使用
Xgboost算法案例与调参实例
LightGBM算法的基本介绍

参考来源：

1. https://github.com/datawhalechina/team-learning-data-mining/tree/master/EnsembleLearning
2. https://blog.csdn.net/wishchin/article/details/53634396

1.Boosting

1.1 Bagging与Boosting

通过之前的学习我们知道，Bagging的主要方法是：①通过Bootstrap 的方式对全样本数据集进行抽样得到抽样子集，这样，每个学习器用于训练的数据集不同。②在随机森林中，使用不同的属性划分提高不同学习器之间的“差异”，来提升总体学习器的效果。

通过以上分析我们发现，Bagging主要通过降低方差的方式减少预测误差。那么，Boosting是与Bagging截然不同的思想，Boosting方法是使用同一组数据集进行反复学习，得到一系列简单模型，然后组合这些模型构成一个预测性能十分强大的机器学习模型。显然，Boosting思想提高最终的预测效果是通过不断减少偏差的形式，与Bagging有着本质的不同。

常用的Boosting方法有：Adaptive Boosting 和 Gradient Boosting 以及它们的变体Xgboost、LightGBM以及Catboost。

1.2 Boosting理论基础

先说结论：强可学习和弱可学习是等价的。

强学习
识别准确率很高并能在多项式时间内完成的学习算法
弱学习
识别错误率小于1/2（即准确率仅比随机猜测略高的学习算法）

Kearns和Valiant(1988,1994)在PAC的基础上，提出弱可学习的理论。他这样描述一个概念是弱可学习：F(x)是自然模型，f(x)是从样本集学习后建立的模型，|F(x)-f(x)|≤ε成立的概率大于(1/2)+δ , 0≤δ≤1/2。这意味着，一个概念如果是弱可学习的，那么只要求一个弱可学习算法产生的模型的精度高于50%，也就是比随机猜想稍好。同时他将满足PAC原始定义的概念可学习称为强可学习。进而，他问了如下一个问题，强可学习在什么条件下与弱可学习等价。

1990年，Schapire回答了这个问题。他使用构造的方法证明：一个概念弱可学习的充要条件是这个概念强可学习。这是一个有些“不可思议”的结论。正是由于这个定理，开始了至今还在人们关注视野中的一类机器学习的研究，机器学习研究者将这类学习方式称为集成学习(Ensemble Learning)。

这样一来，问题便是：在学习中，如果已经发现了弱可学习算法，能否将他提升至强可学习算法。因为，弱可学习算法比强可学习算法容易得多。提升方法就是从弱学习算法出发，反复学习，得到一系列弱分类器(又称为基本分类器)，然后通过一定的形式去组合这些弱分类器构成一个强分类器。

1.3 Boosting原理

Boosting是一族可将弱学习器提升为强学习器的算法，这族算法的工作机制类似：先从初试训练集训练出一个基学习器，再根据基学习器的表现对训练样本分布进行调整，使得先前基学习器做错的训练样本在后续受到更多关注，然后基于调整后的样本分布来训练一个基学习器；如此重复进行，直至基学习器数目达到事先指定的值T，最终将这T个基学习器进行加权结合。

大多数的Boosting方法都是通过改变训练数据集的概率分布(训练数据不同样本的权值分布)，针对不同概率分布的数据调用弱分类算法学习一系列的弱分类器。

对于Boosting方法来说，有两个问题需要给出答案：第一个是每一轮学习应该如何改变数据的概率分布，第二个是如何将各个弱分类器组合起来。关于这两个问题，不同的Boosting算法会有不同的答案，我们接下来介绍一种最经典的Boosting算法—Adaboost，我们需要理解Adaboost是怎么处理这两个问题以及为什么这么处理的。

2. Adaboost算法的原理

对于以上提出的第一个问题，Adaboost的做法是：提高那些被前一轮分类器错误分类的样本的权重，而降低那些被正确分类的样本的权重。这样一来，那些在上一轮分类器中没有得到正确分类的样本，由于其权重的增大而在后一轮的训练中“备受关注”。于是，分类问题被一系列的弱分类器“分而治之”

关于第二个问题，即弱分类器的组合，Adaboost采取加权多数表决的方法，具体地，加大分类错误率低的弱分类器的权重，因为这些分类器能更好地完成分类任务，而减小分类错误率较大的弱分类器的权重，使其在表决中起较小的作用。

Adaboost
（以下推导过程来源于《统计学习方法》 李航 清华大学出版社）

假设给定一个二分类的训练数据集：
T = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , ⋯   , ( x N , y N ) } T=\left\{\left(x_{1}, y_{1}\right),\left(x_{2}, y_{2}\right), \cdots,\left(x_{N}, y_{N}\right)\right\} T={(x1​,y1​),(x2​,y2​),⋯,(xN​,yN​)}
其中,每个样本点由特征与类别组成。实例$x_i\in \mathcal{X}\subseteq {\mathbf{R}}^n$，标记 y i ∈ Y = { − 1 , + 1 } y_{i} \in \mathcal{Y}=\{-1,+1\} yi​∈Y={−1,+1}，$\mathcal{X}$是实例空间，$\mathcal{Y}$是标记集合，输出最终分类器$G(x)$。

Adaboost算法如下：
(1) 初始化训练数据的权值分布：
$$D_1=\left(w_{11},\cdots ,w_{1i},\cdots ,w_{1N}\right),w_{1i}=\frac{1}{N},i=1,2,\cdots ,N$$

(2) 对于m=1,2,…,M
    ( a ) 使用具有权值分布$D_m$的训练数据集进行学习，得到基本分类器： G m ( x ) : X → { − 1 , + 1 } G_{m}(x): \mathcal{X} \rightarrow\{-1,+1\} Gm​(x):X→{−1,+1}
    ( b )计算$G_m(x)$在训练集上的分类误差率:$$e_m=\sum _{i=1}^{N}P\left(G_m\left(x_i\right)\ne y_i\right)=\sum _{i=1}^N{w}_{mi}I\left(G_m\left(x_i\right)\ne y_i\right)\text{\hspace{1em}(2.1)}$$
     ( c )计算$G_m(x)$的系数$${\alpha }_m=\frac{1}{2}\log \frac{1-e_m}{e_m}\text{\hspace{1em}(2.2)}$$
这里的log是自然对数ln
    ( d )更新训练数据集的权重分布:
$$D_{m+1}=\left(w_{m+1,1},\cdots ,w_{m+1,i},\cdots ,w_{m+1,N}\right)\text{\hspace{1em}(2.3)}$$
$$w_{m+1,i}=\frac{w_{mi}}{Z_m}\exp \left(-{\alpha }_m{y}_i{G}_m\left(x_i\right)\right),i=1,2,\cdots ,N\text{\hspace{1em}(2.4)}$$
这里的$Z_m$是规范化因子，使得$D_{m+1}$称为概率分布，
$$Z_m=\sum _{i=1}^N{w}_{mi}\exp \left(-{\alpha }_m{y}_i{G}_m\left(x_i\right)\right)\text{\hspace{1em}(2.5)}$$

(3) 构建基本分类器的线性组合$$f(x)=\sum _{m=1}^M{\alpha }_m{G}_m(x)\text{\hspace{1em}(2.6)}$$，得到最终的分类器
$$\begin{array}{rl}G(x)& =\mathrm{sign}(f(x))\\ & =\mathrm{sign}\left(\sum _{m=1}^M{\alpha }_m{G}_m(x)\right)\end{array}\text{\hspace{1em}(2.7)}$$

下面对Adaboost算法做如下说明：

对于步骤(1)，假设训练数据的权值分布是均匀分布，是为了使得第一次没有先验信息的条件下每个样本在基本分类器的学习中作用一样。

对于步骤(2)，每一次迭代产生的基本分类器$G_m(x)$在加权训练数据集上的分类错误率$\begin{array}{rl}{e}_m& =\sum _{i=1}^{N}P\left(G_m\left(x_i\right)\ne y_i\right)=\sum _{G_m\left(x_i\right)\ne y_i}{w}_{mi}\end{array}$代表了在$G_m(x)$中分类错误的样本权重和，这点直接说明了权重分布$D_m$与$G_m(x)$的分类错误率$e_m$有直接关系。同时，在步骤(2)中，计算基本分类器$G_m(x)$的系数${\alpha }_m$，${\alpha }_m=\frac{1}{2}\log \frac{1-e_m}{e_m}$，它表示了$G_m(x)$在最终分类器的重要性程度，${\alpha }_m$的取值由基本分类器$G_m(x)$的分类错误率有直接关系，当$e_m⩽\frac{1}{2}$时，${\alpha }_m⩾0$，并且${\alpha }_m$随着$e_m$的减少而增大，因此分类错误率越小的基本分类器在最终分类器的作用越大！

**最重要的，对于步骤(2)中的样本权重的更新： **
$$w_{m+1,i}=\{\begin{array}{ll}\frac{w_{mi}}{Z_m}{\mathrm{e}}^{-{\alpha }_m},& G_m\left(x_i\right)=y_i\\ \frac{w_{mi}}{Z_m}{\mathrm{e}}^{{\alpha }_m},& G_m\left(x_i\right)\ne y_i\end{array}$$
因此，从上式可以看到：被基本分类器$G_m(x)$错误分类的样本的权重扩大，被正确分类的样本权重减少，二者相比相差${\mathrm{e}}^{2{\alpha }_m}=\frac{1-e_m}{e_m}$倍。
对于步骤(3)，线性组合$f(x)$实现了将M个基本分类器的加权表决，系数${\alpha }_m$标志了基本分类器$G_m(x)$的重要性，值得注意的是：所有的${\alpha }_m$之和不为1。$f(x)$的符号决定了样本x属于哪一类。

Adaboost的例子
下面，使用一组简单的数据来手动计算Adaboost算法的过程：(例题来源：http://www.csie.edu.tw)

训练数据如下表，假设基本分类器的形式是一个分割$x<v$或$x>v$表示，阈值v由该基本分类器在训练数据集上分类错误率$e_m$最低确定。

解：
初始化样本权值分布
$$\begin{array}{rl}{D}_1& =\left(w_{11},w_{12},\cdots ,w_{110}\right)\\ w_{1i}& =0.1,i=1,2,\cdots ,10\end{array}$$
对m=1:
    ( a ) 在权值分布$D_1$的训练数据集上，遍历每个结点并计算分类误差率$e_m$，阈值取v=2.5时分类误差率最低，那么基本分类器为：
$$G_1(x)=\{\begin{array}{ll}1,& x<2.5\\ -1,& x>2.5\end{array}$$
    ( b ) $G_1(x)$在训练数据集上的误差率为$e_1=P\left(G_1\left(x_i\right)\ne y_i\right)=0.3$。
    ( c ) 计算$G_1(x)$的系数：${\alpha }_1=\frac{1}{2}\log \frac{1-e_1}{e_1}=0.4236$
    ( d ) 更新训练数据的权值分布：
$$\begin{array}{rl}{D}_2=& \left(w_{21},\cdots ,w_{2i},\cdots ,w_{210}\right)\\ w_{2i}=& \frac{w_{1i}}{Z_1}\exp \left(-{\alpha }_1{y}_i{G}_1\left(x_i\right)\right),i=1,2,\cdots ,10\\ D_2=& (0.07143,0.07143,0.07143,0.07143,0.07143,0.07143,\\ & 0.16667,0.16667,0.16667,0.07143)\\ f_1(x)& =\sum _{m=1}^M{\alpha }_m{G}_m(x)=0.4236G_1(x)\end{array}$$
分类器$sign[f_1(x)]$在训练数据集上有3个误分类点。

对于m=2：
    ( a ) 在权值分布$D_2$的训练数据集上，遍历每个结点并计算分类误差率$e_m$，阈值取v=8.5时分类误差率最低，那么基本分类器为：
$$G_2(x)=\{\begin{array}{ll}1,& x<8.5\\ -1,& x>8.5\end{array}$$
    ( b ) $G_2(x)$在训练数据集上的误差率为$e_2=0.2143$
    ( c ) 计算$G_2(x)$的系数：${\alpha }_2=0.6496$
    ( d ) 更新训练数据的权值分布：
$$\begin{array}{rl}{D}_3=& (0.0455,0.0455,0.0455,0.1667,0.1667,0.1667\\ & 0.1060,0.1060,0.1060,0.0455)\\ f_2(x)& =0.4236G_1(x)+0.6496G_2(x)\end{array}$$
分类器$sign[f_2(x)]$在训练数据集上有3个误分类点。

对m=3：
    ( a )在权值分布$D_3$的训练数据集上，遍历每个结点并计算分类误差率$e_m$，阈值取v=5.5时分类误差率最低，那么基本分类器为：
$$G_3(x)=\{\begin{array}{ll}1,& x>5.5\\ -1,& x<5.5\end{array}$$
    ( b )$G_3(x)$在训练数据集上的误差率为$e_3=0.1820$
    ( c )计算$G_3(x)$的系数：${\alpha }_3=0.7514$
    ( d )更新训练数据的权值分布：
$$D_4=(0.125,0.125,0.125,0.102,0.102,0.102,0.065,0.065,0.065,0.125)$$

于是得到：$$f_3(x)=0.4236G_1(x)+0.6496G_2(x)+0.7514G_3(x)$$，分类器$\mathrm{sign}\left[f_3(x)\right]$在训练数据集上的误分类点的个数为0。
于是得到最终分类器为：$$G(x)=\mathrm{sign}\left[f_3(x)\right]=\mathrm{sign}\left[0.4236G_1(x)+0.6496G_2(x)+0.7514G_3(x)\right]$$

3. Adaboost算法实现

# 引入数据科学相关工具包：
import numpy as np
import pandas as pd 
import matplotlib.pyplot as plt
plt.style.use("ggplot")
%matplotlib inline
import seaborn as sns

# 加载训练数据：         
wine = pd.read_csv("https://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.data",header=None)
wine.columns = ['Class label', 'Alcohol', 'Malic acid', 'Ash', 'Alcalinity of ash','Magnesium', 'Total phenols','Flavanoids', 'Nonflavanoid phenols', 
                'Proanthocyanins','Color intensity', 'Hue','OD280/OD315 of diluted wines','Proline']

# 数据查看：
print("Class labels",np.unique(wine["Class label"]))
wine.head()

数据前五行如下：

Class label：分类标签
Alcohol：酒精
Malic acid：苹果酸
Ash：灰
Alcalinity of ash：灰的碱度
Magnesium：镁
Total phenols：总酚
Flavanoids：黄酮类化合物
Nonflavanoid phenols：非黄烷类酚类
Proanthocyanins：原花青素
Color intensity：色彩强度
Hue：色调
OD280/OD315 of diluted wines：稀释酒OD280 OD350
Proline：脯氨酸

# 数据预处理
# 仅仅考虑2，3类葡萄酒，去除1类
wine = wine[wine['Class label'] != 1]
y = wine['Class label'].values
X = wine[['Alcohol','OD280/OD315 of diluted wines']].values

# 将分类标签变成二进制编码：
from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
y = le.fit_transform(y)

# 按8：2分割训练集和测试集
from sklearn.model_selection import train_test_split
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=1,stratify=y)  # stratify参数代表了按照y的类别等比例抽样

# 使用单一决策树建模
from sklearn.tree import DecisionTreeClassifier
tree = DecisionTreeClassifier(criterion='entropy',random_state=1,max_depth=1)
from sklearn.metrics import accuracy_score
tree = tree.fit(X_train,y_train)
y_train_pred = tree.predict(X_train)
y_test_pred = tree.predict(X_test)
tree_train = accuracy_score(y_train,y_train_pred)
tree_test = accuracy_score(y_test,y_test_pred)
print('Decision tree train/test accuracies %.3f/%.3f' % (tree_train,tree_test))

# 使用sklearn实现Adaboost(基分类器为决策树)
'''
AdaBoostClassifier相关参数：
base_estimator：基本分类器，默认为DecisionTreeClassifier(max_depth=1)
n_estimators：终止迭代的次数
learning_rate：学习率
algorithm：训练的相关算法，{'SAMME'，'SAMME.R'}，默认='SAMME.R'
random_state：随机种子
'''
from sklearn.ensemble import AdaBoostClassifier
ada = AdaBoostClassifier(base_estimator=tree,n_estimators=500,learning_rate=0.1,random_state=1)
ada = ada.fit(X_train,y_train)
y_train_pred = ada.predict(X_train)
y_test_pred = ada.predict(X_test)
ada_train = accuracy_score(y_train,y_train_pred)
ada_test = accuracy_score(y_test,y_test_pred)
print('Adaboost train/test accuracies %.3f/%.3f' % (ada_train,ada_test))

# 画出单层决策树与Adaboost的决策边界：
x_min = X_train[:, 0].min() - 1
x_max = X_train[:, 0].max() + 1
y_min = X_train[:, 1].min() - 1
y_max = X_train[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.1),np.arange(y_min, y_max, 0.1))
f, axarr = plt.subplots(nrows=1, ncols=2,sharex='col',sharey='row',figsize=(12, 6))
for idx, clf, tt in zip([0, 1],[tree, ada],['Decision tree', 'Adaboost']):
    clf.fit(X_train, y_train)
    Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
    Z = Z.reshape(xx.shape)
    axarr[idx].contourf(xx, yy, Z, alpha=0.3)
    axarr[idx].scatter(X_train[y_train==0, 0],X_train[y_train==0, 1],c='blue', marker='^')
    axarr[idx].scatter(X_train[y_train==1, 0],X_train[y_train==1, 1],c='red', marker='o')
    axarr[idx].set_title(tt)
axarr[0].set_ylabel('Alcohol', fontsize=12)
plt.tight_layout()
plt.text(0, -0.2,s='OD280/OD315 of diluted wines',ha='center',va='center',fontsize=12,transform=axarr[1].transAxes)
plt.show()

由图可以看到，adaboost的决策边界比单决策树的决策边界要复杂得多，所以adaboost试图使用增加模型复杂度的方法来降低偏差，但同时这也有可能导致过拟合问题。这也就是为什么在上一步中，adaboost在训练集和测试集表现差异较大的原因。