5.7 支援向量機

支援向量機（SVM）是一種特別強大且靈活的監督演算法，用於分類和迴歸。 在本節中，我們將探索支援向量機背後的直覺，及其在分類問題中的應用。

我們以標準匯入開始：

%matplotlib inline
import numpy as np
import matplotlib.pyplot as plt
from scipy import stats

# use seaborn plotting defaults
import seaborn as sns; sns.set()

支援向量機的動機

作為貝葉斯分類討論的一部分（見樸素貝葉斯分類），我們學習了一個簡單模型，它描述每個底層類的分佈，並使用這些生成模型，依概率確定新的點的標籤。 這是生成分類的一個例子。 這裡我們將考慮區分性分類：我們不對每個類進行建模，只需找到一條或兩條直線（在兩個維度上），或者流形（在多個維度上），將類彼此劃分。

作為一個例子，考慮分類任務的簡單情況，其中兩個類別的點是良好分隔的：

from sklearn.datasets.samples_generator import make_blobs
X, y = make_blobs(n_samples=50, centers=2,
                  random_state=0, cluster_std=0.60)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='autumn');

線性判別分類器將嘗試繪製分離兩組資料的直線，從而建立分類模型。 對於這裡所示的二維資料，這是我們可以手動完成的任務。 但是立刻我們看到一個問題：有兩個以上的可能的分界線可以完美地區分兩個類！

我們可以畫出如下：

線性判別分類器嘗試繪製分離兩組資料的直線，從而建立分類模型。 對於這裡所示的二維資料，這是我們可以手動完成的任務。 但是我們立刻看到一個問題：有兩個以上的可能的分界線，可以完美地區分兩個類！

我們可以這樣繪製：

xfit = np.linspace(-1, 3.5)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='autumn')
plt.plot([0.6], [2.1], 'x', color='red', markeredgewidth=2, markersize=10)

for m, b in [(1, 0.65), (0.5
 
, 1.6), (-0.2, 2.9)]:
    plt.plot(xfit, m * xfit + b, '-k')

plt.xlim(-1, 3.5);

這些是三個非常不同的分隔直線，然而，這些分隔直線能夠完全區分這些樣例。 根據你的選擇，為新資料點（例如，該圖中由“X”標記的資料點）分配不同的標籤！ 顯然，我們簡單的直覺，“在分類之間劃線”是不夠的，我們需要進一步思考。

支援向量機：間距最大化

支援向量機提供了一種改進方法。 直覺是這樣的：我們並非在分類之間，簡單繪製一個零寬度的直線，而是畫出邊距為一定寬度的直線，直到最近的點。 這是一個例子：

xfit = np.linspace(-1, 3.5)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='autumn')

for m, b, d in [(1, 0.65, 0.33), (0.5, 1.6, 0.55), (-0.2, 2.9, 0.2)]:
    yfit = m * xfit + b
    plt.plot(xfit, yfit, '-k')
    plt.fill_between(xfit, yfit - d, yfit + d, edgecolor='none',
                     color='#AAAAAA', alpha=0.4)

plt.xlim(-1, 3.5);

在支援向量機中，邊距最大化的直線是我們將選擇的最優模型。 支援向量機是這種最大邊距估計器的一個例子。

擬合支援向量機

我們來看看這個資料的實際結果：我們將使用 Scikit-Learn 的支援向量分類器，對這些資料訓練 SVM 模型。 目前，我們將使用一個線性核並將C引數設定為一個非常大的數值（我們之後深入討論這些引數的含義）。

from sklearn.svm import SVC # "Support vector classifier"
model = SVC(kernel='linear', C=1E10)
model.fit(X, y)

SVC(C=10000000000.0, cache_size=200, class_weight=None, coef0=0.0,
  decision_function_shape=None, degree=3, gamma='auto', kernel='linear',
  max_iter=-1, probability=False, random_state=None, shrinking=True,
  tol=0.001, verbose=False)

為了更好展現這裡發生的事情，讓我們建立一個輔助函式，為我們繪製 SVM 的決策邊界。

def plot_svc_decision_function(model, ax=None, plot_support=True):
    """Plot the decision function for a 2D SVC"""
    if ax is None:
        ax = plt.gca()
    xlim = ax.get_xlim()
    ylim = ax.get_ylim()

    # create grid to evaluate model
    x = np.linspace(xlim[0], xlim[1], 30)
    y = np.linspace(ylim[0], ylim[1], 30)
    Y, X = np.meshgrid(y, x)
    xy = np.vstack([X.ravel(), Y.ravel()]).T
    P = model.decision_function(xy).reshape(X.shape)

    # plot decision boundary and margins
    ax.contour(X, Y, P, colors='k',
               levels=[-1, 0, 1], alpha=0.5,
               linestyles=['--', '-', '--'])

    # plot support vectors
    if plot_support:
        ax.scatter(model.support_vectors_[:, 0],
                   model.support_vectors_[:, 1],
                   s=300, linewidth=1, facecolors='none');
    ax.set_xlim(xlim)
    ax.set_ylim(ylim)

plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='autumn')
plot_svc_decision_function(model);

這是最大化兩組點之間的間距的分界線。 請注意，一些訓練點只是碰到了邊緣：它們由該圖中的黑色圓圈表示。 這些點是這種擬合的關鍵要素，被稱為支援向量，並提供了演算法的名稱。 在 Scikit-Learn 中，這些點儲存在分類器的support_vectors_屬性中：

model.support_vectors_

array([[ 0.44359863,  3.11530945],
       [ 2.33812285,  3.43116792],
       [ 2.06156753,  1.96918596]])

這個分類器的成功的關鍵在於，為了擬合，只有支援向量的位置是重要的；任何遠離邊距的點，都不會影響擬合。 從技術上講，這是因為這些要點不用於擬合模型的損失函式，所以只要不超過邊距，它們的位置和數值就不重要了。

我們可以看到這一點，例如，如果我們繪製該資料集的前 60 個點和前120個點獲得的模型：

def plot_svm(N=10, ax=None):
    X, y = make_blobs(n_samples=200, centers=2,
                      random_state=0, cluster_std=0.60)
    X = X[:N]
    y = y[:N]
    model = SVC(kernel='linear', C=1E10)
    model.fit(X, y)

    ax = ax or plt.gca()
    ax.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='autumn')
    ax.set_xlim(-1, 4)
    ax.set_ylim(-1, 6)
    plot_svc_decision_function(model, ax)

fig, ax = plt.subplots(1, 2, figsize=(16, 6))
fig.subplots_adjust(left=0.0625, right=0.95, wspace=0.1)
for axi, N in zip(ax, [60, 120]):
    plot_svm(N, axi)
    axi.set_title('N = {0}'.format(N))

在左圖中，我們看到了 60 個訓練點的模型和支援向量。 在右圖中，我們將訓練點數量翻了一番，但是模型沒有改變：左圖的三個支援向量仍然是右圖的支援向量。 遠端點的確切行為的這種不敏感性，是 SVM 模型的優點之一。

如果你正在執行這個筆記，可以使用 IPython 的互動式小部件，以互動方式檢視 SVM 模型的此功能：

from ipywidgets import interact, fixed
interact(plot_svm, N=[10, 200], ax=fixed(None));

超越支援向量機：核

SVM 與核結合在一起，就會變得非常強大。 之前，我們已經看到了一個核的版本，就是“線性迴歸”中的基函式。 在那裡，我們將資料投影到更高維空間中，由多項式和高斯基函式定義，從而能夠將線性分類器用於非線性關係。

在 SVM 模型中，我們可以使用相同想法的一個版本。 為了闡述核的動機，我們來看一些不是線性分離的資料：

from sklearn.datasets.samples_generator import make_circles
X, y = make_circles(100, factor=.1, noise=.1)

clf = SVC(kernel='linear').fit(X, y)

plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='autumn')
plot_svc_decision_function(clf, plot_support=False);

很明顯，這些資料不可能線性分隔。 但是，我們可以從線性迴歸中的基函式迴歸中吸取經驗，並考慮如何將資料投影到更高的維度，使得線性分隔就足夠了。 例如，我們可以使用的一個簡單的投影是徑向基函式，中心是中間那一堆點：

r = np.exp(-(X ** 2).sum(1))

我們可以使用三維圖形來顯示這個額外的資料維度 - 如果你正在執行筆記本，則可以使用滑塊來旋轉圖形：

from mpl_toolkits import mplot3d

def plot_3D(elev=30, azim=30, X=X, y=y):
    ax = plt.subplot(projection='3d')
    ax.scatter3D(X[:, 0], X[:, 1], r, c=y, s=50, cmap='autumn')
    ax.view_init(elev=elev, azim=azim)
    ax.set_xlabel('x')
    ax.set_ylabel('y')
    ax.set_zlabel('r')

interact(plot_3D, elev=[-90, 90], azip=(-180, 180),
         X=fixed(X), y=fixed(y));

我們可以看到，使用這個附加維度，通過在r = 0.7處繪製分離平面，資料可以線性分離。

在這裡，我們必須選擇並仔細調整我們的預測：如果我們沒有將徑向基函式置於正確的位置，我們就不會看到這樣清晰的線性可分離結果。一般來說，做出這樣的選擇的需求是一個問題：我們想以某種方式自動找到最佳的基函式來使用。

為此，一個策略是計算以資料集中每個點為中心的基函式，並使 SVM 演算法篩選出結果。這種型別的基函式變換被稱為核變換，因為它基於每對點之間的相似關係（或核）。

