Python3《機器學習實戰》學習筆記（九）：支持向量機實戰篇之再撕非線性SVM

01-26

轉載請註明作者和出處： https://zhuanlan.zhihu.com/ml-jack

機器學習知乎專欄：https://zhuanlan.zhihu.com/ml-jack

CSDN博客專欄：http://blog.csdn.net/column/details/16415.html

Github代碼獲取：https://github.com/Jack-Cherish/Machine-Learning/

Python版本： Python3.x

運行平台： Windows

IDE： Sublime text3

一、前言

上篇文章講解的是線性SVM的推導過程以及簡化版SMO演算法的代碼實現。本篇文章將講解SMO演算法的優化方法以及非線性SVM。

本文出現的所有代碼，均可在我的github上下載，歡迎Follow、Star：https://github.com/Jack-Cherish/Machine-Learning

碼文章的時候，正好是中秋佳節，祝各位中秋快樂！

二、SMO演算法優化

在幾百個點組成的小規模數據集上，簡化版SMO演算法的運行是沒有什麼問題的，但是在更大的數據集上的運行速度就會變慢。簡化版SMO演算法的第二個α的選擇是隨機的，針對這一問題，我們可以使用啟發式選擇第二個α值，來達到優化效果。

1、啟發選擇方式

下面這兩個公式想必已經不再陌生：

在實現SMO演算法的時候，先計算η，再更新 $a_j$ 。為了加快第二個 $α_j$ 乘子的迭代速度，需要讓直線的斜率增大，對於 $α_j$ 的更新公式，其中η值沒有什麼文章可做，於是只能令：

因此，我們可以明確自己的優化方法了：

最外層循環，首先在樣本中選擇違反KKT條件的一個乘子作為最外層循環，然後用"啟發式選擇"選擇另外一個乘子並進行這兩個乘子的優化
在非邊界乘子中尋找使得 $|E_i - E_j|$ 最大的樣本
如果沒有找到，則從整個樣本中隨機選擇一個樣本

接下來，讓我們看看完整版SMO演算法如何實現。

2、完整版SMO演算法

完整版Platt SMO演算法是通過一個外循環來選擇違反KKT條件的一個乘子，並且其選擇過程會在這兩種方式之間進行交替：

在所有數據集上進行單遍掃描
在非邊界α中實現單遍掃描

非邊界α指的就是那些不等於邊界0或C的α值，並且跳過那些已知的不會改變的α值。所以我們要先建立這些α的列表，用於才能出α的更新狀態。

在選擇第一個α值後，演算法會通過"啟發選擇方式"選擇第二個α值。

3、編寫代碼

我們首先構建一個僅包含init方法的optStruct類，將其作為一個數據結構來使用，方便我們對於重要數據的維護。代碼思路和之前的簡化版SMO演算法是相似的，不同之處在於增加了優化方法，如果上篇文章已經看懂，我想這個代碼會很好理解。創建一個svm-smo.py文件，編寫代碼如下：

# -*-coding:utf-8 -*-import matplotlib.pyplot as pltimport numpy as npimport random"""Author: Jack CuiBlog: http://blog.csdn.net/c406495762Zhihu: https://www.zhihu.com/people/Jack--Cui/Modify: 2017-10-03"""class optStruct: """ 數據結構，維護所有需要操作的值 Parameters： dataMatIn - 數據矩陣 classLabels - 數據標籤 C - 鬆弛變數 toler - 容錯率 """ 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] #數據矩陣行數 self.alphas = np.mat(np.zeros((self.m,1))) #根據矩陣行數初始化alpha參數為0 self.b = 0 #初始化b參數為0 self.eCache = np.mat(np.zeros((self.m,2))) #根據矩陣行數初始化虎誤差緩存，第一列為是否有效的標誌位，第二列為實際的誤差E的值。def loadDataSet(fileName): """ 讀取數據 Parameters: fileName - 文件名 Returns: dataMat - 數據矩陣 labelMat - 數據標籤 """ dataMat = []; labelMat = [] fr = open(fileName) for line in fr.readlines(): #逐行讀取，濾除空格等 lineArr = line.strip().split( ) dataMat.append([float(lineArr[0]), float(lineArr[1])]) #添加數據 labelMat.append(float(lineArr[2])) #添加標籤 return dataMat,labelMatdef calcEk(oS, k): """ 計算誤差 Parameters： oS - 數據結構 k - 標號為k的數據 Returns: Ek - 標號為k的數據誤差 """ fXk = float(np.multiply(oS.alphas,oS.labelMat).T*(oS.X*oS.X[k,:].T) + oS.b) Ek = fXk - float(oS.labelMat[k]) return Ekdef selectJrand(i, m): """ 函數說明:隨機選擇alpha_j的索引值 Parameters: i - alpha_i的索引值 m - alpha參數個數 Returns: j - alpha_j的索引值 """ j = i #選擇一個不等於i的j while (j == i): j = int(random.uniform(0, m)) return jdef selectJ(i, oS, Ei): """ 內循環啟發方式2 Parameters： i - 標號為i的數據的索引值 oS - 數據結構 Ei - 標號為i的數據誤差 Returns: j, maxK - 標號為j或maxK的數據的索引值 Ej - 標號為j的數據誤差 """ maxK = -1; maxDeltaE = 0; Ej = 0 #初始化 oS.eCache[i] = [1,Ei] #根據Ei更新誤差緩存 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,Ejdef updateEk(oS, k): """ 計算Ek,並更新誤差緩存 Parameters： oS - 數據結構 k - 標號為k的數據的索引值 Returns: 無 """ Ek = calcEk(oS, k) #計算Ek oS.eCache[k] = [1,Ek] #更新誤差緩存def clipAlpha(aj,H,L): """ 修剪alpha_j Parameters: aj - alpha_j的值 H - alpha上限 L - alpha下限 Returns: aj - 修剪後的alpah_j的值 """ if aj > H: aj = H if L > aj: aj = L return ajdef innerL(i, oS): """ 優化的SMO演算法 Parameters： i - 標號為i的數據的索引值 oS - 數據結構 Returns: 1 - 有任意一對alpha值發生變化 0 - 沒有任意一對alpha值發生變化或變化太小 """ #步驟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 0def smoP(dataMatIn, classLabels, C, toler, maxIter): """ 完整的線性SMO演算法 Parameters： dataMatIn - 數據矩陣 classLabels - 數據標籤 C - 鬆弛變數 toler - 容錯率 maxIter - 最大迭代次數 Returns: oS.b - SMO演算法計算的b oS.alphas - SMO演算法計算的alphas """ oS = optStruct(np.mat(dataMatIn), np.mat(classLabels).transpose(), C, toler) #初始化數據結構 iter = 0 #初始化當前迭代次數 entireSet = True; alphaPairsChanged = 0 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 #返回SMO演算法計算的b和alphasdef showClassifer(dataMat, classLabels, w, b): """ 分類結果可視化 Parameters: dataMat - 數據矩陣 w - 直線法向量 b - 直線解決 Returns: 無 """ #繪製樣本點 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()def calcWs(alphas,dataArr,classLabels): """ 計算w Parameters: dataArr - 數據矩陣 classLabels - 數據標籤 alphas - alphas值 Returns: w - 計算得到的w """ 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 wif __name__ == __main__: dataArr, classLabels = loadDataSet(testSet.txt) b, alphas = smoP(dataArr, classLabels, 0.6, 0.001, 40) w = calcWs(alphas,dataArr, classLabels) showClassifer(dataArr, classLabels, w, b)

