机器学习第七章利用AdaBoost算法提高分类性能

最新推荐文章于 2022-10-05 15:00:05 发布

m0_50882524

最新推荐文章于 2022-10-05 15:00:05 发布

阅读量355

点赞数

本文链接：https://blog.csdn.net/m0_50882524/article/details/127034893

版权

文章目录

引言
7.1基于数据多重抽样的分类器
- 7.1.1bagging
- 7.1.2bososting
7.2训练算法：基于错误分类器的性能
7.3基于单层决策树构架弱分类器
7.4完整AdaBoost算法的实现
7.5测试算法：基于AdaBoost的分类
7.6示例：在一个难数据集上应用AdaBoost
7.7非均衡分类问题
7.8本章小结

引言

7.1基于数据多重抽样的分类器

我们可以将不同的分类器组合起来，而这种组合结果则被称为集成方法或者元算法。使用集成方法时会有多种形式：可以是不同算法的集成，也可以是统一算法在不同设置下的集成，还可以是数据集不同部分分配给不同分类器之后的集成。

AdaBoost
优点：泛化错误率低，易编码，可以应用在大部分分类器上，无参数调整。
缺点：对离群点敏感。
适用数据类型：数值型和标称型数据。

7.1.1bagging

自举汇聚法，也称为bagging方法，是在从原始数据集选择S次后得到S个新数据集的一种技术。新数据集和原数据集的大小相等。每个数据集都是通过在原始数据集中随机选择一个样本来进行替换而得到的。替换意味着可以多次地选择同一样本。这一性质就允许新数据集中可以有重复的值，而原始数据集的某些值在新集合中则不再出现。

在S个数据集建好之后，将某个学习算法分别作用于每个数据集就得到了S个分类器。当我们要对新数据进行分类时，就可以应用这S个分类器进行分类。与此同时，选择分类器投票结果中最多的类别作为最后的分类结果。

7.1.2bososting

boosting是一种与bagging类似的技术。不论是在boosting还是bagging当中，所使用的的多个分类器的类型都是一致的。但是在前者当中，不同的分类器是通过串行训练而获得的，每个新分类器都根据已训练出的分类器的性能来进行训练。boosting是通过集中关注被已有分类器错分的那些数据来获得新的分类器。

由于boosting分类的结果是基于所有分类器的加权求和结果的，因此boosting与bagging不太一样。boosting中的分类器权重是相等的，而boosting中的分类器权重并不相等，每个权重代表的是其对应分类器在上一轮迭代中的成功度。

7.2训练算法：基于错误分类器的性能

能否使用弱分类器和多个实例来构建一个强分类器？“弱”意味着分类器的性能比随机猜测要略好，但不会好太多。也就是说，在二分类情况下弱分类器的错误率会高于50%，而“强”分类器的错误率将会低很多。AdaBoost算法即脱胎于上述理论问题。

Adaboost是adaptive boosting（自适应boosting）的缩写，其运行过程如下：训练数据中的每个样本，并赋予其一个权重，这些权重构成了向量D。一开始，这些权重都初始化成相等值。首先在训练数据上训练出一个弱分类器并计算该分类器的错误率，然后在同一数据集上再次训练弱分类器。在分离器的第二次训练当中，将会重新调整每个样本的权重，其中第一次分对的样本的权重将会降低，而第一次分错的样本的权重将会提高。为了从所有弱分类器中得到最终的分类结果，AdaBoost为每个分类器都分配了一个权重值alpha，这些alpha值是基于每个弱分类器的错误率进行计算的

错误率的定义为
在这里插入图片描述
alpha的计算公式如下：
$\alpha=\frac{1}{2} \ln \left(\frac{1-\varepsilon}{\varepsilon}\right)$

