本章內容

• 組合相似的分類器來提高分類效能
• 應用AdaBoost演算法
• 處理非均衡分類問題

主題：利用AdaBoost元演算法提高分類效能

1.基於資料集多重抽樣的分類器

bagging:基於資料隨機重抽樣的分類器構建方法

自舉匯聚法(bootstrap aggregating),也稱為bagging方法，是從原始資料集選擇S次後得到S個新資料集的一種技術。新資料集和原始資料集的大小相等。每個資料集都是通過在原始資料集中隨機選擇一個本來進行替換而得到的。

在S個數據集建好之後，將某個學習演算法分別作用域每個資料集得到了S個分類器。當我們對新資料進行分類時，就可以應用S個分類器進行分類。與此同時，選擇分類器投票結果最多的類別作為最後的分類結果。

有一些比較先進的bagging方法，如隨機森林（RF）。

boosting是一種與bagging很類似的技術。不論是boosting還是bagging當中，當使用的多個分類器的型別都是一致的。但是在前者當中，不同的分類器是通過序列訓練而獲得的，每個新分類器都根據已訓練出的分類器的效能來進行訓練。boosting是通過訓練集中關注被已有分類器錯分的那些資料來獲得新的分類器。

boosting方法有多個版本，當前最流行便屬於AdaBoost

AdaBoost的一般流程

（1）收集資料：可以使用任何方法；
（2）準備資料：依賴於所使用的若分類器型別；
（3）分析資料：可以使用任意方法
（4）訓練演算法：AdaBoost的大部分時間都用在訓練上，分類器將多次在同一資料集上訓練若分類器；
（5）測試演算法：計算分類的錯誤率；
（6）使用演算法：同SVM一樣，AdaBoost預測的兩個類別中的一個，如果想要把它應用到多個類的場合，那麼就像多類SVM中的做法一樣對AdaBoost進行修改。

2.訓練演算法：基於錯誤提升分類器的效能

AdaBoost是adaptive boosting（自適應boosting）的縮寫，其執行過程：訓練集中的每個樣本，賦予其一個權重，這些權重構成向量D。一開始，這些權重都初試化成相等值。首先在訓練資料上訓練處一個若分類器並計算該分類器的錯誤率，然後在同一資料集上再次訓練若分類器。在分類器的第二次訓練當中，將會重新調整每個樣本的權重，其中第一次分隊的樣本的權重值將會降低，而第一次分錯的樣本的權重將會提高。為了從所有分類器中得到最終的分類結果，AdaBoost為每個分類器都分配了一個權重值alpha，這些alpha值是基於每個分類器的錯誤率進行計算的。其中錯誤率定義為

alpha計算公式

計算出alpha值之後，可以對權重向量D進行更新，使得正確分類的樣本的權重值降低而分錯的樣本權重值升高，D的計算方法如下
如果某個樣本被正確分類，更新該樣本權重值為：

如果某個樣本被錯誤分類，更新該樣本的權重值為：

計算出D後，AdaBoost接著開始下一輪的迭代。AdaBoost演算法會不斷地重複訓練和調整權重的過程，知道訓練錯誤率為0或者若分類器的數目達到使用者指定值為止。

在建立完整的AdaBoost演算法之前，需要通過一些程式碼建立若分類器及儲存資料集的權重。

演算法描述：

3.基於單層決策樹構建若分類器

單層決策樹是一種簡單的決策樹。首先構建一個簡單的資料集,建立一個adaboost.py檔案並加入下列程式碼：

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

匯入資料

>>> import adaboost
>>> datMat,classLabels=adaboost.loadSimpData()

附：自適應資料載入函式

def loadDataSet(fileName):      #general function to parse tab -delimited floats
    numFeat = len(open(fileName).readline().split('\t')) #get number of fields 
    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

下面兩個函式，一個用於測試是否某個值小於或者大於我們正在測試的閾值，一個會在一個加權資料集中迴圈，並找到具有最低錯誤率的單層決策樹。

虛擬碼如下：

將最小錯誤率minError設為無窮大
對資料及中的每一個特徵（第一層迴圈）：
    對每個步長（第二層迴圈）：
        對每個不等號（第三層迴圈）：
            建立一顆單層決策樹並利用加權資料集對它進行測試
            如果錯誤率低於minError，則將當前單層決策樹設定為最佳單層決策樹
