Adaboost Python实现

Adaboost Python实现

本文是根据李航的《统计学习方法》进行复现，按照二分类的Adaboost进行操作（当然现在也已经有了多分类的改进算法）。

算法原理简介

集成学习算法往往可以分成Boosting族和Bagging族两大类，他们的区别主要就是Boosting是类似于串行的结构，每个基分类器之间有着强依存关系，而Bagging一族则是并行式的集成算法。

Adaboost作为集成学习的入门算法，简单有效，是Boosting一族算法中的重要代表。

他的原理其实很简单，就是通过寻找最优的阈值来进行分类，分类错误的权值变大，在下次分类时分类器为了得到较低的误差率会更倾向于把他分类正确。

算法流程

1. 初始化数据集权值分布
$D_1=(w_{11},...,w_{1i},w_{1N}),...,w_{1i}=\frac{1}{N},i=1,2,...,N$
2. 对$m=1,2,...,M$
（a）使用具有权值分布$D_m$的训练数据集学习，得到基分类器
$G_m(x):X\to \{-1,+1\}$
（b）计算$G_m(x)$在训练数据集上的分类误差率
$e_m=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}ln\frac{1-e_m}{e_m}$
（d）更新训练数据集的权值分布
$D_{m+1}=(w_{m+1,1},...,w_{m+1,i},...,w_{m+1,N})$
$w_{m+1,i}=\frac{w_{mi}}{Z_m}{e}^{-{\alpha }_m{y}_i{G}_m(x_i)}$
tip:$Z_m$是规范化因子，$Z_m={\sum }_{i=1}^N{w}_{mi}{e}^{-{\alpha }_m{y}_i{G}_m(x_i)}$

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))$

实现代码

定义函数如下：

def get_data(col,fold): #通过分层采样划分训练集和测试集
    fpath = r'your files' ###
    object = pd.read_excel(fpath,header=None)
    dataSet = object.iloc[:, 0:col]
    trans_dataSet = dataSet.values.tolist()
    labels = []
    total_size = len(trans_dataSet)
    for i in range(0,total_size):
        labels.append(trans_dataSet[i][-1])
    labels = np.unique(labels) #获取所有标签值
    sampling = [[] for i in range(0,len(labels))]
    for i in range(0, total_size):
        for k in range(0,len(labels)):
            if trans_dataSet[i][-1] == labels[k]:
                sampling[k].append(trans_dataSet[i])
    train_data = []
    test_data = []
    for i in range(0, len(labels)):
        for k in range(0,len(sampling[i])):
            random.shuffle(sampling[i])  # shuffle()方法将序列的所有元素随机排序。
        test_size = len(sampling[i]) // 10
        for j in range((fold-1)*test_size,fold*test_size):
            test_data.append(sampling[i][j])
        for j in range(0,(fold-1)*test_size):
            train_data.append(sampling[i][j])
        for j in range(fold*test_size,len(sampling[i])):
            train_data.append(sampling[i][j])
    train_size = len(train_data)
    test_size = len(test_data)
    return train_data,test_data,train_size,test_size


def divi(train_data,col):  #选出划分阈值
    a = [[] for i in range(col)]
    blist = [[] for i in range(col)]
    for x in train_data:
        for i in range(0,col):
            a[i].append(x[i])
            a[i] = list(set(a[i]))
    for i in range(0,col):
        sorted(a[i])
    for i in range(0,col):
        for k in range(0,len(a[i])-1):
            blist[i].append((a[i][k]+a[i][k+1])/2)
    return blist


