完整版的Platt SMO算法和上一节的简化版中，实现alpha的更改和代数运算的优化环节一模一样。在优化过程中，唯一的不同是选择alpha的方式，完整版的Platt SMO算法应用了一些能够提速的启发方法。完整版中的辅助函数有一个用于清理代码的数据结构和3个用于对E进行缓存的辅助函数
完整版辅助函数
#数据结构保存所有的重要值
#参数 dataMatIn 数据矩阵，classLabels数据标签 c松弛变量 toler容错率
class optStruct:
def __init__(self, dataMatIn, classLabels, C, toler):
self.X = dataMatIn #数据矩阵
self.labelMat = classLabels#数据标签
self.C = C #松弛变量
self.tol = toler #容错率
self.m = np.shape(dataMatIn)[0] #数据矩阵行数100
self.alphas = np.mat(np.zeros((self.m,1))) #根据矩阵行数初始化alpha参数为0,100行2列
self.b = 0 #初始化b参数为0
#根据矩阵行数初始化误差缓存，第一列为是否有效的标志位，第二列为实际的误差E的值。
self.eCache = np.mat(np.zeros((self.m,2)))
#计算E值并返回 k标号为k的数据 oS数据结构
def calcEk(oS, k):
fXk = float(np.multiply(oS.alphas,oS.labelMat).T*(oS.X*oS.X[k,:].T) + oS.b)
Ek = fXk - float(oS.labelMat[k])#标号为k的数据误差
return Ek
#内循环启发方式2
#用于选择第二个alpha或者内循环的alpha值
def selectJ(i, oS, Ei):
maxK = -1; maxDeltaE = 0; Ej = 0 #初始化
oS.eCache[i] = [1,Ei] #根据Ei更新误差缓存的每一行数据为[1,Ei]1和误差值
validEcacheList = np.nonzero(oS.eCache[:,0].A)[0] #返回误差不为0的数据的列表值
if (len(validEcacheList)) > 1: #有不为0的误差
for k in validEcacheList: #遍历,找到最大的Ek
if k == i: continue #不计算i,浪费时间
Ek = calcEk(oS, k) #计算Ek
deltaE = abs(Ei - Ek) #计算|Ei-Ek|
if (deltaE > maxDeltaE):#找到maxDeltaE
maxK = k; maxDeltaE = deltaE; Ej = Ek
return maxK, Ej #返回maxK,Ej
else: #没有不为0的误差
j = selectJrand(i, oS.m) #随机选择alpha_j的索引值
Ej = calcEk(oS, j) #计算Ej
return j, Ej #j,Ej
#更新误差缓存
def updateEk(oS, k):
Ek = calcEk(oS, k) #计算Ek
oS.eCache[k] = [1,Ek]#更新误差缓存
用于寻找决策边界的优化例程
这里的代码和smoSimple()函数一模一样，但是这里的代码使用自己的数据结构，该结构在参数oS中传递。第二个重要的修改就是使用程序selectJ()而不是选择selectJrand()来选择第二个alpha值。最后，在alpha值改变时更新Ecache
#优化SMO算法
def innerL(i, oS):
#步骤1：计算误差Ei
Ei = calcEk(oS, i)
#优化alpha,设定一定的容错率。
if ((oS.labelMat[i] * Ei < -oS.tol) and (oS.alphas[i] < oS.C)) or ((oS.labelMat[i] * Ei > oS.tol) and (oS.alphas[i] > 0)):
#使用内循环启发方式2选择alpha_j,并计算Ej
j,Ej = selectJ(i, oS, Ei)
#保存更新前的aplpha值，使用深拷贝
alphaIold = oS.alphas[i].copy();
alphaJold = oS.alphas[j].copy();
#步骤2：计算上下界L和H
if (oS.labelMat[i] != oS.labelMat[j]):
L = max(0, oS.alphas[j] - oS.alphas[i])
H = min(oS.C, oS.C + oS.alphas[j] - oS.alphas[i])
else:
L = max(0, oS.alphas[j] + oS.alphas[i] - oS.C)
H = min(oS.C, oS.alphas[j] + oS.alphas[i])
if L == H:
print("L==H")
return 0
#步骤3：计算eta
eta = 2.0 * oS.X[i,:] * oS.X[j,:].T - oS.X[i,:] * oS.X[i,:].T - oS.X[j,:] * oS.X[j,:].T
if eta >= 0:
print("eta>=0")
return 0
#步骤4：更新alpha_j
oS.alphas[j] -= oS.labelMat[j] * (Ei - Ej)/eta
#步骤5：修剪alpha_j
oS.alphas[j] = clipAlpha(oS.alphas[j],H,L)
#更新Ej至误差缓存
updateEk(oS, j)
if (abs(oS.alphas[j] - alphaJold) < 0.00001):
print("alpha_j变化太小")
return 0
#步骤6：更新alpha_i
oS.alphas[i] += oS.labelMat[j]*oS.labelMat[i]*(alphaJold - oS.alphas[j])
#更新Ei至误差缓存
updateEk(oS, i)
#步骤7：更新b_1和b_2
b1 = oS.b - Ei- oS.labelMat[i]*(oS.alphas[i]-alphaIold)*oS.X[i,:]*oS.X[i,:].T - oS.labelMat[j]*(oS.alphas[j]-alphaJold)*oS.X[i,:]*oS.X[j,:].T
b2 = oS.b - Ej- oS.labelMat[i]*(oS.alphas[i]-alphaIold)*oS.X[i,:]*oS.X[j,:].T - oS.labelMat[j]*(oS.alphas[j]-alphaJold)*oS.X[j,:]*oS.X[j,:].T
#步骤8：根据b_1和b_2更新b
if (0 < oS.alphas[i]) and (oS.C > oS.alphas[i]): oS.b = b1
elif (0 < oS.alphas[j]) and (oS.C > oS.alphas[j]): oS.b = b2
else: oS.b = (b1 + b2)/2.0
return 1
else:
return 0
完整版的Platt SMO的外循环代码
该算法的输入和函数smoSimple()完全一样，函数一开始构建一个数据结构来容纳所有的数据，然后需要对控制函数退出的一些变量进行初始化。当然代码的主体还是while循环，这里的退出条件更多(当迭代次数超过指定的最大值或遍历整个集合都未对任意alpha对进行修改时，就退出)。这里的maxIter变量和函数smoSimple()中的作用有一点不同，后者当没有任何alpha发生改变时会将整个集合的一次遍历过程计成一次迭代，而这里的一次迭代定义为一次循环过程，而不管该循环具体做了什么事。此时，如果在优化过程中存在波动就会停止，优于smoSimple()函数中的计数方法。
while循环的内部与smosimple()中有所不同，一开始的for循环在数据集上遍历任意可能的alpha。我们通过调用innerL()来选择第二个alpha,并可能时对其进行优化处理。如果有任意一对alpha值发生变化，那么会返回1.第二个for循环遍历所有的非边界alpha值，也就是不在边界0或C上的值
#完整的线性SMO算法
#dataMatIn数据矩阵 classLabels数据标签 C 松弛变量 toler 容错率 maxIter最大迭代次数
def smoP(dataMatIn, classLabels, C, toler, maxIter):
oS = optStruct(np.mat(dataMatIn), np.mat(classLabels).transpose(), C, toler)#初始化数据结构
iter = 0 #初始化当前迭代次数
entireSet = True;
alphaPairsChanged = 0
#当迭代次数超过指定的最大值或遍历整个集合都未对任意alpha对进行修改时就退出循环
while (iter < maxIter) and ((alphaPairsChanged > 0) or (entireSet)): #遍历整个数据集都alpha也没有更新或者超过最大迭代次数,则退出循环
alphaPairsChanged = 0
if entireSet: #遍历整个数据集
for i in range(oS.m):
alphaPairsChanged += innerL(i,oS) #使用优化的SMO算法
print("全样本遍历:第%d次迭代 样本:%d, alpha优化次数:%d" % (iter,i,alphaPairsChanged))
iter += 1
else: #遍历非边界值
nonBoundIs = np.nonzero((oS.alphas.A > 0) * (oS.alphas.A < C))[0] #遍历不在边界0和C的alpha
for i in nonBoundIs:
alphaPairsChanged += innerL(i,oS)
print("非边界遍历:第%d次迭代 样本:%d, alpha优化次数:%d" % (iter,i,alphaPairsChanged))
iter += 1
if entireSet: #遍历一次后改为非边界遍历
entireSet = False
elif (alphaPairsChanged == 0): #如果alpha没有更新,计算全样本遍历
entireSet = True
print("迭代次数: %d" %iter)
return oS.b,oS.alphas
测试
dataArr, classLabels = loadDataSet('testSet.txt')
b, alphas = smoP(dataArr, classLabels, 0.6, 0.001, 40)
ps:这里还是用到了selectJrand,记得从上一节引进来
L==H
全样本遍历:第0次迭代 样本:0, alpha优化次数:0
L==H
全样本遍历:第0次迭代 样本:1, alpha优化次数:0
全样本遍历:第0次迭代 样本:2, alpha优化次数:1
L==H
全样本遍历:第0次迭代 样本:3, alpha优化次数:1
全样本遍历:第0次迭代 样本:4, alpha优化次数:2
全样本遍历:第0次迭代 样本:5, alpha优化次数:2
全样本遍历:第0次迭代 样本:6, alpha优化次数:2
alpha_j变化太小
全样本遍历:第0次迭代 样本:7, alpha优化次数:2
L==H
全样本遍历:第0次迭代 样本:8, alpha优化次数:2
全样本遍历:第0次迭代 样本:9, alpha优化次数:2
.....
.....
.....
全样本遍历:第2次迭代 样本:91, alpha优化次数:0
全样本遍历:第2次迭代 样本:92, alpha优化次数:0
全样本遍历:第2次迭代 样本:93, alpha优化次数:0
全样本遍历:第2次迭代 样本:94, alpha优化次数:0
全样本遍历:第2次迭代 样本:95, alpha优化次数:0
全样本遍历:第2次迭代 样本:96, alpha优化次数:0
alpha_j变化太小
全样本遍历:第2次迭代 样本:97, alpha优化次数:0
全样本遍历:第2次迭代 样本:98, alpha优化次数:0
全样本遍历:第2次迭代 样本:99, alpha优化次数:0
首先基于alpha值得到超平面，这也包括w的计算
w的计算
这部分主要的就是for循环，虽然在循环中实现的仅仅是多个数的乘积，由上面的测试就会发现大部分的alpha值为0，而非零alpha所对应的也就是支持向量，也就是最终起作用的
def calcWs(alphas,dataArr,classLabels):
X = np.mat(dataArr); labelMat = np.mat(classLabels).transpose()
m,n = np.shape(X)
w = np.zeros((n,1))
for i in range(m):
w += np.multiply(alphas[i]*labelMat[i],X[i,:].T)
return w
为了使用前面给出的函数，输入如下命令:
ws = calcWs(alphas,dataArr,classLabels)
print(ws)
输出
[[ 0.65307162]
[-0.17196128]]
现在对数据进行分类处理，比如对第一个数据点分类，可以这样输入:
from numpy import*
datMat = mat(dataArr)
print(datMat[0]*mat(ws)+b)
输出
[[-0.92555695]]
如果该值大于0，那么属于1类；如果该值小于0，那么则属于-1类。对于数据点0，应该得到的类别标签是-1，可以通过如下的命令来确认分类结果的正确性
print(classLabels[0])
输出
-1.0
当然，这里我们只测试一个值，感兴趣的可以按照这种方式多测试几个数据
现在我们已经可以成功训练出分类器了，可视化一下吧
可视化
#分类结果可视化
def showClassifer(dataMat, classLabels, w, b):
#绘制样本点
data_plus = [] #正样本
data_minus = [] #负样本
for i in range(len(dataMat)):
if classLabels[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 abs(alpha) > 0:
x, y = dataMat[i]
plt.scatter([x], [y], s=150, c='none', alpha=0.7, linewidth=1.5, edgecolor='red')
plt.show()
测试
w = calcWs(alphas,dataArr, classLabels)
showClassifer(dataArr, classLabels, w, b)
输出
完整版的可视化结果
源码