【Python机器学习实战】感知机和支持向量机学习笔记（三）之SVM的实现
前面已经对感知机和SVM进行了简要的概述，本节是SVM算法的实现过程用于辅助理解SVM算法的具体内容，然后借助sklearn对SVM工具包进行实现。
SVM算法的核心是SMO算法的实现，首先对SMO算法过程进行实现，先对一些辅助函数进行定义：
1 # 先定义一些辅助函数 2 # 选取第二变量函数 3 def select_J_rand(i, m): 4 j=i 5 while(j==i): 6 j = int(random.uniform(0, m)) 7 return j 8 9 # 定义对α进行裁剪的函数 10 def clip_alpha(aj, H, L): 11 if aj > H: 12 aj=H 13 if L > aj: 14 aj = L 15 return aj
然后实现一个简化版的SMO算法：
"""
Input：dataX, dataY, C(惩罚因子), toler（容忍度）, iter_num
Output: alpha、b
"""
def smo_simple(dataX, dataY, C, toler, iter_num): dataMatrix = mat(dataX); labelMat = dataY.transpose() # 初始化参数 b = 0; m, n = np.shape(dataMatrix) alphas = mat(np.zeros((m, 1))) iter = 0 # 当超过迭代次数停止 while iter < iter_num: # 记录α1和α2变化次数 alphaPairsChanged = 0 for i in range(m): # 计算f(xi),预测类别 fXi = float(np.multiply(alphas, labelMat).T * (dataMatrix * dataMatrix[i, :].T)) + b # 计算误差 Ei = fXi - float(labelMat[i]) # 当不满足条件时，选取变量j，这里要判断α是否在[0,C]内，若超出范围则不再进行优化 if ((labelMat[i] * Ei < -toler) and (alphas[i] < C)) or ((labelMat[i]*Ei > toler) and alphas[i] > 0): j = select_J_rand(i, m) # 计算x2的预测值y2 fXj = float(np.multiply(alphas, labelMat).T * (dataMatrix * dataMatrix[j, :].T)) + b Ej = fXj - float(labelMat[j]) alpha_I_old = alphas[i].copy() alpha_J_old = alphas[j].copy() if (labelMat[i] != labelMat[j]): L = max(0, alphas[j] - alphas[i]) H = min(C, C + alphas[j] - alphas[i]) else: L = max(0, alphas[i] + alphas[j] - C) H = min(C, alphas[i] + alphas[j]) 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 if eta > 0: print("eta > 0") continue alphas[j] -= labelMat[j] * (Ej - Ei)/eta alphas[j] = clip_alpha(alphas[j], H, L) # 当α2不再变化 if (abs(alphas[j]-alpha_J_old) < 0.00001): print("j not moving enough") continue # 更新α1 alphas[i] += labelMat[i] * labelMat[j] * (alpha_J_old - alphas[j]) # 计算b1和b2 b1 = b - Ei - labelMat[i] * (alphas[i] - alpha_I_old) * dataMatrix[i, :] * dataMatrix[i, :].T - labelMat[j] * (alphas[j] - alpha_J_old) * dataMatrix[i, :] * dataMatrix[j, :].T b2 = b - Ej - labelMat[i] * (alphas[i] - alpha_I_old) * dataMatrix[i, :] * dataMatrix[j, :].T - labelMat[j] * (alphas[j] - alpha_J_old) * dataMatrix[j, :] * dataMatrix[j, :].T if (alphas[i] > 0) and (alphas[i] < C): b = b1 elif (alphas[j] > 0) and (alphas[j] < C): b = b2 else: b = (b1 + b2)/2 alphaPairsChanged += 1 if alphaPairsChanged == 0: iter += 1 else: iter = 0 print("iteration number: %d"%iter) return b, alphas
SMO算法具有一定的随机性，因此每次运行的结果不一定相同。上面就是一个简单的SMO算法的实现部分，对于小批量数据可以满足需求，但当数据量过于庞大时，上面的算法的效率将会很慢，这是因为在α的选择问题上，下面提供一种改进的SMO算法，改进的SMO算法会通过一个外循环选择第一个α的值，选择方法是在遍历所有样本（数据集）和非边界α中进行扫描，所谓非边界α是指那些不等于0或者C的α值，建立这些α值的列表，在列表中进行遍历，并在扫描时跳过不再改变的α进行遍历。下面是具体实现过程
首先定义辅助函数用于存储和更新E，并建立一个数据结构存储变量
1 # 首先建立3个辅助函数用于对E进行缓存，以及1种用于存储数据的数据结构 2 # 存储变量的数据结构 3 class optStruct: 4 def __init__(self, dataX, dataY, C, toler): 5 self.X = dataX 6 self.Y = dataY 7 self.C = C 8 self.toler = toler 9 self.m = np.shape(dataX)[0] 10 self.alphas = np.mat(zeros((self.m, 1))) 11 self.b = 0 12 # cache第一列为有效性标志位，第二列为E值 13 self.eCache = np.mat(np.zeros((self.m, 2))) 14 15 # 计算E值并返回，由于频繁使用单独写成一个函数 16 def calcEk(oS, k): 17 fXk = float(np.multiply(oS.alphas, oS.labelMat).T * (oS.X * oS.X[k, :].T)) + oS.b 18 Ek = fXk - float(oS.labelMat[k]) 19 return Ek 20 21 # 用于选择第二个α的值，保证每次优化采用最大的步长 22 def select_J(i, oS, Ei): 23 maxK = -1; maxDeltaE = 0; Ej = 0 24 oS.eCache[i] = [1, Ei] 25 validEcacheList = nonzero(oS.eCache[:, 0].A)[0] 26 if len(validEcacheList) > 1: 27 for k in validEcacheList: 28 if k == i: 29 continue 30 Ek = calcEk(oS, k) 31 deltaE = abs(Ei - Ek) 32 # 选择变化最大的那个 33 if deltaE > maxDeltaE: 34 maxK = k 35 maxDeltaE = deltaE 36 Ej = Ek 37 return maxK, Ej 38 else: 39 j = select_J_rand(i, oS.m) 40 Ej = calcEk(oS, j) 41 return j, Ej 42 43 44 def updateEk(oS, k): 45 Ek = calcEk(oS, k) 46 oS.eCache[k] = [1, Ek]
接下来就是SMO算法的改进版本
1 # 与simpleSMO一致，更新的alpha存入cache中 2 def innerL(i, oS): 3 Ei = calcEk(oS, i) 4 if ((oS.labelMat[i] * Ei < -oS.toler) and (oS.alphas[i] < oS.C)) or ((oS.labelMat[i] * Ei > oS.toler) and (oS.alphas[i] > 0)): 5 j, Ej = select_J(i, oS, Ei) 6 alpha_I_old = oS.alphas[i].copy() 7 alpha_J_old = oS.alphas[j].copy() 8 if oS.labelMat[i] != oS.labelMat[j]: 9 L = max(0, oS.alphas[j] - oS.alphas[i]) 10 H = min(oS.C, oS.C+ oS.alphas[j] - oS.alphas[i]) 11 else: 12 L = min(0, oS.alphas[i] + oS.alphas[j] - oS.C) 13 H = max(oS.C, oS.alphas[i] + oS.alphas[j]) 14 if H == L: 15 return 0 16 eta = 2.0 * oS.X[i, :] * oS.X[j, :].T - oS.X[i, :] * oS.X[i, :].T - oS.X[j, :] * oS.X[j, :].T 17 if eta >= 0: 18 return 0 19 oS.alphas[j] -= oS.labelMat[j] * (Ei - Ej)/eta 20 oS.alphas[j] = clip_alpha(oS.alphas[j], H, L) 21 updateEk(oS, j) 22 if abs(oS.alphas[j] - alpha_J_old) < 0.00001: 23 return 0 24 oS.alphas[i] -= oS.labelMat[i] * oS.labelMat[j] * (oS.alphas[j] - alpha_J_old) 25 updateEk(oS, i) 26 b1 = oS.b - Ei - oS.labelMat[i] * (oS.alphas[i] - alpha_I_old) * oS.X[i, :] * oS.X[i, :].T - oS.labelMat[j] * (oS.alphas[j] - alpha_J_old) * oS.X[i, :] * oS.X[j, :].T 27 b2 = oS.b - Ej - oS.labelMat[i] * (oS.alphas[i] - alpha_I_old) * oS.X[i, :] * oS.X[j, :].T - oS.labelMat[j] * (oS.alphas[j] - alpha_J_old) * oS.X[j, :] * oS.X[j, :].T 28 if oS.alphas[i] > 0 and oS.alphas[i] < oS.C: 29 oS.b = b1 30 elif oS.alphas[j] > 0 and oS.alphas[j] < oS.C: 31 oS.b = b2 32 else: 33 os.b = (b1 + b2)/2 34 return 1 35 else: 36 return 0 37 38 39 def smoP(dataX, labelMat, C, toler, maxIter, kTup=('lin', 0)): 40 oS = optStruct(mat(dataX), mat(labelMat).transpose(), C, toler) 41 iter = 0 42 entireSet = True 43 alphaPairsChanged = 0 44 while (iter < maxIter) and alphaPairsChanged > 0 or entireSet: 45 alphaPairsChanged = 0
# 搜索第一个变量的值，采用两个方法交替进行的方式，利用entireSet变量控制 46 # 第一种遍历全体样本 47 if entireSet: 48 for i in range(oS.m): 49 alphaPairsChanged += innerL(i, oS) 50 iter += 1 51 # 第二种遍历非边界样本 52 else: 53 nonBoundIs = nonzero((oS.alphas.A > 0) * oS.alphas.A < C)[0] 54 for i in nonBoundIs: 55 alphaPairsChanged += innerL(i, oS) 56 iter += 1 57 if entireSet: 58 entireSet = False 59 elif alphaPairsChanged == 0: 60 entireSet = True 61 return oS.alphas, oS.b
获取到α的值后，则可以进一步求出模型的w和b，具体实现过程为:
1 def calW(alphas, dataArr, classLabels): 2 X = mat(dataArr) 3 labelMat = mat(classLabels).transpose() 4 m, n = shape(X) 5 w = zeros((m, 1)) 6 for i in range(m): 7 w += multiply(alphas[i] * labelMat[i], X[i, :]) 8 return w
上述即为SVM的实现过程，是对线性可分的数据的分类的实现过程，当对于非线性数据，需要运用到核函数，在实现过程中也较为简单，只需只需将（xi·xj）替换为核函数即可，具体实现过程如下
1 # 首先原先的数据结构中要计算核矩阵，将下述代码加入数据结构代码部分即可 2 self.K = mat(zeros(self.m, self.m)) 3 for i in range(self.m): 4 self.K[:, i] = kernelTrans(self.X, self.X[i, :], self.kTup)
接下来实现核转换函数
1 def kernelTrans(X, A, kTup): 2 m, n = shape(X) 3 K = mat(zeros((m, 1))) 4 if kTup['0'] == 'lin': 5 K = X * A.T 6 elif kTup[0] == 'rbf': 7 for j in range(m): 8 deltaRow = X[j, :] - A 9 K[j] = deltaRow * deltaRow.T 10 K = exp(K/(-1 * kTup[1] ** 2)) 11 else: 12 raise NameError('没有定义核函数') 13 return K
然后需要在参数计算的函数中将对应的xi*xj替换为核函数即可：
1 # 首先是innerL中 2 eta = 2.0 * oS.K[i, j] - oS.K[i, i] - oS.K[j, j] 3 b1 = oS.b - Ei - oS.labelMat[i] * (oS.alphas[i] - alpha_I_old) * oS.K[i, i] - oS.labelMat[j] * (oS.alphas[j] - alpha_J_old) * oS.K[i, j] 4 b2 = oS.b - Ej - oS.labelMat[i] * (oS.alphas[i] - alpha_I_old) * oS.K[i, j] - oS.labelMat[j] * (oS.alphas[j] - alpha_J_old) * oS.K[j, j] 5 6 # 然后是calcEk 7 fXk = float(multiply(oS.alphas, oS.labelMat).T * oS.K[:, k] + oS.b)
至此，SVM算法的实现过程基本已经完成了，接下来我们利用MNIST的数据集，对手写数字进行分类和辨识，MNIST手写辨识数据在网上就可以找到。
首先需要写一个读取数据的函数以及将函数图像转化为矩阵的函数：
1 def img2Vector(filename): 2 returnVec = zeros((1, 1024)) 3 fr = open(filename) 4 for i in range(32): 5 lineStr = fr.readline() 6 for j in range(32): 7 returnVec[0, 32*i + j] = int(lineStr[j]) 8 return returnVec
1 def loadImages(dir): 2 hwLabels = [] 3 trainingFileList = os.listdir(dir) 4 m = len(trainingFileList) 5 for i in range(m): 6 fileNameStr = trainingFileList[i] 7 fileStr = fileNameStr.split('.')[0] 8 classNumStr = int(fileStr.split('_')[0])
# 只考虑二分类问题 9 if classNumStr == 9: 10 hwLabels.append(-1) 11 else: 12 hwLabels.append(1) 13 trainingMat[i, :] = img2Vector('%s/%s' % (dir, fileNameStr)) 14 return trainingMat, hwLabels
然后编写主程序，用于分类和测试。
1 def testDigits(kTup=('rbf', 10)):
# 获取数据 2 dataArr, labelArr = loadImages('trainingDigits')
# 利用SMO算法求解出α和b 3 alphas, b = smoP(dataArr, labelArr, 200, 0.0001, 10000, kTup) 4 dataMat = mat(dataArr) 5 labelMat = mat(labelArr).transpose()
# 获取支持向量的索引 6 svInd = nonzero(alphas.A > 0)[0]
# 获取支持向量 7 svs = dataMat[svInd] 8 labelSv = labelMat[svInd] 9 m, n = shape(dataMat) 10 errorCount = 0 11 for i in range(m): 12 kernelEval = kernelTrans(svs, dataMat[i, :], kTup) 13 predict = kernelEval.T * multiply(labelSv, alphas[svInd]) + b 14 if sign(predict) != sign(labelArr[i]): 15 errorCount += 1 16 print('there are %d Support Vectors'%shape(svs)[0]) 17 print('the error rate is %f' % (errorCount / (len(labelMat)))) 18 test_dataArr, test_labelArr = loadImages('testDigits') 19 test_dataMat = mat(test_dataArr) 20 test_labelMat = mat(test_labelArr).transpose() 21 m1, n1 = shape(test_dataMat) 22 test_errorCount = 0 23 for i in range(m1): 24 kernelEval = kernelTrans(svs, test_dataMat[i, :], kTup) 25 predict = kernelEval.T * multiply(labelSv, alphas[svInd]) + b 26 if sign(predict) != sign(test_labelArr[i]): 27 errorCount += 1 28 print('the error rate is %f' % (test_errorCount / (len(test_labelMat))))
输出结果如下：
至此，上述是一个完整的SVM算法用于二分类的实现过程，核函数可以进行修改和替换，同时，对于多分类情况相当于建立多个分类器进行分类，过程这里不再赘述，接下来，使用python中sklearn包对Mnist的数据集分类实现一遍。
首先是从sklearn导入svm包，并读取数据
1 from sklearn import svm 2 train_dataArr, train_labelArr = loadImages(dir)
然后是模型的初始化，这里模型中有一些参数，其具体说明如下
1 model = svm.SVC(C=200, kernel='rbf', tol=1e-4, max_iter=-1, degree=3, gamma='auto_deprecated', coef0=0, shrinking=True, 2 probability=False, cache_size=200, verbose=False, class_weight=None, decision_function_shape='ovr') 3 """ 4 C: 惩罚因子，默认为1.0，C越大，相当于惩罚松弛变量，希望松弛变量接近0，即对误分类的惩罚增大，趋向于对训练集全分对的情况，这样对训练集测试时准确率很高，但泛化能力弱。C值小，对误分类的惩罚减小，允许容错，将他们当成噪声点，泛化能力较强。 5 tol: 容忍度阈值 6 max_iter: 迭代次数 7 kernel：核函数，包括: 8 linear(线性核)：u*v 9 poly(多项式核):(gamma * u * v + coef0)^degree 10 rbf(高斯核): exp(-gamma|u-v|^2) 11 sigmoid核: tanh(gamma*u*v + coef0) 12 degree: 多项式核中的维度 13 gamma： 核函数中的参数，默认为“auto”，选择1/n_features 14 coef： 多项式核和simoid核中的常数项，仅对这两个核函数有效 15 probability: 是否采用概率估计，默认为False 16 shrinking： 是否采用shrinking heuristic方法，默认为true 17 cache_size: 核函数的缓存大小，默认为200 18 verbose: 是否允许冗余输出 19 class_weight: 类别权重 20 decision_function_shape: 可以取'ovo'一对一和'ovr'一对其他 21 """
然后就是数据进行训练，并查看训练准确率
1 model.fit(mat(train_dataArr), mat(train_labelArr).transpose()) 2 train_score = model.score(mat(train_dataArr), mat(train_labelArr).transpose()) 3 print('训练集上的准确率为%s'%train_score) 4 5 test_dataArr, test_labelArr = loadImages('E:\资料\PythonML_Code\Charpter 5\data\\testDigits'.format(dir)) 6 test_score = model.score(mat(test_dataArr), mat(test_labelArr).transpose()) 7 print('测试集上的准确率为%f' % test_score)
最终结果为：
至此，SVM的基本内容已基本完毕，此外还有利用SVM进行线性回归的算法以及采用SVM算法进行半监督学习的算法，后面看到这一块会进一步完善这一块内容。
