adaboost python 实例

<pre name="code" class="cpp">'''
集成方法(ensemble method)或者元算法(meta-algorithm)是将不同的分类器组合起来。
使用集成方法时会有多种形式:
    可以是不同算法的集成,
    也可以是同一算法在不同设置下的集成,
    还可以是数据集不同部分分配给不同分类器之后的集成。
AdaBoost
优点：泛化错误率低，易编码，可以应用在大部分分类器上，无参数调整。
缺点：对离群点敏感。
适用数据类型：数值型和标称型数据。
--------------------------------------
bagging：基于数据随机重抽样的分类器构建方法
自举汇聚法(bootstrap aggregating)，也称为bagging方法,是在从原始数据集选择S次后得到S个新数据集的一种技术。
新数据集和原数据集的大小相等。每个数据集都是通过在原始数据集中随机选择一个样本来进行替换而得到的。
这里的替换就意味着可以多次地选择同一样本。这一性质就允许新数据集中可以有重复的值，而原始数据集的某些值在新集合中则不再出现。
在S个数据集建好之后，将某个学习算法分别作用于每个数据集就得到了S个分类器。当我们要对新数据进行分类时，就可以应用这S个分类器进行分类。
与此同时，选择分类器投票结果中最多的类别作为最后的分类结果。
-------------
更先进的bagging方法，比如随机森林(random forest)有关这些方法的一个很好的讨论材料
参见网页http://www.stat.berkeley.edu/~breiman/RandomForests/cc_home.htm。
---------------
两种集成方法是boosting、bagging、随机森林
boosting其中一个最流行的版本AdaBoost(adaptive boosting,自适应boosting).
boosting vs bagging
相同：不论是在boosting还是bagging当中，所使用的多个分类器的类型都是一致的。
不同： 1)在bagging中，是通过随机抽样的替换方式，得到了与原始数据集规模一样的数据集。
        boosting中，在数据集上顺序应用了多个不同的分类器，每个新分类器都根据已训练出的分类器的性能来进行训练。
        boosting是通过集中关注被已有分类器错分的那些数据来获得新的分类器。
       2)boosting分类的结果是基于所有分类器的加权求和结果的,分类器权重并不相等，每个权重代表的是其对应分类器在上一轮迭代中的成功度。
       bagging中的分类器权重是相等的
AdaBoost
以弱分类器作为基分类器，并且输人数据，使其通过权重向量进行加权。在第一次迭代当中，所有数据都等权重。
但是在后续的迭代当中，前次迭代中分错的数据的权重会增大。
AdaBoost理论基础：
    使用弱分类器和多个实例来构建一个强分类器
    （“弱”意味着分类器的性能比随机猜测要略好,但是也不会好太多。
    就是说，在二分类情况下弱分类器的错误率会高于50%,而"强"分类器的错误率将会低很多)
    
AdaBoosting运行过程:
    训练数据中的每个样本，并赋予其一个权重，这些权重构成了向量D。
    一开始，这些权重都初始化成相等值。
    首先在训练数据上训练出一个弱分类器并计算该分类器的错误率，然后在同一数据集上再次训练弱分类器。
    在分类器的第二次训练当中，将会重新调整每个样本的权重，其中第一次分对的样本的权重将会降低，而第一次分错的样本的权重将会提高。
    为了从所有弱分类器中得到最终的分类结果，AdaBoost为每个分类器都分配了一个权重值alpha，这些alpha值是基于每个弱分类器的错误率进行计算的。
        其中，错误率的定义为：
             alpha的计算公式:   
    计算出alpha值之后，可以对权重向量D进行更新，以使得那些正确分类的样本的权重降低而错分样本的权重升高。
        D的计算方法如下:
            如果某个样本被正确分类，那么该样本的权重更改为:
            如果某个样本被错分，那么该样本的权重更改为:
AdaBoost的一般流程
(1)收集数据：可以使用任意方法。
(2)准备数据：依赖于所使用的弱分类器类型，本章使用的是单层决策树，这种分类器可以处理任何数据类型。
            当然也可以使用任意分类器作为弱分类器，第2章到第6章中的任一分类器都可以充当弱分类器。
            作为弱分类器，简单分类器的效果更好。
(3)分析数据：可以使用任意方法。
(4)训练算法：AdaBoost的大部分时间都用在训练上，分类器将多次在同一数据集上训练弱分类器。
(5)测试算法：计算分类的错误率
(6)使用算法：同SVM一样,AdaBoost预测两个类别中的一个。如果想把它应用到多个类别的场合，那么就要像多类别SVM中的做法一样对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()

#========================================================================
'''弱分类器之单层决策树(decision stump,也称决策树桩),仅基于单个特征来做决策。
'''
'''通过阈值比较对数据进行了分类'''
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
    
'''它会在一个加权数据集中循环，并找到具有最低错误率的单层决策树。伪代码如下:
将最小错误率minError设为+00
对数据集中的每一个特征(第一层循环)：
    对每个步长(第二层循环)：
        对每个不等号(第三层循环)：
            建立一棵单层决策树并利用加权数据集对它进行测试
            如果错误率低于minError，则将当前单层决策树设为最佳单层决策树
