支持向量机与核方法：从最大间隔到 RBF 核实战

minimize     (1/2) ||w||²
subject to   y_i (w·x_i + b) >= 1,   i = 1..n

import numpy as np
from sklearn.datasets import make_blobs

X, y = make_blobs(n_samples=200, centers=2, cluster_std=1.2, random_state=0)
y = np.where(y == 0, -1, 1)          # SVM 习惯用 -1/+1 标签

def margin_width(w):
    return 2 / np.linalg.norm(w)

w = np.array([1.0, 1.0])
print("间隔宽度:", round(margin_width(w), 4))

minimize     (1/2) ||w||² + C · Σ ξ_i
subject to   y_i (w·x_i + b) >= 1 - ξ_i,   ξ_i >= 0

L(w) = Σ max(0, 1 - y_i (w·x_i + b))  +  λ ||w||²

import numpy as np

def hinge_loss(y, scores):
    return np.maximum(0, 1 - y * scores).mean()

y_true = np.array([1, -1, 1, -1])
scores = np.array([1.2, -0.3, 0.4, 0.9])   # 第三个点越界
print("铰链损失:", round(hinge_loss(y_true, scores), 4))

maximize     Σ α_i - (1/2) ΣΣ α_i α_j y_i y_j (x_i · x_j)
subject to   0 <= α_i <= C,   Σ α_i y_i = 0

f(x) = sign( Σ_{i ∈ SV} α_i y_i (x_i · x) + b )

from sklearn.svm import SVC

svm = SVC(kernel="linear", C=1.0)
svm.fit(X, y)
print("支持向量数:", svm.n_support_)            # 每类各有多少个
print("支持向量索引:", svm.support_[:5])
print("对偶系数 alpha:", svm.dual_coef_[0][:5])

K(x, z) = (x·z + 1)²
       = (x1 z1 + x2 z2 + 1)²
       = 1 + 2 x1 z1 + 2 x2 z2 + x1²z1² + 2 x1x2z1z2 + x2²z2²

import numpy as np

def poly_kernel(X, Z, degree=2, coef0=1.0):
    return (X @ Z.T + coef0) ** degree

def rbf_kernel(X, Z, gamma=1.0):
    sq = (np.sum(X**2, axis=1)[:, None] + np.sum(Z**2, axis=1)[None, :]
          - 2 * X @ Z.T)
    return np.exp(-gamma * sq)

X2 = np.array([[1.0, 2.0]])
print("多项式核:", poly_kernel(X2, X2))
print("RBF 核:", rbf_kernel(X2, X2))

小 gamma         中 gamma        大 gamma
──────────       ────────        ────────
平滑边界          合适           边界碎片化，包围每个点

from sklearn.model_selection import GridSearchCV
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC

pipe = make_pipeline(StandardScaler(), SVC(kernel="rbf"))
param_grid = {
    "svc__C": [0.1, 1, 10, 100],
    "svc__gamma": ["scale", 0.01, 0.1, 1.0],
}
grid = GridSearchCV(pipe, param_grid, cv=5, scoring="f1_macro", n_jobs=-1)
grid.fit(X, y)
print("最优参数:", grid.best_params_)
print("最优分数:", round(grid.best_score_, 4))

minimize  (1/2)||w||² + C Σ (ξ_i + ξ_i*)

from sklearn.svm import SVR
from sklearn.datasets import make_regression

Xr, yr = make_regression(n_samples=200, n_features=5, noise=10, random_state=0)
svr = SVR(kernel="rbf", C=10, epsilon=0.1, gamma="scale")
svr.fit(Xr, yr)
print("R²:", round(svr.score(Xr, yr), 4))

svm_prob = SVC(kernel="rbf", C=1.0, probability=True, random_state=0)
svm_prob.fit(X, y)
proba = svm_prob.predict_proba(X[:3])
print("概率:", proba.round(3))

from sklearn.kernel_approximation import Nystroem, RBFSampler
from sklearn.linear_model import SGDClassifier
from sklearn.pipeline import make_pipeline

# Nystroem：用采样点构造低秩核近似
nys = make_pipeline(
    Nystroem(kernel="rbf", gamma=0.1, n_components=300, random_state=0),
    SGDClassifier(loss="log_loss", max_iter=1000, random_state=0),
)
nys.fit(X, y)
print("Nystroem 近似精度:", round(nys.score(X, y), 4))

rbf_feat = RBFSampler(gamma=0.1, n_components=500, random_state=0)
X_feat = rbf_feat.fit_transform(X)
lin = SGDClassifier(loss="hinge", max_iter=1000, random_state=0).fit(X_feat, y)
print("随机傅里叶特征精度:", round(lin.score(X_feat, y), 4))

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
from sklearn.svm import SVC
from sklearn.metrics import classification_report

X, y = make_moons(n_samples=500, noise=0.25, random_state=42)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.25, stratify=y,
                                          random_state=42)

pipe = make_pipeline(StandardScaler(), SVC(kernel="rbf"))
grid = GridSearchCV(pipe, {"svc__C": [0.1, 1, 10, 100],
                           "svc__gamma": [0.1, 0.5, 1, 2]},
                    cv=5, scoring="accuracy", n_jobs=-1)
grid.fit(X_tr, y_tr)
print("最优:", grid.best_params_)
print(classification_report(y_te, grid.predict(X_te)))

def plot_boundary(model, X, y):
    xx, yy = np.meshgrid(np.linspace(X[:, 0].min() - 0.5, X[:, 0].max() + 0.5, 200),
                         np.linspace(X[:, 1].min() - 0.5, X[:, 1].max() + 0.5, 200))
    Z = model.predict(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)
    plt.contourf(xx, yy, Z, alpha=0.3, cmap="coolwarm")
    plt.scatter(X[:, 0], X[:, 1], c=y, cmap="coolwarm", edgecolors="k")
    plt.title(f"C={model[-1].C}, gamma={model[-1].gamma}")
    plt.show()

plot_boundary(grid.best_estimator_, X, y)

svm_bal = SVC(kernel="rbf", C=1.0, class_weight="balanced", random_state=0)

样本量 < 10 万 且 特征维度高 / 需要清晰间隔？
  ├── 是 → 优先 RBF 核 SVM（先标准化 + 网格搜索）
  └── 否
        ├── 超大规模稀疏文本 → 线性 SVM / SGD
        ├── 需要概率与可解释系数 → 逻辑回归
        └── 表格数据、追求精度 → 梯度提升树（见集成学习）