AdaBoost-Machine Learning In Action学习笔记

元算法（集成方法）是对其他算法进行组合的一种方式。
使用集成方法时会有多种形式：
  • 可以是不同算法的集成，
  • 也可以是同一算法在不同设置下的集成，
  • 还可以是数据集不同部分分配给不同分类器之后的集成。

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

自举汇聚法（bootstrap aggregating），也称为bagging方法：数据集通常被认为是放回取样得到的，比如要得到一个大小为n的新数据集，该数据集中的每个样本都是在原始数据集中随机抽样（即抽样之后又放回）得到的。（分类器权重是相等的）
boosting：与bagging类似的集成分类器方法。不同的分类器是通过串行训练而获得的，每个新分类器都根据已训练出的分类器的性能来进行训练。（分类器权重并不相等，每个权重代表的是其对应分类器在上一轮迭代中的成功度。）
AdaBoost：boosting方法拥有多个版本，AdaBoost是其中一个最流行的版本。

AdaBoost的一般流程
收集数据：可以使用任意方法。
准备数据：依赖于所使用的弱分类器类型，本章使用的是单层决策树，这种分类器可以处理任何数据类型。当然也可以使用任意分类器作为弱分类器，第2章到第6章中的任一分类器都可以充当弱分类器。作为弱分类器，简单分类器的效果更好。（“弱”意味着分类器的性能比随机猜测要略好，但是也不会好太多。）
分析数据：可以使用任意方法。
训练算法：AdaBoost的大部分时间都用在训练上，分类器将多次在同一数据集上训练弱分类器。
测试算法：计算分类的错误率。
使用算法：同SVM一样，AdaBoost预测两个类别中的一个。如果想把它应用到多个类别的场合，那么就要像多类SVM中的做法一样对AdaBoost进行修改。

AdaBoost运行过程：
  1. 训练数据中的每个样本，并赋予其一个权重，这些权重构成了向量D。一开始，这些权重都初始化成相等值。
  2. 首先在训练数据上训练出一个弱分类器并计算该分类器的错误率，然后在同一数据集上再次训练弱分类器。
  3. 在分类器的第二次训练当中，将会重新调整每个样本的权重，其中第一次分对的样本的权重将会降低，而第一次分错的样本的权重将会提高。（为了从所有弱分类器中得到最终的分类结果，AdaBoost为每个分类器都分配了一个权重值（alpha），这些alpha值是基于每个弱分类器的错误率（ε）进行计算的。）
  4. 计算出alpha值之后，可以对权重向量D进行更新，以使得那些正确分类的样本的权重降低而错分样本的权重升高。
  5. 在计算出D之后，AdaBoost又开始进入下一轮迭代。AdaBoost算法会不断地重复训练和调整权重的过程，直到训练错误率为0或者弱分类器的数目达到用户的指定值为止。

以下公式计算依次为错误率，alpha，正确分类的样本权重，错分的样本权重。
                 
                  

单层决策树：仅基于单个特征来做决策，这棵树只有一次分裂过程。

基于单层决策树构建弱分类器伪代码：
将最小错误率minError设为+∞  
对数据集中的每一个特征（第一层循环）：  
    对每个步长（第二层循环）：  
       对每个不等号（第三层循环）：  
          建立一棵单层决策树并利用加权数据集对它进行测试  
          如果错误率低于minError，则将当前单层决策树设为最佳单层决策树  
返回最佳单层决策树

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

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

过拟合（过学习）：测试错误率在达到了一个最小值之后又开始上升了。

非均衡分类问题：在大多数情况下不同类别的分类代价并不相等。
混淆矩阵：帮助更好地了解分类中的错误

分类性能度量指标：错误率、正确率、召回率及ROC曲线
  • 正确率：TP/(TP+FP)，给出的是预测为正例的所有样本中的真正正例的比例
  • 召回率：TP/(TP+FN)，给出的是预测为正例的真实正例占所有真实正例的比例
很容易构造一个高正确率或高召回率的分类器，但是很难同时保证两者成立。
  • ROC曲线：ROC曲线给出的是当阈值变化时假阳率（FP/(FP+TN)）和真阳率（TP/(TP+FN)）的变化情况。
