机器学习理论与实战（七）Adaboost

         Adaboost也是一种原理简单，但很实用的有监督机器学习算法，它是daptive boosting的简称。说到boosting算法，就不得提一提bagging算法，他们两个都是把一些弱分类器组合起来来进行分类的方法，统称为集成方法（ensemble method）,类似于投资，“不把鸡蛋放在一个篮子”，虽然每个弱分类器分类的不那么准确，但是如果把多个弱分类器组合起来可以得到相当不错的结果，另外要说的是集成方法还可以组合不同的分类器，而Adaboost和boosting算法的每个弱分类器的类型都一样的。他们两个不同的地方是：boosting的每个弱分类器组合起来的权重不一样，本节的Adaboost就是一个例子，而bagging的每个弱分类器的组合权重是相等，代表的例子就是random forest。Random forest的每个弱分类器是决策树，输出的类别有多个决策树分类的类别的众数决定。今天的主题是Adaboost,下面来看看Adaboost的工作原理：

         既然Adaboost的每个弱分类器的类型都一样，那么怎么组织安排每个分类器呢？如（图一）所示：

（图一）

       （图一）是Adaboost的原理示意图，左边矩形表示数据集，中间表示根据特征阈值来做分类，这样每一个弱分类器都类似于一个单节点的决策树，其实就是阈值判断而已，右边的三角形对每个弱分类器赋予一个权重，最后根据每个弱分类器的加权组合来判断总体类别。要注意一下数据集从上到下三个矩形内的直方图不一样，这表示每个样本的权重也发生了变化，样本权重的一开始初始化成相等的权重，然后根据弱分类器的错误率来调整每个弱分类器的全总alpha,如（图一）中的三角形所示，alpha 的计算如（公式一）所示：

（公式一）

        从（公式一）中也能感觉出来，弱分类器权重alpha和弱分类器分类错误率epsilon成反比，如果不能看出反比关系，分子分母同时除以epsilon就可以了，而ln是单调函数。这很make sense,当然分类器的错误率越高，越不能器重它，它的权重就应该低。同样的道理，样本也要区分对待，样本的权重要用弱分类器权重来计算，其实也是间接靠分类错误率，如（公式二）所示：

(公式二)

        其中D表示样本权重向量，有多少个样本就有多少个权重，下标i表示样本索引，而上标t表示上一次分类器训练迭代次数。这样一直更新迭代，一直到最大迭代次数或者整个分类器错误率为0或者不变时停止迭代，就完成了Adaboost的训练。但是这样就可以把样本分开了吗？下面从一组图解答这个问题，如（图二）所示：

（图二）

         由（图二）所示，每个弱分类器Hi可以要求不高的准确率，哪怕错误率是50%也可以接受，但是最后通过线性加权组合就可以得到一个很好的分类器，这点也可以通过错误率分析验证，有兴趣的可以看看：http://math./~rothvoss/18.304.3PM/Presentations/1-Eric-Boosting304FinalRpdf.pdf，想了解为什么alpha的计算如（公式一）的样子，可以看看：http://math./~rothvoss/18.304.3PM/Presentations/1-Eric-Boosting304FinalRpdf.pdf。

这样Adaboost的原理基本分析完毕，下面进入代码实战阶段：

首先来准备个简单数据集：

[python] view plaincopy

1. from numpy import *  
2.   
3. def loadSimpData():        
4.     datMat = matrix([[ 1. ,  2.1],  
5.         [ 2. ,  1.1],  
6.         [ 1.3,  1. ],  
7.         [ 1. ,  1. ],  
8.         [ 2. ,  1. ]])  
9.     classLabels = [1.0, 1.0, -1.0, -1.0, 1.0]  
10.     return datMat,classLabels  

       上面有5个样本，接下来就是初始化每个样本的权重，刚开始相等的：

[python] view plaincopy

1. D = mat(ones((5,1))/5)  

        有了样本和初始化权重，接下来的任务就是构建一个弱分类器，其实就是一个单节点决策树，找到决策树每个特征维度上对应的最佳阈值以及表示是大于阈值还是小于阈值为正样本的标识符。代码如下：

[python] view plaincopy