返回最佳單層決策樹

單層決策樹生成函式程式碼：

def stumpClassify(dataMatrix,dimen,threshVal,threshIneq):#just classify the data
    retArray = ones((shape(dataMatrix)[0],1))
    if threshIneq == 'lt':
        retArray[dataMatrix[:,dimen] <= threshVal] = -1.0
    else:
        retArray[dataMatrix[:,dimen] > threshVal] = -1.0
    return retArray


def buildStump(dataArr,classLabels,D):
    dataMatrix = mat(dataArr); labelMat = mat(classLabels).T
    m,n = shape(dataMatrix)
    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 = dataMatrix[:,i].min(); rangeMax = dataMatrix[:,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']: #go over less than and greater than
                threshVal = (rangeMin + float(j) * stepSize)
                predictedVals = stumpClassify(dataMatrix,i,threshVal,inequal)#call stump classify with i, j, lessThan
                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

4.AdaBoost演算法的實現

整個實現的虛擬碼如下：

對每次迭代：
    利用buildStump()函式找到最佳的單層決策樹
    將最佳單層決策樹加入到單層決策樹資料中
    計算alpha
    計算心的權重向量D
    更新累計類別估計值
    如果錯誤率低於0.0 則退出迴圈

基於單層決策樹的AdaBoost訓練過程

def adaBoostTrainDS(dataArr,classLabels,numIt=40):
    weakClassArr = []
    m = shape(dataArr)[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(dataArr,classLabels,D)#build Stump
        #print "D:",D.T
        alpha = float(0.5*log((1.0-error)/max(error,1e-16)))#calc alpha, throw in max(error,eps) to account for error=0
        bestStump['alpha'] = alpha  
        weakClassArr.append(bestStump)                  #store Stump Params in Array
        #print "classEst: ",classEst.T
        expon = multiply(-1*alpha*mat(classLabels).T,classEst) #exponent for D calc, getting messy
        D = multiply(D,exp(expon))                              #Calc New D for next iteration
        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,aggClassEst

5.測試演算法

擁有了多個若分類器以及其對應的alpha值，進行測試就方便了。

AdaBoost分類函式:利用訓練處的多個若分類器進行分類的函式。

def adaClassify(datToClass,classifierArr):
    dataMatrix = mat(datToClass)#do stuff similar to last aggClassEst in adaBoostTrainDS
    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'])#call stump classify
        aggClassEst += classifierArr[i]['alpha']*classEst
        print aggClassEst
    return sign(aggClassEst)

6.繪製ROC曲線

ROC曲線繪製程式碼：

def plotROC(predStrengths, classLabels):
    import matplotlib.pyplot as plt
    cur = (1.0,1.0) #cursor
    ySum = 0.0 #variable to calculate AUC
    numPosClas = sum(array(classLabels)==1.0)
    yStep = 1/float(numPosClas); xStep = 1/float(len(classLabels)-numPosClas)
    sortedIndicies = predStrengths.argsort()#get sorted index, it's reverse
    fig = plt.figure()
    fig.clf()
    ax = plt.subplot(111)
    #loop through all the values, drawing a line segment at each point
    for index in sortedIndicies.tolist()[0]:
        if classLabels[index] == 1.0:
            delX = 0; delY = yStep;
        else:
            delX = xStep; delY = 0;
            ySum += cur[1]
        #draw line from cur to (cur[0]-delX,cur[1]-delY)
        ax.plot([cur[0],cur[0]-delX],[cur[1],cur[1]-delY], c='b')
        cur = (cur[0]-delX,cur[1]-delY)
    ax.plot([0,1],[0,1],'b--')
    plt.xlabel('False positive rate'); plt.ylabel('True positive rate')
    plt.title('ROC curve for AdaBoost horse colic detection system')
    ax.axis([0,1,0,1])
    plt.show()
    print "the Area Under the Curve is: ",ySum*xStep

說明：文章中的程式碼來自機器學習實戰。

References

【1】Machine Learning in Action 機器學習實戰 第七章