机器学习算法实战系列：支持向量机(SVM)完全指南

引言

“曾被称作’万能分类器’的SVM，现在依然是工业界和学术界的宠儿！想知道它是如何在复杂分类问题中画出完美决策边界的吗？”

支持向量机(Support Vector Machine)是机器学习中最强大且数学优美的算法之一。它不仅能处理线性可分数据，还能通过核技巧解决高度复杂的非线性问题。本文将带你从SVM的数学基础出发，逐步深入到核方法、软间隔等高级概念，并通过多个工业级案例展示其强大能力。准备好迎接这场数学与实战的完美结合了吗？

第一部分：SVM基础与线性可分情况

1.1 SVM核心思想

SVM的核心目标是找到一个最优超平面，将不同类别的数据分开，并且使这个超平面到最近数据点（支持向量）的距离最大化。

关键概念：

超平面：在n维空间中的(n-1)维子空间，决策边界
支持向量：距离超平面最近的样本点，决定超平面位置
间隔(margin)：超平面到最近支持向量的距离的两倍

1.2 数学推导：从感知机到SVM

感知机的目标是找到一个能分开数据的超平面，而SVM更进一步，要求找到”最优”超平面。

给定训练数据{(xⁱ, yⁱ)}, i=1,…,n, yⁱ∈{-1,1}，超平面可以表示为：

w·x + b = 0

我们需要最大化间隔，这等价于最小化||w||，约束条件为：

yⁱ(w·xⁱ + b) ≥ 1, ∀i

这是一个带约束的凸优化问题，可以通过拉格朗日乘子法求解。

1.3 拉格朗日对偶问题

原始优化问题的拉格朗日函数：

L(w,b,α) = 1/2 ||w||² – Σ αⁱ[yⁱ(w·xⁱ + b) – 1]

其中αⁱ≥0是拉格朗日乘子。通过对w和b求偏导并令其为零，可以得到对偶问题：

max Σ αⁱ – 1/2 Σ Σ αⁱαʲyⁱyʲ(xⁱ·xʲ)
s.t. Σ αⁱyⁱ = 0, αⁱ ≥ 0

这个对偶形式在引入核方法时至关重要。

1.4 Python实现线性SVM

下面我们实现一个简化版的线性SVM：

import numpy as np
from cvxopt import matrix, solvers

class LinearSVM:
    def __init__(self):
        self.w = None
        self.b = None
    
    def fit(self, X, y):
        n_samples, n_features = X.shape
        
        # 转换为cvxopt需要的格式
        P = matrix(np.eye(n_features + 1))
        P[n_features, n_features] = 0  # 不惩罚b
        
        q = matrix(np.zeros(n_features + 1))
        
        # 约束 yⁱ(w·xⁱ + b) ≥ 1
        h = matrix(-np.ones(n_samples))
        G = matrix(-np.diag(y) @ np.hstack([X, np.ones((n_samples, 1))]))
        
        # 求解QP问题
        solution = solvers.qp(P, q, G, h)
        
        # 解析解
        params = np.array(solution['x']).flatten()
        self.w = params[:-1]
        self.b = params[-1]
    
    def predict(self, X):
        return np.sign(X @ self.w + self.b)

第二部分：非线性SVM与核技巧

2.1 核方法原理

“SVM最强大的地方在于它能通过核技巧将线性算法变成非线性算法，而计算复杂度几乎没有增加！”

核函数的基本思想是将数据映射到高维空间，使得在高维空间中数据线性可分。核函数K定义为：

K(x,z) = φ(x)·φ(z)

其中φ是映射函数。这样我们无需显式计算φ(x)，只需计算核函数。

2.2 常用核函数

线性核：K(x,z) = x·z
多项式核：K(x,z) = (γx·z + r)^d
高斯核(RBF)：K(x,z) = exp(-γ||x-z||²)
Sigmoid核：K(x,z) = tanh(γx·z + r)

2.3 核SVM的对偶形式

引入核函数后，对偶问题变为：

max Σ αⁱ – 1/2 Σ Σ αⁱαʲyⁱyʲK(xⁱ,xʲ)
s.t. Σ αⁱyⁱ = 0, 0 ≤ αⁱ ≤ C

其中C是正则化参数，控制对误分类的惩罚程度。

2.4 Python实现核SVM

