[完]机器学习实战 第七章 利用AdaBoost元算法提高分类性能

非均衡分类问题

小结

使用的函数

for i in mat1.tolist()[0]:

程序代码

# coding=utf-8

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

# 是否有某个值小于或者大于测试的阈值
# threshVal：阈值（threshold）
def stumpClassify(dataMatrix, dimen, threshVal, threshIneq) :
retArray = ones((shape(dataMatrix)[0], 1))
if threshIneq == 'lt' :
retArray[dataMatrix[:, dimen] <= threshVal] = -1.0
else :
retArray[dataMatrix[:, dimen] > threshVal] = 1.0
return retArray

# 在一个加权数据集中循环，并找到具有最低错误率的单层决策树
# 遍历stumpClassify()函数所有的可能输入值，找到数据集上最佳的单层决策树
# 这里的“最佳”是基于数据的权重向量D来定义的
def buildStump(dataArr, classLabels, D) :
dataMatrix = mat(dataArr)
labelMat = mat(classLabels).T
m,n = shape(dataMatrix)
# numSteps用于在特征的所有可能值上进行遍历
numSteps = 10.0
# bestStump用于存储给定权重向量D时所得到的最佳单层决策树的相关信息
bestStump = {}
bestClassEst = mat(zeros((m,1)))
# minError则在一开始就初始化为正无穷大，之后用于寻找可能的最小错误率
minError = inf
# 第一层for循环在数据集的所有特征上遍历
for i in range(n) :
# 特征为数值型，可通过计算最小值和最大值来了解应该需要多大的步长
rangeMin = dataMatrix[:, i].min()
rangeMax = dataMatrix[:, i].max()
stepSize = (rangeMax - rangeMin)/numSteps
# 第二层在步长上进行遍历，甚至将阈值设置为整个取值范围之外也是可以的，
# 在取值之外还应该有两个额外的步骤
for j in range(-1, int(numSteps) + 1) :
# 最后一个for循环在大于和小于之间切换不等式
for inequal in ['lt', 'gt'] :
threshVal = rangeMin + float(j) * stepSize
# 在数据集和三个循环变量上调用stumpClassify()函数，其中threshVal与j相关
predictedVals = stumpClassify(dataMatrix, i, threshVal, inequal)
# 构建errArr列向量，默认所有元素都为1，如果预测的结果和labelMat中标签值相等，则置为0
errArr = mat(ones((m, 1)))
errArr[predictedVals == labelMat] = 0
# 将errArr向量和权重向量D的相应元素相乘并求和，得到数值weightedError，这就是AdaBoost和分类器交互的地方
# 即，计算加权错误率
weightedError = D.T*errArr
print "split: dim %d, thresh %.2f, thresh ineqal: %s, the weighted error is %.3f" %\
(i, threshVal, inequal, weightedError)
# 将当前的错误率与已有的最小错误率进行对比，如果当前的值较小，那么就在词典bestStump中保存该单层决策树
if weightedError < minError :
minError = weightedError
bestClassEst = predictedVals.copy()
bestStump['dim'] = i
bestStump['thresh'] = threshVal
bestStump['ineq'] = inequal
# 返回字典，错误率和类别估计值
return bestStump, minError, bestClassEst

# 基于单层决策树的AdaBoost训练过程
# 输入参数：数据集、类别标签、迭代次数
def adaBoostTrainDS(dataArr, classLabels, numIt=40) :
# 存储得到单层决策树
weakClassArr = []
# 数据点的数目
m = shape(dataArr)[0]
# 列向量D，包含每个数据点的权重，开始时每个数据点的权重相等，后续迭代会增加错分数据的权重，
# 降低正确分类数据的权重。D是一个概率分布向量，所有元素之和为1.0
D = mat(ones((m,1))/m)
# 列向量aggClassEst，记录每个数据点的类别估计累计值
aggClassEst = mat(zeros((m,1)))
for i in range(numIt) :
# 具有最小错误率的单层决策树、最小的错误率，估计的类别向量
bestStump, error, classEst = buildStump(dataArr, classLabels, D)
print "D: ", D.T
# alpha告诉总分类器本次单层决策树输出结果的权重，其中max(error, 1e-16)确保没有错误时，不会发生除零溢出
alpha = float(0.5*log((1.0-error)/max(error, 1e-16)))
bestStump['alpha'] = alpha
weakClassArr.append(bestStump)
print "classEst: ", classEst.T
# 计算下一次迭代中的新的权重向量D
expon = multiply(-1*alpha*mat(classLabels).T, classEst)
D = multiply(D, exp(expon))
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, "\n"
if errorRate == 0.0 : break
# 绘制ROC曲线时，需要返回aggClassEst
return weakClassArr, aggClassEst

# 基于AdaBoost的分类
# 一个或者多个待分类样例datToClass
# classifierArr：多个弱分类器组成的数组
def adaClassify(datToClass, classifierArr) :
dataMatrix = mat(datToClass)
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'])
aggClassEst += classifierArr[i]['alpha'] * classEst
print aggClassEst
return sign(aggClassEst)

# 自适应数据加载函数，该函数能够自动检测出特征的数目，假定最后一个特征是类别标签
def loadDataSet(fileName) :
numFeat = len(open(fileName).readline().split('\t'))
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