完整版SMO演算法(左圖)與簡化版SMO演算法(右圖)運行結果對比如下圖所示：

圖中畫紅圈的樣本點為支持向量上的點，是滿足演算法的一種解。完整版SMO演算法覆蓋整個數據集進行計算，而簡化版SMO演算法是隨機選擇的。可以看出，完整版SMO演算法選出的支持向量樣點更多，更接近理想的分隔超平面。

對比兩種演算法的運算時間，我的測試結果是完整版SMO演算法的速度比簡化版SMO演算法的速度快6倍左右。

其實，優化方法不僅僅是簡單的啟發式選擇，還有其他優化方法，SMO演算法速度還可以進一步提高。但是鑒於文章進度，這裡不再進行展開。感興趣的朋友，可以移步這裡進行理論學習：http://www.cnblogs.com/zangrunqiang/p/5515872.html

三、非線性SVM

1、核技巧

我們已經了解到，SVM如何處理線性可分的情況，而對於非線性的情況，SVM的處理方式就是選擇一個核函數。簡而言之：在線性不可分的情況下，SVM通過某種事先選擇的非線性映射（核函數）將輸入變數映到一個高維特徵空間，將其變成在高維空間線性可分，在這個高維空間中構造最優分類超平面。

根據上篇文章，線性可分的情況下，可知最終的超平面方程為：

將上述公式用內積來表示：

對於線性不可分，我們使用一個非線性映射，將數據映射到特徵空間，在特徵空間中使用線性學習器，分類函數變形如下：

其中?從輸入空間(X)到某個特徵空間(F)的映射，這意味著建立非線性學習器分為兩步：

首先使用一個非線性映射將數據變換到一個特徵空間F；
然後在特徵空間使用線性學習器分類。

如果有一種方法可以在特徵空間中直接計算內積 $<?(x_i),?(x)>$ ，就像在原始輸入點的函數中一樣，就有可能將兩個步驟融合到一起建立一個分線性的學習器，這樣直接計算的方法稱為核函數方法。

這裡直接給出一個定義：核是一個函數 $k$ ，對所有 $x,z∈X$ ，滿足 $k(x,z)=<?(x_i),?(x)>$ ，這裡 $?(·)$ 是從原始輸入空間X到內積空間F的映射。

簡而言之：如果不是用核技術，就會先計算線性映 $?(x_1)$ 和 $?(x_2)$ ，然後計算這它們的內積，使用了核技術之後，先把 $?(x_1)$ 和 $?(x_2)$ 的一般表達式 $<?(x_1),?(x_2)>=k(<?(x_1),?(x_2) >)$ 計算出來，這裡的 $<·，·>$ 表示內積， $k(·，·)$ 就是對應的核函數，這個表達式往往非常簡單，所以計算非常方便。

這種將內積替換成核函數的方式被稱為核技巧(kernel trick)。

2、非線性數據處理

已經知道了核技巧是什麼，但是為什麼要這樣做呢？我們先舉一個簡單的例子，進行說明。假設二維平面x-y上存在若干點，其中點集A服從 ${x,y|x^2+y^2=1}$ ，點集B服從 ${x,y|x^2+y^2=9}$ ，那麼這些點在二維平面上的分布是這樣的：