AdaBoost算法流程如下：
在这里插入图片描述
计算出alpha值后，可以对权重向量D进行更新，以使得那些正确分类的样本权重降低而错分样本的权重升高。
如果某个样本被正确分类，那么该样本的权重更改为：
$D_{i}^{(t+1)}=\frac{D_{i}^{(t)} \mathrm{e}^{-\alpha}}{\operatorname{Sum}(D)}$
如果某个样本被错分，那么该样本的权重更改为：
$D_{i}^{(t+1)}=\frac{D_{i}^{(t)} \mathrm{e}^{\alpha}}{\operatorname{Sum}(D)}$
计算出D后，AdaBoost将开始下一轮迭代。AdaBoost算法会不断地重复训练和调整权重的过程，直到训练错误率为0或者弱分类器的数目达到用户的指定值为止。

7.3基于单层决策树构架弱分类器

单层决策树（decision stump ）
也称决策树桩，是一种简单的决策树仅基于单个特征来做决策。由于这棵树只有一次分裂过程，因此它实际上就是一个树桩。

我们首先通过一个简单数据集来确保在算法实现上一切就绪。创建adaboost.py文件并加入代码：

from numpy import *
def loadSimpData():
    datMat = matrix([[ 1. ,  2.1],
        [ 1.5 ,  1.6],
        [ 1.3,  1. ],
        [ 1. ,  1. ],
        [ 2. ,  1. ]])
    classLabels = [1.0, 1.0, -1.0, -1.0, 1.0]
    return datMat,classLabels

实验结果如下所示
在这里插入图片描述

实验分析：可以看到，如果想要试着从某个坐标轴上选择一个值（即选择一条与坐标轴平行的直线）来将所有的蓝色圆点和橘色圆点分开，这显然是不可能的。这就是单层决策树难以处理的一个著名问题。
通过使用多颗单层决策树，我们可以构建出一个能够对该数据集完全正确分类的分类器。

下面构建多个函数来建立单层决策树。第一个函数用于测试是否有某个值小于或大于我们正在测试的阈值。第二个函数会在一个加权数据集中循环，并找到具有最低错误率的单层决策树。伪代码如下：

将最小错误率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

