参考：机器学习实战Peter Harrington
(11条消息) 机器学习实战教程(13篇)_chenyanlong_v的博客-CSDN博客_机器学习实战
六、支持向量机 （SVM）：每一个可能把数据集正确分开的方向都有一个最优决策面（有些方向无论如何移动决策面的位置也不可能将两类样本完全分开），而不同方向的最优决策面的分类间隔通常是不同的，那个具有“最大间隔”的决策面就是SVM要寻找的最优解。而这个真正的最优解对应的两侧虚线所穿过的样本点，就是SVM中的支持样本点，称为"支持向量"。（在保证决策面方向不变且不会出现错分样本的情况下移动决策面，会在原来的决策面两侧找到两个极限位置，越过该位置就会产生错分现象，如虚线所示。）
优点：泛化错误率低，计算开销不大，结果易解释
缺点：对参数调节和核函数的选择敏感，原始分类器不加修饰只适合处理二类问题
适用数据类型：数值型和标称型数据
求解这个"决策面"的过程，就是最优化。最优化问题通常有两个基本的因素：①目标函数，也就是你希望什么东西的什么指标达到最好；②优化对象，你期望通过改变哪些因素来使你的目标函数达到最优。在线性SVM算法中，目标函数显然就是那个"分类间隔"，而优化对象则是决策面。
→SMO算法：求出一系列alpha和b，一旦求出了这些alpha，就很容易计算出权重向量w并得到分隔超平面。每次循环中选择两个alpha进行优化处理。一旦找到了一对合适的alpha，那么就增大其中一个同时减小另一个。这里所谓的"合适"就是指两个alpha必须符合以下两个条件，条件之一就是两个alpha必须要在间隔边界之外，而且第二个条件则是这两个alpha还没有进行过区间化处理或者不在边界上。
梳理下SMO算法的步骤：
- 步骤1：计算误差：
- 步骤2：计算上下界L和H：
- 步骤3：计算η：
- 步骤4：更新αj：
- 步骤5：根据取值范围修剪αj：
- 步骤6：更新αi：
- 步骤7：更新b1和b2：
- 步骤8：根据b1和b2更新b：
示例1：简易版SMO
ime import sleep
import matplotlib.pyplot as plt
import numpy as np
import random
import types
def loadDataSet(fileName):
dataMat = [];labelMat = []
fr = open(fileName)
for line in fr.readlines(): #逐行读取，滤除空格
lineArr = line.strip().split('\t')
dataMat.append([float(lineArr[0]),float(lineArr[1])]) #添加数据
labelMat.append(float(lineArr[2])) #添加标签
return dataMat,labelMat
def selectJrand(i,m): #随机选择alpha，i是alpha,m是alpha参数个数
j = i
while(j==i): #选择一个不等于i的j
j = int(random.uniform(0,m))
return j
def clipAlpha(aj,H,L): #修建alpha，aj是alpha值，H是alpha上界，L是下界
if aj > H:
aj = H
if L > aj:
aj = L
return aj
def smoSimple(dataMatIn,classLabels,C,toler,maxIter): #C为惩罚参数，toler为松弛变量
dataMatrix = np.mat(dataMatIn);labelMat=np.mat(classLabels).transpose() #转化为numpy的mat存储
b = 0;m,n = np.shape(dataMatrix) #初始化参数b，统计dataMatrix的维度
alphas=np.mat(np.zeros((m,1))) #初始化alphas参数，设为0
iter_num = 0 #初始化迭代次数
while(iter_num < maxIter): #最多迭代maxIter次
alphaPairsChanged = 0 #用于记录alphas是否已经进行优化
for i in range(m):
fXi = float(np.multiply(alphas,labelMat).T*(dataMatrix*dataMatrix[i,:].T)) + b #步骤1：计算误差Ei
Ei = fXi-float(labelMat[i])
if((labelMat[i] * Ei < -toler)and(alphas[i] < C)) or ((labelMat[i]*Ei > toler)and(alphas[i] > 0)): #优化alpha,设置一定的容错率
j = selectJrand(i,m) #随机选择另一个与alpha_i成对优化的alpha_j
fXj = float(np.multiply(alphas,labelMat).T * (dataMatrix*dataMatrix[j,:].T)) + b #计算误差Ej
Ej = fXj - float(labelMat[j])
alphaIold=alphas[i].copy(); #保存更新前的aplpha值，使用深拷贝
alphaJold=alphas[j].copy();
if (labelMat[i] != labelMat[j]): #步骤2：计算上下界L和H
L = max(0,alphas[j] - alphas[i])
H = min(C,C + alphas[j]-alphas[i])
else:
L = max(0,alphas[j] + alphas[i] - C)
H = min(C,alphas[j] + alphas[i])
if L==H: print("L==H"); continue
eta = 2.0 * dataMatrix[i,:] * dataMatrix[j,:].T - dataMatrix[i,:] * dataMatrix[i,:].T - dataMatrix[j,:] * dataMatrix[j,:].T #计算eta
if eta >= 0:print("eta>=0");continue
alphas[j] -= labelMat[j] * (Ei - Ej)/eta #步骤4：更新aj
alphas[j] = clipAlpha(alphas[j],H,L) #步骤6：更新ai
if (abs(alphas[j] - alphaJold) < 0.00001):print("j not moving enough");continue
alphas[i] += labelMat[j]*labelMat[i] * (alphaJold-alphas[j])
b1 = b - Ei - labelMat[i]*(alphas[i] - alphaIold) * dataMatrix[i,:] * dataMatrix[i,:].T - labelMat[j] * (alphas[j] - alphaJold) * dataMatrix[i,:] * dataMatrix[j,:].T #更新b1和b2
b2 = b - Ej - labelMat[i]*(alphas[i] - alphaJold) * dataMatrix[i,:] * dataMatrix[j,:].T - labelMat[j] * (alphas[j] - alphaJold) * dataMatrix[j,:] * dataMatrix[j,:].T
if (0 < alphas[i]) and (C > alphas[i]): b=b1 #根据b1和b2更新b
elif (0 < alphas[j]) and (C > alphas[j]): b=b2
else: b = (b1 + b2)/2.0
alphaPairsChanged += 1
print("第%d次迭代 样本：%d,alphas优化次数：%d" % (iter_num,i,alphaPairsChanged))
if (alphaPairsChanged==0): iter_num += 1 #更新迭代次数
else: item_num =0
print("迭代次数：%d" % iter_num)
return b,alphas
def showClassifer(dataMat,w,b):
#绘制样本点
data_plus = [] #正样本
data_minus = [] #负样本
for i in range(len(dataMat)):
if labelMat[i] > 0:
data_plus.append(dataMat[i])
else:
data_minus.append(dataMat[i])
data_plus_np = np.array(data_plus) #转化为numpy矩阵
data_minus_np = np.array(data_minus) #转化为numpy矩阵
plt.scatter(np.transpose(data_plus_np)[0],np.transpose(data_plus_np)[1],s=30,alpha=0.7) #正样本散点图
plt.scatter(np.transpose(data_minus_np)[0],np.transpose(data_minus_np)[1],s=30,alpha=0.7) #负样本散点图
#绘制直线
x1 = max(dataMat)[0]
x2 = min(dataMat)[0]
a1,a2 = w
b = float(b)
a1 = float(a1[0])
a2 = float(a2[0])
y1,y2 = (-b - a1*x1)/a2,(-b - a1 * x2)/a2
plt.plot([x1,x2],[y1,y2])
#找出支持向量点
for i,alpha in enumerate(alphas):
if alpha > 0:
x,y = dataMat[i]
plt.scatter([x],[y],s=150,c='none',alpha=0.7,linewidths=1.5,edgecolor='red')
plt.show()
def get_w(dataMat,labelMat,alphas):
alphas,dataMat,labelMat = np.array(alphas),np.array(dataMat),np.array(labelMat)
w = np.dot((np.tile(labelMat.reshape(1,-1).T,(1,2)) * dataMat).T,alphas)
return w.tolist()
if __name__ == '__main__':
dataMat,labelMat = loadDataSet('testSet.txt')
b,alphas = smoSimple(dataMat,labelMat,0.6,0.001,40)
w = get_w(dataMat,labelMat,alphas)
showClassifer(dataMat,w,b)
示例2：在几百个点组成的小规模数据集上，简化版SMO算法的运行是没有什么问题的，但是在更大的数据集上的运行速度就会变慢。简化版SMO算法的第二个α的选择是随机的，针对这一问题，我们可以使用启发式选择第二个α值，来达到优化效果。
完整Platt SMO算法是通过一个外循环来选择第一个alpha值的，并且其选择的方式会在两种方式中交替进行：一种是在所有数据集上进行单遍扫描，另一种则是在非边界的alpha中进行单遍扫描（非边界alpha即那些不等于边界0或C的alpha值）。对于整个数据集的扫描相对容易，而实现非边界alpha值的扫描时，首先需建立这些alpha值的列表，然后再对这个表进行遍历（该步骤会跳过那些已知的不会改变的alpha值。
在选择第一个alpha值之后，算法会通过第一个内循环来选择第二个alpha值。在优化过程中，会通过最大化步长的方式来获得第二个alpha值。在简化版SMO算法中，我们会在选择j之后计算错误率Ej。但在这里，我们会建立一个全局的缓存用于保存误差值，并从中选择使得步长或Ei-Ej最大的alpha值。
核函数：
七、利用AdaBoost算法提高分类性能
前面的文章已经介绍了五种不同的分类器，它们各有优缺点。我们可以很自然地将不同的分类器组合起来，而这种组合结果则被成为集成方法或者元算法。使用集成方法时会有多种形式：可以是不同算法的集成，也可以是同一种算法在不同设置下的集成，还可以是数据集不同部分分配给不同分类器之后的集成。
集成方法主要包括Bagging和Boosting两种方法，Bagging和Boosting都是将已有的分类或回归算法通过一定方式组合起来，形成一个性能更加强大的分类器，更准确的说这是一种分类算法的组装方法，即将弱分类器组装成强分类器的方法。
1.bagging（自举汇聚法）
（1）从原始样本集中抽取训练集。每轮从原始样本集中使用Bootstraping的方法抽取n个训练，（在训练集中，有些样本可能被多次抽取到，而有些样本可能一次都没有被抽中），共进行k轮抽取，得到k个训练集（k个训练集之间是相互独立的）。
（2）每次使用一个训练集得到一个模型，k个训练集共得到k个模型（这里并没有具体的分类算法或回归方法，我们可以根据具体问题采用不同的分类或回归方法）。
（3）①对分类问题：将上步得到的k个模型采用投票的方式得到分类结果；②对回归问题，计算上述模型的均值作为最后的结果。（所有模型的重要性相同）
Bagging + 决策树 = 随机森林
2.boosting
（1）每一轮的训练数据样本赋予一个权重，并且每一轮样本的权值分布依赖上一轮的分类结果。
（2）基分类器之间采用序列式的线性加权方式进行组合。
3、Bagging、Boosting二者之间的区别
（1）样本选择上：
Bagging：训练集是在原始集中有放回选取的，从原始集中选出的各轮训练集之间是独立的。
Boosting：每一轮的训练集不变，只是训练集中每个样例在分类器中的权重发生变化。而权值是根据上一轮的分类结果进行调整。
（2）样例权重：
Bagging：使用均匀取样，每个样例的权重相等。
Boosting：根据错误率不断调整样例的权值，错误率越大则权重越大。
（3）预测函数：
Bagging：所有预测函数的权重相等。
Boosting：每个弱分类器都有相应的权重，对于分类误差小的分类器会有更大的权重。
（4）并行计算：
Bagging：各个预测函数可以并行生成。
Boosting：各个预测函数只能顺序生成，因为后一个模型参数需要前一轮模型的结果。
4.AdaBoost(自适应Boosting):AdaBoost算法是基于Boosting思想的机器学习算法。
优点：泛化错误率低，易编码，可以应用在大部分分类器上，无参数调整
缺点：对离群点敏感
适用数据类型：数值型和标称型数据
（1）计算样本权重：训练数据中的每个样本，赋予其权重，即样本权重，用向量D表示，这些权重都初始化成相等值。
（2）先在数据集上训练出一个弱分类器，①计算该分类器的错误率，错误率的定义如下：
②算法为每个分类器都分配了一个权重值alpha，alpha的定义：
（3）权重更新：然后在同一数据集上再次训练弱数据集（重新调整每个样本的权重，其中第一次分对的样本的权重将会降低，第一次分错的样本权重将会提高）。
其中，ht(xi) = yi表示对第i个样本训练正确，不等于则表示分类错误。Zt是一个归一化因子：
不断重复训练和调整权重的过程，直到错误率为0或弱分类器的数目达到用户的指定值为止。
示例1：基于单层决策树构建弱分类器
单层决策树：它基于单个特征来做决策，只有一次分裂过程。
如果想要试着从某个坐标轴上选择一个值（即选择一条与坐标轴平行的直线）来将所有的蓝色圆点和橘色圆点分开，这显然是不可能的。这就是单层决策树难以处理的一个著名问题。通过使用多颗单层决策树，我们可以构建出一个能够对该数据集完全正确分类的分类器。
蓝横线上边的是一个类别，蓝横线下边是一个类别。显然，此时有一个蓝点分类错误，计算此时的分类误差，误差为1/5 = 0.2。这个横线与坐标轴的y轴的交点，就是我们设置的阈值，通过不断改变阈值的大小，找到使单层决策树的分类误差最小的阈值。同理，竖线也是如此，找到最佳分类的阈值，就找到了最佳单层决策树。
import numpy as np
import matplotlib.pyplot as plt
def loadSimpData():
dataMat = np.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 dataMat,classLabels
def stumpClassify(dataMatrix,dimen,threshVal,threshIneq): #单层决策树分类函数
retArray = np.ones((np.shape(dataMatrix)[0],1)) #初始化retArray为1
if threshIneq == 'lt': #threshIneq为标志，threshVal为阈值
retArray[dataMatrix[:,dimen] <= threshVal] = -1.0 #如果小于阈值,则赋值为-1。第dim列即第几个特征
else:
retArray[dataMatrix[:,dimen] > threshVal] = -1.0
return retArray #返回分类结果
def buildStump(dataArr,classLabels,D): #找到数据集上最佳单层决策树，D为样本权重
dataMatrix = np.mat(dataArr);labelMat = np.mat(classLabels).T
m,n = np.shape(dataMatrix)
numSteps = 10.0;bestStump = {};bestClasEst = np.mat(np.zeros((m,1))) #bestStump储存最佳单层决策树信息，bestClasEst为最佳分类结果
minError = float('inf') #最小误差初始化为正无穷大
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 inequal in ['lt','gt']: #大于和小于的情况，均遍历。lt:less than，gt:greater than
threshVal = (rangeMin + float(j) * stepSize) #计算阈值
predictedVals = stumpClassify(dataMatrix,i,threshVal,inequal) #计算分类结果
errArr = np.mat(np.ones((m,1))) #初始化误差矩阵
errArr[predictedVals == labelMat] = 0 #分类正确的，赋值为0
weightedError = D.T * errArr #计算误差
print("spilt: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
if __name__ == '__main__':
dataArr,classLabels = loadSimpData()
D = np.mat(np.ones((5,1))/5)
bestStump,minError,bestClasEst = buildStump(dataArr,classLabels,D)
print('bestStump:\n',bestStump)
print('minError:\n',minError)
print('bestClasEst:\n',bestClasEst)
上述程序包含两个函数。第一个函数stumpClassify()是通过阈值比较对数据进行分类的。所有在阈值一边的数据会分到类别-1，在另一边的分到类别+1。该函数通过数组过滤实现，首先将返回数组的全部元素设置为1，不满足等式要求的设置为-1。
第二个函数buildStump()会遍历stumpClassify()函数所有可能的输入值，并找到数据集上最佳单层决策树。这里的最佳是根据权重D来衡量的。
三层嵌套for循环是程序最主要的部分，第一层for循环在数据集的所有特征上遍历，考虑到数值型的特征，我们就可以通过计算最小值和最大值来了解应需要多大的步长。第二层for循环再在这些值上遍历，最后一个for循环则是在大于和小于之间切换不等式。
在循环之内，调用stumpClassify()函数返回分类预测结果。然后构建一个errArr，若predictedVals中的值不等于labelMat中真正类别标签值，则表示分类错误，errArr的值赋为1。数值weightedError为errErr和权重向量D的相应元素相乘并求和。最后将当前的错误率与已有的最小错误率进行比较，如果当前的较小，就在bestStump中保存该决策树。
示例2：使用AdaBoost提升分类器性能
import numpy as np
import matplotlib.pyplot as plt
def loadSimpData():
dataMat = np.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 dataMat,classLabels
def stumpClassify(dataMatrix,dimen,threshVal,threshIneq): #单层决策树分类函数
retArray = np.ones((np.shape(dataMatrix)[0],1)) #初始化retArray为1
if threshIneq == 'lt': #threshIneq为标志，threshVal为阈值
retArray[dataMatrix[:,dimen] <= threshVal] = -1.0 #如果小于阈值,则赋值为-1。第dim列即第几个特征
else:
retArray[dataMatrix[:,dimen] > threshVal] = -1.0
return retArray #返回分类结果
def buildStump(dataArr,classLabels,D): #找到数据集上最佳单层决策树，D为样本权重
dataMatrix = np.mat(dataArr);labelMat = np.mat(classLabels).T
m,n = np.shape(dataMatrix)
numSteps = 10.0;bestStump = {};bestClasEst = np.mat(np.zeros((m,1))) #bestStump储存最佳单层决策树信息，bestClasEst为最佳分类结果
minError = float('inf') #最小误差初始化为正无穷大
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 inequal in ['lt','gt']: #大于和小于的情况，均遍历。lt:less than，gt:greater than
threshVal = (rangeMin + float(j) * stepSize) #计算阈值
predictedVals = stumpClassify(dataMatrix,i,threshVal,inequal) #计算分类结果
errArr = np.mat(np.ones((m,1))) #初始化误差矩阵
errArr[predictedVals == labelMat] = 0 #分类正确的，赋值为0
weightedError = D.T * errArr #计算误差
print("spilt: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
def adaBoostTrainDS(dataArr,classLabels,numIt = 40):
weakClassArr = []
m = np.shape(dataArr)[0]
D = np.mat(np.ones((m,1))/m) #初始化权重
aggClassEst = np.mat(np.zeros((m,1))) #记录每个数据点的类别估计值
for i in range(numIt):
bestStump,error,classEst = buildStump(dataArr,classLabels,D) #构建单层决策树
print("D:",D.T)
alpha = float(0.5 * np.log((1.0 - error)/max(error,1e-16))) #计算弱学习算法权重alpha,使error不等于0,因为分母不能为0
bestStump['alpha'] = alpha #存储弱学习算法权重
weakClassArr.append(bestStump) #存储单层决策树
print("classEst:",classEst.T)
expon = np.multiply(-1 * alpha * np.mat(classLabels).T,classEst) #计算e的指数项
D = np.multiply(D,np.exp(expon))
D = D/D.sum() #根据样本权重公式，更新样本权重
# 计算AdaBoost误差，当误差为0的时候，退出循环
aggClassEst += alpha * classEst
print("aggClassEst:",aggClassEst.T)
aggErrors = np.multiply(np.sign(aggClassEst) != np.mat(classLabels).T,np.ones((m,1)))
errorRate = aggErrors.sum()/m
print("total error:",errorRate,"\n")
if errorRate == 0.0: break #误差为0，退出循环
return weakClassArr,aggClassEst
if __name__ == '__main__':
dataArr,classLabels = loadSimpData()
weakClassArr,aggClassEst = adaBoostTrainDS(dataArr,classLabels)
print(weakClassArr)
print(aggClassEst)
在第一轮迭代中，D中的所有值都相等。于是，只有第一个数据点被错分了。在第二轮迭代中，D向量给第一个数据点0.5的权重，第二次迭代之后，我们发现第一个数据点已经正确分类了，但此时最后一个数据点却错分了。所以在第三轮迭代中，给最后一个向量0.5的权重，第三次迭代之后aggClassEst所有值的符号和真是类别标签都完全吻合，训练错误率为0，程序终止运行。
最后训练结果包含了三个弱分类器，其中包含了分类所需要的所有信息。一共迭代了3次，所以训练了3个弱分类器构成一个使用AdaBoost算法优化过的分类器，分类器的错误率为0。
一旦拥有了多个弱分类器以及其对应的alpha值，进行测试就变得想当容易了。
import numpy as np
import matplotlib.pyplot as plt
def loadSimpData():
dataMat = np.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 dataMat,classLabels
def showDataSet(dataMat,labelMat):
data_plus = [] #正样本
data_minus =[] #负样本
for i in range(len(dataMat)):
if labelMat[i] > 0:
data_plus.append(dataMat[i])
else:
data_minus.append(dataMat[i])
data_plus_np = np.array(data_plus) #转化为numpy矩阵
data_minus_np = np.array(data_minus)
plt.scatter(np.transpose(data_plus_np)[0],np.transpose(data_plus_np)[1]) #正样本散点图
plt.scatter(np.transpose(data_minus_np)[0],np.transpose(data_minus_np)[1]) #负样本散点图
plt.show()
def stumpClassify(dataMatrix,dimen,threshVal,threshIneq): #单层决策树分类函数
retArray = np.ones((np.shape(dataMatrix)[0],1)) #初始化retArray为1
if threshIneq == 'lt': #threshIneq为标志，threshVal为阈值
retArray[dataMatrix[:,dimen] <= threshVal] = -1.0 #如果小于阈值,则赋值为-1。第dim列即第几个特征
else:
retArray[dataMatrix[:,dimen] > threshVal] = -1.0
return retArray #返回分类结果
def buildStump(dataArr,classLabels,D): #找到数据集上最佳单层决策树，D为样本权重
dataMatrix = np.mat(dataArr);labelMat = np.mat(classLabels).T
m,n = np.shape(dataMatrix)
numSteps = 10.0;bestStump = {};bestClasEst = np.mat(np.zeros((m,1))) #bestStump储存最佳单层决策树信息，bestClasEst为最佳分类结果
minError = float('inf') #最小误差初始化为正无穷大
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 inequal in ['lt','gt']: #大于和小于的情况，均遍历。lt:less than，gt:greater than
threshVal = (rangeMin + float(j) * stepSize) #计算阈值
predictedVals = stumpClassify(dataMatrix,i,threshVal,inequal) #计算分类结果
errArr = np.mat(np.ones((m,1))) #初始化误差矩阵
errArr[predictedVals == labelMat] = 0 #分类正确的，赋值为0
weightedError = D.T * errArr #计算误差
print("spilt: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
def adaBoostTrainDS(dataArr,classLabels,numIt = 40):
weakClassArr = []
m = np.shape(dataArr)[0]
D = np.mat(np.ones((m,1))/m) #初始化权重
aggClassEst = np.mat(np.zeros((m,1))) #记录每个数据点的类别估计值
for i in range(numIt):
bestStump,error,classEst = buildStump(dataArr,classLabels,D) #构建单层决策树
print("D:",D.T)
alpha = float(0.5 * np.log((1.0 - error)/max(error,1e-16))) #计算弱学习算法权重alpha,使error不等于0,因为分母不能为0
bestStump['alpha'] = alpha #存储弱学习算法权重
weakClassArr.append(bestStump) #存储单层决策树
print("classEst:",classEst.T)
expon = np.multiply(-1 * alpha * np.mat(classLabels).T,classEst) #计算e的指数项
D = np.multiply(D,np.exp(expon))
D = D/D.sum() #根据样本权重公式，更新样本权重
# 计算AdaBoost误差，当误差为0的时候，退出循环
aggClassEst += alpha * classEst
print("aggClassEst:",aggClassEst.T)
aggErrors = np.multiply(np.sign(aggClassEst) != np.mat(classLabels).T,np.ones((m,1)))
errorRate = aggErrors.sum()/m
print("total error:",errorRate,"\n")
if errorRate == 0.0: break #误差为0，退出循环
return weakClassArr,aggClassEst
def adaClassify(datToClass,classifierArr): #dataToClass为待分类样例，classifierArr为训练好的分类器
dataMatrix = np.mat(datToClass)
m = np.shape(dataMatrix)[0] #得到待分类样例的个数m
aggClassEst = np.mat(np.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 np.sign(aggClassEst)
if __name__ == '__main__':
dataArr,classLabels = loadSimpData()
weakClassArr,aggClassEst = adaBoostTrainDS(dataArr,classLabels)
print(adaClassify([[0,0],[5,5]],weakClassArr))
通过sign函数最终的结果。可以看到，分类没有问题，(5,5)属于正类，(0,0)属于负类。
示例3：在一个难数据集上应用AdaBoost
import numpy as np
import matplotlib.pyplot as plt
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
def stumpClassify(dataMatrix,dimen,threshVal,threshIneq): #单层决策树分类函数
retArray = np.ones((np.shape(dataMatrix)[0],1)) #初始化retArray为1
if threshIneq == 'lt': #threshIneq为标志，threshVal为阈值
retArray[dataMatrix[:,dimen] <= threshVal] = -1.0 #如果小于阈值,则赋值为-1。第dim列即第几个特征
else:
retArray[dataMatrix[:,dimen] > threshVal] = -1.0
return retArray #返回分类结果
def buildStump(dataArr,classLabels,D): #找到数据集上最佳单层决策树，D为样本权重
dataMatrix = np.mat(dataArr);labelMat = np.mat(classLabels).T
m,n = np.shape(dataMatrix)
numSteps = 10.0;bestStump = {};bestClasEst = np.mat(np.zeros((m,1))) #bestStump储存最佳单层决策树信息，bestClasEst为最佳分类结果
minError = float('inf') #最小误差初始化为正无穷大
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 inequal in ['lt','gt']: #大于和小于的情况，均遍历。lt:less than，gt:greater than
threshVal = (rangeMin + float(j) * stepSize) #计算阈值
predictedVals = stumpClassify(dataMatrix,i,threshVal,inequal) #计算分类结果
errArr = np.mat(np.ones((m,1))) #初始化误差矩阵
errArr[predictedVals == labelMat] = 0 #分类正确的，赋值为0
weightedError = D.T * errArr #计算误差
print("spilt: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
def adaBoostTrainDS(dataArr,classLabels,numIt = 40):
weakClassArr = []
m = np.shape(dataArr)[0]
D = np.mat(np.ones((m,1))/m) #初始化权重
aggClassEst = np.mat(np.zeros((m,1))) #记录每个数据点的类别估计值
for i in range(numIt):
bestStump,error,classEst = buildStump(dataArr,classLabels,D) #构建单层决策树
print("D:",D.T)
alpha = float(0.5 * np.log((1.0 - error)/max(error,1e-16))) #计算弱学习算法权重alpha,使error不等于0,因为分母不能为0
bestStump['alpha'] = alpha #存储弱学习算法权重
weakClassArr.append(bestStump) #存储单层决策树
print("classEst:",classEst.T)
expon = np.multiply(-1 * alpha * np.mat(classLabels).T,classEst) #计算e的指数项
D = np.multiply(D,np.exp(expon))
D = D/D.sum() #根据样本权重公式，更新样本权重
# 计算AdaBoost误差，当误差为0的时候，退出循环
aggClassEst += alpha * classEst
print("aggClassEst:",aggClassEst.T)
aggErrors = np.multiply(np.sign(aggClassEst) != np.mat(classLabels).T,np.ones((m,1)))
errorRate = aggErrors.sum()/m
print("total error:",errorRate,"\n")
if errorRate == 0.0: break #误差为0，退出循环
return weakClassArr,aggClassEst
def adaClassify(datToClass,classifierArr): #dataToClass为待分类样例，classifierArr为训练好的分类器
dataMatrix = np.mat(datToClass)
m = np.shape(dataMatrix)[0] #得到待分类样例的个数m
aggClassEst = np.mat(np.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 np.sign(aggClassEst)
if __name__ == '__main__':
dataArr,LabelArr = loadDataSet('horseColicTraining2.txt')
weakClassArr,aggClassEst = adaBoostTrainDS(dataArr,LabelArr)
testArr,testLabelArr = loadDataSet('horseColicTest2.txt')
print(weakClassArr)
predictions = adaClassify(dataArr,weakClassArr)
errArr = np.mat(np.ones((len(dataArr),1)))
print('训练集的错误率：%.3f%%' % float(errArr[predictions != np.mat(LabelArr).T].sum()/len(dataArr) * 100))
predictions = adaClassify(testArr,weakClassArr)
errArr = np.mat(np.ones((len(testArr),1)))
print('测试集的错误率：%.3f%%' % float(errArr[predictions != np.mat(testLabelArr).T].sum()/len(testArr) * 100))
训练集错误率未显示。
5.非均衡问题
至此，本书都是基于错误率来衡量分类器任务的成功程度的，这样的度量错误掩盖了样例如何被分错的事实。
（1）
正确率 ：TP/(TP+FP)，预测为正例的样本中真正正例的比例
召回率：TP/(TP+FN),预测为正例的真实正例占所有真实正例的比例
（2）ROC曲线
图中的横坐标是伪正例的比例（假阳率=FP/（FP+TN）），而纵坐标是真正例的比例（真阳率=TP/（TP+FN））。ROC曲线给出的是当阈值变化时假阳率和真阳率的变化情况。左下角的点所对应的将所有样例判为反例的情况，而右上角的点对应的则是将所有样例判为正例的情况。虚线给出的是随机猜测的结果曲线。
在理想的情况下，最佳的分类器应该尽可能地处于左上角，这就意味着分类器在假阳率很低的同时获得了很高的真阳率。
对不同的ROC曲线进行比较的一个指标是曲线下的面积（Area Unser the Curve，AUC）。AUC给出的是分类器的平均性能值，当然它并不能完全代替对整条曲线的观察。一个完美分类器的ACU为1.0，而随机猜测的AUC则为0.5。
→ROC曲线原理：
- 当阈值为0.9时，样本1的“Score”值为0.9，大于等于阈值，那么样本1为正类，其余为负类，则TPR=TP/（TP+FN）=1/10=0.1，FPR=FP/（FP+TN）=0/10=0；
- 当阈值为0.8时，样本1的“Score”值为0.9，样本2的“Score”值为0.8，大于等于阈值，那么样本1，2为正类，其余为负类，则TPR=2/10=0.2，FPR=0/10=0；
- 当阈值为0.7时，样本1，2，3的"Score"值大于等于阈值，那么样本1，2，3为正类，其余为负类，则TPR=2/10=0.2，FPR=1/10=0.1；
- 当阈值为0.6时，样本1，2，3，4的"Score"值大于等于阈值，那么样本1，2，3，4为正类，其余为负类，则TPR=3/10=0.3，FPR=1/10=0.1；
结果如下图：
ROC越靠拢于左上角，分类器性能越好。同理AUC越接近于1，分类器性能越好。
（3）处理非均衡问题的数据抽样问题：对分类器的训练数据进行改造，可以通过欠抽样（删除样例）或过抽样（复制样例）来实现。
1035
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