返回最佳单层决策树
'''
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

#D是一个概率分布向量，因此其所有的元素之和为1.0。一开始的所有元素都会被初始化成1/m
D = mat(ones((5,1))/5)

bestStump,minError,bestClasEst=buildStump(datMat,classLabels,D)


'''基于单层决策树的AdaBoost训练过程,伪代码如下:
对每次迭代：
    利用buildStump()函数找到最佳的单层决策树
    将最佳单层决策树加入到单层决策树数组
    计算alpha
    计算新的权重向量D
    更新累计类别估计值
    如果错误率等于0.0,则退出循环
'''
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
        #为下一次迭代计算D
        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()
        
        #错误率累加计算
        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
weakClassArr,aggClassEst=adaBoostTrainDS(datMat,classLabels,9)
 
'''每个弱分类器的结果以其对应的alpha值作为权重。所有这些弱分类器的结果加权求和就得到了最后的结果。
datToClass：由一个或者多个待分类样例
classifierArr：多个弱分类器组成的数组
predictedVals = stumpClassify(dataMatrix,i,threshVal,inequal)#c
'''
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)

'''随着迭代的进行，数据点[0,0]的分类结果越来越强'''
print '----------------------------'
print adaClassify([0,0],weakClassArr)
print '----------------------------'
print adaClassify([[5,5],[0,0]],weakClassArr)

*****************************************************************************************************************

<pre name="code" class="cpp">'''示例:在一个难数据集上的AdaBoost的应用
(1)收集数据：提供的文本文件。
(2)准备数据：确保类别标签是+1和-1而非1和0。
(3)分析数据：手工检查数据。
(4)训练算法：在数据上，利用adaBoostTrainsDS()函数训练出一系列的分类器。
(5)测试算法：我们拥有两个数据集。在不釆用随机抽样的方法下，我们就会对AdaBoost和Logistic回归的结果进行完全对等的比较。
(6)使用算法：观察该例子上的错误率。不过，也可以构建一个Web网站，让驯马师输入马的症状然后预测马是否会死去。
'''
import AdaBoost

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

datArr,labelArr = loadDataSet('horseColicTest2.txt')
weakClassArr,aggClassEst = AdaBoost.adaBoostTrainDS(datArr,labelArr,40)
'''
testDataArr,testLabelArr= loadDataSet('horseColicTest2.txt')
prediction10=AdaBoost.adaClassify(testDataArr,weakClassArr)
errArr = mat(ones((67,1)))
#统计错误数（错误率=错误数/67）
errArr[prediction10!=mat(testLabelArr).T].sum()
'''


'''非均衡分类问题
假设所有类别的分类代价,在大多数情况下不同类别的分类代价并不相等。
1.调节分类器的阈值
    一种不同分类器的评价方法:ROC曲线、AUC
    度量分类器性能的指标:构建一个同时使正确率和召回率最大的分类器是具有挑战性的。
'''
import AdaBoostROC as ad
print '***************************'
print aggClassEst,labelArr
ad.plotROC(aggClassEst,labelArr)

'''
2.基于代价函数的分类器决策控制
代价敏感的学习(cost-sensitivelearning)
    -------------------------------------------------------------
    分类器的代价矩阵(代价不是0就是1)
                          预测结果
                        +1      -1
                +1      0        1  
    真实结果   
                -1      1        0
                
    基于该代价矩阵计算其总代价：TP*0 + FN*1 + FP*1 + TN*0
    -------------------------------------------------------------
                          预测结果
                        +1      -1
                +1      -5        1  
    真实结果   
                -1      50        0   
    
    基于该代价矩阵计算其总代价：TP*(-5)+FN*l+FP*50+TN*0
    -------------------------------------------------------------
    在分类算法中,我们有很多方法可以用来引人代价信息。
    在AdaBoost中,可以基于代价函数来调整错误权重向量D。
    在朴素贝叶斯中,可以选择具有最小期望代价而不是最大概率的类别作为最后的结果。
    在SVM中,可以在代价函数中对于不同的类别选择不同的参数0。
    上述做法就会给较小类更多的权重，即在训练时，小类当中只允许更少的错误。
3.处理非均衡问题的数据抽样方法
欠抽样(undersampling):意味着删除样例。
过抽样(oversampling):意味着复制样例
信用卡欺诈中
    正例少,反例多：
        保留正例类别中的所有样例(正例类别属于罕见类别)，而对反例类别进行欠抽样或者样例删除处理
        缺点:要确定哪些样例需要进行删除。但是,在选择删除的样例中可能携带了剩余样例中并不包含的有价值信息。
        解决办法:择那些离决策边界较远的样例进行删除
    正例多,反例少
        对正例进行欠抽样处理
        缺点:极端
        解决方案:使用反例类别的欠抽样和正例类别的过抽样相混合的方法
            对正例类别进行过抽样， 我们可以复制已有样例或者加人与已有样例相似的点。
            一种方法是加人已有数据点的插值点，但是这种做法可能会导致过拟合的问题。
'''

'''

*************************************************************************************************************************************88

def plotROC(predStrengths, classLabels):
    import matplotlib.pyplot as plt
    import numpy as np
    cur = (1.0,1.0) #cursor
    ySum = 0.0 #variable to calculate AUC
    numPosClas = sum(np.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()
   
    #loop through all the values, drawing a line segment at each point
    for index in sortedIndicies.tolist()[0]:
        ax = plt.subplot(111)
        if classLabels[index] == 1.0:
            delX = 0; delY = yStep;
        else:
            delY = 0; delX = xStep; 
            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='r')
        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