机器学习实战-【AdaBoost】

最新推荐文章于 2020-11-10 20:58:32 发布

DisguiseR6

最新推荐文章于 2020-11-10 20:58:32 发布

阅读量550

点赞数 1

分类专栏： # 机器学习实战

本文链接：https://blog.youkuaiyun.com/qq_25614773/article/details/90384027

版权

机器学习实战专栏收录该内容

4 篇文章

订阅专栏

机器学习实战-【AdaBoost】

1. 难点说明

1- stumpClassify( )

构建单层决策树中

参数threshIneq，它取值 lt 或 gt 。lt 表示小于阈值的为 -1，gt 表示大于阈值的为-1（ $\color{Red}事先不知道大于阈值判断为+1还是-1$ ）

2-adaBoostTrainDS( )

aggclassEst 参数——记录每个数据点的类别估计值

aggClassEst+=alpha*classEst

$f(x)=\sum \alpha G_m(x)$

权重向量：D

错误率定义(errorRate)
$\varepsilon = \frac{未正确分类的样本数目}{所有样本数目}$
区别于计算 $G_m(x)$ 在训练集上的分类误差率（ $\color{Red}权值之和$ ）
$e_{m}=P\left(G_{m}\left(x_{i}\right) \neq y_{i}\right)=\sum_{i=1}^{N} w_{m i} I\left(G_{m}\left(x_{i}\right) \neq y_{i}\right)$

alpha的计算公式：
$\alpha=\frac{1}{2} \ln \left(\frac{1-\varepsilon}{\varepsilon}\right)$
权重更新：
$正确分类：D_{i}^{(t+1)}=\frac{D_{i}^{(t)} \mathrm{e}^{-\alpha}}{\operatorname{Sum}(D)}$

$错误分类：D_{i}^{(t+1)}=\frac{D_{i}^{(t)} \mathrm{e}^{\alpha}}{\operatorname{Sum}(D)}$

2.基于单层决策树构建弱分类器

单层决策树（dicision stump,也称决策树桩）——仅基于单个特征来做决策

伪代码

将最小错误率minError设为+∞
对数据集中的每个特征（第一层循环）
	对每个步长（第二层循环）
		对每个不等号（第三层循环）
			建立一颗单层决策树并利用加权数据集对它进行测试
			如果错误率低于minError,则将当前单层决策树设为最佳单层决策树
返回最佳单层决策树

代码（adaBoost.py）

import numpy as np
import matplotlib.pyplot as plt

def loadSimpData():
    '''获取数据'''
    dataMat= np.matrix([[1. ,2.1],
        [2. ,1.1],
        [1.3,1. ],
        [1. ,1. ],
        [2. ,1. ]])
    classLabels=[1.0, 1.0, -1.0, -1.0, 1.0]
    return dataMat,classLabels

def stumpClassify(dataMatrix, dimen, threshVal, threshIneq):
    '''测试是否有某个值小于或者大于正在测试的阈值
    @ dataMatrix 数据集
    @ dimen 维度
    @ threshVal 阈值
    @ threshIneq 取值lt或 gt，lt表示小于阈值的为-1，gt表示大于阈值的为-1
    '''    
    retArray = np.ones((np.shape(dataMatrix)[0],1))
    # 阈值模式， 将小于某一阈值的特征归类为 -1
    if threshIneq == 'lt':
        retArray[dataMatrix[:,dimen] <= threshVal] = -1.0
    else:
        retArray[dataMatrix[:,dimen] > threshVal] = -1.0
    return retArray

