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

時間  2020-11-24
標籤 html git 算法 數據庫 數組 緩存 微信 網絡 數據結構 app 欄目 HTML 简体版
原文   原文鏈接

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

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

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

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

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

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

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

但，現實每每事與願違。微信

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

爲了幫助你們更好的理解非線性SVM對問題的處理方式，咱們瞅瞅下面的一個例子。數據結構

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

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

那咋搞呢？真讓人頭大！

各位看官還記得，咱們最初在介紹線性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 \]

即雖然映射以前的數據樣本是線性不可分的，可是映射以後的數據樣本集是線性可分的。因此，咱們能夠獲得解決非線性問題的兩個步驟：

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

也就是說，在對非線性可分數據集進行分類的時候，咱們常用到映射函數，不妨令其表示爲\(\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_一、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}} \]

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

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

  1. 高斯核函數會將有限維映射到無窮維空間。
  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行，三列，其中第1、第二列表示的是數據樣本的屬性特徵，而第三列表明的是數據樣本標籤。數據下載地址：

部分數據樣本以下所示：

爲了更加直觀的感覺下數據樣本集的分佈，咱們不妨經過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：https://cuijiahua.com/blog/2017/11/ml_9_svm_2.html

推薦閱讀

《Machine Learning in Action》—— hao朋友，快來玩啊，決策樹呦
《Machine Learning in Action》—— Taoye給你講講決策樹究竟是支什麼「鬼」
《Machine Learning in Action》—— 剖析支持向量機，優化SMO
《Machine Learning in Action》—— 剖析支持向量機，單手狂撕線性SVM
print( "Hello，NumPy！" )
幹啥啥不行，吃飯第一名
Taoye滲透到一家黑平臺總部，背後的真相細思極恐
《大話數據庫》-SQL語句執行時，底層究竟作了什麼小動做？
那些年，咱們玩過的Git，真香
基於Ubuntu+Python+Tensorflow+Jupyter notebook搭建深度學習環境
網絡爬蟲之頁面花式解析

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程