分类器集成和非均衡分类

小鱼儿 2022-06-02 11:38 172阅读 0赞

不同的分类器进行集成组合被称为集成方法或者元方法，可以是不同算法的集成，也可以是同一种算法的集成，也可以是数据集的不同部分分给不同分类器的集成

![20180111220326670][]

Bagging方式：

自举汇聚法（bootstrap aggregating），也称为bagging方法，N个训练集中随机选N次构成一个新的N个训练集，这样就可以基于一份训练数据随机造出任意多份的新的训练集，当然每份训练集中都很大概率有重复数据。然后基于新的训练集训练出的结果，进行民主投票，票高者当选。

随机森林（random forest），是bagging方法的进化版，

用随机的方式建立一个森林，森林里面有很多的决策树组成，随机森林的每一棵决策树之间是没有关联的。在得到森林之后，当有一个新的输入样本进入的时候，就让森林中的每一棵决策树分别进行一下判断，看看这个样本应该属于哪一类（对于分类算法），然后看看哪一类被选择最多，就预测这个样本为那一类

随机森林在生成训练集时除了对样本行进行随机回放外，还会随机选择特性，换句话说每片森林对特性的侧重点又是不同的。

Boosting方式：

与bagging很类似的技术。不论是在boosting还是bagging当中，所使用的多个分类器的类型都是一致的。但是Boosting中不同的分类器是通过串行训练而获得的，每个新分类器都根据已训练出的分类器的性能来进行训练。最终的选择也不是基于投票，而是基于权重结果累加。

AdaBoost：每个训练集初始赋值一个平等的权重，随着每个弱分类器的迭代，被分错的样本的权重会增高，被分对的样本的权重会降低，经过不断迭代最终训练出100%正确的权重或者达到阈值终止。

迭代过程如下：

错误率：

![20180111220432169][]

参数α：

![20180111220451212][]

正确的权重调整：

![20180111220511657][]

错误的权重调整：

![20180111220534428][]

对比：

再回头对比下Bagging方式和Boosting方式，前者的优点是相对简单而且支持并发；后者的优点是训练集稳定结果可信度更高。最终又变成了一个性能与准确度的平衡择取问题。

单层决策树（decision stump，也称决策树桩）是一种简单的决策树，它仅基于单个特征来做决策。例如训练集有N个特性，只取其中一个特性来作为所有特性的拆分规则。

单层决策树python代码：

#构造简单训练集
    def loadSimpleData() :
        dataMat = matrix([[1.0,2.1],
                          [2.0,1.1],
                          [1.3,1.0],
                          [1.0,1.0],
                          [2.0,1.0]])
        classLabel = [1.0,1.0,-1.0,-1.0,1.0]
        return dataMat,classLabel
    
    #根据第dimen个特性对threshVal做比较给出的预测结果
    def stumpClassify(dataMat,dimen,threshVal, threshIneq) :
        retArray = ones((shape(dataMat)[0],1))
        if threshIneq == 'lt':
            retArray[dataMat[:,dimen] <= threshVal] = -1.0
        else :
            retArray[dataMat[:, dimen] > threshVal] = -1.0
        return retArray
    
    #D为初始权重
    #dataArr为训练集
    #classLabels为结果集
    #该函数是按照单一特性某个值去判断，如何得到最小错误率
    def buildStump(dataArr, classLabels,D):
        dataMat = mat(dataArr)
        labelMat = mat(classLabels).transpose()
        m,n = shape(dataMat)
        numSteps = 10.0
        bestStump = {}
        bestClasEst = mat(zeros((m,1)))
        #最小错误率初始化为无穷大
        minError = inf
        #第一个循环，遍历特性
        for i in range(n) :
            #取每列的最大和最小值
            rangeMin = dataMat[:,i].min()
            rangeMax = dataMat[:,i].max()
            #拆分成10块
            stepSize = (rangeMax-rangeMin)/numSteps
            #第二个循环，遍历特性的值
            for j in range(-1,int(numSteps)+1) :
                #第三个循环，遍历大小
                for inequal in ['lt','gt'] :
                    threshVal = (rangeMin+float(j)*stepSize)
                    predictedVals = stumpClassify(dataMat,i,threshVal,inequal)
                    errArr = mat(ones((m,1)))
                    #相等的被清零，剩下的都是预测错误的，默认值为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

现在有了单决策树这个弱学习器，试下学习效果：

D = mat(ones((5,1))/5)
    dataMat,classLabel = loadSimpleData()
    bestStump, minError, bestClasEst = buildStump(dataMat,classLabel,D)
    print(bestStump)
    print(minError)
    print(bestClasEst)

结果是：

{'dim': 0, 'thresh': 1.3, 'ineq': 'lt'}
    [[ 0.2]]
    [[-1.]
     [ 1.]
     [-1.]
     [-1.]
     [ 1.]]

有80%的成功率，貌似还不错，下面我们用集成方式把它改造成一个AdaBoosting强学习器，添加一个集成函数：