# predStrengths: 一个Numpy数组或者一个行向量组成的矩阵，该参数代表的是分类器的预测强度，
# 在分类器和训练函数将这些数值应用到sign()函数之前，它们就已经产生
# classLabels: 类别标签
def plotROC(predStrengths, classLabels) :
import matplotlib.pyplot as plt
# cur保留的是绘制光标的位置
cur = (1.0, 1.0)
# ySum则用于计算AUC的值
ySum = 0.0
# 通过数组过滤方式计算正例的数目，并赋给numPosClas，接着在x轴和y轴的0.0到1.0区间上绘点
numPosClas = sum(array(classLabels)==1.0)
# 在y轴上的步长
yStep = 1/float(numPosClas)
# 在x轴上的步长
xStep = 1/float(len(classLabels) - numPosClas)
# 获取排好序的索引sortedIndicies，这些索引从小到大排序。需要从<1, 1>开始绘，一直到<0,0>
sortedIndicies = predStrengths.argsort()
fig = plt.figure()
fig.clf()
ax = plt.subplot(111)
# 在所有排序值上进行循环。这些值在一个NumPy数组或矩阵中进行排序，
# python则需要一个表来进行迭代循环，因此需要调用tolist()方法
for index in sortedIndicies.tolist()[0] :
# 每得到一个标签为1.0的类，则要沿着y轴的方向下降一个步长，即降低真阳率
if classLabels[index] == 1.0 :
delX = 0; delY = yStep
# 对于每个其他的标签，则是x轴方向上倒退一个步长（假阴率方向），
# 代码只关注1这个类别标签，采用1/0标签还是+1/-1标签就无所谓了
else :
delX = xStep; delY = 0
# 所有高度的和ySum随着x轴的每次移动而渐次增加
ySum += cur[1]
# 一旦决定了在x轴还是y轴方向上进行移动，就可在当前点和新点之间画出一条线段
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 Rate')
plt.ylabel('True Positive Rate')
plt.title('ROC curve for AdaBoost Horse Colic Detection System')
ax.axis([0,1,0,1])
plt.show()
# 计算AUC需要对多个小矩形的面积进行累加，这些小矩形的宽度都是xStep，
# 因此可对所有矩形的高度进行累加，然后再乘以xStep得到其总面积
print "the Area Under the Curve is: ", ySum*xStep

>>> import ml.adaboost as adaboost
>>> datMat, classLabels=adaboost.loadSimpData()
# 构建单层决策树
>>> from numpy import *
>>> D=mat(ones(5,1)/5)
>>> adaboost.buildStump(datMat, classLabels, D)
split: dim 0, thresh 0.90, thresh ineqal: lt, the weighted error is 0.400
split: dim 0, thresh 0.90, thresh ineqal: gt, the weighted error is 0.400
split: dim 0, thresh 1.00, thresh ineqal: lt, the weighted error is 0.400
......
split: dim 0, thresh 1.90, thresh ineqal: lt, the weighted error is 0.200
split: dim 0, thresh 1.90, thresh ineqal: gt, the weighted error is 0.400
......
split: dim 1, thresh 2.10, thresh ineqal: lt, the weighted error is 0.600
split: dim 1, thresh 2.10, thresh ineqal: gt, the weighted error is 0.400
({'dim': 0, 'ineq': 'lt', 'thresh': 1.3}, matrix([[ 0.2]]), array([[-1.],
[ 1.],
[-1.],
[-1.],
[ 1.]]))
# 完整AdaBoost算法的实现
>>> reload(adaboost)
<module 'ml.adaboost' from 'C:\Python27\ml\adaboost.py'>
>>> classifierArray = adaboost.adaBoostTrainDS(datMat, classLabels, 9)
D:  [[ 0.2  0.2  0.2  0.2  0.2]]
classEst:  [[-1.  1. -1. -1.  1.]]
aggClassEst:  [[-0.69314718  0.69314718 -0.69314718 -0.69314718  0.69314718]]
total error:  0.2

D:  [[ 0.5    0.125  0.125  0.125  0.125]]
classEst:  [[ 1.  1. -1. -1. -1.]]
aggClassEst:  [[ 0.27980789  1.66610226 -1.66610226 -1.66610226 -0.27980789]]
total error:  0.2

D:  [[ 0.28571429  0.07142857  0.07142857  0.07142857  0.5       ]]
classEst:  [[ 1.  1.  1.  1.  1.]]
aggClassEst:  [[ 1.17568763  2.56198199 -0.77022252 -0.77022252  0.61607184]]
total error:  0.0

>>> reload(adaboost)
<module 'ml.adaboost' from 'C:\Python27\ml\adaboost.py'>
>>> datArr, labelArr = adaboost.loadSimpData()
>>> classifierArr = adaboost.adaBoostTrainDS(datArr, labelArr, 30)
>>> adaboost.adaClassify([[5,5],[0,0]],classifierArr)
[[ 0.69314718]
[-0.69314718]]
[[ 1.66610226]
[-1.66610226]]
[[ 2.56198199]
[-2.56198199]]
matrix([[ 1.],
[-1.]])
# 自适应数据加载
>>> reload(adaboost)
>>> dataArr, labelArr = adaboost.loadDataSet('c:\python26\ml\\horseColicTraining2.txt')
>>> classifierArray = adaboost.adaBoostTrainDS(dataArr, labelArr, 10)
>>> testArr, testLabelArr = adaboost.loadDataSet('c:\python27\ml\\horseColicTest2.txt')
>>> prediction10 = adaboost.adaClassify(testArr, classifierArray)
# 获取被错误分类的元素个数
>>> errArr = mat(ones((67,1)))
>>> errArr[prediction10!=mat(testLabelArr).T].sum()
# 绘制ROC
>>> reload(adaboost)
>>> dataArr, labelArr = adaboost.loadDataSet('c:\python27\ml\\horseColicTraining2.txt')
>>> classifierArray, aggClassEst = adaboost.adaBoostTrainDS(dataArr, labelArr, 10)
>>> adaboost.plotROC(aggClassEst.T, labelArr)
the Area Under the Curve is:  0.858296963506