《Machine Learning in Action》—— 懂的都懂，不懂的也能懂。非線性支援向量機

2020 年 11 月 23 日
筆記
numpy, Python, 數據挖掘, 機器學習, 演算法

說在前面：前幾天，公眾號不是給大家推送了第二篇關於決策樹的文章嘛。閱讀過的讀者應該會發現，在最後排版已經有點亂套了。真的很抱歉，也不知道咋回事，到了後期Markdown格式文件的內容就解析出現問題了，似乎涉及到Latex就會多多少少排版錯亂？？？暫時也沒什麼比較好的解決辦法，如果有朋友知道的可以聯繫下Taoye，長時間用Markdown + Latex碼文已成習慣了，關於機器學習文章的內容，更好的閱讀體驗，大家可以跳轉至我在Cmd Markdown平台發布的內容，也可前往我的掘金主頁，閱讀體驗都是不錯的，PC端食用更佳：

《Machine Learning in Action》—— 懂的都懂，不懂的也能懂。非線性支援向量機

關於支援向量機（SVM），前面我們已經詳細講解了線性SVM的推導過程以及程式碼實現。之後我們發現，雖然效果還算不錯，數據集基本都能夠分類正確，模型訓練效率的話也還說的過去，但這是基於我們訓練樣本數據集比較少、迭代次數比較少的前提下。

假如說我們數據集比較大，而且還需要迭代不少次數的話，使用第一篇SVM文章中所提到的SMO演算法的效率可就不敢恭維了，訓練的速度可堪比龜龜。所以之後也就有了SVM第二篇的內容——優化SMO演算法的優化，進一步提高了SVM模型的訓練效率。

關於前兩篇SVM文章的詳細內容，可暫且跳轉至：

有了線性SVM所提到的知識做基礎，非線性SVM的內容應該不會很難，理解起來也不會有那麼大的壓力。大家在食用前也不要畏懼它，Taoye一定給你安排的明明白白。原理部分的內容一定要理解清楚、理解透徹，尤其是核技巧的奇妙之處，而程式碼部分的內容只需要能看懂就行，知道程式碼所表達的意思即可。所以，一定要加強內功的修鍊，才能在之後實戰過程中如魚得水

前面也有講到，對於一些線性可分的分類問題，線性SVM的確是一種非常有效的方法。

但，現實往往事與願違。

在實際問題中，我們的原始數據集往往是線性不可分的，也就是說我們無法找到一條直線 | 平面 | 超平面將目標數據集分隔開來，這個時候就要引出我們的非線性SVM了，而其中主要特點就是巧妙的利用了核技巧，既能解決低維空間下分類困難的問題，又能巧妙的避免了高維空間下計算量大的困擾。

為了幫助大家更好的理解非線性SVM對問題的處理方式，我們瞅瞅下面的一個例子。

例子來源：李航——《統計學習方法》第七章

在左圖，我們可以看見兩類樣本，其中圓點代表正樣本，叉叉代表負樣本。我們根本無法通過一條直線將兩類樣本分割開來，可以通過一個橢圓才能將兩類樣本分隔開，也就是說這個原始數據集是線性不可分的。

那咋搞呢？真讓人頭大！

各位看官還記得，我們最初在介紹線性SVM的時候那個生動形象的例子么？

我們可以這樣想像一下：假如我們上面的數據樣本點都放在桌面上，此時我們凝神屏氣，鐵砂掌一拍，此時圓點樣本彈起，就在這麼一瞬間，我們使用一個平面就可以完美的將兩類樣本數據分隔開。而非線性SVM所用到的就是這麼一種思想，將低維度空間映射到高緯度空間，以此達到方便分類的目的。

這個時候，就引入了一個映射函數的概念。而對於同一個分類問題，我們可以使用不同的映射函數來進行處理。如上右圖處理方式雖然使用到了映射函數，但是維度並沒有發生改變，卻依然能夠完美分類，下面我們來看看這個分類的處理過程：

我們不妨將上面的數據樣本集表示為\(T=\{(x_1,y_1), (x_2,y_2),…,(x_N,y_N)\}\)，其中\(x_i\)表示的是樣本的屬性特徵向量（相信大家都能夠反應過來），\(y_i\)表示的是樣本的分類標籤。通過初步目測，我們可以發現這些數據樣本集可能滿足這麼一種關係：負樣本的數據集在一個橢圓的內部，而正樣本被夾在兩個橢圓的之間。

既然是橢圓，我們不妨對原始數據集進行一個映射，將所有的數據樣本\(x_i=(x_1^{(1)},x_2^{(2)})\)，映射成\(z_i=((x_1^{(1)})^2,(x_2^{(2)})^2)\)。經過這種「平方」映射的結果，我們可以發現，之前的數據樣本總體在的四個象限都存在，映射之後就只存在於第一象限，且兩類數據樣本有明顯的分割間距。所有樣本映射之後，將原空間中的橢圓:

\[w_1(x^{(1)})^2+w_2(x^{(2)})^2+b = 0
\]

變換成為新空間中的直線：

\[w_1z^{(1)}+w_2z^{(2)}+b=0
\]

即雖然映射之前的數據樣本是線性不可分的，但是映射之後的數據樣本集是線性可分的。所以，我們可以得到解決非線性問題的兩個步驟：

找到一個映射函數將原始數據樣本映射成一個新的數據樣本（簡單理解就是數學中的代換）
映射之後的數據樣本就是一個線性可分的了，之後利用我們前面那篇文章中的方法進行處理，即可實現線性可分

也就是說，在對非線性可分數據集進行分類的時候，我們經常使用到映射函數，不妨令其表示為\(\phi(x)\)，對於上述映射來講，\(\phi(x)=((x_1^{(1)})^2,(x_2^{(2)})^2)\)。對此，我們給出核函數的定義：

設\(X\)是輸入空間，又設\(H\)為映射後的特徵空間，如果存在一個從\(X\)到\(H\)的映射

\[\phi(x):X -> H
\]

使得對所有的\(x,z \in X\)（注意\(X\)是輸入空間，也就是說\(x,z\)其實是兩個樣本的屬性特徵向量），函數K(x,z)滿足條件

\[K(x, z)=\phi(x)\cdot\phi(z)
\]

則稱\(K(x,z)\)為核函數，\(\phi(x)\)為映射函數。

上面是李航——《統計學習方法》中給出核函數的定義，務必要理解清楚。也就是說我們現在的當務之急就是要找出\(K(x_1,x_2)\)來代替\(\phi(x_1)\cdot\phi(x_2)\)。

在前面，我們已經得到了決策面的表達式：

\[\begin{aligned}
f(x) & =\sum_{i=1}^N\alpha_iy_ix_i^Tx+b \\
& = \sum_{i=1}^N\alpha_iy_ix_i\cdot x+b
\end{aligned}
\]

由於此時我們的數據集是非線性可分的，所以需要對屬性特徵進行映射，映射之後變成：

\[\begin{aligned}
f(x) & =\sum_{i=1}^N\alpha_iy_i\phi(x_i)\cdot \phi(x)+b \\
& = \sum_{i=1}^N\alpha_iy_iK(x_i,x)+b
\end{aligned}
\]

幹啥子一定要藉助核函數來解決最終非線性問題呢，直接通過映射再內積的方式不是照樣香么？？？

對於這個問題，我們可以這樣理解：① 先找到映射函數，再進行內積，這是兩個步驟。而直接採用核函數就是一步到位，這是省力。② 映射還需要找到映射對應的映射函數才能繼續下一步，而且映射之後在內積往往計算量比較的複雜，而採用核函數的計算量就比較的簡單，這是省時。

省時又省力的核函數，何樂為不為呢？？？這種將內積的形式轉化成核函數進行處理，就是我們常說的核技巧。

下面我們通過一個簡單的例子來進一步理解下核函數的魅力。

由上圖，我們首先定義了兩個二維向量的樣本\(x_1、x_2\)，然後將其通過映射函數進行處理，處理成了一個三維向量的形式。通過計算可以發現，此時\(\phi^T(x_1)\cdot \phi(x_2)=(x_1\cdot x_2)^2\)，我們令\(K(x_1, x_2)=(x_1\cdot x_2)^2\)，假設我們事先已經知道了核函數\(K(x_1,x_2)\)的表達式，此時就能將數據直接代入到核函數中，這樣所取得的效果與映射之後的內積計算相等，這樣就巧妙的避免了尋找映射函數的麻煩以及計算大的困擾。

當然了，上述僅僅只是其中一種映射的方式，即將2維映射到3維。我們也可以把2維映射成5維，這就涉及到了排列組合了。當我們的維數比較少的時候計算量還尚且可以接受，假如說我們的維度比較大，甚至達到了無窮維的程度，此時的計算量就真的無從下手了。所以，有的時候使用核技巧還是很有必要的。

講到這裡，可能有的讀者會有疑問：既然是需要在知道核函數的前提下，才能巧妙的利用核技巧。那麼，我怎麼知道核函數具體的表達式是什麼呢？？？

其實是這樣的，我們一般在解決非線性分類問題的時候，通常都會事先在常用的幾個核函數中選擇一個核函數來解決問題。常用的核函數主要有以下幾個：

多項式核函數（\(p\)次多項式）

\[K(x_i,x_j)=(x_i \cdot x_j + 1)^p
\]

高斯核函數

\[K(x_i,x_j)=e^{-\frac{||x_i-x_j||^2}{2\sigma^2}}
\]

還有其他一些像徑向基核函數、拉普拉斯核、二次有理核、多元二次核等等，下面我們重點講講高斯核函數，這個也是我們在實際進行非線性分類的時候使用比較頻繁的一個核函數。