#整个函数体有2个动态变化的参数，D和alpha。
    #D代表每轮测评时每条数据的权重
    #alpha代表每轮测评时当前轮次对最终结果影响的权重
    def adaBoostTrainDs(dataArr, classLabels, numIt=40) :
        weakClassArr = []
        m = shape(dataArr)[0]
        #动态的权重
        D = mat(ones((m,1))/m)
        #累计估计值，对结果集多次累计估算的结果
        aggClassEst = mat(zeros((m,1)))
        for i in range(numIt) :
            bestStump, error, classEst = buildStump(dataArr, classLabels, D)
            print('D: ',D.T)
            #套公式，1e-16是为了防止除0
            alpha = float(0.5*log((1.0-error)/max(error,1e-16)))
            print('Alpha: ', alpha)
            bestStump['alpha'] = alpha
            weakClassArr.append(bestStump)
            print('classEst: ',classEst)
            #套公式
            expon = multiply(-1*alpha*mat(classLabels).T, classEst)
            D = multiply(D,exp(expon))
            D = D/D.sum()
            #更新累计估计值，alpha影响本次测评
            aggClassEst +=alpha*classEst
            print('aggClassEst: ',aggClassEst.T)
            aggErrors = multiply(sign(aggClassEst)!=mat(classLabels).T,ones((m,1)))
            errorRate = aggErrors.sum()/m
            print('total error is :',errorRate)
            if errorRate==0.0 : break
        return weakClassArr

这里会产出一个weakClassArr，这个就是集成的产出，里面包含了每轮的弱学习器已经结果占据的权重。

我们给出强学习器的预测函数：

#对测试数据进行评估
    def adaClassify(datToClass, classifierArr):
        dataMat = mat(datToClass)
        m = shape(dataMat)[0]
        #累计预计结果
        aggClassEst = mat(zeros((m,1)))
        for i in range(len(classifierArr)) :
            classEst = stumpClassify(dataMat,classifierArr[i]['dim'],classifierArr[i]['thresh'],classifierArr[i]['ineq'])
            aggClassEst += classifierArr[i]['alpha']*classEst
        return sign(aggClassEst)

预测函数使用如下：

dataMat,classLabel = loadSimpleData()
    weakClassArr = adaBoostTrainDs(dataMat,classLabel,10)
    print(weakClassArr)
    print(adaClassify([[0,1],[3,4]],weakClassArr))

前面《[Logistic回归（2）][Logistic_2]》预测过疝气马死亡的概率，当时用的是Logistic回归方法，现在用AdaBoosting强分类器再试下：

代码：

#加载训练集和结果集
    def loadDataSetByfile(fineName) :
        numFeat = len(open(fineName).readline().split('\t'))
        dataMat = []
        labelMat = []
        fr = open(fineName)
        for line in fr.readlines():
            lineArray = []
            curline = line.strip().split('\t')
            for i in range(numFeat-1) :
                lineArray.append(float(curline[i]))
            dataMat.append(lineArray)
            labelMat.append(float(curline[-1]))
        return dataMat,labelMat
    
    dataMat,labelMat = loadDataSetByfile('C:\\2017\\提高\\机器学习\\训练样本\\horseColicTraining2.txt')
    weakClassArr=adaBoostTrainDs(dataMat,labelMat,10)
    dataMat,labelMat = loadDataSetByfile('C:\\2017\\提高\\机器学习\\训练样本\\horseColicTest2.txt')
    predict=adaClassify(dataMat,weakClassArr)
    errArr = mat(ones((67,1)))
    errRate = errArr[predict!=mat(labelMat).T].sum()/67
    print(errRate)

adaBoostTrainDs中的numInt代表了弱学习器的数目，numInt的不同测试结果也不同，结果如下：

现测试错误率在达到了一个小值之后又开始上升了。这类现象称之为过拟合（overfitting，也称过度学习）

可以看到这里的最高的正确率达到了80%，比前面评估的63%好些。

**非均衡分类器：**

是不是错误率越低，实际效果就越好？非也，因为我们没有考虑错误引起的代价，换句话说没有考虑到结果的权重。例如大数据分析一个人是否是死刑，一旦预判错了，错放了坏人还好说，如果错杀了好人真心无法挽回。

有什么办法可以再进行一下干预或者优化么？

1 利用正确率、召回率、ROC曲线等其它参数：

混淆矩阵（confusion matrix），描述了样例如何被分错的事实，帮助人们更好地了解分类中的错误。

三类问题混淆矩阵案例：

![20180111222714072][]

红框的意思是有4次把鼠预测称狗，整体看来这个预测结果还算靠谱，大部分都可以预测的对，完美的结果是非对角元素都为0.

二类问题混淆矩阵：

![20180111222747040][]

TP；又叫真阳；FN又叫假阴；FP又叫假阳；TN又叫真阴

假如还是大数据分析罪犯的问题，上面\+1代表有罪，\-1代表无罪，给出两个概念：

正确率=TP/(TP+FP), 判处有罪的样本中真正有罪的概率。1-正确率就是你刀下魂误杀的概率。

召回率=TP/(TP+FN)，真正有罪的人被我们预测出来的概率。1-召回率也就是在你刀下漏网的概率。