這種策略的潛在問題 - 將N個點投影到N個維度 - 就是隨著N增長，它的計算開銷可能會變得非常大。然而，由於一個被稱為核技巧的簡潔的小過程，核心轉換資料上的擬合可以隱式完成，也就是說，不需要為核投影構建完全的N維資料表示！這個核技巧內建在 SVM 中，也是該方法如此強大的原因之一。

在 Scikit-Learn 中，我們可以通過使用kernel模型超引數，將線性核更改為 RBF（徑向基函式）核來應用核化 SVM：

clf = SVC(kernel='rbf', C=1E6)
clf.fit(X, y)

SVC(C=1000000.0, cache_size=200, class_weight=None, coef0=0.0,
  decision_function_shape=None, degree=3, gamma='auto', kernel='rbf',
  max_iter=-1, probability=False, random_state=None, shrinking=True,
  tol=0.001, verbose=False)

plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='autumn')
plot_svc_decision_function(clf)
plt.scatter(clf.support_vectors_[:, 0], clf.support_vectors_[:, 1],
            s=300, lw=1, facecolors='none');

使用這個核化的 SVM，我們得到了合適的非線性決策邊界。這個核的轉換策略，通常用在機器學習中，將線性方法快速調整為非線性方法，尤其是可以使用核技巧的模型。

調整 SVM：軟邊距

我們迄今為止的討論集中在非常乾淨的資料集，其中存在完美的決策邊界。 但是如果你的資料有一定的重疊呢？ 例如，你可能擁有如下資料：

X, y = make_blobs(n_samples=100, centers=2,
                  random_state=0, cluster_std=1.2)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='autumn');

為了處理這種情況，SVM 實現了軟化因子，即“軟化”邊距：也就是說，如果允許更好的匹配，它允許某些點進入邊距。 邊緣的硬度由調整引數控制，通常稱為C。 對於非常大的C，邊距是硬的，點不能進入。 對於較小的C，邊緣較軟，可以擴充套件幷包含一些點。

下圖顯示了引數的變化C，如何影響最終擬合，通過軟化邊緣：

X, y = make_blobs(n_samples=100, centers=2,
                  random_state=0, cluster_std=0.8)

fig, ax = plt.subplots(1, 2, figsize=(16, 6))
fig.subplots_adjust(left=0.0625, right=0.95, wspace=0.1)

for axi, C in zip(ax, [10.0, 0.1]):
    model = SVC(kernel='linear', C=C).fit(X, y)
    axi.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='autumn')
    plot_svc_decision_function(model, axi)
    axi.scatter(model.support_vectors_[:, 0],
                model.support_vectors_[:, 1],
                s=300, lw=1, facecolors='none');
    axi.set_title('C = {0:.1f}'.format(C), size=14)

引數C的最佳值將取決於你的資料集，並應使用交叉驗證或類似的過程進行調整（請參閱超引數和模型驗證）。

示例：人臉識別

作為支援向量機的一個例子，我們來看看人臉識別問題。 我們將使用 Wild 資料集中的標記人臉，其中包含數千張各種公眾人物的整理照片。 資料集的獲取器內置於 Scikit-Learn中：

from sklearn.datasets import fetch_lfw_people
faces = fetch_lfw_people(min_faces_per_person=60)
print(faces.target_names)
print(faces.images.shape)

['Ariel Sharon' 'Colin Powell' 'Donald Rumsfeld' 'George W Bush'
 'Gerhard Schroeder' 'Hugo Chavez' 'Junichiro Koizumi' 'Tony Blair']
(1348, 62, 47)

讓我們繪製這些人臉來看看我們要處理什麼：

fig, ax = plt.subplots(3, 5)
for i, axi in enumerate(ax.flat):
    axi.imshow(faces.images[i], cmap='bone')
    axi.set(xticks=[], yticks=[],
            xlabel=faces.target_names[faces.target[i]])

每個影象包含[62×47]或近 3,000 個畫素。 我們可以簡單地使用每個畫素值作為特徵，但是通常使用某種前處理器，來提取更有意義的特徵更有效；在這裡，我們將使用主成分分析（參見主成分分析）來提取150個基本成分，並扔給我們的支援向量機分類器。 我們可以將前處理器和分類器打包成單個管道，來最直接地執行此操作：

from sklearn.svm import SVC
from sklearn.decomposition import RandomizedPCA
from sklearn.pipeline import make_pipeline

pca = RandomizedPCA(n_components=150, whiten=True, random_state=42)
svc = SVC(kernel='rbf', class_weight='balanced')
model = make_pipeline(pca, svc)

出於測試我們的分類器輸出的目的，我們將資料分割成訓練集和測試集。