def train(train_data,test_data,y1,y2,blist,w1,w2,col,n1,n2):  #在该权重分布下进行训练并输出该次训练精度
    cc = []  #获取每个特征列下最小误差率的阈值信息
    slist = []
    for i in range(0,col):
        box = []  #存放该阈值下分类情况的信息，包括误差率、特征列、阈值、阈值分类情况
        for k in range(0,len(blist[i])):  #先假定阈值以左为-1，阈值以右为1
            s = blist[i][k]  #s为当前阈值
            count = 0
            flag = 0
            for j in range(0,n1):
                if train_data[j][i] < s:
                    count += (y1[j] != -1) * w1[j]
                else:
                    count += (y1[j] != 1) * w1[j]
            if count > 0.5:  #若误差率大于0.5，则实际情况为阈值以左为1，阈值以右为-1，更正误差率
                count = 0
                flag = 1
                for j in range(0,n1):
                    if train_data[j][i] < s:
                        count += (y1[j] != 1) * w1[j]
                    else:
                        count += (y1[j] != -1) * w1[j]
            box.append([count,i,k,flag])
        cc.append(min(box))
    mark = min(cc)  #获取该权重分布下全体最小误差率阈值的信息
    error1 = mark[0]  #当前权重分布下最小误差率
    #print(mark)  #mark[1],mark[2]对应该分类器下最佳阈值的i,k值。  mark[3]作为阈值是否服从原假设情形的标记。
    gx1 = []
    s = blist[mark[1]][mark[2]]
    slist.append(s)  # 存储该次分类的最佳阈值
    if mark[3] == 0:
        for i in range(0,n1):
            if train_data[i][mark[1]] < s:
                gx1.append(-1)
            else:
                gx1.append(1)
    if mark[3] == 1:
        for i in range(0,n1):
            if train_data[i][mark[1]] < s:
                gx1.append(1)
            else:
                gx1.append(-1)
    alpha1 = 1/2*np.log((1-error1)/(error1))  #计算该分类器系数
    z_m_1 = 0
    for i in range(0,n1):
        z_m_1 += w1[i]*np.exp(-alpha1*y1[i]*gx1[i])
    for m in range(0,n1):  #更新训练集权值分布
        w1[m] = w1[m]/z_m_1*np.exp(-alpha1*y1[m]*gx1[m])

    # 通过上述得到的阈值对测试集进行划分，计算误差率
    gx2 = []
    error2 = 0
    for i in range(0, n2):
        if test_data[i][mark[1]] < s:
            gx2.append(-1)
            error2 += w2[i] * (y2[i] != gx2[i])
        else:
            gx2.append(1)
            error2 += w2[i] * (y2[i] != gx2[i])
    if error2 > 0.5:
        gx2 = []
        error2 = 0
        for i in range(0, n2):
            if test_data[i][mark[1]] < s:
                gx2.append(1)
                error2 += w2[i] * (y2[i] != gx2[i])
            else:
                gx2.append(-1)
                error2 += w2[i] * (y2[i] != gx2[i])
    try:
        error2 == 0
    except:
        print("ZeroDivisionError")
    else:
        error2 += 0.00001
    alpha2 = 1/2 * np.log((1 - error2)/(error2))  # 计算该分类器系数
    z_m_2 = 0
    for i in range(0, n2):
        z_m_2 += w2[i] * np.exp(-alpha2 * y2[i] * gx2[i])
    for m in range(0, n2):  # 更新训练集权值分布
        w2[m] = w2[m] / z_m_2 * np.exp(-alpha2 * y2[m] * gx2[m])
    return w1,w2,gx2,alpha2


def adaboost(train_data,test_data,blist,w1,w2,col,multi_num):  #进行adaboost集成训练
    n1 = len(train_data)
    n2 = len(test_data)
    y1 = []
    y2 = []
    for i in range(0,n1):
        y1.append(2*train_data[i][col]-3) ###
    for i in range(0,n2):
        y2.append(2*test_data[i][col]-3) ###
    fn2 = [0] * n2
    for i in range(multi_num):
        w1 , w2 , gx2 , alpha2 = train(train_data,test_data,y1,y2,blist,w1,w2,col,n1,n2)
        for j in range(0,n2):
            fn2[j] += alpha2 * gx2[j]
    for j in range(0,n2):
        if fn2[j] > 0:
            fn2[j] = 1
        else:
            fn2[j] = -1
    rati2 = 0
    for l in range(0,n2):
        if fn2[l] == y2[l]:
            rati2 += 1
    acc2 = rati2/n2
    return acc2