支持向量機整理

介紹整理了SVM的基本數學推導，SMO算法的基本過程，LibSVM的用法，SMO算法的python實現四大部分(pdf版及測試數據相關電子書百度云 密碼：itih)

基本型

支持向量機(Support vector machine)通常用來解決二分類問題，首先考慮一種最簡單的情況，即數據線性可分的情況。

劃分超平面

考慮下面兩點的劃分，對于平面上的點集，存在一條直線將其完全劃分，但是在實際情況中，樣本屬性通常是多維的，所以稱劃分線為劃分超平面。

通常將劃分超平面表示為：

\[\vec w·\vec x+b=0

\]

注：有的地方將\(\vec w\)表示為\(\vec w^T\) 是考慮到w和x相乘需要列數和行數相等，但是參照線性代數里可省略轉置

Margin及支持向量

顯然存在最優的劃分使兩類數據集距離最遠，此時的泛化性能最好，稱最大距離為margin，最優的劃分為最優超平面，兩邊數據集的邊界為支持向量。

首先定義支持向量為：

\[\vec w\vec x+b=s \quad or \quad \vec w\vec x+b=-s

\]

同除以s可得:

\[\vec w\vec x+b=1 \quad or \quad \vec w\vec x+b=-1

\]

則對于右上方的點集y定義為1，左下點集y定義為-1

顯然右上方的點集為：\(\vec w\vec x+b \ge1 \quad y=1\)，左下方的點集可表示為：\(\vec w\vec x+b1\le-1 \quad y=-1\)

可合并為

\[y(\vec w\vec x+b) \ge1

\]

Margin的表示

計算margin如下圖,長度用k表示，\(H_1\)，\(H_0\)為支持向量

對于\(H_1\)上的點\(z_0\)滿足

\[\vec w\vec z_0+b=1

\]

顯然有

\[\vec z_0=\vec x_0 +\vec k

\]

帶入化簡可得

\[\vec w\vec x_0+b+\vec w \vec k=1

\]

\[\vec w \left (k\frac {\vec w}{||\vec w||} \right )=2

\]

\[k=\frac {2}{||\vec w||}

\]

最大的k值即為所求

有約束的最優化問題

通過上面的計算，可將問題表示為約束條件下的最優化問題

\[max\quad \frac {2}{||\vec w||}

\\

s.t.\quad y_i(\vec w\vec x_i+b) \ge1 \quad i=1...m

\]

目標函數經常表示為 \(min\ \frac{1}{2}||\vec w||^2\)

對偶問題

通常引入拉格朗日函數簡化上述問題，稱此類問題為對偶問題(The wolfe dual problem)

拉格朗日乘數法

拉格朗日乘數法用來解決等式約束下的最優化問題

將目標函數表示為\(f(\vec w)= \frac {2}{||\vec w||}\) ,約束函數表示為\(g(\vec w,b)=y_i(\vec w\vec x_i+b) \ge1\) ,定義如下拉格朗日函數\(L(\vec w,b,\alpha)\)，其中\(\alpha_i\)為拉格朗日算子

\[L(\vec w,b,\alpha)=f(\vec w)-\sum_{i=1}^m \alpha_ig_i(\vec w,b)

\\

L(\vec w,b,\alpha)=\frac{1}{2}||\vec w||^2-\sum_{i=1}^m \alpha_ig_i[y_i(\vec w\vec x_i+b)-1]

\]

求解要求\(\nabla L=0\)，可以解得

\[\vec w=\sum_{i=1}^m \alpha_i y_i \vec x_i

\\

\sum_{i=1}^m \alpha_i y_i=0

\]

將\(\vec w\)帶入\(L(\vec w,b,\alpha)\)可得

\[f(\vec w,b)=\sum_{i=1}^m\alpha_i-\frac{1}{2} \sum_{i=1}^m\sum_{j=1}^m \alpha_i\alpha_jy_iy_j \vec x_i \vec x_j

\]

所以問題轉化為

\[max \quad \sum_{i=1}^m\alpha_i-\frac{1}{2} \sum_{i=1}^m\sum_{j=1}^m \alpha_i\alpha_jy_iy_j \vec x_i \vec x_j

\\

s.t. \quad \alpha_i\ge0 \quad i=1...m

\\

\quad \sum_{i=1}^m \alpha_i y_i=0

\]

KKT條件