def buildStump(dataArr, classLabels, D):
    '''
    @ dataArr 数据集
    @ classLabels 标签
    @ D 权重向量
    '''
    dataMatrix = np.mat(dataArr)
    labelMat = np.mat(classLabels).T  # 将数据集和标签转化为矩阵形式
    m,n = np.shape(dataMatrix)  # m 为数据集个数， n 为特征数
    # 步长或区间总数 最优决策树信息 最优单层决策树预测结果
    numSteps = 10.0
    bestStump = {}
    bestClasEst = np.mat(np.zeros((m,1)))   
    minError = float('inf') # 最小错误率初始化为+∞   
    for i in range(n):
        #找出列中特征值的最小值和最大值
        rangeMin=dataMatrix[:,i].min(); rangeMax=dataMatrix[:,i].max()
        # 求取步长大小或者说区间间隔
        stepSize=(rangeMax-rangeMin)/numSteps
        # 遍历各个步长区间
        for j in range(-1,int(numSteps)+1):
            #两种阈值过滤模式
            for inequal in ['lt','gt']:
            #阈值计算公式：最小值+j(-1<=j<=numSteps+1)*步长
                threshVal=(rangeMin+float(j)*stepSize)
                #选定阈值后，调用阈值过滤函数分类预测
                predictedVals = stumpClassify(dataMatrix,i,threshVal,inequal)                
                #初始化错误向量
                errArr=np.mat(np.ones((m,1)))
                #将错误向量中分类正确项置0
                errArr[predictedVals==labelMat]=0
                #计算"加权"的错误率
                weigthedError=D.T*errArr
                #print("split: dim %d, thresh %.2f, thresh ineqal: %s, the weighted error is %.3f" % (i, threshVal, inequal,weigthedError ))
            
                #如果当前错误率小于当前最小错误率，将当前错误率作为最小错误率
                #存储相关信息
                if weigthedError < minError:
                    minError = weigthedError
                    bestClasEst = predictedVals.copy()
                    bestStump['dim']=i
                    bestStump['thresh']= threshVal
                    bestStump['ineq']= inequal
    #返回最佳单层决策树相关信息的字典，最小错误率，决策树预测输出结果
    return bestStump,minError,bestClasEst
    
    
def plot(dataMat, classLabels):
    dataArr = np.array(dataMat)        #转化为矩阵
    n = np.shape(dataArr)[0]   
    xcord1 = [];ycord1 = []
    xcord2 = [];ycord2 = []
    for i in range(n):
        if int(classLabels[i]==1):
            xcord1.append(dataArr[i,0]);ycord1.append(dataArr[i,1])
        else:
            xcord2.append(dataArr[i,0]);ycord2.append(dataArr[i,1])  
    fig = plt.figure() # 生成一个新的图片
    ax = fig.add_subplot(111) # 创建一个或多个子图（subplot）
    ax.scatter(xcord1,ycord1,c='blue', marker='s')
    ax.scatter(xcord2,ycord2, c='green')
    plt.show()
if __name__=='__main__':
    dataMat, classLabels = loadSimpData()
    plot(dataMat, classLabels)
    D = np.mat(np.ones((5,1))/5)
    
    bestStump, minError, bestClasEst = buildStump(dataMat, classLabels, D)
    print('最佳决策树相关信息的字典：{}'.format(bestStump))
    print('最小错误率：{}'.format(minError))
    print('决策树预测的输出结果：{}'.format(bestClasEst))

最佳决策树相关信息的字典：{'dim': 0, 'thresh': 1.3, 'ineq': 'lt'}
最小错误率：[[ 0.2]]
决策树预测的输出结果：[[-1.]
 [ 1.]
 [-1.]
 [-1.]
 [ 1.]]

3.完整 Adaboost 算法的实现

伪代码

对每次迭代：
	利用buildStump()函数找到最佳的单层决策树
    将最佳单层决策树加入到单层决策树数组
    计算alpha
    计算新的权重向量D
    更新累计类别估计值
    如果错误率为等于0.0，退出循环

代码（adaBoost_1.py）

import numpy as np
import adaBoost

def adaBoostTrainDS(dataArr, classLabels, numIt=40):
    '''
    @ dataArr 数据
    @ classLabels 标签
    @ numIt 迭代次数
    '''
    # 弱分类器相关信息列表
    weakClassArr = []
    m = np.shape(dataArr)[0]  # 获取数据数量
    D = np.mat(np.ones((m,1))/m)  # 初始化权值
    # 累计估计值向量
    aggClassEst = np.mat(np.zeros((m,1)))
    
    for i in range(numIt):
        # 构建最佳单层决策树
        bestStump, error, classEst = adaBoost.buildStump(dataArr, classLabels, D)
        print('D:',D.T)
        alpha = float(0.5*np.log((1.0-error)/max(error, 1e-16)))
        bestStump['alpha'] = alpha # 存储决策树的系数alpha到字典
        weakClassArr.append(bestStump)
        print("预测结果classEst:",classEst.T)
        #预测正确为exp(-alpha),预测错误为exp(alpha)
        #即增大分类错误样本的权重，减少分类正确的数据点权重
        expon=np.multiply(-1*alpha*np.mat(classLabels).T,classEst)
        '''更新权值向量'''
        D=np.multiply(D,np.exp(expon))
        D=D/D.sum()
        #累加当前单层决策树的加权预测值
        aggClassEst+=alpha*classEst
        print("aggClassEst",aggClassEst.T)
        #求出分类错的样本个数
        aggErrors=np.multiply(np.sign(aggClassEst)!=np.mat(classLabels).T,np.ones((m,1)))
        #计算错误率
        errorRate=aggErrors.sum()/m
        print("total error:",errorRate,"\n")
        #错误率为0.0退出循环
        if errorRate==0.0:break
    #返回弱分类器的组合列表
    return weakClassArr