1. def buildStump(dataArr,classLabels,D):  
2.     dataMatrix = mat(dataArr); labelMat = mat(classLabels).T  
3.     m,n = shape(dataMatrix)  
4.     numSteps = 10.0; bestStump = {}; bestClasEst = mat(zeros((m,1)))  
5.     minError = inf #init error sum, to +infinity   
6.     for i in range(n):#loop over all dimensions   
7.         rangeMin = dataMatrix[:,i].min(); rangeMax = dataMatrix[:,i].max();  
8.         stepSize = (rangeMax-rangeMin)/numSteps  
9.         for j in range(-1,int(numSteps)+1):#loop over all range in current dimension   
10.             for inequal in ['lt', 'gt']: #go over less than and greater than   
11.                 threshVal = (rangeMin + float(j) * stepSize)  
12.                 predictedVals = stumpClassify(dataMatrix,i,threshVal,inequal)#call stump classify with i, j, lessThan   
13.                 errArr = mat(ones((m,1)))  
14.                 errArr[predictedVals == labelMat] = 0  
15.                 weightedError = D.T*errArr  #calc total error multiplied by D   
16.                 #print "split: dim %d, thresh %.2f, thresh ineqal: %s, the weighted error is %.3f" % (i, threshVal, inequal, weightedError)   
17.                 if weightedError < minError:  
18.                     minError = weightedError  
19.                     bestClasEst = predictedVals.copy()  
20.                     bestStump['dim'] = i  
21.                     bestStump['thresh'] = threshVal  
22.                     bestStump['ineq'] = inequal  
23.     return bestStump,minError,bestClasEst  

          注意代码中有三个for循环，这三个for循环其实就是为了完成决策树的每个特征维度上对应的最佳阈值以及表示是大于阈值还是小于阈值为正样本的标识符，这三个要素。其中it,gt分别表示大于和小于，阈值的选择是靠增加步长来需找，最终三者的确定是靠决策树分类错误率最小者决定，每个决策树的分类代码如下，很简单，就是靠阈值判断：

[python] view plaincopy

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

        有了弱分类器的构造代码，下面来看Adaboost的训练代码：

[python] view plaincopy

1. def adaBoostTrainDS(dataArr,classLabels,numIt=40):  
2.     weakClassArr = []  
3.     m = shape(dataArr)[0]  
4.     D = mat(ones((m,1))/m)   #init D to all equal   
5.     aggClassEst = mat(zeros((m,1)))  
6.     for i in range(numIt):  
7.         bestStump,error,classEst = buildStump(dataArr,classLabels,D)#build Stump   
8.         #print "D:",D.T   
9.         alpha = float(0.5*log((1.0-error)/max(error,1e-16)))#calc alpha, throw in max(error,eps) to account for error=0   
10.         bestStump['alpha'] = alpha    
11.         weakClassArr.append(bestStump)                  #store Stump Params in Array   
12.         #print "classEst: ",classEst.T   
13.         expon = multiply(-1*alpha*mat(classLabels).T,classEst) #exponent for D calc, getting messy   
14.         D = multiply(D,exp(expon))                              #Calc New D for next iteration   
15.         D = D/D.sum()  
16.         #calc training error of all classifiers, if this is 0 quit for loop early (use break)   
17.         aggClassEst += alpha*classEst  
18.         #print "aggClassEst: ",aggClassEst.T   
19.         aggErrors = multiply(sign(aggClassEst) != mat(classLabels).T,ones((m,1)))  
20.         errorRate = aggErrors.sum()/m  
21.         print "total error: ",errorRate  
22.         if errorRate == 0.0: break  
23.     return weakClassArr,aggClassEst  

       上面的代码中训练过程主要任务就是完成（公式二）中的样本权重D和弱分类器权重alpha的更新，另外还要注意一下，代码中迭代了40次，每次都调用了buildStump，这就意味着创建了40个弱分类器。当模型收敛后，有了样本权重和弱弱弱分类器权重，最后就是对测试样本进行分类，分类代码如下：

[python] view plaincopy

1. def adaClassify(datToClass,classifierArr):  
2.     dataMatrix = mat(datToClass)#do stuff similar to last aggClassEst in adaBoostTrainDS   
3.     m = shape(dataMatrix)[0]  
4.     aggClassEst = mat(zeros((m,1)))  
5.     for i in range(len(classifierArr)):  
6.         classEst = stumpClassify(dataMatrix,classifierArr[i]['dim'],\  
7.                                  classifierArr[i]['thresh'],\  
8.                                  classifierArr[i]['ineq'])#call stump classify   
9.         aggClassEst += classifierArr[i]['alpha']*classEst  
10.         print aggClassEst  
11.     return sign(aggClassEst)  

     考虑到有些做学术的为了比较不同机器学习算法的好坏，常常需要画ROC曲线，这里也给出画ROC的代码：

[python] view plaincopy

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

       到此位置，Adaboost的代码也介绍完了，最终程序的运行结果如（图三）所示：

（图三）

       而Adaboost的模型ROC运行曲线如（图四）所示：

（图四）

最近MIT的几个人证明了Adaboost可以用一阶梯度的角度来解释，详见链接

参考文献：

[1] machinelearning in action.

[2] http://www.robots./~az/lectures/cv/adaboost_matas.pdf

转载请注明来源：http://blog.csdn.net/cuoqu/article/details/9319459