集成学习(1)AdaBoost分别应用于分类和回归及其python实现

前言：近期在做比赛的时候建模阶段普遍都是使用集成模型效果更好，如xgboost、lgb、catboost等，但是对其中原理并不了解，所以准备从adaboost开始慢慢学习这一系列的集成模型…

1.AdaBoost分类

集成模型主要有bagging和boosting两种，这里都是boosting类的。

1.1Boosting基本思路

1. 先用每个样本权重相等的训练集训练一个初始的基学习器。
2. 根据上轮得到的学习器对训练集的预测表现情况调整训练集中的样本权重，然后据此训练一个新的基学习器。
3. 重复上面的步骤2得到M个基学习器，最终的集成结果就是这M个基学习器的组合。

上面的步骤很明显是一个串行的过程，并且所使用到的基学习器都是比较简单的。

1.2AdaBoost分类的基本思路

1. 提高上一轮被错误分类的样本的权值，降低被正确正确分类的样本权值。
2. 在最后集成结果线性加权求和过程中，误差率小的基学习器拥有更大的权值，误差率大的基学习器拥有较小的权值。

其中第二步集成的思想也经常用于模型融合。

1.3AdaBoost的算法步骤

首先假设样本数量为N，基学习器的数目为M。

1. 初始化样本权重：$D_1=(w_{11},w_{12},...,w_{1N}),w_{1i}=\frac{1}{N},i=1,2,...,N$；
2. 对$m=1,2,...,M$重复以下操作得到M个基学习器：
   (1)按照样本权重分布$D_m$训练数据得到第$m$个基学习器$G_m(x)$;
   (2)计算$G_m(x)$在加权训练数据集上的分类误差率：$e_m={\sum }_{i=1}^{N}D(G_m(x_i)\ne y_i)={\sum }_{i=1}^N{w}_{m,i}I(G_m(x_i)\ne y_i)$
   (3)计算$G_m(x)$的系数（即最终集成的基学习器的权重）：${\alpha }_m=\frac{1}{2}log(\frac{1-e_m}{e_m})$，可以看到误差率$e_m$越大，基学习器权重${\alpha }_m$越小。
   (4)更新样本权重：$D_{m+1}=(w_{m,1},w_{m,2},...,w_{m,N})$，$w_{m+1,i}=\frac{w_{m,i}}{Z_m}exp(-{\alpha }_m{y}_i{G}_m(x_i)),i=1,2,...,N$。其中$Z_m$是规范化因子，目的就是为了使$D_{m+1}$得所有元素之和为1，$Z_m={\sum }_{i=1}^N{w}_{m,i}exp(-{\alpha }_m{y}_i{G}_m(x_i))$。可以看到当分类错误时，$y_i{G}_m(x_i)=-1$，对应的权值增加。
3. 构建最终的分类器线性组合:$f(x)={\sum }_{m=1}^M{\alpha }_m{G}_m(x)$，分类器$G(x)=sign(f(x))$。

1.4AdaBoost算法的解释

在上面算法步骤中可以看到基学习器权重${\alpha }_m$得更新公式和样本权重$w_m$的更新公式是符合基本思路的，但是对于为什么是要这么更新？我们可以从另一个角度出发，把AdaBoost看作模型是加法模型、损失函数是指数损失函数、学习算法为前向分步算法的二分类学习方法。

（1）首先看一下前向分步算法的基本思想(这里为了一般化，用其他符号进行表示)：
对于我们的加法模型：$f(x)={\sum }_{m=1}^M{\beta }_{m}b(x;{\gamma }_m)$, 其中$b(x;{\gamma }_m)$是基函数，${\gamma }_m$是基函数的参数，${\beta }_m$是基函数的系数；在给定损失函数$L(y,f(x))$的条件下，学习加法模型的过程就是最小化损失函数：$min{\sum }_{i=1}^{N}L(y_i,{\sum }_{m=1}^M{\beta }_{m}b(x;{\gamma }_m))$，而这个最优化的过程通常比较复杂，前向分布算法解决这个优化问题的思想就是每次只学习一个基函数，然后再用学习得到的这个基函数更新我们的加法模型。