我們先說下高斯核函數中比較重要的兩個特性：

高斯核函數會將有限維映射到無窮維空間。
\(\sigma\)是用戶自定義的用於確定到達率(reach)或者說函數值跌落到0的速度參數，它也叫作高斯核函數的頻寬，該值趨近於無窮大的時候，樣本與樣本之間的距離區分度很小，所以比較難分類。該值趨近於0的時候，樣本與樣本之間的區分度很大，雖然有利於樣本的分類，但是很有可能會出現過擬合的問題。所以，通過調控\(\sigma\)參數，高斯核函數具有比較高的靈活性。

下面我們具體看看上面高斯核函數的特性。

高斯核函數為什麼會將有限維映射到無窮維？？？

這個問題就牽涉到泰勒展開了。

如圖可見，當\(n -> \infty\)時，此時的泰勒展開就相當於指數形式，即高斯核函數其實是一種無窮維映射所得到的結果。

為什麼\(\sigma\)參數的取值會影響到樣本的分類結果？？？

通過計算兩樣本之間的「距離」\(d=||\phi(x_i)-\phi_j||^2\)化簡分析可知，當\(\sigma\)趨向於\(\infty\)時，此時兩樣本的區分度很小，很難區分各個樣本的分類。而當\(\sigma\)趨向於\(0\)時，此時兩樣本的區分度很大，有可能導致過擬合。

接下來我們通過實際的例子來實現非線性問題的分類吧。訓練數據集採用的是testSetRBF.txt，測試數據集採用的是testSetRBF2.txt，兩個數據集都有100行，三列，其中第一、第二列表示的是數據樣本的屬性特徵，而第三列代表的是數據樣本標籤。數據下載地址：

部分數據樣本如下所示：

為了更加直觀的感受下數據樣本集的分布，我們不妨通過Matplotlib分別對兩個數據樣本集進行可視化，可視化程式碼如下：

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 showDataSet(dataMat, labelMat):
    data_plus, data_minus = list(), list()
    for i in range(len(dataMat)):
        if labelMat[i] > 0: data_plus.append(dataMat[i])
        else: data_minus.append(dataMat[i])
    data_plus_np, data_minus_np = np.array(data_plus), 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()

可視化結果如下：

可以發現，我們根本無法通過一條直線來將兩類數據進行分類。也就說我們需要通過一個核函數來對數據集進行處理，以下採用的是高斯核函數，大部分程式碼和前幾篇一樣，在其基礎上進行改進，完整程式碼如下：

完整程式碼參考於：《機器學習實戰》以及非線性SVM

import matplotlib.pyplot as plt
import numpy as np
import random

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                                             #返回計算的核K

def loadDataSet(fileName):
    """
    讀取數據
    Parameters:
        fileName - 文件名
    Returns:
        dataMat - 數據矩陣
        labelMat - 數據標籤
    """
    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 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 Ek

def 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 j

def 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,Ej

def 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 aj

def 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:
            return 0
        #步驟3：計算eta
        eta = 2.0 * oS.K[i,j] - oS.K[i,i] - oS.K[j,j]
        if 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):
            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 0

def 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演算法
            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)
            iter += 1
        if entireSet:                                                                                #遍歷一次後改為非邊界遍歷
            entireSet = False
        elif (alphaPairsChanged == 0):                                                                #如果alpha沒有更新,計算全樣本遍歷
            entireSet = True 
    return oS.b,oS.alphas                                                                             #返回SMO演算法計算的b和alphas

def 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%%" % ((1 - 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%%" % ((1 - 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(k1 = 0.5)

運行結果如下：

由結果，我們可以發現，此時訓練集的正確率為98%，而測試集的正確率為88%，可以看出有可能出現了一定的過擬合，讀者可自行調節k1參數進一步觀察數據集正確率情況，這東西慢慢體會吧。

以上就是非線性SVM的內容了，重點在於要把核技巧理解透徹。SVM的全部內容就更新到這裡了，其他SVM涉及到的相關內容，在今後的文章可能會提及。下期的話應該會更新Knn相關的內容。

我是Taoye，愛專研，愛分享，熱衷於各種技術，學習之餘喜歡下象棋、聽音樂、聊動漫，希望藉此一畝三分地記錄自己的成長過程以及生活點滴，也希望能結實更多志同道合的圈內朋友，更多內容歡迎來訪微信公主號：玩世不恭的Coder

參考資料：

[1] 《機器學習實戰》：Peter Harrington 人民郵電出版社
[2] 《統計學習方法》：李航第二版清華大學出版社
[3] 《機器學習》：周志華清華大學出版社
[4] 支援向量機之非線性SVM：//cuijiahua.com/blog/2017/11/ml_9_svm_2.html

Tags: numpy Python 數據挖掘機器學習演算法