藍色的是點集A，紅色的是點集B，他們在xy平面上並不能線性可分，即用一條直線分割（雖然肉眼是可以識別的）。採用映射 $(x,y)->(x,y,x^2+y^2)$ 後，在三維空間的點的分布為：

可見紅色和藍色的點被映射到了不同的平面，在更高維空間中是線性可分的（用一個平面去分割）。

上述例子中的樣本點的分布遵循圓的分布。繼續推廣到橢圓的一般樣本形式：

上圖的兩類數據分布為兩個橢圓的形狀，這樣的數據本身就是不可分的。不難發現，這兩個半徑不同的橢圓是加上了少量的噪音生成得到的。所以，一個理想的分界應該也是一個橢圓，而不是一個直線。如果用X1和X2來表示這個二維平面的兩個坐標的話，我們知道這個分界橢圓可以寫為：

這個方程就是高中學過的橢圓一般方程。注意上面的形式，如果我們構造另外一個五維的空間，其中五個坐標的值分別為：

那麼，顯然我們可以將這個分界的橢圓方程寫成如下形式：

這個關於新的坐標 $Z_1,Z_2,Z_3,Z_4,Z_5$ 的方程，就是一個超平面方程，它的維度是5。也就是說，如果我們做一個映射 ? : 二維 → 五維，將 $X_1,X_2$ 按照上面的規則映射為 $Z_1,Z_2,··· ,Z_5$ ，那麼在新的空間中原來的數據將變成線性可分的，從而使用之前我們推導的線性分類演算法就可以進行處理了。

我們舉個簡單的計算例子，現在假設已知的映射函數為：

這個是一個從2維映射到5維的例子。如果沒有使用核函數，根據上一小節的介紹，我們需要先結算映射後的結果，然後再進行內積運算。那麼對於兩個向量a1=(x1,x2)和a2=(y1,y2)有：

另外，如果我們不進行映射計算，直接運算下面的公式：

你會發現，這兩個公式的計算結果是相同的。區別在於什麼呢？

一個是根據映射函數，映射到高維空間中，然後再根據內積的公式進行計算，計算量大；
另一個則直接在原來的低維空間中進行計算，而不需要顯式地寫出映射後的結果，計算量小。

其實，在這個例子中，核函數就是：

我們通過 $k(x_1,x_2)$ 的低維運算得到了先映射再內積的高維運算的結果，這就是核函數的神奇之處，它有效減少了我們的計算量。在這個例子中，我們對一個2維空間做映射，選擇的新的空間是原始空間的所以一階和二階的組合，得到了5維的新空間；如果原始空間是3維的，那麼我們會得到19維的新空間，這個數目是呈爆炸性增長的。如果我們使用 $?(·)$ 做映射計算，難度非常大，而且如果遇到無窮維的情況，就根本無從計算了。所以使用核函數進行計算是非常有必要的。

3、核技巧的實現

通過核技巧的轉變，我們的分類函數變為：

我們的對偶問題變成了：

這樣，我們就避開了高緯度空間中的計算。當然，我們剛剛的例子是非常簡單的，我們可以手動構造出來對應映射的核函數出來，如果對於任意一個映射，要構造出對應的核函數就很困難了。因此，通常，人們會從一些常用的核函數中進行選擇，根據問題和數據的不同，選擇不同的參數，得到不同的核函數。接下來，要介紹的就是一個非常流行的核函數，那就是徑向基核函數。

徑向基核函數是SVM中常用的一個核函數。徑向基核函數採用向量作為自變數的函數，能夠基於向量舉例運算輸出一個標量。徑向基核函數的高斯版本的公式如下：

其中，σ是用戶自定義的用於確定到達率(reach)或者說函數值跌落到0的速度參數。上述高斯核函數將數據從原始空間映射到無窮維空間。關於無窮維空間，我們不必太擔心。高斯核函數只是一個常用的核函數，使用者並不需要確切地理解數據到底是如何表現的，而且使用高斯核函數還會得到一個理想的結果。如果σ選得很大的話，高次特徵上的權重實際上衰減得非常快，所以實際上（數值上近似一下）相當於一個低維的子空間；反過來，如果σ選得很小，則可以將任意的數據映射為線性可分——當然，這並不一定是好事，因為隨之而來的可能是非常嚴重的過擬合問題。不過，總的來說，通過調控參數σ，高斯核實際上具有相當高的靈活性，也是使用最廣泛的核函數之一。

四、編程實現非線性SVM

接下來，我們將使用testSetRBF.txt和testSetRBF2.txt，前者作為訓練集，後者作為測試集。數據集下載地址：https://github.com/Jack-Cherish/Machine-Learning/tree/master/SVM

1、可視化數據集

我們先編寫程序簡單看下數據集：

# -*-coding:utf-8 -*-import matplotlib.pyplot as pltimport numpy as npdef showDataSet(dataMat, labelMat): """ 數據可視化 Parameters: dataMat - 數據矩陣 labelMat - 數據標籤 Returns: 無 """ 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]) #正樣本散點圖 plt.scatter(np.transpose(data_minus_np)[0], np.transpose(data_minus_np)[1]) #負樣本散點圖 plt.show()if __name__ == __main__: dataArr,labelArr = loadDataSet(testSetRBF.txt) #載入訓練集 showDataSet(dataArr, labelArr)