注意到上面的拉格朗日乘數法用來解決等式優化問題，在對于不等式約束的優化問題時還需附加如下的KKT條件

\[\begin{cases}

\ \alpha_i \ge 0

\\ \ y_if(x_i)-1 \ge 0

\\ \ \alpha_i(y_if(\vec x_i)-1) \ge 0

\end{cases}

\]

軟間隔

線性不可分時

實際遇到的問題數據總是有噪音的，也就是說可能存在一兩個可忽略的特殊點使margin大大減小，也可能有一兩個特殊點導致集合線性不可分(如下圖)，所以我們需要允許模型犯一定的錯誤來過濾掉噪音，即允許間隔的調整稱為軟間隔

松弛變量

引入松弛變量(slack variable)\(\xi_i\) ，則約束函數可寫為

\[y_i(\vec w\vec x_i+b) \ge1-\xi_i

\]

控制出錯

同時引入變量C表示對\(\xi_i\)的控制程度，即表示允許模型忽略噪音的程度，顯然當C->\(\infty\)退化成基本型的硬間隔，C->0時成為無約束問題

引入C后基本型可表示為

\[max\quad \frac {1}{2}{||\vec w||}^2+C\sum_{i=1}^m \xi_i

\\

s.t.\quad y_i(\vec w\vec x_i+b) \ge1-\xi_i \quad

\\

\xi_i \ge 0 \quad i=1...m

\]

同樣由拉格朗日乘數法可得

\[max \quad \sum_{i=1}^m\alpha_i-\frac{1}{2} \sum_{i=1}^m\sum_{j=1}^m \alpha_i\alpha_jy_iy_j\vec x_i \vec x_j

\\

s.t. \quad 0\le \alpha_i\le C \quad i=1...m

\\

\quad \sum_{i=1}^m \alpha_i y_i=0

\]

核方法

升維

考慮更通常的情況，當點集線性不可分時，更有趣的方法是升維，如下圖在二維平面內不能找到一個劃分超平面

然而當在更高維的情況比如三維，我們就可以找到劃分超平面來解決問題

這種方法通常成為核方法(kernel)

構造核函數

比如我們可以簡單的\((\vec x,\vec y)\) ->\((\vec x,\vec x\vec y,\vec y)\) 將點集升維，但是當樣本空間很大時代價太高，考慮上面的目標函數

我們可以利用目標函數中的點積來構建核函數避免計算量的增加

常用核函數

線性核：\(k(\vec x_i,\vec y_i)=x_i·y_i\)

多項式核：\(k(\vec x,\vec y)=(\vec x_i·\vec y_i)^d\) ，\(d\ge 1\)為多項式的次數

高斯核(RBF,常用)：\(k(\vec x,\vec y)=exp(-\frac {||x_i-x_j||^2}{2 \sigma ^2})\)，\(\sigma\)為高斯核的帶寬

SMO算法

SMO概念

對于上述問題的求解，SMO算法每次迭代優化兩個\(\alpha\) (若只選擇1個，由約束條件可以直接解出\(\alpha\)，就不是最優化問題了)，把原始求解N個參數二次規劃問題分解成很多個子二次規劃問題分別求解，每個子問題只需要求解2個參數，方法類似于坐標上升，節省時間成本和降低了內存需求。每次啟發式選擇兩個變量進行優化，不斷循環，直到達到函數最優值。

SMO原理分析(參考博客)

視為一個二元函數

SMO算法選擇同時優化兩個參數，固定其他N-2個參數，假設選擇的變量為α1,α2,固定其他參數α3,α4,...,αN,由于參數α3,α4,...,αN的固定，可以簡化目標函數為只關于α1,α2的二元函數，Const表示常數項(不包含變量α1,α2的項)。

\[minW(\alpha_i,\alpha_j)=\frac {1}{2}K_{11}\alpha_1^2+\frac {1}{2}K_{22}\alpha_2^2+y_1y_2K_{12}\alpha_1 \alpha_2-(\alpha_1+\alpha_2)+y_1v_1\alpha_1+y_2v_2\alpha_2+Const

\\

其中，v_i=\sum _{j=3}^m \alpha_jy_jK(x_i,x_j) \quad i=1,2

\]

視為一元函數求極值點