（2）算法步骤：
输入训练集 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​)}；损失函数$L(y,f(x))$；基函数集 { b ( x ; γ ) } \{b(x;\gamma)\} {b(x;γ)}

1. 初始化$f_0(x)=0$
2. 对$m=1,2,...,M$
   (1)极小化损失函数：$({\beta }_m,{\gamma }_m)=argmi{n}_{\beta ,\gamma }{\sum }_{i=1}^{N}L(y_i,f_{m-1}(x_i)+\beta b(x;\gamma ))$，得到第m个基函数参数
   (2)更新加法模型：$f_m(x)=f_{m-1}(x)+{\beta }_{m}b(x;{\gamma }_m)$
3. 得到加法模型：$f(x)=f_M(x)={\sum }_{m=1}^M{\beta }_{m}b(x;{\gamma }_m)$

我们在1.3中得到的加法分类器也是这样的一个加法模型，所以也可以使用前向分步算法来进行求解。

（3）具体推导：
首先基于前向分步算法的思想和AdaBoost得到的加法模型，AdaBoost可以看作前向分步算法的一个特例，其基函数为基本分类器$G(x)$，损失函数为指数损失函数$L(y,f(x))=exp(-yf(x))$。结合上面的算法步骤，假设前m-1轮已经得到$f_{m-1}(x)$，我们的第m轮的优化目标如下：
$$\begin{gathered} argmi{n}_{{\alpha }_m,G_m}\sum _{i=1}^{N}L(y_i,f_{m-1}(x_i)+{\alpha }_m{G}_m(x_i)) \\ \Rightarrow argmi{n}_{{\alpha }_m,G_m}\sum _{i=1}^{N}exp[-y_i(f_{m-1}(x_i)+{\alpha }_m{G}_m(x_i))] \\ \Rightarrow argmi{n}_{{\alpha }_m,G_m}\sum _{i=1}^{N}exp[-y_i{f}_{m-1}(x_i)]exp[-y_i{\alpha }_m{G}_m(x_i)] \end{gathered}$$
因为$y_i$和$f_{m-1}(x)$已经得到，所以可以令$w_{m,i}=exp[-y_i{f}_{m-1}(x_i)]$，然后上面的优化目标变成如下形式：
$$\begin{gathered} argmi{n}_{{\alpha }_m,G_m}\sum _{i=1}^N{w}_{m,i}exp[-y_i{\alpha }_m{G}_m(x_i)] \\ \Rightarrow argmi{n}_{{\alpha }_m,G_m}\sum _{y_i=G_m(x_i)}{w}_{m,i}{e}^{-{\alpha }_m}+\sum _{y_i\ne G_m(x_i)}{w}_{m,i}{e}^{{\alpha }_m} \\ \Rightarrow argmi{n}_{{\alpha }_m,G_m}\sum _{y_i=G_m(x_i)}{w}_{m,i}{e}^{-{\alpha }_m}+\sum _{y_i\ne G_m(x_i)}{w}_{m,i}{e}^{-{\alpha }_m}-\sum _{y_i\ne G_m(x_i)}{w}_{m,i}{e}^{-{\alpha }_m}+\sum _{y_i\ne G_m(x_i)}{w}_{m,i}{e}^{{\alpha }_m} \\ \Rightarrow argmi{n}_{{\alpha }_m,G_m}(e^{{\alpha }_m}-a^{-{\alpha }_m})\sum _{i=1}^N{w}_{m,i}I(y_i\ne G_m(x_i))+e^{-{\alpha }_m}\sum _{i=1}^N{w}_{m,i} \end{gathered}$$
然后上式关于${\alpha }_m$求导，并令其为0：
$$\begin{gathered} (e^{{\alpha }_m}+a^{-{\alpha }_m})\sum _{i=1}^N{w}_{m,i}I(y_i\ne G_m(x_i))-e^{-{\alpha }_m}\sum _{i=1}^N{w}_{m,i}=0 \\ \Rightarrow \frac{{\sum }_{i=1}^N{w}_{m,i}I(y_i\ne G_m(x_i))}{{\sum }_{i=1}^N{w}_{m,i}}=\frac{e^{-{\alpha }_m}}{(e^{{\alpha }_m}+a^{-{\alpha }_m})} \end{gathered}$$
可以看到上式左边部分就是我们的当前第m轮模型的误差率，所以令$e_m=\frac{{\sum }_{i=1}^N{w}_{m,i}I(y_i\ne G_m(x_i))}{{\sum }_{i=1}^N{w}_{m,i}}$，这里的e时误差的意思，和上式右半部分的e的不同，然后将其带入上式可得到:
$${\alpha }_m=\frac{1}{2}log\frac{1-e_m}{e_m}$$
然后结合$w_{m,i}=exp[-y_i{f}_{m-1}(x_i)]$和$f_m(x)=f_{m-1}(x)+{\alpha }_m{G}_m(x)$得出权值更新的公式：
$$\begin{gathered} f_m(x_i)=f_{m-1}(x_i)+{\alpha }_m{G}_m(x_i) \\ \Rightarrow -y_i{f}_m(x_i)=-y_i{f}_{m-1}(x_i)-y_i{\alpha }_m{G}_m(x_i) \\ \Rightarrow e^{-y_i{f}_m(x_i)}=e^{-y_i{f}_{m-1}(x_i)}{e}^{-y_i{\alpha }_m{G}_m(x_i)} \\ \Rightarrow w_{m+1,i}=w_{m,i}{e}^{-y_i{\alpha }_m{G}_m(x_i)} \end{gathered}$$
然后对权值继续规范化，使其之和为1，然后对应的误差$e_m$中的分母也就为1。