第一个函数 stumpClassify() 是通过阈值比较对数据进行分类的。所有在阈值一边的数据会分到类别-1，而在另一边的数据分到类别+1。该函数可以通过数组过滤来实现，首先将返回数组的全部元素设置为1，然后将所有不满足不等式要求的元素设置为-1。可以基于数据集中的任一元素进行比较，同时也可以将不等号在大于、小于之间切换。
第二个函数 buildStump() 将会遍历 stumpClassify() 函数所有的可能输入值，并找到数据集上最佳的单层决策树。“最佳”是基于数据的权重向量来定义的。在确保输入数据符合矩阵格式之后，整个函数就开始执行。然后，函数将构建一个称为bestStump的空字典，这个字典用于存储给定权重向量时所得到的最佳单层决策树相关信息。变量numSteps用于在特征的所有可能值上进行遍历。而遍历minError则在一开始就初始化成无穷大，之后用于寻找可能的最小错误率。
三层嵌套的for循环是程序最主要的部分。第一层for循环在数据集的所有特征上遍历。考虑到数值型的特征，我们就可以通过计算最小值和最大值来了解应该需要多大的步长。然后，第二层for循环再在这些值上遍历。甚至将阈值设置为整个取值范围之外也是可以的。因此，在取值范围之外还应该有两个额外的步骤。最后一个for循环则是在大于和小于之间切换不等式。
在嵌套的三层for循环之内，我们在数据集及三个循环变量上调用stumpclassify(〉函数。基于这些循环变量，该函数将会返回分类预测结果。接下来构建一个列向量errArr，如果predictedvals中的值不等于1abelMat中的真正类别标签值，那么errArr的相应位置为1。将错误向量errArr和权重向量D的相应元素相乘并求和，就得到了数值weightedError①。这就是AdaBoost和分类器交互的地方。这里，我们是基于权重向量D而不是其他错误计算指标来评价分类器的。如果需要使用其他分类器的话，就需要考虑D上最佳分类器所定义的计算过程。
程序接下来输出所有的值。虽然这一行后面可以注释掉,但是它对理解函数的运行还是很有帮助的。最后，将当前的错误率与已有的最小错误率进行对比，如果当前的值较小，那么就在词典beststump中保存该单层决策树。字典、错误率和类别估计值都会返回给AdaBoost算法。

然后再通过以下代码

import adaboost
from numpy import *
datmat,classLables = adaboost.loadSimpData()
D = mat(ones((5,1))/5)
print(adaboost.buildStump(datmat,classLables,D))

在这里插入图片描述
buildStump在所有可能的值上遍历的同时，也能观察到输出结果和最后返回的字典。

7.4完整AdaBoost算法的实现

使用单层决策树来实现完整AdaBoost算法，实现伪代码如下
对每次迭代：
利用buildStump()函数找到最佳的单层决策树
将最佳单层决策树加入到单层决策树数组
计算alpha
计算新的权重向量D
更新累计类别估计值
如果错误率等于0.0，则退出循环
将下面的代码加入adaboost.py：

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

import adaboost
from numpy import *
datmat,classLables = adaboost.loadSimpData()
D = mat(ones((5,1))/5)
classifierArray = adaboost.adaBoostTrainDS(datmat,classLables,9)

import adaboost
from numpy import *
datmat,classLables = adaboost.loadSimpData()
D = mat(ones((5,1))/5)
classifierArray = adaboost.adaBoostTrainDS(datmat,classLables,9)
print(classifierArray)

在这里插入图片描述
当错误率达到0时程序便会跳出循环。一开始先创建一次单层决策树，得到错误率，分类结果以及最好分类信息。之后计算总体错误率。得到alpha之后便误差率，判断误差率。
该数组包含三部词典，其中包含了分类所需要的所有信息。

7.5测试算法：基于AdaBoost的分类

接下来需要将弱分类器的训练过程从程序中抽出来，然后应用到某个具体的实例上去。每个弱分类器的结果以其对应的alpha值为权重，所有这些弱分类器的结果加权求和就得到了最后的结果。将下面的代码添加到adaboost.py中，就可以利用它基于 adaboTrainDS() 中的弱分类器对数据进行分类。

添加下列代码到文件中

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)

import adaboost
datArr,labelArr = adaboost.loadSimpData()
classifierArr = adaboost.adaBoostTrainDS(datArr,labelArr,30)
adaboost.adaClassify([0,0],classifierArr)

测试结果
在这里插入图片描述
可以看到，随着迭代的进行，数据点[0,0]的分类结果越来越强。

7.6示例：在一个难数据集上应用AdaBoost

下面的函数在向文件中加载数据时，能够自动检测出特征的数目。同时，该函数也假定最后一个特征是类别标签。将代码加入到 adaboost.py 中：

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

import adaboost
from numpy import *
datArr,labelArr = adaboost.loadDataSet('horseColicTraining2.txt')
classifierArray = adaboost.adaBoostTrainDS(datArr,labelArr,10)
testArr,testLabelArr = adaboost.loadDataSet('horseColicTest2.txt')
prediction10 = adaboost.adaClassify(testArr,classifierArray)
errArr = mat(ones((67,1)))
print(errArr[prediction10 != mat(testLabelArr).T].sum())

在这里插入图片描述
得到训练集与测试集的错误率，对比第四章测试集错误率大多在40%左右，可以观察到准确率有了明显的提高。

7.7非均衡分类问题

7.7.1其他分类性能度量指标：正确率、召回率及ROC曲线

之前对于错误率的度量，掩盖了样例如何被分错的事实。在机器学习中，有一个普遍适用的称为混淆矩阵的工具，它可以帮助人们更好地了解分类中的错误。一个示例如下
在这里插入图片描述
利用混淆矩阵就可以更好地理解分类中的错误。如果矩阵中的非对角元素均为0，就会得到一个完美的分类器。
接下来我们考虑另外一个混淆矩阵，这次的矩阵只针对一个简单的二类问题、。在下表中，如果一个正例判为正例，就可以认为产生了一个真正例（真阳）；如果对一个反例正确地判为了反例，则认为陈胜了一个真反例（真阴）。相应地，另外两种情况则分别称为伪反例（假阴）和伪正例（假阳）。
在这里插入图片描述
我们可以根据上述定义定义出多个新指标。