程序運行結果：

可見，數據明顯是線性不可分的。下面我們根據公式，編寫核函數，並增加初始化參數kTup用於存儲核函數有關的信息，同時我們只要將之前的內積運算變成核函數的運算即可。最後編寫testRbf()函數，用於測試。創建svmMLiA.py文件，編寫代碼如下：

# -*-coding:utf-8 -*-import matplotlib.pyplot as pltimport numpy as npimport random"""Author: Jack CuiBlog: http://blog.csdn.net/c406495762Zhihu: https://www.zhihu.com/people/Jack--Cui/Modify: 2017-10-03"""class optStruct: """ 數據結構，維護所有需要操作的值 Parameters： dataMatIn - 數據矩陣 classLabels - 數據標籤 C - 鬆弛變數 toler - 容錯率 kTup - 包含核函數信息的元組,第一個參數存放核函數類別，第二個參數存放必要的核函數需要用到的參數 """ def __init__(self, dataMatIn, classLabels, C, toler, kTup): self.X = dataMatIn #數據矩陣 self.labelMat = classLabels #數據標籤 self.C = C #鬆弛變數 self.tol = toler #容錯率 self.m = np.shape(dataMatIn)[0] #數據矩陣行數 self.alphas = np.mat(np.zeros((self.m,1))) #根據矩陣行數初始化alpha參數為0 self.b = 0 #初始化b參數為0 self.eCache = np.mat(np.zeros((self.m,2))) #根據矩陣行數初始化虎誤差緩存，第一列為是否有效的標誌位，第二列為實際的誤差E的值。 self.K = np.mat(np.zeros((self.m,self.m))) #初始化核K for i in range(self.m): #計算所有數據的核K self.K[:,i] = kernelTrans(self.X, self.X[i,:], kTup)def kernelTrans(X, A, kTup): """ 通過核函數將數據轉換更高維的空間 Parameters： X - 數據矩陣 A - 單個數據的向量 kTup - 包含核函數信息的元組 Returns: K - 計算的核K """ m,n = np.shape(X) K = np.mat(np.zeros((m,1))) if kTup[0] == lin: K = X * A.T #線性核函數,只進行內積。 elif kTup[0] == rbf: #高斯核函數,根據高斯核函數公式進行計算 for j in range(m): deltaRow = X[j,:] - A K[j] = deltaRow*deltaRow.T K = np.exp(K/(-1*kTup[1]**2)) #計算高斯核K else: raise NameError(核函數無法識別) return K #返回計算的核Kdef loadDataSet(fileName): """ 讀取數據 Parameters: fileName - 文件名 Returns: dataMat - 數據矩陣 labelMat - 數據標籤 """ dataMat = []; labelMat = [] fr = open(fileName) for line in fr.readlines(): #逐行讀取，濾除空格等 lineArr = line.strip().split( ) dataMat.append([float(lineArr[0]), float(lineArr[1])]) #添加數據 labelMat.append(float(lineArr[2])) #添加標籤 return dataMat,labelMatdef calcEk(oS, k): """ 計算誤差 Parameters： oS - 數據結構 k - 標號為k的數據 Returns: Ek - 標號為k的數據誤差 """ fXk = float(np.multiply(oS.alphas,oS.labelMat).T*oS.K[:,k] + oS.b) Ek = fXk - float(oS.labelMat[k]) return Ekdef selectJrand(i, m): """ 函數說明:隨機選擇alpha_j的索引值 Parameters: i - alpha_i的索引值 m - alpha參數個數 Returns: j - alpha_j的索引值 """ j = i #選擇一個不等於i的j while (j == i): j = int(random.uniform(0, m)) return jdef selectJ(i, oS, Ei): """ 內循環啟發方式2 Parameters： i - 標號為i的數據的索引值 oS - 數據結構 Ei - 標號為i的數據誤差 Returns: j, maxK - 標號為j或maxK的數據的索引值 Ej - 標號為j的數據誤差 """ maxK = -1; maxDeltaE = 0; Ej = 0 #初始化 oS.eCache[i] = [1,Ei] #根據Ei更新誤差緩存 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,Ejdef updateEk(oS, k): """ 計算Ek,並更新誤差緩存 Parameters： oS - 數據結構 k - 標號為k的數據的索引值 Returns: 無 """ Ek = calcEk(oS, k) #計算Ek oS.eCache[k] = [1,Ek] #更新誤差緩存def clipAlpha(aj,H,L): """ 修剪alpha_j Parameters: aj - alpha_j的值 H - alpha上限 L - alpha下限 Returns: aj - 修剪後的alpah_j的值 """ if aj > H: aj = H if L > aj: aj = L return ajdef innerL(i, oS): """ 優化的SMO演算法 Parameters： i - 標號為i的數據的索引值 oS - 數據結構 Returns: 1 - 有任意一對alpha值發生變化 0 - 沒有任意一對alpha值發生變化或變化太小 """ #步驟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.K[i,j] - oS.K[i,i] - oS.K[j,j] 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.K[i,i] - oS.labelMat[j]*(oS.alphas[j]-alphaJold)*oS.K[i,j] b2 = oS.b - Ej- oS.labelMat[i]*(oS.alphas[i]-alphaIold)*oS.K[i,j]- oS.labelMat[j]*(oS.alphas[j]-alphaJold)*oS.K[j,j] #步驟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 0def smoP(dataMatIn, classLabels, C, toler, maxIter, kTup = (lin,0)): """ 完整的線性SMO演算法 Parameters： dataMatIn - 數據矩陣 classLabels - 數據標籤 C - 鬆弛變數 toler - 容錯率 maxIter - 最大迭代次數 kTup - 包含核函數信息的元組 Returns: oS.b - SMO演算法計算的b oS.alphas - SMO演算法計算的alphas """ oS = optStruct(np.mat(dataMatIn), np.mat(classLabels).transpose(), C, toler, kTup) #初始化數據結構 iter = 0 #初始化當前迭代次數 entireSet = True; alphaPairsChanged = 0 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 #返回SMO演算法計算的b和alphasdef testRbf(k1 = 1.3): """ 測試函數 Parameters: k1 - 使用高斯核函數的時候表示到達率 Returns: 無 """ dataArr,labelArr = loadDataSet(testSetRBF.txt) #載入訓練集 b,alphas = smoP(dataArr, labelArr, 200, 0.0001, 100, (rbf, k1)) #根據訓練集計算b和alphas datMat = np.mat(dataArr); labelMat = np.mat(labelArr).transpose() svInd = np.nonzero(alphas.A > 0)[0] #獲得支持向量 sVs = datMat[svInd] labelSV = labelMat[svInd]; print("支持向量個數:%d" % np.shape(sVs)[0]) m,n = np.shape(datMat) errorCount = 0 for i in range(m): kernelEval = kernelTrans(sVs,datMat[i,:],(rbf, k1)) #計算各個點的核 predict = kernelEval.T * np.multiply(labelSV,alphas[svInd]) + b #根據支持向量的點，計算超平面，返回預測結果 if np.sign(predict) != np.sign(labelArr[i]): errorCount += 1 #返回數組中各元素的正負符號，用1和-1表示，並統計錯誤個數 print("訓練集錯誤率: %.2f%%" % ((float(errorCount)/m)*100)) #列印錯誤率 dataArr,labelArr = loadDataSet(testSetRBF2.txt) #載入測試集 errorCount = 0 datMat = np.mat(dataArr); labelMat = np.mat(labelArr).transpose() m,n = np.shape(datMat) for i in range(m): kernelEval = kernelTrans(sVs,datMat[i,:],(rbf, k1)) #計算各個點的核 predict=kernelEval.T * np.multiply(labelSV,alphas[svInd]) + b #根據支持向量的點，計算超平面，返回預測結果 if np.sign(predict) != np.sign(labelArr[i]): errorCount += 1 #返回數組中各元素的正負符號，用1和-1表示，並統計錯誤個數 print("測試集錯誤率: %.2f%%" % ((float(errorCount)/m)*100)) #列印錯誤率def showDataSet(dataMat, labelMat): """ 數據可視化 Parameters: dataMat - 數據矩陣 labelMat - 數據標籤 Returns: 無 """ 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]) #正樣本散點圖 plt.scatter(np.transpose(data_minus_np)[0], np.transpose(data_minus_np)[1]) #負樣本散點圖 plt.show()if __name__ == __main__: testRbf()