1.5python实现

这里实现的一个简易版的，基学习器使用一个根节点的决策树，数据集采用西瓜书对应章节的数据进行简单测试。

import numpy as np
import pandas as pd
#构建单层决策树为基分类器的提升模型
def load_data():
    df = pd.DataFrame()
    df['密度'] = [0.697, 0.774, 0.634, 0.608, 0.556, 0.403, 0.481, 0.437, 0.666, 0.243, 0.245, 0.343, 0.639, 0.657,
                0.360, 0.593, 0.719]
    df['含糖量'] = [0.460, 0.376, 0.264, 0.318, 0.215, 0.237, 0.149, 0.211, 0.091, 0.267, 0.057, 0.099, 0.161, 0.198,
                 0.370, 0.042, 0.103]
    df["好瓜"] = ["是", "是", "是", "是", "是", "是", "是", "是", "否", "否", "否", "否", "否", "否", "否", "否", "否"]
    df.to_csv('data/watermelon45.csv', index=0)

#计算更新样本的权重
def cal_sample_weight(weight_list:[],y_true:[],y_pred:[],am):
    weight_list = np.array(weight_list)*np.exp(-am*(y_true*y_pred))
    Zm = np.sum(weight_list)
    return list(weight_list/Zm)

#计算第m轮模型的权重
def cal_tree_weight(em):
    return np.log((1 - em) / em) / 2

def cal_em(feat_value_list:[], threshold, y_true:[], weight_list:[], flag='l'):
    :param feat_value_list: 划分特征的所有取值
    :param threshold: 阈值
    :param y_true: 样本的真实标签列表
    :param weight_list: 样本当前的权重
    :return: 误差率

    y_pred = np.ones(len(y_true))
    if flag == 'l':
        y_pred[np.array(feat_value_list)>threshold] = -1 #大于阈值的预测为-1,小于阈值的预测为1
    elif flag == 'r':
        y_pred[np.array(feat_value_list) < threshold] = -1 #大于阈值的预测为1,小于阈值的预测为-1
    em = np.sum(np.array(weight_list)[y_pred != y_true])
    return em,y_pred