from sklearn.cross_validation import train_test_split
Xtrain, Xtest, ytrain, ytest = train_test_split(faces.data, faces.target,
                                                random_state=42)

最後，我們可以使用網格搜尋的交叉驗證來探索引數的組合。 這裡我們將調整C（控制邊緣硬度）和gamma（其控制徑向基函式核的大小），並確定最佳模型：

from sklearn.grid_search import GridSearchCV
param_grid = {'svc__C': [1, 5, 10, 50],
              'svc__gamma': [0.0001, 0.0005, 0.001, 0.005]}
grid = GridSearchCV(model, param_grid)

%time grid.fit(Xtrain, ytrain)
print(grid.best_params_)

CPU times: user 47.8 s, sys: 4.08 s, total: 51.8 s
Wall time: 26 s
{'svc__gamma': 0.001, 'svc__C': 10}

最優值落在我們網格中間；如果他們落在邊緣，我們需要擴大網格，來確保我們找到了真正的最優值。

現在有了這種交叉驗證的模型，我們可以預測測試資料的標籤，該模型還沒有看到：

model = grid.best_estimator_
yfit = model.predict(Xtest)

讓我們看一看一些測試影象，以及它們的預測值。

fig, ax = plt.subplots(4, 6)
for i, axi in enumerate(ax.flat):
    axi.imshow(Xtest[i].reshape(62, 47), cmap='bone')
    axi.set(xticks=[], yticks=[])
    axi.set_ylabel(faces.target_names[yfit[i]].split()[-1],
                   color='black' if yfit[i] == ytest[i] else 'red')
fig.suptitle('Predicted Names; Incorrect Labels in Red', size=14);

在這個小樣本中，我們的最佳估計器只錯誤標記一個人臉（底部的行中，布什的臉錯誤標記為布萊爾）。 我們可以使用分類報告更好了解我們的估計器的表現，該分類報告按標籤列出了恢復統計量：

from sklearn.metrics import classification_report
print(classification_report(ytest, yfit,
                            target_names=faces.target_names))

                   precision    recall  f1-score   support

     Ariel Sharon       0.65      0.73      0.69        15
     Colin Powell       0.81      0.87      0.84        68
  Donald Rumsfeld       0.75      0.87      0.81        31
    George W Bush       0.93      0.83      0.88       126
Gerhard Schroeder       0.86      0.78      0.82        23
      Hugo Chavez       0.93      0.70      0.80        20
Junichiro Koizumi       0.80      1.00      0.89        12
       Tony Blair       0.83      0.93      0.88        42

      avg / total       0.85      0.85      0.85       337

我們也可以展示這些分類之間的混淆矩陣：

from sklearn.metrics import confusion_matrix
mat = confusion_matrix(ytest, yfit)
sns.heatmap(mat.T, square=True, annot=True, fmt='d', cbar=False,
            xticklabels=faces.target_names,
            yticklabels=faces.target_names)
plt.xlabel('true label')
plt.ylabel('predicted label');

這有助於我們瞭解哪些標籤可能被估算器混淆。

對於真實的人臉識別任務，其中照片不會被預先裁剪成漂亮的網格，人臉分類方案的唯一區別是特徵選擇：您需要使用更復雜的演算法來查詢人臉， 並提取獨立於畫素的特徵。 對於這種應用，一個很好的選擇是使用 OpenCV，除了別的以外，它包括用於一般影象的，以及專用於人臉的現代化特徵提取工具。

支援向量機總結

我們在這裡看到了支援向量機背後的原則的簡單直觀的介紹。這些方法是強大的分類方法，原因有很多：

• 他們依賴相對較少的支援向量，意味著它們是非常緊湊的模型，並且佔用很少的記憶體。
• 一旦訓練了模型，預測階段非常快。
• 因為它們僅受邊緣附近的點的影響，它們適用於高維資料，甚至維度大於樣本的資料，這對於其他演算法來說是一個挑戰。
• 核心方法的整合使得它們非常通用，能夠適應許多型別的資料。

然而，SVM也有幾個缺點：

• 在最差的情況下，樣本數N的複雜度為O(N^3)，對於高效的實現，是O(N^2)。對於大量的訓練樣本，這種計算成本可能令人望而卻步。
• 結果強烈依賴於軟化引數C的合適選擇。這必須通過交叉驗證仔細選擇，隨著資料集增大，開銷也增大。
• 結果沒有直接的概率解釋。這可以通過內部交叉驗證來估計（參見SVC的概率引數），但這種額外的估計是昂貴的。

考慮到這些特性，一般來說，只要其他更簡單，更快，並且不需要調優的方法不足以滿足我的需求，我一般只會考慮 SVM。然而，如果你投入了足夠的 CPU 週期，使用 SVM 訓練和驗證你的資料，這個方法有很好的效果。