由等式約束：\(\alpha_i y1+\alpha_2 y2=-\sum _{i=3}^{m} \alpha_i y_i=\xi\)，可見\(\xi\)為定值，將\(\alpha_1 y1+\alpha_2 y2=\xi\)兩邊同時乘以\(y_1\),且\(y_1^2=1\)，得

\[\alpha_1=(\xi-y_2\alpha_2)y_1

\]

代回上述二元函數可得關于\(\alpha_2\)的一元函數，求導令其等于0可得

\[\frac {\partial W(\alpha_2)}{\partial \alpha_2}=(K_{11}+K_{22}-2K_{12})\alpha_2-K_{11}\xi y_2+K_{12}\xi y_2+y_1y_2-1-v_1y_1+v_2y_2=0

\]

假設從上式中求得了\(\alpha_2\)的解，代回可得\(\alpha_1\)分別記為\(\alpha_1^{new} ,\alpha_2^{new}\)優化前的為\(\alpha_1^{old} ,\alpha_2^{old}\)

同樣由約束條件可得

\[\alpha_1^{old} y1+\alpha_2^{old} y2=\xi

\]

在對偶問題中解得的\(\vec w\)代入超平面方程\(f(x)=\vec w\vec x+b=\sum_{i=1}^{m}\alpha_iy_iK(x_i,x_j)+b\),同時定義\(E_i\)表示預測值與真實值之差

\[E_i=f(x_i)-y_i

\]

由\(v_i=\sum _{j=3}^m \alpha_jy_jK(x_i,x_j) \quad i=1,2\)可得

\[v_1=f(x_1)-\sum_{j=1}^{2}y_j\alpha_jK_{1j}-b

\\

v_2=f(x_2)-\sum_{j=1}^{2}y_j\alpha_jK_{2j}-b

\]

將上述式子帶入\(\frac {\partial W(\alpha_2)}{\partial \alpha_2}=0\)可得

\[\alpha_2^{new}=\alpha_2^{old}+\frac{y_2(E_1-E_2)}{\eta},其中\eta=K_{11}+K{22}-2K_{12}

\]

對上述解進行修剪

考慮到約束條件

\[0\le \alpha_i \le C

\\

\alpha_1y_1+\alpha_2y_2=\xi

\]

定義\(\alpha_2\)區間為[L,H]，則有

當\(y_1\not=y_2\)時，\(L=max(0,\alpha_2^{old}-\alpha_1^{old})\);\(H=min(C,C+\alpha_2^{old}-\alpha_1^{old})\);

當\(y_1=y_2\)時，\(L=max(0,\alpha_2^{old}+\alpha_1^{old}-C)\);\(H=min(C,\alpha_2^{old}+\alpha_1^{old})\);

求解\(\alpha_1^{new}\)

由\(\alpha_1^{old} y1+\alpha_2^{old}y2=\alpha_1^{new} y1+\alpha_2^{new}y2\) ,可得

\[\alpha_1^{new}=\alpha_1^{old} +y_1y_2(\alpha_2^{old}-\alpha_2^{new})

\]

考慮臨界情況

大部分情況下由\(\eta=K_{11}+K_{22}-2K_{12}>0\)，但當如下兩種情況時\(\alpha_2\)取臨界值L或H

η<0,當核函數K不滿足Mercer定理時，矩陣K非正定；

η=0,樣本x1與x2輸入特征相同；

也可以理解成對一元函數求二階導就是\(\eta=K_{11}+K_{22}-2K_{12}>0\)

當\(\eta\)<0時，目標函數為凸函數，沒有極小值，極值在定義域邊界處取得

當\(\eta\)=0時，目標函數為單調函數，同樣在邊界處取極值

啟發式選擇變量

上述分析是在從N個變量中已經選出兩個變量進行優化的方法，下面分析如何高效地選擇兩個變量進行優化，使得目標函數下降的最快。

\(\alpha_1\)

第一個變量的選擇稱為外循環