運行結果如下圖所示：

可以看到，訓練集錯誤率為1%，測試集錯誤率都是4%，訓練耗時1.7s 。可以嘗試更換不同的K1參數以觀察測試錯誤率、訓練錯誤率、支持向量個數隨k1的變化情況。你會發現K1過大，會出現過擬合的情況，即訓練集錯誤率低，但是測試集錯誤率高。

五、Sklearn構建SVM分類器

在第一篇文章中，我們使用了kNN進行手寫數字識別。它的缺點是存儲空間大，因為要保留所有的訓練樣本，如果你的老闆讓你節約這個內存空間，並達到相同的識別效果，甚至更好。那這個時候，我們就要可以使用SVM了，因為它只需要保留支持向量即可，而且能獲得可比的效果。

使用的數據集還是kNN用到的數據集（testDigits和trainingDigits）：https://github.com/Jack-Cherish/Machine-Learning/tree/master/kNN/3.%E6%95%B0%E5%AD%97%E8%AF%86%E5%88%AB

如果對這個數據集不了解的，可以先看看我的第一篇文章：

CSDN：http://blog.csdn.net/c406495762/article/details/75172850

知乎：https://zhuanlan.zhihu.com/p/28656126

首先，我們先使用自己用python寫的代碼進行訓練。創建文件svm-digits.py文件，編寫代碼如下：