class KernelSVM:
    def __init__(self, kernel='rbf', C=1.0, gamma=0.1):
        self.kernel = kernel
        self.C = C
        self.gamma = gamma
        self.alpha = None
        self.support_vectors = None
        self.support_vector_labels = None
        self.b = 0
    
    def _kernel_function(self, x1, x2):
        if self.kernel == 'linear':
            return np.dot(x1, x2)
        elif self.kernel == 'poly':
            return (self.gamma * np.dot(x1, x2) + 1)**3
        elif self.kernel == 'rbf':
            return np.exp(-self.gamma * np.linalg.norm(x1 - x2)**2)
        else:
            raise ValueError("未知核函数")
    
    def fit(self, X, y):
        n_samples, n_features = X.shape
        
        # 计算核矩阵
        K = np.zeros((n_samples, n_samples))
        for i in range(n_samples):
            for j in range(n_samples):
                K[i,j] = self._kernel_function(X[i], X[j])
        
        # 设置QP参数
        P = matrix(np.outer(y, y) * K)
        q = matrix(-np.ones(n_samples))
        A = matrix(y.reshape(1, -1).astype(np.double))
        b = matrix(0.0)
        G = matrix(np.vstack((-np.eye(n_samples), np.eye(n_samples))))
        h = matrix(np.hstack((np.zeros(n_samples), np.ones(n_samples) * self.C)))
        
        # 求解QP问题
        solution = solvers.qp(P, q, G, h, A, b)
        
        # 获取拉格朗日乘子
        self.alpha = np.ravel(solution['x'])
        
        # 获取支持向量
        sv_indices = self.alpha > 1e-5
        self.support_vectors = X[sv_indices]
        self.support_vector_labels = y[sv_indices]
        self.alpha = self.alpha[sv_indices]
        
        # 计算偏置项b
        self.b = 0
        for i in range(len(self.alpha)):
            self.b += self.support_vector_labels[i]
            self.b -= np.sum(self.alpha * self.support_vector_labels * 
                           K[sv_indices][i, sv_indices])
        self.b /= len(self.alpha)
    
    def predict(self, X):
        y_pred = np.zeros(X.shape[0])
        for i in range(X.shape[0]):
            s = 0
            for alpha, sv_y, sv in zip(self.alpha, self.support_vector_labels, 
                                     self.support_vectors):
                s += alpha * sv_y * self._kernel_function(X[i], sv)
            y_pred[i] = s
        return np.sign(y_pred + self.b)

第三部分：SVM实战案例与调优

3.1 手写数字识别案例

from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.preprocessing import StandardScaler

# 加载数据
digits = load_digits()
X, y = digits.data, digits.target

# 二分类问题：识别数字是否为8
y = (y == 8).astype(int) * 2 - 1  # 转换为-1,1

# 数据预处理
scaler = StandardScaler()
X = scaler.fit_transform(X)

# 划分数据集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 训练SVM
svm = KernelSVM(kernel='rbf', C=1.0, gamma=0.01)
svm.fit(X_train, y_train)

# 评估
y_pred = svm.predict(X_test)
print("准确率:", accuracy_score(y_test, y_pred))

3.2 超参数调优技巧

SVM的关键参数：

C：正则化参数，权衡间隔最大化与分类误差
γ：核函数参数，控制单个样本的影响范围
核函数选择：根据数据特性选择合适核函数

使用网格搜索进行调优：

from sklearn.svm import SVC
from sklearn.model_selection import GridSearchCV

param_grid = {
            
    'C': [0.1, 1, 10, 100],
    'gamma': [1, 0.1, 0.01, 0.001],
    'kernel': ['rbf', 'poly', 'sigmoid']
}

grid = GridSearchCV(SVC(), param_grid, refit=True, verbose=3, cv=5)
grid.fit(X_train, y_train)

print("最佳参数:", grid.best_params_)
print("最佳准确率:", grid.best_score_)

3.3 支持向量可视化

import matplotlib.pyplot as plt

# 使用PCA降维可视化
from sklearn.decomposition import PCA

pca = PCA(n_components=2)
X_pca = pca.fit_transform(X_train)

# 训练一个2D SVM便于可视化
svm_2d = SVC(kernel='rbf', C=1, gamma=0.1)
svm_2d.fit(X_pca, y_train)

# 创建网格用于绘制决策边界
def plot_decision_boundary(clf, X, y):
    h = .02  # 步长
    x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
    y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
    xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                         np.arange(y_min, y_max, h))
    
    Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
    Z = Z.reshape(xx.shape)
    
    plt.contourf(xx, yy, Z, alpha=0.8)
    plt.scatter(X[:, 0], X[:, 1], c=y, edgecolors='k')
    plt.scatter(clf.support_vectors_[:, 0], 
                clf.support_vectors_[:, 1], 
                facecolors='none', edgecolors='r', s=100)
    plt.title('SVM决策边界与支持向量')
    plt.xlabel('PCA1')
    plt.ylabel('PCA2')

plot_decision_boundary(svm_2d, X_pca, y_train)
plt.show()