#构建单层决策树
def build_stump(data:pd.DataFrame, weight_list:[], label:[]):

    :param data: 训练数据
    :param weight_list: 训练样本的权重
    :param label: 数据的真实标签
    :return:
    min_em = np.inf #找到使得当前权重下误差率最小的分类器
    tree = {} #返回的单层决策树
    best_feat = '' #最优划分特征
    best_threshold = -1 #最优划分特征下产生的最优化阈值
    ret_y_pred = [] #最优划分下决策树的预测结果
    best_flag = ''
    for feat in data.columns.values:
        feat_value_list = list(data[feat]) #该属性下的取值
        sorted_feat_value_list = sorted(list(set(feat_value_list)))
        threshold_list = [(sorted_feat_value_list[i]+sorted_feat_value_list[i+1])/2 for i in np.arange(len(sorted_feat_value_list)-1)]
        for threshold in threshold_list:
            for flag in ['l','r']:
                cur_em, y_pred = cal_em(feat_value_list, threshold, label, weight_list, flag) #计算误差率
                if cur_em < min_em:
                    min_em = cur_em
                    best_feat = feat
                    best_threshold = threshold
                    ret_y_pred = y_pred
                    best_flag = flag

    return best_feat, best_threshold, min_em, ret_y_pred, best_flag

#构建提升树分类模型
def build_adaboost_classifier(data:pd.DataFrame, n=5):
    :param data: 训练数据集
    :param n: 指定基分类器的数量
    :return: 返回集成分类器

    train_features = np.array(data.columns)[:-1]
    label_feature = np.array(data.columns)[-1]
    train_data = data[train_features]
    label = data[label_feature]
    weight_list = np.ones(len(label))/len(label) #初始化权重
    adaboost_clf = []
    for _ in np.arange(n):
        best_feat, best_threshold, min_em, y_pred,best_flag = build_stump(train_data, weight_list, label)
        am = cal_tree_weight(min_em)
        weight_list = cal_sample_weight(weight_list,label,y_pred,am)
        adaboost_clf.append((am,best_feat,best_threshold,best_flag))
        print(weight_list)
        print('误差率：.{} 阈值：.{} flag:.{}'.format(min_em, best_threshold, best_flag))

    return adaboost_clf

#分类器预测
def predict(data:pd.DataFrame, clf_list:[]):
    y_pred = np.zeros(len(data))
    for (am,best_feat,best_threshold,best_flag) in clf_list:
        y_pred_tmp = np.ones(len(data))
        if best_flag == 'l':
            y_pred_tmp[data[best_feat]>best_threshold] = -1
        elif best_flag == 'r':
            y_pred_tmp[data[best_feat] < best_threshold] = -1

        y_pred += am*y_pred_tmp

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

    return y_pred


if __name__ == '__main__':
    watermelon = pd.read_csv('data/watermelon45.csv')
    watermelon['好瓜'] = watermelon['好瓜'].map({'是':1,'否':-1})
    print(watermelon)
    # feat_value_list = [0,1,2,3,4,5,6,7,8,9]
    # df = pd.DataFrame(columns=['feat1','feat2'])
    # y_true = [1, 1, 1, -1, -1, -1, 1, 1, 1, -1]
    # df['feat1'] = feat_value_list
    # df['feat2'] = feat_value_list
    # df['label'] = y_true
    # weight_list = [0.1,0.1,0.1,0.1,0.1,0.1,0.1,0.1,0.1,0.1]

    # print(build_stump(df,weight_list,y_true))
    clf_list = build_adaboost_classifier(watermelon, n=11)
    y_pred = predict(watermelon, clf_list)
    print(list(watermelon['好瓜']))
    print(y_pred)
    print(np.sum(np.ones(len(y_pred))[y_pred!=list(watermelon['好瓜'])]))

2.AdaBoost回归

2.1基本思想