# -*-coding:utf-8 -*-import matplotlib.pyplot as pltimport numpy as npimport random"""Author: Jack CuiBlog: http://blog.csdn.net/c406495762Zhihu: https://www.zhihu.com/people/Jack--Cui/Modify: 2017-10-03"""class optStruct: """ 數據結構，維護所有需要操作的值 Parameters： dataMatIn - 數據矩陣 classLabels - 數據標籤 C - 鬆弛變數 toler - 容錯率 kTup - 包含核函數信息的元組,第一個參數存放核函數類別，第二個參數存放必要的核函數需要用到的參數 """ def __init__(self, dataMatIn, classLabels, C, toler, kTup): self.X = dataMatIn #數據矩陣 self.labelMat = classLabels #數據標籤 self.C = C #鬆弛變數 self.tol = toler #容錯率 self.m = np.shape(dataMatIn)[0] #數據矩陣行數 self.alphas = np.mat(np.zeros((self.m,1))) #根據矩陣行數初始化alpha參數為0 self.b = 0 #初始化b參數為0 self.eCache = np.mat(np.zeros((self.m,2))) #根據矩陣行數初始化虎誤差緩存，第一列為是否有效的標誌位，第二列為實際的誤差E的值。 self.K = np.mat(np.zeros((self.m,self.m))) #初始化核K for i in range(self.m): #計算所有數據的核K self.K[:,i] = kernelTrans(self.X, self.X[i,:], kTup)def kernelTrans(X, A, kTup): """ 通過核函數將數據轉換更高維的空間 Parameters： X - 數據矩陣 A - 單個數據的向量 kTup - 包含核函數信息的元組 Returns: K - 計算的核K """ m,n = np.shape(X) K = np.mat(np.zeros((m,1))) if kTup[0] == lin: K = X * A.T #線性核函數,只進行內積。 elif kTup[0] == rbf: #高斯核函數,根據高斯核函數公式進行計算 for j in range(m): deltaRow = X[j,:] - A K[j] = deltaRow*deltaRow.T K = np.exp(K/(-1*kTup[1]**2)) #計算高斯核K else: raise NameError(核函數無法識別) return K #返回計算的核Kdef loadDataSet(fileName): """ 讀取數據 Parameters: fileName - 文件名 Returns: dataMat - 數據矩陣 labelMat - 數據標籤 """ dataMat = []; labelMat = [] fr = open(fileName) for line in fr.readlines(): #逐行讀取，濾除空格等 lineArr = line.strip().split( ) dataMat.append([float(lineArr[0]), float(lineArr[1])]) #添加數據 labelMat.append(float(lineArr[2])) #添加標籤 return dataMat,labelMatdef calcEk(oS, k): """ 計算誤差 Parameters： oS - 數據結構 k - 標號為k的數據 Returns: Ek - 標號為k的數據誤差 """ fXk = float(np.multiply(oS.alphas,oS.labelMat).T*oS.K[:,k] + oS.b) Ek = fXk - float(oS.labelMat[k]) return Ekdef selectJrand(i, m): """ 函數說明:隨機選擇alpha_j的索引值 Parameters: i - alpha_i的索引值 m - alpha參數個數 Returns: j - alpha_j的索引值 """ j = i #選擇一個不等於i的j while (j == i): j = int(random.uniform(0, m)) return jdef selectJ(i, oS, Ei): """ 內循環啟發方式2 Parameters： i - 標號為i的數據的索引值 oS - 數據結構 Ei - 標號為i的數據誤差 Returns: j, maxK - 標號為j或maxK的數據的索引值 Ej - 標號為j的數據誤差 """ maxK = -1; maxDeltaE = 0; Ej = 0 #初始化 oS.eCache[i] = [1,Ei] #根據Ei更新誤差緩存 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,Ejdef updateEk(oS, k): """ 計算Ek,並更新誤差緩存 Parameters： oS - 數據結構 k - 標號為k的數據的索引值 Returns: 無 """ Ek = calcEk(oS, k) #計算Ek oS.eCache[k] = [1,Ek] #更新誤差緩存def clipAlpha(aj,H,L): """ 修剪alpha_j Parameters: aj - alpha_j的值 H - alpha上限 L - alpha下限 Returns: aj - 修剪後的alpah_j的值 """ if aj > H: aj = H if L > aj: aj = L return ajdef innerL(i, oS): """ 優化的SMO演算法 Parameters： i - 標號為i的數據的索引值 oS - 數據結構 Returns: 1 - 有任意一對alpha值發生變化 0 - 沒有任意一對alpha值發生變化或變化太小 """ #步驟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.K[i,j] - oS.K[i,i] - oS.K[j,j] 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.K[i,i] - oS.labelMat[j]*(oS.alphas[j]-alphaJold)*oS.K[i,j] b2 = oS.b - Ej- oS.labelMat[i]*(oS.alphas[i]-alphaIold)*oS.K[i,j]- oS.labelMat[j]*(oS.alphas[j]-alphaJold)*oS.K[j,j] #步驟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 0def smoP(dataMatIn, classLabels, C, toler, maxIter, kTup = (lin,0)): """ 完整的線性SMO演算法 Parameters： dataMatIn - 數據矩陣 classLabels - 數據標籤 C - 鬆弛變數 toler - 容錯率 maxIter - 最大迭代次數 kTup - 包含核函數信息的元組 Returns: oS.b - SMO演算法計算的b oS.alphas - SMO演算法計算的alphas """ oS = optStruct(np.mat(dataMatIn), np.mat(classLabels).transpose(), C, toler, kTup) #初始化數據結構 iter = 0 #初始化當前迭代次數 entireSet = True; alphaPairsChanged = 0 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 #返回SMO演算法計算的b和alphasdef img2vector(filename): """ 將32x32的二進位圖像轉換為1x1024向量。 Parameters: filename - 文件名 Returns: returnVect - 返回的二進位圖像的1x1024向量 """ returnVect = np.zeros((1,1024)) fr = open(filename) for i in range(32): lineStr = fr.readline() for j in range(32): returnVect[0,32*i+j] = int(lineStr[j]) return returnVectdef loadImages(dirName): """ 載入圖片 Parameters: dirName - 文件夾的名字 Returns: trainingMat - 數據矩陣 hwLabels - 數據標籤 """ from os import listdir hwLabels = [] trainingFileList = listdir(dirName) m = len(trainingFileList) trainingMat = np.zeros((m,1024)) for i in range(m): fileNameStr = trainingFileList[i] fileStr = fileNameStr.split(.)[0] classNumStr = int(fileStr.split(_)[0]) if classNumStr == 9: hwLabels.append(-1) else: hwLabels.append(1) trainingMat[i,:] = img2vector(%s/%s % (dirName, fileNameStr)) return trainingMat, hwLabels def testDigits(kTup=(rbf, 10)): """ 測試函數 Parameters: kTup - 包含核函數信息的元組 Returns: 無 """ dataArr,labelArr = loadImages(trainingDigits) b,alphas = smoP(dataArr, labelArr, 200, 0.0001, 10, kTup) datMat = np.mat(dataArr); labelMat = np.mat(labelArr).transpose() svInd = np.nonzero(alphas.A>0)[0] sVs=datMat[svInd] labelSV = labelMat[svInd]; print("支持向量個數:%d" % np.shape(sVs)[0]) m,n = np.shape(datMat) errorCount = 0 for i in range(m): kernelEval = kernelTrans(sVs,datMat[i,:],kTup) predict=kernelEval.T * np.multiply(labelSV,alphas[svInd]) + b if np.sign(predict) != np.sign(labelArr[i]): errorCount += 1 print("訓練集錯誤率: %.2f%%" % (float(errorCount)/m)) dataArr,labelArr = loadImages(testDigits) errorCount = 0 datMat = np.mat(dataArr); labelMat = np.mat(labelArr).transpose() m,n = np.shape(datMat) for i in range(m): kernelEval = kernelTrans(sVs,datMat[i,:],kTup) predict=kernelEval.T * np.multiply(labelSV,alphas[svInd]) + b if np.sign(predict) != np.sign(labelArr[i]): errorCount += 1 print("測試集錯誤率: %.2f%%" % (float(errorCount)/m))if __name__ == __main__: testDigits()

