机器学习实战——AdaBoost

书籍：《机器学习实战》中文版
IDE：Spyder

环境：Adaconda3  python3.6

(Spyder相对pycharm来说，比较简洁，而且对于常用matlab的人，感觉更亲切。它可以方便的观察变量值，查看运行结果等。但是spyder没有代码折叠！代码提示方面也远不如pycharm！)

Ensemble方法：集合方法，将弱分类器变成一个强分类器。

可以是不同算法的集成、同一算法在不同设置下的集成、数据集不同部分分配给不同分类器之后的集成。

一、基本概念 

1、bagging方法

Bagging即套袋法，其算法过程如下：

1）从原始样本集中抽取训练集。每轮从原始样本集中使用Bootstraping的方法抽取n个训练样本（在训练集中，有些样本可能被多次抽取到，而有些样本可能一次都没有被抽中）。共进行k轮抽取，得到k个训练集。（k个训练集之间是相互独立的）

2）每次使用一个训练集得到一个模型，k个训练集共得到k个模型。（注：这里并没有具体的分类算法或回归方法，我们可以根据具体问题采用不同的分类或回归方法，如决策树、感知器等）

3）对分类问题：将上步得到的k个模型采用投票的方式得到分类结果；对回归问题，计算上述模型的均值作为最后的结果。（所有模型的重要性相同）

2、boosting

不同分类器通过串行训练获得，每个新分类器根据已训练出的分类器的性能来进行训练。boosting每一轮的训练集不变，通过集中关注被已有分类器错分的那些数据（改变样本权重）来获得新的分类器。

boosting分类结果是基于所有分类器的加权求和结果的，而bagging中的分类器权重是相等的。

最流行的是AdaBoost(adaptive boosting)：训练数据中的每个样本被赋予一个权重D。下一次的训练权重根据上一次的训练结果进行调整，其中上一次分队的样本的权重降低，而上一次分错的样本的权重会提高。为了从所有弱分类器中得到最终的分类结果，AdaBoost为每个分类器分配一个权重alpha。

3、两者比较：

https://www.cnblogs.com/liuwu265/p/4690486.html

二、AdaBoost代码     弱分类器：单层决策树

from numpy import *

def loadSimpData():
    datMat = 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 datMat,classLabels
datMat,classLabels = loadSimpData()
#根据设定的阈值，针对给定维，对数据进行分类
def stumpClassify(dataMat,dimen,threshVal,threshIneq):#just classify the data
    retArr = ones((shape(dataMat)[0],1))
    if threshIneq == 'lt':
        retArr[dataMat[:,dimen]<=threshVal] = -1.0
    else:
        retArr[dataMat[:,dimen]>threshVal] = -1.0
    return retArr
# 单节点决策树，根据adaboost权重D判断最佳的维度
# 确保标签是+1和-1
def buildStump(dataArr,classLabels,D):
    dataMat = mat(dataArr)
    labelMat = mat(classLabels).T
    m,n = shape(dataMat)
    numSteps = 10.0;bestStump={};bestClasEst=mat(zeros((m,1)))
    minError = inf #init error sum, to +infinity
    for i in range(n):  #loop over all dimensions
        rangeMin = dataMat[:,i].min();
        rangeMax = dataMat[:,i].max();
        stepSize = (rangeMax-rangeMin)/numSteps
        for j in range(-1,int(numSteps)+1):#loop over all range in current dimension
            for inequal in ['lt','gt']:
                threshVal = rangeMin + float(j) * stepSize
                predictedVals = stumpClassify(dataMat,i,threshVal,inequal)
                errArr = mat(ones((m,1)))
                errArr[predictedVals == labelMat] = 0
                weightedError = D.T * errArr #calc total error multiplied by D
                #print ('split: dim %d, thresh %.2f, thresh ineqal: %s, the weighted error is %.3f' % (i, threshVal, inequal, weightedError))
                if weightedError < minError:
                    minError = weightedError
                    bestClasEst = predictedVals.copy()
                    bestStump['dim'] = i
                    bestStump['thresh'] = threshVal
                    bestStump['ineq'] = inequal
    return bestStump,minError,bestClasEst                
#D = mat(ones((5,1))/5)      
#bestStump,minError,bestClasEst=buildStump(datMat,classLabels,D)  

#基于单层决策树的AdaBoost训练过程
def adaboostTrainDS(dataMat,classLabels,numIt=40):
    weakClassArr = []
    m = shape(dataMat)[0]
    D = mat(ones((m,1))/m)  #init D to all equal
    aggClassEst = mat(zeros((m,1)))
    for i in range(numIt):
        bestStump,error,classEst = buildStump(dataMat,classLabels,D)  #build Stump
#        print('D:',D.T)
        #calc alpha, throw in max(error,eps) to account for error=0
        alpha = float(0.5*log((1.0-error)/max(error,1e-16))) 
        bestStump['alpha'] = alpha
        weakClassArr.append(bestStump)
#        print ("classEst: ",classEst.T)
        expon = multiply(-1*alpha*mat(classLabels).T,classEst) #exponent for D calc, getting messy
        D = multiply(D,exp(expon))
        D = D/D.sum()
        #calc training error of all classifiers, if this is 0 quit for loop early (use break)
        aggClassEst += alpha*classEst
#        print ("aggClassEst: ",aggClassEst.T)
        #记录每个数据点的类别估计累计值
        aggErrors = multiply(sign(aggClassEst) != mat(classLabels).T,ones((m,1)))
        errorRate = aggErrors.sum()/m
        print ("total error: ",errorRate)
        if errorRate == 0.0: break
    return weakClassArr
#AdaBoost分类函数
def adaClassify(datToClass,classifierArr):
    dataMatrix = mat(datToClass) 
    m = shape(dataMatrix)[0]
    aggClassEst = mat(zeros((m,1)))
    for i in range(len(classifierArr)):
        classEst = stumpClassify(dataMatrix,classifierArr[i]['dim'],\
                                 classifierArr[i]['thresh'],\
                                 classifierArr[i]['ineq']) 
        aggClassEst += classifierArr[i]['alpha']*classEst
        print (aggClassEst)
    return sign(aggClassEst)
#自适应数据加载函数
def loadDataSet(fileName):
    numFeat = len(open(fileName).readline().split('\t'))
    dataMat=[];labelMat=[]
    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

dataArr,labelArr = loadDataSet('horseColicTraining2.txt')
classifierArray = adaboostTrainDS(dataArr,labelArr,10)
testArr,testLabelArr = loadDataSet('horseColicTest2.txt')
errArr = mat(ones((67,1)))
errNum = errArr[predictedVals != mat(testLabelArr).T].sum()

注：

1、主要是权重D和alpha的计算、类别估计累计值

weightedError = D.T * errArr

expon = multiply(-1*alpha*mat(classLabels).T,classEst)

aggErrors = multiply(sign(aggClassEst) != mat(classLabels).T,ones((m,1)))

2、运行问题 ufunc 'multiply' did not contain a loop with signature matching types

原因：labelMat.append(float(curLine[-1]))  中float漏写。

因为从文件中读取的每个数据都是字符串即 'XXX'形式，因此需要float()或int()。