先遍歷非邊界樣本集(0

當遍歷完非邊界樣本集后，再次回到邊界樣本集中尋找，即在邊界樣本集與非邊界樣本集上來回切換，尋找違反KKT條件的\(\alpha_1\)作為第一個變量。直到遍歷整個樣本集后，沒有違反KKT條件αi，然后退出。

邊界上的樣本對應的\(\alpha_1\)=0或者\(\alpha_1\)=C，在優化過程中很難變化，然而非邊界樣本0

\(\alpha_2\)

第二個變量的選擇過程為內循環

第二個變量的選擇希望能使\(\alpha_2\)有較大的變化，通常為每個樣本的\(E_i\)保存在一個列表中，選擇最大的\(|E_1-E_2|\)來近似最大化步長，由于α2是依賴于\(|E_1-E_2|\),當\(E_1\)為正時，那么選擇最小的\(E_i\)作為\(E_2\),如果\(E_1\)為負，選擇最大\(E_i\)作為\(E_2\)

更新b

每完成對兩個變量的優化后，要對b的值進行更新，因為b的值關系到f(x)的計算，即關系到下次優化時\(E_I\)的計算。

LibSVM工具包求解

LibSVM是臺灣林智仁(Chih-Jen Lin)教授2001年開發的一套支持向量機的庫，這套庫運算速度快，可以很方便的對數據做分類或回歸。由于libSVM程序小，運用靈活，輸入參數少，并且是開源的，易于擴展，因此成為目前國內應用最多的SVM的庫。(以下參考博客)

基本介紹

可以從https://www.csie.ntu.edu.tw/~cjlin/libsvm/下載，解壓到任意目錄，有如下幾個目錄

Java——主要是應用于java平臺；

Python——是用來參數優選的工具，稍后介紹；

svm-toy——一個可視化的工具，用來展示訓練數據和分類界面，里面是源碼，其編譯后的程序在windows文件夾下；

tools——主要包含四個python文件，用來數據集抽樣(subset)，參數優選(grid)，集成測試(easy),數據檢查(checkdata)；

windows——包含libSVM四個exe程序包，一般直接用這四個就夠了

其他.h和.cpp文件都是程序的源碼，可以編譯出相應的.exe文件。

自帶數據測試

命令行下進入libsvm下的windows目錄

輸入命令.\svm-train ..\heart_scale test_model

heart_scale是目錄下的已經存在的樣本文件，以后改成自己的文件名就可以了， test_model——是創建模型

其中，#iter為迭代次數，

nu是你選擇的核函數類型的參數

obj為SVM文件轉換為的二次規劃求解得到的最小值

rho為判決函數的偏置項b

nSV為標準支持向量個數(0

nBSV為邊界上的支持向量個數(a[i]=c)，

Total nSV為支持向量總個數(對于二分類來說，因為只有一個分類模型Total nSV = nSV，但是對于多類，這個是各個分類模型的nSV之和)。

在目錄下，還可以看到產生了一個train.model文件，可以用記事本打開，記錄了訓練后的結果。

svm_type c_svc//所選擇的svm類型，默認為c_svc

kernel_type rbf//訓練采用的核函數類型，此處為RBF核

gamma 0.0769231//RBF核的參數γ

nr_class 2//類別數，此處為兩分類問題

total_sv 132//支持向量總個數

rho 0.424462//判決函數的偏置項b

label 1 -1//原始文件中的類別標識

nr_sv 64 68//每個類的支持向量機的個數

SV//以下為各個類的權系數及相應的支持向量

libsvm使用規范

libsvm的數據格式

Label 1:value 2:value(value為0時序號可直接省略)

svm-train的用法

svmtrain我們在前面已經接觸過，他主要實現對訓練數據集的訓練，并可以獲得SVM模型。

用法： svmtrain [options] training_set_file [model_file]

其中，options為操作參數，可用的選項即表示的涵義如下所示:

-s設置svm類型：

0 – C-SVC

1 – v-SVC

2 – one-class-SVM

3 –ε-SVR

4 – n - SVR

-t設置核函數類型，默認值為2

0 --線性核：u'**v*

1 --多項式核：(gu'*v+coef0)degree*

2 -- RBF核：exp(-γ*||u-v||2)

3 -- sigmoid核：tanh(γu'*v+coef*0)

-d degree:設置多項式核中degree的值，默認為3

-gγ:設置核函數中γ的值，默認為1/k，k為特征(或者說是屬性)數；

-r coef 0:設置核函數中的coef 0，默認值為0；

-c cost：設置C-SVC、ε-SVR、n - SVR中從懲罰系數C，默認值為1；

-n v：設置v-SVC、one-class-SVM與n - SVR中參數n，默認值0.5；

-pε：設置v-SVR的損失函數中的e，默認值為0.1；

-m cachesize：設置cache內存大小，以MB為單位，默認值為40；

-eε：設置終止準則中的可容忍偏差，默認值為0.001；

-h shrinking：是否使用啟發式，可選值為0或1，默認值為1；

-b概率估計：是否計算SVC或SVR的概率估計，可選值0或1，默認0；

-wi weight：對各類樣本的懲罰系數C加權，默認值為1；

-v n：n折交叉驗證模式；

model_file：可選項，為要保存的結果文件，稱為模型文件，以便在預測時使用。

默認情況下，只需要給函數提供一個樣本文件名就可以了，但為了能保存結果，還是要提供一個結果文件名，比如:test.model,則命令為：svmtrain test.txt test.model

svm-predict的用法

svmpredict是根據訓練獲得的模型，對數據集合進行預測。

用法：svmpredict [options] test_file model_file output_file

其中，options為操作參數，可用的選項即表示的涵義如下所示:

-b probability_estimates——是否需要進行概率估計預測，可選值為0或者1，默認值為0。

model_file ——是由svmtrain產生的模型文件；

test_file——是要進行預測的數據文件，格式也要符合libsvm格式，即使不知道label的值，也要任意填一個，svmpredict會在output_file中給出正確的label結果，如果知道label的值，就會輸出正確率；

output_file ——是svmpredict的輸出文件，表示預測的結果值。

Python實現SMO算法

#smo

from numpy import *

import time

# calulate kernel value

def calcKernelValue(matrix_x, sample_x, kernelOption):

kernelType = kernelOption[0]

numSamples = matrix_x.shape[0]

kernelValue = mat(zeros((numSamples, 1)))

if kernelType == 'linear':

kernelValue = matrix_x * sample_x.T

elif kernelType == 'rbf':

sigma = kernelOption[1]

if sigma == 0:

sigma = 1.0

for i in xrange(numSamples):

diff = matrix_x[i, :] - sample_x

kernelValue[i] = exp(diff * diff.T / (-2.0 * sigma**2))

else:

raise NameError('Not support kernel type! You can use linear or rbf!')

return kernelValue

# calculate kernel matrix given train set and kernel type

def calcKernelMatrix(train_x, kernelOption):

numSamples = train_x.shape[0]

kernelMatrix = mat(zeros((numSamples, numSamples)))

for i in xrange(numSamples):

kernelMatrix[:, i] = calcKernelValue(train_x, train_x[i, :], kernelOption)

return kernelMatrix

# define a struct just for storing variables and data

class SVMStruct:

def __init__(self, dataSet, labels, C, toler, kernelOption):

self.train_x = dataSet # each row stands for a sample

self.train_y = labels # corresponding label

self.C = C # slack variable

self.toler = toler # termination condition for iteration

self.numSamples = dataSet.shape[0] # number of samples

self.alphas = mat(zeros((self.numSamples, 1))) # Lagrange factors for all samples

self.b = 0

self.errorCache = mat(zeros((self.numSamples, 2)))

self.kernelOpt = kernelOption

self.kernelMat = calcKernelMatrix(self.train_x, self.kernelOpt)

# calculate the error for alpha k

def calcError(svm, alpha_k):

output_k = float(multiply(svm.alphas, svm.train_y).T * svm.kernelMat[:, alpha_k] + svm.b)

error_k = output_k - float(svm.train_y[alpha_k])

return error_k

# update the error cache for alpha k after optimize alpha k

def updateError(svm, alpha_k):

error = calcError(svm, alpha_k)

svm.errorCache[alpha_k] = [1, error]

# select alpha j which has the biggest step

def selectAlpha_j(svm, alpha_i, error_i):

svm.errorCache[alpha_i] = [1, error_i] # mark as valid(has been optimized)

candidateAlphaList = nonzero(svm.errorCache[:, 0].A)[0] # mat.A return array

maxStep = 0; alpha_j = 0; error_j = 0

# find the alpha with max iterative step

if len(candidateAlphaList) > 1:

for alpha_k in candidateAlphaList:

if alpha_k == alpha_i:

continue

error_k = calcError(svm, alpha_k)

if abs(error_k - error_i) > maxStep:

maxStep = abs(error_k - error_i)

alpha_j = alpha_k

error_j = error_k

# if came in this loop first time, we select alpha j randomly

else:

alpha_j = alpha_i

while alpha_j == alpha_i:

alpha_j = int(random.uniform(0, svm.numSamples))

error_j = calcError(svm, alpha_j)

return alpha_j, error_j

# the inner loop for optimizing alpha i and alpha j

def innerLoop(svm, alpha_i):

error_i = calcError(svm, alpha_i)

### check and pick up the alpha who violates the KKT condition

## satisfy KKT condition

# 1) yi*f(i) >= 1 and alpha == 0 (outside the boundary)

# 2) yi*f(i) == 1 and 0

# 3) yi*f(i) <= 1 and alpha == C (between the boundary)

## violate KKT condition

# because y[i]*E_i = y[i]*f(i) - y[i]^2 = y[i]*f(i) - 1, so

# 1) if y[i]*E_i < 0, so yi*f(i) < 1, if alpha < C, violate!(alpha = C will be correct)

# 2) if y[i]*E_i > 0, so yi*f(i) > 1, if alpha > 0, violate!(alpha = 0 will be correct)

# 3) if y[i]*E_i = 0, so yi*f(i) = 1, it is on the boundary, needless optimized

if (svm.train_y[alpha_i] * error_i < -svm.toler) and (svm.alphas[alpha_i] < svm.C) or\

(svm.train_y[alpha_i] * error_i > svm.toler) and (svm.alphas[alpha_i] > 0):

# step 1: select alpha j

alpha_j, error_j = selectAlpha_j(svm, alpha_i, error_i)

alpha_i_old = svm.alphas[alpha_i].copy()

alpha_j_old = svm.alphas[alpha_j].copy()

# step 2: calculate the boundary L and H for alpha j

if svm.train_y[alpha_i] != svm.train_y[alpha_j]:

L = max(0, svm.alphas[alpha_j] - svm.alphas[alpha_i])

H = min(svm.C, svm.C + svm.alphas[alpha_j] - svm.alphas[alpha_i])

else:

L = max(0, svm.alphas[alpha_j] + svm.alphas[alpha_i] - svm.C)

H = min(svm.C, svm.alphas[alpha_j] + svm.alphas[alpha_i])

if L == H:

return 0

# step 3: calculate eta (the similarity of sample i and j)

eta = 2.0 * svm.kernelMat[alpha_i, alpha_j] - svm.kernelMat[alpha_i, alpha_i] \

- svm.kernelMat[alpha_j, alpha_j]

if eta >= 0:

return 0

# step 4: update alpha j

svm.alphas[alpha_j] -= svm.train_y[alpha_j] * (error_i - error_j) / eta

# step 5: clip alpha j

if svm.alphas[alpha_j] > H:

svm.alphas[alpha_j] = H

if svm.alphas[alpha_j] < L:

svm.alphas[alpha_j] = L

# step 6: if alpha j not moving enough, just return

if abs(alpha_j_old - svm.alphas[alpha_j]) < 0.00001:

updateError(svm, alpha_j)

return 0

# step 7: update alpha i after optimizing aipha j

svm.alphas[alpha_i] += svm.train_y[alpha_i] * svm.train_y[alpha_j] \

* (alpha_j_old - svm.alphas[alpha_j])

# step 8: update threshold b

b1 = svm.b - error_i - svm.train_y[alpha_i] * (svm.alphas[alpha_i] - alpha_i_old) \

* svm.kernelMat[alpha_i, alpha_i] \

- svm.train_y[alpha_j] * (svm.alphas[alpha_j] - alpha_j_old) \

* svm.kernelMat[alpha_i, alpha_j]

b2 = svm.b - error_j - svm.train_y[alpha_i] * (svm.alphas[alpha_i] - alpha_i_old) \

* svm.kernelMat[alpha_i, alpha_j] \

- svm.train_y[alpha_j] * (svm.alphas[alpha_j] - alpha_j_old) \

* svm.kernelMat[alpha_j, alpha_j]

if (0 < svm.alphas[alpha_i]) and (svm.alphas[alpha_i] < svm.C):

svm.b = b1

elif (0 < svm.alphas[alpha_j]) and (svm.alphas[alpha_j] < svm.C):

svm.b = b2

else:

svm.b = (b1 + b2) / 2.0

# step 9: update error cache for alpha i, j after optimize alpha i, j and b

updateError(svm, alpha_j)

updateError(svm, alpha_i)

return 1

else:

return 0

# the main training procedure

def trainSVM(train_x, train_y, C, toler, maxIter, kernelOption = ('rbf', 1.0)):

# calculate training time

startTime = time.time()

# init data struct for svm

svm = SVMStruct(mat(train_x), mat(train_y), C, toler, kernelOption)

# start training

entireSet = True

alphaPairsChanged = 0

iterCount = 0

# Iteration termination condition:

# Condition 1: reach max iteration

# Condition 2: no alpha changed after going through all samples,

# in other words, all alpha (samples) fit KKT condition

while (iterCount < maxIter) and ((alphaPairsChanged > 0) or entireSet):

alphaPairsChanged = 0

# update alphas over all training examples

if entireSet:

for i in xrange(svm.numSamples):

alphaPairsChanged += innerLoop(svm, i)

print '---iter:%d entire set, alpha pairs changed:%d' % (iterCount, alphaPairsChanged)

iterCount += 1

# update alphas over examples where alpha is not 0 & not C (not on boundary)

else:

nonBoundAlphasList = nonzero((svm.alphas.A > 0) * (svm.alphas.A < svm.C))[0]

for i in nonBoundAlphasList:

alphaPairsChanged += innerLoop(svm, i)

print '---iter:%d non boundary, alpha pairs changed:%d' % (iterCount, alphaPairsChanged)

iterCount += 1

# alternate loop over all examples and non-boundary examples

if entireSet:

entireSet = False

elif alphaPairsChanged == 0:

entireSet = True

print 'Congratulations, training complete! Took %fs!' % (time.time() - startTime)

return svm

# testing your trained svm model given test set

def testSVM(svm, test_x, test_y):

test_x = mat(test_x)

test_y = mat(test_y)

numTestSamples = test_x.shape[0]

supportVectorsIndex = nonzero(svm.alphas.A > 0)[0]

supportVectors = svm.train_x[supportVectorsIndex]

supportVectorLabels = svm.train_y[supportVectorsIndex]

supportVectorAlphas = svm.alphas[supportVectorsIndex]

matchCount = 0

for i in xrange(numTestSamples):

kernelValue = calcKernelValue(supportVectors, test_x[i, :], svm.kernelOpt)

predict = kernelValue.T * multiply(supportVectorLabels, supportVectorAlphas) + svm.b

if sign(predict) == sign(test_y[i]):

matchCount += 1

accuracy = float(matchCount) / numTestSamples

return accuracy

數據讀寫及輸出的控制程序如下

from numpy import *

import SVM

import csv

################## test svm #####################

## step 1: load data

print "step 1: load data..."

dataSet = []

labels = []

in_file=csv.reader(open('spammer_order.csv','r'))

maxm=[0]*35

minm=[0]*35

index=1

for in_line in in_file:

if index<3:

if index==1:

for i in range(4,32):

maxm[i]=float(in_line[i])

if index==2:

for i in range(4,32):

minm[i]=float(in_line[i])

else:

out_line=[]

if in_line[32]=='yes':

labels.append('1')

else:

labels.append('-1')

for i in range(4,32):

if i!=6:

if i==4:

if in_line[4]=='female':

out_line.append('1')

else:

out_line.append('-1')

else:

max_value=maxm[i]

min_value=minm[i]

value=float(in_line[i])

n=2*(value-min_value)/(max_value-min_value)-1

out_line.append(str(n))

dataSet.append(map(float,out_line))

index=index+1

#3 860 1718

p1=3+(860-3)/3*2

p=860

p2=860+(1718-860)/3*2

labels=map(float,labels)

train_data=mat(dataSet[0:p1]+dataSet[p:p2])

train_labels=mat(labels[0:p1]+labels[p:p2]).T

test_data=mat(dataSet[p1:p]+dataSet[p2:])

test_labels=mat(labels[p1:p]+labels[p:p2]).T

train_x = train_data

train_y = train_labels

test_x = test_data

test_y = test_labels

## step 2: training...

print "step 2: training..."

C = 1

toler = 0.001

maxIter = 428

svmClassifier = SVM.trainSVM(train_x, train_y, C, toler, maxIter, kernelOption = ('rbf', 0.440787))

## step 3: testing

print "step 3: testing..."

accuracy = SVM.testSVM(svmClassifier, test_x, test_y)

## step 4: show the result

print "step 4: show the result..."

print 'The classify accuracy is: %.3f%%' % (accuracy * 100)

總結

以上是生活随笔為你收集整理的python 支持向量机 导出参数_SVM支持向量机推导，工具介绍及python实现的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。