SMO演算法實現部分跟上文是一樣的，我們新創建了img2vector()、loadImages()、testDigits()函數，它們分別用於二進位圖形轉換、圖片載入、訓練SVM分類器。我們自己的SVM分類器是個二類分類器，所以在設置標籤的時候，將9作為負類，其餘的0-8作為正類，進行訓練。這是一種ovr思想，即one vs rest，就是對一個類別和剩餘所有的類別進行分類。如果想實現10個數字的識別，一個簡單的方法是，訓練出10個分類器。這裡簡單起見，只訓練了一個用於分類9和其餘所有數字的分類器，運行結果如下：

可以看到，雖然我們進行了所謂的"優化"，但是訓練仍然很耗時，迭代10次，花費了307.4s。因為我們沒有多進程、沒有設置自動的終止條件，總之一句話，需要優化的地方太多了。儘管如此，我們訓練後得到的結果還是不錯的，可以看到訓練集錯誤率為0，測試集錯誤率也僅為0.01%。

接下來，就是講解本文的重頭戲：sklearn.svm.SVC。

1、sklearn.svm.SVC

官方英文文檔手冊：http://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html

sklearn.svm模塊提供了很多模型供我們使用，本文使用的是svm.SVC，它是基於libsvm實現的。

讓我們先看下SVC這個函數，一共有14個參數：

參數說明如下：

C：懲罰項，float類型，可選參數，默認為1.0，C越大，即對分錯樣本的懲罰程度越大，因此在訓練樣本中準確率越高，但是泛化能力降低，也就是對測試數據的分類準確率降低。相反，減小C的話，容許訓練樣本中有一些誤分類錯誤樣本，泛化能力強。對於訓練樣本帶有雜訊的情況，一般採用後者，把訓練樣本集中錯誤分類的樣本作為雜訊。
kernel：核函數類型，str類型，默認為rbf。可選參數為：

linear：線性核函數
poly：多項式核函數
rbf：徑像核函數/高斯核
sigmod：sigmod核函數
precomputed：核矩陣
precomputed表示自己提前計算好核函數矩陣，這時候演算法內部就不再用核函數去計算核矩陣，而是直接用你給的核矩陣，核矩陣需要為n*n的。

degree：多項式核函數的階數，int類型，可選參數，默認為3。這個參數只對多項式核函數有用，是指多項式核函數的階數n，如果給的核函數參數是其他核函數，則會自動忽略該參數。
gamma：核函數係數，float類型，可選參數，默認為auto。只對rbf ,poly ,sigmod有效。如果gamma為auto，代表其值為樣本特徵數的倒數，即1/n_features。
coef0：核函數中的獨立項，float類型，可選參數，默認為0.0。只有對poly 和,sigmod核函數有用，是指其中的參數c。
probability：是否啟用概率估計，bool類型，可選參數，默認為False，這必須在調用fit()之前啟用，並且會fit()方法速度變慢。
shrinking：是否採用啟發式收縮方式，bool類型，可選參數，默認為True。
tol：svm停止訓練的誤差精度，float類型，可選參數，默認為1e^-3。
cache_size：內存大小，float類型，可選參數，默認為200。指定訓練所需要的內存，以MB為單位，默認為200MB。
class_weight：類別權重，dict類型或str類型，可選參數，默認為None。給每個類別分別設置不同的懲罰參數C，如果沒有給，則會給所有類別都給C=1，即前面參數指出的參數C。如果給定參數balance，則使用y的值自動調整與輸入數據中的類頻率成反比的權重。
verbose：是否啟用詳細輸出，bool類型，默認為False，此設置利用libsvm中的每個進程運行時設置，如果啟用，可能無法在多線程上下文中正常工作。一般情況都設為False，不用管它。
max_iter：最大迭代次數，int類型，默認為-1，表示不限制。
decision_function_shape：決策函數類型，可選參數ovo和ovr，默認為ovr。ovo表示one vs one，ovr表示one vs rest。
random_state：數據洗牌時的種子值，int類型，可選參數，默認為None。偽隨機數發生器的種子,在混洗數據時用於概率估計。