能否给出一种分类器让正确率和召回率都趋于完美呢？结果是不可能的。

你判的严了，宁可错杀100也不放跑一人，召回率会变得非常高趋于100%，因为漏网之鱼少了么，真正犯法的都被你弄死了，但是很可能就会造成冤假错案多死几个鬼，导致正确率下降。

你判的松了，你好我好大家好，好人不再被冤枉了，正确率变高，但是漏网之鱼就会变多，召回率就会下降。

另一个度量非均衡分类器的曲线是ROC曲线

Y向量代表真阳率=TP/（TP+FN）

X左标代表假阳率=FP/（FP+TN）

下面给出ROC图的代码：

def plotROC(predStrengths, classLabels) :
        import matplotlib.pyplot as plt
        #绘图光标的位置
        cur = (1.0,1.0)
        ySum = 0.0
        numPosClas = sum(array(classLabels)==1.0)
        #y为真阳，yStep为y轴步长
        yStep = 1/float(numPosClas)
        # x为假阳，xStep为x轴步长
        xStep = 1/float(len(classLabels)-numPosClas)
        #从小到大排序classLabels的索引
        sortedIndicies = predStrengths.argsort()
        fig = plt.figure()
        fig.clf()
        ax = plt.subplot(111)
        l=len(sortedIndicies.tolist()[0])
        #注意由于cur光标初始在右上角，所以下面绘画是从右上往左下画
        for index in sortedIndicies.tolist()[0] :
            if classLabels[index]==1.0 :
                delX = 0
                #下降一步真阳率，why？
                #因为在起笔的时候绘图标在（1，1）
                delY = yStep
            else :
                #下降一步假阴率，why？
                delX = xStep
                delY=0
                ySum +=cur[1]
            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')
        plt.ylabel('True positive')
        plt.title('ROC')
        ax.axis([0,1,0,1])
        plt.show()
        #面积本质上是个概率
        print('面积为：',ySum*xStep)

代码注释留下两个why，我当时也想了很久，终于想明白了答案：

起笔阶段绘图光标在（1，1），代表真阳率和假阳率都是100%，设想什么情况下这俩值都是100%？对了，就是我们将所有结果都判断为真，这样FN和TN都等于0.后面判断的代码就好理解了，if classLabel==1说明我们判断正确了，属于TP，所以真阳率就提高一点。什么？代码里命名是减号为什么这里说是提高？因为我们最终判断效果是通过AUC，x\*y的面积，假设没有任何算法瞎猜，那么面积基本就是0.5，也就是图中中间的虚线成功率50%。最然上面情况x在缩减，但是x先左方向位移代表的是最终面积增大的趋势！。最理想的结果是x最终移动到（0，1）左标，x从1降为0，但是面试变成了1，成功率100%！同理，if classLabel==-1说明我们判断错误了，属于FP，y的下降就天经地义了，因为要减少面积。极端情况x一点都没有往右移，y降到了底，说明我们全预测错了嘛，面积为0，概率也变成了0.

numInt输入10，AUC为0.8582969635063604

![20180111223556577][]

numInt输入40，AUC为0.8953941870182941

![20180111223606918][]

2 引入代价函数

还是利用上面法官断案的案例，引入一个代价矩阵：

![20180111223636610][]

如果一个犯人漏网了，代价是1；如果一个好人被放了，代价是0；如果一个犯人被绳之以法了，大快人心，\-5标识对算法的奖励；如果一个好人被冤枉了，这个是万万不行的，所以代价最高为50.通过不同的代价，给算法掺杂了“情感干预”，让某些情况的权重发生变化，就可以选择“最小代价分类器”了。

在很多方法中，例如AdaBoost中调整错误权重的D，朴素贝叶斯中最终的返回结果采用最小代价而不是最大概率，SVM中根据代价参数对不同类别选择不同的松弛度C，K-近邻中最终返回的投票改成最小代价，这些做法都可以给算法夹杂人类的干预进去使其变得更有“感情”

[20180111220326670]: /images/20220602/a51206d7dced40e6965f14c237035d5b.png
[20180111220432169]: /images/20220602/32ff2b113da547ecae264ac718a5763b.png
[20180111220451212]: /images/20220602/8a3ab354614346029a0675ed9fefeb0a.png
[20180111220511657]: /images/20220602/ffaeea214cf444889b17fc42df01b5c4.png
[20180111220534428]: /images/20220602/d82c7dd0b981478a9c8f67a4944541fc.png
[Logistic_2]: http://blog.csdn.net/yejingtao703/article/details/78990793
[20180111222714072]: /images/20220602/f70b672cd3a545e2b6a2b7d35cadfff3.png
[20180111222747040]: /images/20220602/86a817c42748482192fe871863b8421c.png
[20180111223556577]: /images/20220602/bdf5bd7745644d4399cf0dcb389f0620.png
[20180111223606918]: /images/20220602/35137872198d428281f53f139221e59d.png
[20180111223636610]: /images/20220602/3c1a8b968a4a435fb041101a38fd2eb0.png