阅读目录

• 前言
• 一种原始的元算法 - bagging (自举汇聚法)
• boost (提高任意给定学习算法精确度算法) vs bagging (自举汇聚法)
• AdaBoost 元算法的基本原理
• 基于单层决策树的 AdaBoost 元算法分类器实现
• 小结

 1 #==========================================2 # 输入:3 #        dataMatrix:    输入数据4 #        dimen:    划分特征下标5 #        threshVal:    划分阈值6 #        threshIneq:    划分方向(是左1右0分类还是左0右1分类)7 # 输出:8 #        retArray:    分类结果9 #==========================================
10 def stumpClassify(dataMatrix,dimen,threshVal,threshIneq):
11     '按照指定方式分类并返回结果'
12
13     retArray = numpy.ones((numpy.shape(dataMatrix)[0],1))
14     if threshIneq == 'lt':
15         retArray[dataMatrix[:,dimen] <= threshVal] = -1.0
16     else:
17         retArray[dataMatrix[:,dimen] > threshVal] = -1.0
18
19     return retArray
20
21
22 #==========================================
23 # 输入:
24 #        dataArr:    输入数据
25 #        classLabels:    分类标签集
26 #        D:    权重向量
27 # 输出:
28 #        bestStump:    决策树信息
29 #        minError:    带权错误(用于生成分类器权重值 alpha)
30 #        bestClasEst:    分类结果
31 #==========================================
32 def buildStump(dataArr,classLabels,D):
33     '创建单层最佳决策树'
34
35     dataMatrix = numpy.mat(dataArr);
36     labelMat = numpy.mat(classLabels).T
37     m,n = numpy.shape(dataMatrix)
38
39     # 特征值阈值步长
40     numSteps = 10.0;
41     # 当前最佳决策树信息集
42     bestStump = {};
43     # 分类结果
44     bestClasEst = numpy.mat(numpy.zeros((m,1)))
45     # 最小带权错误初始化为无穷大
46     minError = numpy.inf
47
48     for i in range(n):      # 遍历所有的特征选取最佳划分特征
49         rangeMin = dataMatrix[:,i].min();
50         rangeMax = dataMatrix[:,i].max();
51         stepSize = (rangeMax-rangeMin)/numSteps
52
53         for j in range(-1,int(numSteps)+1):     # 遍历所有的特征值选取最佳划分特征值 stepSize为探测步长
54
55             for inequal in ['lt', 'gt']:        # 对于 左1右0 和 左0右1 两种分类方式
56
57                 # 当前划分阈值
58                 threshVal = (rangeMin + float(j) * stepSize)
59                 # 分类
60                 predictedVals = stumpClassify(dataMatrix,i,threshVal,inequal)
61                 # 统计分类错误信息
62                 errArr = numpy.mat(numpy.ones((m,1)))
63                 errArr[predictedVals == labelMat] = 0
64                 weightedError = D.T*errArr
65
66                 # 更新最佳决策树的信息
67                 if weightedError < minError:
68                     minError = weightedError
69                     bestClasEst = predictedVals.copy()
70                     bestStump['dim'] = i
71                     bestStump['thresh'] = threshVal
72                     bestStump['ineq'] = inequal
73
74     return bestStump,minError,bestClasEst

1 对每次迭代:
2     找到最佳单层决策树
3     将该树加入到最佳决策树数组
4     计算分类器权重 alpha
5     更新权重向量 D
6     更新累计类别估计值
7     PS: 如果错误率等于0.0,则立马退出循环。

 1 #==========================================2 # 输入:3 #        dataArr:    输入数据4 #        classLabels:    分类标签集5 #        numIt:    最大迭代次数6 # 输出:7 #        bestStump:    决策树信息8 #        minError:    带权错误(用于生成分类器权重值 alpha)9 #        bestClasEst:    分类结果
10 #==========================================
11 def adaBoostTrainDS(dataArr,classLabels,numIt=40):
12     'AdaBoost 分类器'
13
14     # 最佳决策树集合
15     weakClassArr = []
16     # 样本个数
17     m = numpy.shape(dataArr)[0]
18     # 权重向量
19     D = numpy.mat(numpy.ones((m,1))/m)
20     # 各个类别的估计累积值
21     aggClassEst = numpy.mat(numpy.zeros((m,1)))
22
23     for i in range(numIt):  # 迭代 numIt 次
24         # 构建最佳决策树
25         bestStump,error,classEst = buildStump(dataArr,classLabels,D)
26         # 计算该决策树的分类器权重值 alpha
27         alpha = float(0.5*numpy.log((1.0-error)/max(error,1e-16)))
28         bestStump['alpha'] = alpha
29         # 将该决策树加入到决策树数组中去
30         weakClassArr.append(bestStump)
31
32         # 更新权重向量
33         expon = numpy.multiply(-1*alpha*numpy.mat(classLabels).T,classEst)
34         D = numpy.multiply(D,numpy.exp(expon))
35         D = D/D.sum()
36
37         # 计算当前的总错误率。如果错误率为0则退出循环。
38         aggClassEst += alpha*classEst
39         aggErrors = numpy.multiply(numpy.sign(aggClassEst) != numpy.mat(classLabels).T,numpy.ones((m,1)))
40         errorRate = aggErrors.sum()/m
41         print "错误率: ",errorRate
42         if errorRate == 0.0: break
43
44     return weakClassArr

1     # 获取训练集
2     classifierArr = adaBoostTrainDS(daaArr, labelArr, 30)
3     # 分类并打印结果
4     print adaClassify([0,0], classifierArr)

小结

本文介绍了分类器中的元算法思想。通过这样的思想，能够将多种分类器组合起来，大大地加强了分类性能。

另外据可靠数据分析，较之逻辑回归，AdaBoost 分类器没有过度拟合(overfitting)现象。

Boost算法还有很多种，AdaBoost 只是其中最为经典的实现之一，还有更多高级实习需要在日后学习工作中进行研究。