其實，只要自己寫了SMO演算法，每個參數的意思，大概都是能明白的。

2、編寫代碼

SVC很是強大，我們不用理解演算法實現的具體細節，不用理解演算法的優化方法。同時，它也滿足我們的多分類需求。創建文件svm-svc.py文件，編寫代碼如下：

# -*- coding: UTF-8 -*-import numpy as npimport operatorfrom os import listdirfrom sklearn.svm import SVC"""Author: Jack CuiBlog: http://blog.csdn.net/c406495762Zhihu: https://www.zhihu.com/people/Jack--Cui/Modify: 2017-10-04"""def img2vector(filename): """ 將32x32的二進位圖像轉換為1x1024向量。 Parameters: filename - 文件名 Returns: returnVect - 返回的二進位圖像的1x1024向量 """ #創建1x1024零向量 returnVect = np.zeros((1, 1024)) #打開文件 fr = open(filename) #按行讀取 for i in range(32): #讀一行數據 lineStr = fr.readline() #每一行的前32個元素依次添加到returnVect中 for j in range(32): returnVect[0, 32*i+j] = int(lineStr[j]) #返迴轉換後的1x1024向量 return returnVectdef handwritingClassTest(): """ 手寫數字分類測試 Parameters: 無 Returns: 無 """ #測試集的Labels hwLabels = [] #返回trainingDigits目錄下的文件名 trainingFileList = listdir(trainingDigits) #返迴文件夾下文件的個數 m = len(trainingFileList) #初始化訓練的Mat矩陣,測試集 trainingMat = np.zeros((m, 1024)) #從文件名中解析出訓練集的類別 for i in range(m): #獲得文件的名字 fileNameStr = trainingFileList[i] #獲得分類的數字 classNumber = int(fileNameStr.split(_)[0]) #將獲得的類別添加到hwLabels中 hwLabels.append(classNumber) #將每一個文件的1x1024數據存儲到trainingMat矩陣中 trainingMat[i,:] = img2vector(trainingDigits/%s % (fileNameStr)) clf = SVC(C=200,kernel=rbf) clf.fit(trainingMat,hwLabels) #返回testDigits目錄下的文件列表 testFileList = listdir(testDigits) #錯誤檢測計數 errorCount = 0.0 #測試數據的數量 mTest = len(testFileList) #從文件中解析出測試集的類別並進行分類測試 for i in range(mTest): #獲得文件的名字 fileNameStr = testFileList[i] #獲得分類的數字 classNumber = int(fileNameStr.split(_)[0]) #獲得測試集的1x1024向量,用於訓練 vectorUnderTest = img2vector(testDigits/%s % (fileNameStr)) #獲得預測結果 # classifierResult = classify0(vectorUnderTest, trainingMat, hwLabels, 3) classifierResult = clf.predict(vectorUnderTest) print("分類返回結果為%d 真實結果為%d" % (classifierResult, classNumber)) if(classifierResult != classNumber): errorCount += 1.0 print("總共錯了%d個數據錯誤率為%f%%" % (errorCount, errorCount/mTest * 100))if __name__ == __main__: handwritingClassTest()

代碼和kNN的實現是差不多的，就是換了個分類器而已。運行結果如下：

可以看到，訓練和測試的時間總共加起來才7.3s。而且，測試集的錯誤率僅為1.37%。試著改變SVC的參數，慢慢體會一下吧~

六、總結

1、SVM的優缺點

優點

可用於線性/非線性分類，也可以用於回歸，泛化錯誤率低，也就是說具有良好的學習能力，且學到的結果具有很好的推廣性。
可以解決小樣本情況下的機器學習問題，可以解決高維問題，可以避免神經網路結構選擇和局部極小點問題。
SVM是最好的現成的分類器，現成是指不加修改可直接使用。並且能夠得到較低的錯誤率，SVM可以對訓練集之外的數據點做很好的分類決策。

缺點

對參數調節和和函數的選擇敏感。

2、其他

至此，關於SVM的文章已經寫完，還有一些理論和細節，可能會在今後的文章提及。
下篇文章將講解AdaBoost，歡迎各位的捧場！
如有問題，請留言。如有錯誤，還望指正，謝謝！

PS：如果覺得本篇本章對您有所幫助，歡迎關注、評論、贊！

參考資料：

[1] SVM多維空間線性可分的理解：https://www.zhihu.com/question/27210162/answer/44815488
[2] 《機器學習實戰》第六章