if __name__=='__main__':
    dataMat, classLabels = adaBoost.loadSimpData()
    adaBoostTrainDS(dataMat, classLabels, 9)

D: [[ 0.2  0.2  0.2  0.2  0.2]]
classEst: [[-1.  1. -1. -1.  1.]]
aggClassEst [[-0.69314718  0.69314718 -0.69314718 -0.69314718  0.69314718]]
total error: 0.2 

D: [[ 0.5    0.125  0.125  0.125  0.125]]
classEst: [[ 1.  1. -1. -1. -1.]]
aggClassEst [[ 0.27980789  1.66610226 -1.66610226 -1.66610226 -0.27980789]]
total error: 0.2 

D: [[ 0.28571429  0.07142857  0.07142857  0.07142857  0.5       ]]
classEst: [[ 1.  1.  1.  1.  1.]]
aggClassEst [[ 1.17568763  2.56198199 -0.77022252 -0.77022252  0.61607184]]
total error: 0.0

4.测试算法：基于AdaBoost的分类（adaBoost_2.py）

import numpy as np 
import adaBoost
import adaBoost_1

def adaClassify(datToclass, classifierArr):
   '''
   @ datToclass 测试数据点
   @ classifierArr 构建好的分裂器
   '''
   #构建数据向量或矩阵
   dataMatrix = np.mat(datToclass)
   #获取矩阵行数
   m=np.shape(dataMatrix)[0]
   #初始化最终分类器
   aggClassEst=np.mat(np.zeros((m,1)))
   #遍历分类器列表中的每一个弱分类器
   for i in range(len(classifierArr)):
       #每一个弱分类器对测试数据进行预测分类
       classEst=adaBoost.stumpClassify(dataMatrix,
                              classifierArr[i]['dim'],
                              classifierArr[i]['thresh'],
                              classifierArr[i]['ineq'])
       '''对各个分类器的预测结果进行加权累加'''
       aggClassEst += classifierArr[i]['alpha']*classEst
       print('aggClassEst',aggClassEst)
   #通过sign函数根据结果大于或小于0预测出+1或-1
   return np.sign(aggClassEst)

if __name__=='__main__':
   dataMat, classLabels = adaBoost.loadSimpData()
   clasifierArr = adaBoost_1.adaBoostTrainDS(dataMat, classLabels, 30)
   
   print(adaClassify([[0,0],[5,5]],clasifierArr))

5.示例：在一个难数据集上应用AdaBoost（adaBoost_3.py）

与第四章数据相同

import numpy as np
import adaBoost_1
import adaBoost_2

def loadDataSet(filename):
    #创建数据集矩阵，标签向量
    dataMat=[];labelMat=[]
    #获取特征数目(包括最后一类标签)
    #readline():读取文件的一行
    #readlines:读取整个文件所有行
    numFeat=len(open(filename).readline().split('\t'))
    #打开文件
    fr=open(filename)
    #遍历文本每一行
    for line in fr.readlines():
        lineArr=[]
        curLine=line.strip().split('\t')
        for i in range(numFeat-1):
            lineArr.append(float(curLine[i]))
        #数据矩阵
        dataMat.append(lineArr)
        #标签向量
        labelMat.append(float(curLine[-1]))
    return dataMat,labelMat

if __name__=='__main__':
    datArr, labelArr = loadDataSet('horseColicTraining2.txt')
    classifierArray = adaBoost_1.adaBoostTrainDS(datArr,labelArr,1000)
    
    testArr,testLabelArr=loadDataSet('horseColicTest2.txt')
    prediction= adaBoost_2.adaClassify(testArr,classifierArray)
    
    errArr=np.mat(np.ones((67,1)))
    error=errArr[prediction!=np.mat(testLabelArr).T].sum()
    print("the test_error is: {}".format(error/float(67)))