組合方法：

我們分類中用到很多經典分類演算法如：SVM、logistic 等，我們很自然的想到一個方法，我們是否能夠整合多個演算法優勢到解決某一個特定分類問題中去，答案是肯定的！

通過聚合多個分類器的預測來提高分類的準確率。這種技術稱為組合方法(ensemble method) 。組合方法由訓練資料構建一組基分類器，然後通過對每個基分類器的預測進行權重控制來進行分類。

考慮25個二元分類組合，每個分類誤差是0.35 ，如果所有基分類器都是相互獨立的（即誤差是不相關的），則在超過一半的基分類器預測錯誤組合分類器才會作出錯誤預測。這種情況下的組合分類器的誤差率：

下圖對角線表示所有基分類器都是等同的情況，實線是基分類器獨立時情況。

組合分類器效能優於單個分類器必須滿足兩個條件：（1）基分類器之間是相互獨立的 （2） 基分類器應當好於隨機猜測分類器。實踐上很難保證基分類器之間完全獨立，但是在基分類器輕微相關情況下，組合方法可以提高分類的準確率。

組合方法分為兩類：（from http://scikit-learn.org/stable/modules/ensemble.html）

Two families of ensemble methods are usually distinguished:

• In averaging methods, the driving principle is to build several estimators independently and then to average their predictions. On average, the combined estimator is usually better than any of the single base estimator because its variance is reduced.

• By contrast, in boosting methods, base estimators are built sequentially and one tries to reduce the bias of the combined estimator. The motivation is to combine several weak models to produce a powerful ensemble.

先介紹強可學習與弱可學習，如果存在一個多項式的學習演算法能夠學習它並且正確率很高，那麼就稱為強可學習，相反弱可學習就是學習的正確率僅比隨機猜測稍好。

提升方法有兩個問題：1. 每一輪如何改變訓練資料的權重或概率分佈 2. 如何將弱分類器整合為強分類器。

很樸素的思想解決提升方法中的兩個問題：第1個問題-- 提高被前一輪弱分類器錯誤分類的權值，而降低那些被正確分類樣本權值 ，這樣導致結果就是 那些沒有得到正確分類的資料，由於權值加重受到後一輪弱分類器的更大關注。 第2個問題 adaboost 採取加權多數表決方法，加大分類誤差率小的弱分類器的權值，使其在表決中起到較大的作用，相反較小誤差率的弱分類的權值，使其在表決中較小的作用。

具體說來，整個Adaboost 迭代演算法就3步：

1. 初始化訓練資料的權值分佈。如果有N個樣本，則每一個訓練樣本最開始時都被賦予相同的權重：1/N。
   
2. 訓練弱分類器。具體訓練過程中，如果某個樣本點已經被準確地分類，那麼在構造下一個訓練集中，它的權重就被降低；相反，如果某個樣本點沒有被準確地分類，那麼它的權重就得到提高。然後，權重更新過的樣本集被用於訓練下一個分類器，整個訓練過程如此迭代地進行下去。
3. 將各個訓練得到的弱分類器組合成強分類器。各個弱分類器的訓練過程結束後，加大分類誤差率小的弱分類器的權重，使其在最終的分類函式中起著較大的決定作用，而降低分類誤差率大的弱分類器的權重，使其在最終的分類函式中起著較小的決定作用。換言之，誤差率低的弱分類器在最終分類器中佔的權重較大，否則較小。

Adaboost演算法流程

 給定一個訓練資料集T={(x1,y1), (x2,y2)…(xN,yN)}，其中例項，而例項空間，yi屬於標記集合{-1,+1}，Adaboost的目的就是從訓練資料中學習一系列弱分類器或基本分類器，然後將這些弱分類器組合成一個強分類器。

    Adaboost的演算法流程如下：

• 步驟1. 首先，初始化訓練資料的權值分佈。每一個訓練樣本最開始時都被賦予相同的權重：1/N。

• 步驟2. 進行多輪迭代，用m = 1,2, ..., M表示迭代的第多少輪

a. 使用具有權值分佈Dm的訓練資料集學習，得到基本分類器：

由上述式子可知，Gm(x)在訓練資料集上的誤差率em就是被Gm(x)誤分類樣本的權值之和。

由上述式子可知，em <= 1/2時，am >= 0，且am隨著em的減小而增大，意味著分類誤差率越小的基本分類器在最終分類器中的作用越大。

使得被基本分類器Gm(x)誤分類樣本的權值增大，而被正確分類樣本的權值減小。就這樣，通過這樣的方式，AdaBoost方法能“聚焦於”那些較難分的樣本上。

    其中，Zm是規範化因子，使得Dm+1成為一個概率分佈：

• 步驟3. 組合各個弱分類器

從而得到最終分類器，如下：

Adaboost的誤差界

通過上面的例子可知，Adaboost在學習的過程中不斷減少訓練誤差e，直到各個弱分類器組合成最終分類器，那這個最終分類器的誤差界到底是多少呢

事實上，Adaboost 最終分類器的訓練誤差的上界為：

下面，咱們來通過推導來證明下上述式子。

當G(xi)≠yi時，yi*f(xi)<0，因而exp(-yi*f(xi))≥1，因此前半部分得證。

關於後半部分，別忘了：

整個的推導過程如下：

    這個結果說明，可以在每一輪選取適當的Gm使得Zm最小，從而使訓練誤差下降最快。接著，咱們來繼續求上述結果的上界。

    對於二分類而言，有如下結果：

    其中，。

    繼續證明下這個結論。

    由之前Zm的定義式跟本節最開始得到的結論可知：

    而這個不等式可先由e^x和1-x的開根號，在點x的泰勒展開式推出。

    值得一提的是，如果取γ1, γ2… 的最小值，記做γ（顯然，γ≥γi>0，i=1,2,...m），則對於所有m，有：

    這個結論表明，AdaBoost的訓練誤差是以指數速率下降的。另外，AdaBoost演算法不需要事先知道下界γ，AdaBoost具有自適應性，它能適應弱分類器各自的訓練誤差率 。在統計學習方法第八章 中有關於這部分比較詳細的講述可以參考！！

在一個簡單資料集上的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

def stumpClassify(dataMatrix,dimen,threshVal,threshIneq):
    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
    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']:
                threshVal = (rangeMin + float(j)* stepSize)
                predictedVals = stumpClassify(dataMatrix, i, threshVal, inequal)
                errArr = mat(ones((m,1)))
                errArr[predictedVals == labelMat]=0
                weightedError = D.T *errArr
               # 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

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


if __name__ == "__main__":
    D = mat(ones((5,1))/5)
    datMat,classLabels = loadSimpData()
    buildStump(datMat, classLabels, D)
    adaBoostTrainDS(datMat, classLabels, 10)
                

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

參考：統計學習方法、機器學習實戰、http://blog.csdn.net/v_july_v/article/details/40718799