正确率，它等于TP/(TP+FP)，给出的是预测为正例的样本中的真正正例的比例。
召回率，它等于TP/(TP+FN)，给出的是预测为正例的真实正例占所有真实正例的比例

另一个用于度量分类中的非均衡性的工具是ROC曲线，ROC代表接收者操作特征。
在这里插入图片描述
图中横轴是伪正例的比例（假阳率=FP/(FP+TN)），而纵轴是真正例的比例（真阳率=TP(TP+FN)）。ROC曲线给出的是当阈值变化时假阳率和真阳率的变化情况。左下角的点所对应的是所有样例判为反例的情况，而右上角的点对应的是将所有样例判为正例的情况。虚线给出的是随机猜测的结果曲线。
ROC曲线不但可以用于比较分类器，还可以基于成本效益分析来做出决策。由于在不同的阈值下，不同分类器表现可能各不相同，因此某种方式将它们组合起来或许更有意义。
在理想的情况下，最佳的分类器应该尽可能地处于左上角，这意味着分类器在假阳率很低的同时获得了很高的真阳率。对不同的ROC曲线进行比较的一个指标是曲线下的面积。AUC给出的是分类器的平均性能值，当然它并不能完全替代对整条曲线的观察，一个完美分类器的AUC为1.0，而随机猜测的AUC为0.5。

7.7.2基于代价函数的分类器决策控制

代价敏感学习也是用于处理非均匀分类代价问题的方法。考虑下图中的代价矩阵，第一张表给出的是到目前为止分类器的代价矩阵（代价不是0就是1）。我们可以基于该代价矩阵计算其总代价：TP0+FN1+FP1+TN0。第二张表基于该代价矩阵的分类代价的计算公式为：TP*(-5)+FN1+FP50+TN*0。采用第二张表作为代价矩阵时，两种分类错误的代价是不一样的。类似地，这两种正确分类所得到的收益也不一样。如果在构建分类器时，知道了这些代价值，那么就可以选择付出最小代价的分类器

在这里插入图片描述

7.7.3处理非均衡问题的数据抽样方法

另外一种针对非均衡问题调节分类器的方法，就是对分类器的训练数据进行改造。这可以通过欠抽样或者过抽样来实现。过抽样意味着复制样例，而欠抽样意味着删除样例。不管采用哪种方式，数据都会从原始形式改造为新形式。抽样过程则可以通过随机方式或者某个预定方式来实现。
通常也会存在某个罕见的类别需要我们来识别，比如在信用卡欺诈当中。如前所述，正例类别属于罕见类别。我们希望对于这种罕见类别能尽可能保留更多的信息，因此，我们应该保留正例类别中的所有样例，而对反例类别进行欠抽样或者样例删除处理。这种方法的一个缺点就在于要确定哪些样例需要进行剔除。但是，在选择剔除的样例中可能携带了剩余样例中并不包含的有价值信息。
上述问题的一种解决办法，就是选择那些离决策边界较远的样例进行删除。假定我们有一个数据集，其中有50例信用卡欺诈交易和5000例合法交易。如果我们想要对合法交易样例进行欠抽样处理，使得这两类数据比较均衡的话，那么我们就需要去掉4950个样例，而这些样例中可能包含很多有价值的信息。这看上去有些极端，因此有一种替代的策略就是使用反例类别的欠抽样和正例类别的过抽样相混合的方法。
要对正例类别进行过抽样，我们可以复制已有样例或者加入与已有样例相似的点。一种方法是加入已有数据点的插值点，但是这种做法可能会导致过拟合的问题。