AdaBoost用于回归问题时也是采用前向分步算法的思想，基函数使用回归树$T(x)$（回归树的原理可以参考机器学习决策树DecisionTree以及python代码实现），损失函数使用平方误差损失$L(y,f(x))=(y-f(x){)}^2$，根据前向分步算法的思想，我们当前m轮的加法模型就是$f_m(x)=f_{m-1}(x)+T_m(x)$，假设我们已经经过m-1轮得到了$f_{m-1}(x)$，那么我们第m轮的优化目标就变成如下形式：
$$\begin{gathered} argmi{n}_{T_m}\sum _{i=1}^{N}L(y_i,f_{m-1}(x_i)+T_m(x_i){)}^2 \\ \Rightarrow argmi{n}_{T_m}\sum _{i=1}^N(y_i-f_{m-1}(x_i)-T_m(x_i){)}^2 \\ \Rightarrow argmi{n}_{T_m}\sum _{i=1}^N(r_{m,i}-T_m(x_i){)}^2 \end{gathered}$$
其中，$r_{m,i}=y_i-f_{m-1}(x_i)$表示当前模型的残差（即当前模型预测值和真实值的差），所以第m轮的优化目标就变成去拟合当前模型$f_{m-1}(x)$的残差，所以我们只需要每一轮使用一个回归树去拟合残差即可，最后将模型线性相加即可。

2.2算法的具体步骤：

输入：训练数据集 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​)}，$x\in R^n,y\in R$
输出：提升树

1. 初始化$f_0(x)=0$
2. 对m=1,2,…,M。
   (1)计算残差：$r_{m,i}=y_i-f_{m-1}(x_i),i=1,2,...,N$
   (2)通过拟合$r_{m,i}$构建一个回归树$T_m(x)$
   (3)更新：$f_m(x)=f_{m-1}(x)+T_m(x)$
3. 得到回归提升树：$f_M(x)={\sum }_{m=1}^M{T}_m(x)$

2.3python实现

这里我们调用的前面决策树中实现的回归树，来构建一个简易版的提升树。

import numpy as np
import pandas as pd
from DecisionTree import decisiontreeRegressor

'''构建回归树为基模型的提升树回归模型'''

def build_adaboost_regressor(data:pd.DataFrame, n=5):
    '''
    :param data: 训练集
    :param n: 基分类器的数量,基模型默认使用max_depth=1的回归树
    :return:
    '''
    adaboost_regressor = [] #集成模型
    train_data = data[np.array(data.columns)[:-1]]
    y_true = data[np.array(data.columns)[-1]]
    base_model = decisiontreeRegressor.build_regressionTree(train_data, y_true, cur_depth=1,max_depth=1)
    y_pred = decisiontreeRegressor.predict(base_model, train_data) #当前加法模型的预测结果
    adaboost_regressor.append(base_model)
    for _ in np.arange(n-1):
        r = y_true - y_pred #当前模型和真实值的残差
        # print('mse:.{}'.format(np.sum(r**2)))
        base_model = decisiontreeRegressor.build_regressionTree(train_data, r, cur_depth=1, max_depth=1)
        r_pred = decisiontreeRegressor.predict(base_model, train_data)
        y_pred = y_pred + r_pred # 模型相加的预测结果
        adaboost_regressor.append(base_model)

    return adaboost_regressor

def predict(data:pd.DataFrame, model:[]):
    y_pred = np.zeros(len(data))
    for base_model in model:
        y_pred += decisiontreeRegressor.predict(base_model, data)

    return y_pred

if __name__ == '__main__':
    df = pd.DataFrame(columns=['x1'])
    df['x1'] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    y_true = [5.56, 5.70, 5.91, 6.40, 6.80, 7.05, 8.90, 8.70, 9.00, 9.05]
    df['y'] = y_true
    tree_list = build_adaboost_regressor(df, 6)
    for tree in tree_list:
        print(tree)

    y_pred = predict(df.loc[:,['x1']],tree_list)
    # print(np.sum((y_pred-y_true)**2)/len(y_pred))