1. 由于在不同的阈值下，不同的分类器的表现情况可能各不相同，因此以某种方式将它们组合起来或许会更有意义。如果只是简单地观察分类器的错误率，那么我们就难以得到这种更深入的洞察效果了。
2. 最佳的分类器应该尽可能地处于左上角，这就意味着分类器在假阳率很低的同时获得了很高的真阳率。
  • 曲线下的面积（AUC）：对不同的ROC曲线进行比较的一个指标。（AUC给出的是分类器的平均性能值，当然它并不能完全代替对整条曲线的观察。一个完美分类器的AUC为1.0，而随机猜测的AUC则为0.5。）

代价敏感的学习：比如分类代价的计算公式为：TP*(-5)+FN*1+FP*50+TN*0（数值可变，调整代价策略）

处理非均衡问题的数据抽样方法：对分类器的训练数据进行改造
  • 欠抽样：删除样例
  • 过抽样：复制样例
  1. # -*- coding:utf8 -*-
  2. from numpy import *
  5. def loadSimpData():
  6.     datMat = matrix([[1., 2.1],
  7.                      [2., 1.1],
  8.                      [1.3, 1.],
  9.                      [1., 1.],
  10.                      [2., 1.]])
  11.     classLabels = [1.0, 1.0, -1.0, -1.0, 1.0]
  12.     return datMat, classLabels
  15. # 基于单层决策树构建弱分类器
  17. # 测试是否有某个值小于或者大于我们正在测试的阈值
  18. def stumpClassify(dataMatrix, dimen, threshVal, threshIneq):
  19.     retArray = ones((shape(dataMatrix)[0], 1))
  20.     # 数组过滤，所有在阈值外的数据会分到类别-1，否则为+1
  21.     if threshIneq == 'lt':
  22.         retArray[dataMatrix[:, dimen] <= threshVal] = -1.0
  23.     else:
  24.         retArray[dataMatrix[:, dimen] > threshVal] = -1.0
  25.     return retArray
  28. # 在一个加权数据集中循环，找到具有最低错误率的单层决策树，D为权重向量
  29. def buildStump(dataArr, classLabels, D):
  30.     dataMatrix = mat(dataArr)
  31.     labelMat = mat(classLabels).T
  32.     m, n = shape(dataMatrix)
  33.     numSteps = 10.0  # 用于在特征的所有可能值上进行遍历
  34.     bestStump = {}  # 存储给定权重向量D时所得到的最佳单层决策树的相关信息
  35.     bestClasEst = mat(zeros((m, 1)))
  36.     minError = inf  # 初始化成正无穷大，之后用于寻找可能的最小错误率
  38.     # 第一层for循环在数据集的所有特征上遍历
  39.     for i in range(n):
  40.         rangeMin = dataMatrix[:, i].min()
  41.         rangeMax = dataMatrix[:, i].max()
  42.         stepSize = (rangeMax - rangeMin) / numSteps
  43.         # 第二层for循环，遍历不同等级的阈值
  44.         for j in range(-1, int(numSteps) + 1):
  45.             # 最后一个for循环则是在大于和小于之间切换不等式
  46.             for inequal in ['lt', 'gt']:
  47.                 threshVal = (rangeMin + float(j) * stepSize)
  48.                 predictedVals = stumpClassify(dataMatrix, i, threshVal, inequal)
  49.                 errArr = mat(ones((m, 1)))
  50.                 errArr[predictedVals == labelMat] = 0
  51.                 weightedError = D.T * errArr
  52.                 # print "split: dim %d, thresh %.2f, thresh ineqal: %s, the weighted error is %.3f" % (i, threshVal, inequal, weightedError)
  53.                 if weightedError < minError:
  54.                     minError = weightedError
  55.                     bestClasEst = predictedVals.copy()
  56.                     bestStump['dim'] = i
  57.                     bestStump['thresh'] = threshVal
  58.                     bestStump['ineq'] = inequal
  60.     return bestStump, minError, bestClasEst
  63. # 基于单层决策树的AdaBoost训练过程
  64. def adaBoostTrainDS(dataArr, classLabels, numIt=40):
  65.     weakClassArr = []
  66.     m = shape(dataArr)[0]
  67.     # D是一个概率分布向量，因此其所有的元素之和为1.0
  68.     # 后续的迭代中，算法会在增加错分数据的权重的同时，降低正确分类数据的权重
  69.     D = mat(ones((m, 1)) / m)
  70.     # 每个数据点的类别估计累计值
  71.     aggClassEst = mat(zeros((m, 1)))
  72.     # 循环运行numIt次或者直到训练错误率为0为止
  73.     for i in range(numIt):
  74.         bestStump, error, classEst = buildStump(dataArr, classLabels, D)
  75.         # print "D:", D.T
  76.         # max(error, 1e-16)用于确保在没有错误时不会发生除零溢出，double极限就是1e-16
  77.         alpha = float(0.5 * log((1.0 - error) / max(error, 1e-16)))
  78.         bestStump['alpha'] = alpha
  79.         weakClassArr.append(bestStump)
  80.         # print "classEst: ", classEst.T
  81.         # 为下一次迭代计算*D*
  82.         expon = multiply(-1 * alpha * mat(classLabels).T, classEst)
  83.         D = multiply(D, exp(expon))
  84.         D = D / D.sum()
  85.         # 错误率累加计算
  86.         aggClassEst += alpha * classEst
  87.         # print "aggClassEst: ", aggClassEst.T
  88.         # 调用sign()函数得到二值分类结果
  89.         aggErrors = multiply(sign(aggClassEst) != mat(classLabels).T, ones((m, 1)))
  90.         errorRate = aggErrors.sum() / m
  91.         print "total error: ", errorRate, "\n"
  92.         if errorRate == 0.0:
  93.             break
  94.     return weakClassArr, aggClassEst
  97. def adaClassify(datToClass, classifierArr):
  98.     dataMatrix = mat(datToClass)
  99.     m = shape(dataMatrix)[0]
  100.     aggClassEst = mat(zeros((m, 1)))
  101.     # 遍历classifierArr中的所有弱分类器
  102.     for i in range(len(classifierArr)):
  103.         classEst = stumpClassify(dataMatrix, classifierArr[i]['dim'], classifierArr[i]['thresh'], classifierArr[i]['ineq'])
  104.         aggClassEst += classifierArr[i]['alpha'] * classEst
  105.         # print aggClassEst
  106.     return sign(aggClassEst)
  109. def loadDataSet(fileName):
  110.     numFeat = len(open(fileName).readline().split('\t'))
  111.     dataMat, labelMat = [], []
  112.     fr = open(fileName)
  113.     for line in fr.readlines():
  114.         lineArr = []
  115.         curLine = line.strip().split('\t')
  116.         for i in range(numFeat - 1):
  117.             lineArr.append(float(curLine[i]))
  118.         dataMat.append(lineArr)
  119.         labelMat.append(float(curLine[-1]))
  120.     return dataMat, labelMat
  123. # ROC曲线的绘制及AUC计算函数
  124. def plotROC(predStrengths, classLabels):
  125.     import matplotlib.pyplot as plt
  126.     # 绘制光标的位置
  127.     cur = (1.0, 1.0)
  128.     # 用于计算AUC
  129.     ySum = 0.0
  130.     numPosClas = sum(array(classLabels) == 1.0)
  131.     yStep = 1 / float(numPosClas)
  132.     xStep = 1 / float(len(classLabels) - numPosClas)
  133.     # 获取排好序的索引
  134.     sortedIndicies = predStrengths.argsort()
  135.     # 以下3行构建画笔
  136.     fig = plt.figure()
  137.     fig.clf()
  138.     ax = plt.subplot(111)
  139.     for index in sortedIndicies.tolist()[0]:
  140.         if classLabels[index] == 1.0:
  141.             delX = 0
  142.             delY = yStep
  143.         else:
  144.             delX = xStep
  145.             delY = 0
  146.             ySum += cur[1]
  147.         ax.plot([cur[0], cur[0] - delX], [cur[1], cur[1] - delY], c='b')
  148.         cur = (cur[0] - delX, cur[1] - delY)
  149.     ax.plot([0, 1], [0, 1], 'b--')
  150.     plt.xlabel('False Positive Rate')
  151.     plt.ylabel('True Positive Rate')
  152.     plt.title('ROC curve for AdaBoost Test')
  153.     ax.axis([0, 1, 0, 1])
  154.     plt.show()
  155.     print "the AUC is: ", ySum * xStep





posted @ 2016-05-13 15:16  woaielf  阅读(346)  评论(0)  编辑  收藏  举报