企业官网建设流程全解析

1. 从硬间隔到软间隔：为什么需要拉格朗日对偶

1.1 硬间隔SVM的“死穴”在哪里

如果你跟着上一篇笔记一路推下来，应该已经知道硬间隔SVM的核心思路：在特征空间里找一个超平面，让两类样本中离它最近的点到超平面的距离最大化。数学上写出来就是一个带不等式约束的凸二次规划问题：

min (1/2)||w||^2 s.t. y_i(w·x_i + b) >= 1, i = 1,2,...,N

这个形式看起来很干净，但它有一个非常致命的假设——数据必须线性可分。现实里的数据集，尤其是做图像分类、文本分类、生物特征识别的时候，几乎没有完全线性可分的。你总会遇到几个点，它们就是长在对方阵营里，或者两类样本的边界区域互相咬合。

我最早做手写数字二分类的时候就踩过这个坑。当时把两类样本丢进去，硬间隔SVM直接不收敛，求解器报错说约束不可行。后来才发现，只要有一个噪声点或者标注错误的点落在间隔带里面，整个优化问题就无解。这就是硬间隔的“死穴”：它对噪声和异常点零容忍。

那怎么办？两条路。第一条路是核技巧，把数据映射到高维空间，让它在高维里线性可分。第二条路是允许一部分点“犯规”，也就是引入松弛变量，把硬间隔变成软间隔。这两条路其实可以同时走，但今天这篇笔记的重点是第二条路，以及支撑它的一整套数学工具——拉格朗日对偶和KKT条件。

1.2 为什么非要走对偶这条路

很多人第一次看到SVM的求解过程会有一个疑问：原始问题已经是一个凸二次规划了，直接用数值优化方法解不行吗？为什么非要绕一圈，先转成拉格朗日对偶问题，再解对偶问题？

这个问题我当年也问过。后来在实际项目里跑过大规模数据之后才明白，走对偶这条路有三个非常实际的理由。

第一个理由是约束的形式。原始问题的约束是N个不等式约束，N是样本数量。当样本量到几万甚至几十万的时候，直接解原始问题的计算量会非常大。而对偶问题把约束变成了等式约束，并且优化变量从w、b变成了拉格朗日乘子α，问题的结构变得更适合用坐标下降或者SMO这类算法来解。

第二个理由是核函数的引入。对偶形式里，样本只以内积的形式出现。这意味着我们可以用一个核函数K(x_i, x_j)直接替换内积，而不需要显式地把数据映射到高维空间。这个性质是SVM能处理非线性问题的关键，而它只有在对偶形式下才能自然地表达出来。

第三个理由是稀疏性。对偶问题解出来的α向量里，大部分分量都是0，只有少数几个非零的α对应的样本才是支持向量。这个稀疏性不仅让模型存储和预测更高效，还给了我们一个理解SVM几何意义的窗口——最终决定分类边界的，只是那几个离边界最近的点。

所以，走对偶这条路不是数学上的炫技，而是有明确的工程动机。下面我就把这条路上的几个关键路标——拉格朗日函数、对偶问题、KKT条件——一个一个拆开讲。

2. 拉格朗日对偶性的核心逻辑与推导细节

2.1 拉格朗日函数的构造思路

拉格朗日乘子法的基本思想，是把带约束的优化问题转化成无约束的优化问题。具体做法是把约束条件乘以一个乘子，然后加到目标函数上去。

对于SVM的原始问题：

min (1/2)||w||^2 s.t. 1 - y_i(w·x_i + b) <= 0, i = 1,...,N

注意这里我把约束写成了小于等于零的形式，这是为了后面推导KKT条件时符号统一。构造拉格朗日函数：

L(w, b, α) = (1/2)||w||^2 + Σ α_i [1 - y_i(w·x_i + b)]

其中α_i >= 0是拉格朗日乘子。这里有一个直觉上的理解：α_i就像是一个“惩罚系数”，当某个样本违反了约束，也就是1 - y_i(w·x_i + b) > 0的时候，这一项就会对L产生正的贡献，而我们的目标是最小化L，所以优化过程会倾向于让这些违反约束的项消失。

但这里有一个关键点：拉格朗日函数只是把约束“软性”地放进了目标里，它并没有强制约束必须满足。真正让约束生效的，是后面的对偶理论和KKT条件。

2.2 原始问题与对偶问题的关系

构造完拉格朗日函数之后，我们定义原始问题的拉格朗日对偶函数：

g(α) = min_{w,b} L(w, b, α)

注意这里是对w和b求最小值，得到的是一个只关于α的函数。然后对偶问题就是：

max g(α) s.t. α_i >= 0

这里有一个非常重要的定理：对于凸优化问题，如果满足Slater条件，那么原始问题和对偶问题的最优值是相等的。SVM的原始问题是一个凸二次规划，约束是线性的，Slater条件自然满足。所以我们可以放心地通过解对偶问题来得到原始问题的最优解。

这个定理的意义在于，它给了我们一个“曲线救国”的路径。原始问题不好解，但它的对偶问题可能好解。对于SVM来说，对偶问题恰好具有一个非常适合算法处理的结构。

2.3 从对偶函数到对偶问题的完整推导

现在我们来具体算一下g(α)。对L关于w和b求偏导，并令它们为零：

∂L/∂w = w - Σ α_i y_i x_i = 0 => w = Σ α_i y_i x_i ∂L/∂b = -Σ α_i y_i = 0 => Σ α_i y_i = 0

把这两个结果代回L，经过一番化简（中间过程省略，主要是展开和合并同类项），可以得到：

g(α) = Σ α_i - (1/2) ΣΣ α_i α_j y_i y_j (x_i · x_j)

于是对偶问题就变成了：

max Σ α_i - (1/2) ΣΣ α_i α_j y_i y_j (x_i · x_j) s.t. Σ α_i y_i = 0 α_i >= 0, i = 1,...,N

这个形式非常漂亮。目标函数里只有α，约束也只有一个等式约束和一堆非负约束。更重要的是，样本只以内积x_i · x_j的形式出现，这为后面引入核函数铺好了路。

2.4 一个容易踩的坑：符号方向

我第一次推导的时候，在符号上栽了跟头。原始问题是最小化，对偶问题是最大化，这两个方向很容易搞混。后来我总结了一个简单的记忆方法：原始问题的最小化对应拉格朗日函数的鞍点，对偶问题是在鞍点上先对w、b求最小，再对α求最大。

用数学语言说就是：

min_{w,b} max_{α>=0} L(w,b,α) = max_{α>=0} min_{w,b} L(w,b,α)

左边是原始问题，右边是对偶问题。这个等式成立的条件就是KKT条件。所以KKT条件不是凭空冒出来的，它是连接原始问题和对偶问题的桥梁。

注意：很多教程在推导的时候会跳过符号方向的解释，直接给结果。但如果你不理解为什么是最小最大换序，后面看KKT条件的时候会非常困惑。建议在这里多花十分钟，把鞍点的几何图像在脑子里过一遍。

3. KKT条件：SVM最优解的“交通规则”

3.1 KKT条件的完整形式

KKT条件是Karush-Kuhn-Tucker条件的简称，它是非线性规划最优解的必要条件。对于SVM的对偶问题，KKT条件包含以下几部分：

平稳性条件：

∂L/∂w = 0 => w = Σ α_i y_i x_i ∂L/∂b = 0 => Σ α_i y_i = 0

原始可行性条件：

1 - y_i(w·x_i + b) <= 0, 对所有i

对偶可行性条件：

α_i >= 0, 对所有i

互补松弛条件：

α_i [1 - y_i(w·x_i + b)] = 0, 对所有i

这四组条件里，最重要的是互补松弛条件。它告诉我们一个非常深刻的结论：对于每一个样本，要么α_i = 0，要么1 - y_i(w·x_i + b) = 0，两者必居其一。

3.2 互补松弛条件的几何意义

互补松弛条件的几何意义非常直观。如果一个样本点满足1 - y_i(w·x_i + b) < 0，也就是说它被正确分类并且稳稳地落在间隔带外面，那么对应的α_i必须等于0。这些样本对最终的分类超平面没有任何影响。

反过来，如果α_i > 0，那么这个样本必须满足1 - y_i(w·x_i + b) = 0，也就是说它恰好落在间隔边界上。这些样本就是支持向量。

这个结论解释了SVM为什么具有稀疏性：最终模型只依赖于少数几个支持向量，大部分训练样本在训练完成后就可以丢掉了。我在实际项目里验证过这一点，一个几万样本的数据集训练完之后，支持向量通常只有几百个，有时候甚至更少。

3.3 用KKT条件反推w和b

KKT条件不仅告诉我们最优解的性质，还给了我们计算w和b的方法。

w的计算很直接，直接用平稳性条件：

w = Σ α_i y_i x_i

但b的计算稍微麻烦一点。因为b没有出现在对偶问题的目标函数里，我们不能直接通过求导得到它。这时候就要用互补松弛条件：选取一个支持向量，也就是α_i > 0的样本，它满足：

y_i(w·x_i + b) = 1

把w代入，解出b：

b = y_i - Σ α_j y_j (x_j · x_i)

理论上，用任何一个支持向量算出来的b都应该是一样的。但在实际计算中，由于数值误差，不同支持向量算出来的b可能会有微小差异。常见的做法是对所有支持向量算出的b取平均值，这样更稳定。

实操心得：我在写代码的时候，一开始只取第一个支持向量算b，结果发现每次运行结果都有细微差别。后来改成对所有支持向量取平均，模型的稳定性明显提升。这个细节在教科书里往往一笔带过，但在工程实现里很重要。

3.4 KKT条件与对偶互补的直观理解

我习惯用一个类比来理解KKT条件：把SVM的训练过程想象成一场拔河比赛。每个样本点都是一个参赛者，它们通过α_i这个“力气”来拉扯分类超平面。

那些远离边界的样本，它们的位置已经很安全了，不需要出力，所以α_i = 0。而那些刚好在边界上的样本，它们处于“临界状态”，必须使出全力来维持边界的位置，所以α_i > 0。

互补松弛条件说的就是：不出力的样本不关键，关键的样本必须出力。这个直觉在调试模型的时候很有用。如果你发现模型的支持向量特别多，那可能意味着数据本身很难分，或者参数设置有问题。

4. 软间隔SVM：给模型一点“容错空间”

4.1 松弛变量的引入与解释

硬间隔SVM要求所有样本都满足y_i(w·x_i + b) >= 1，这个条件太严格了。软间隔SVM的做法是给每个样本引入一个松弛变量ξ_i >= 0，把约束放宽成：

y_i(w·x_i + b) >= 1 - ξ_i

当ξ_i = 0的时候，样本满足硬间隔约束；当0 < ξ_i < 1的时候，样本落在间隔带内部但被正确分类；当ξ_i >= 1的时候，样本被错误分类。

松弛变量的引入，相当于允许模型在某些样本上“犯错”，但犯错的代价要体现在目标函数里。于是原始问题变成了：

min (1/2)||w||^2 + C Σ ξ_i s.t. y_i(w·x_i + b) >= 1 - ξ_i ξ_i >= 0, i = 1,...,N

这里的C是一个超参数，控制“最大化间隔”和“最小化分类错误”之间的权衡。C越大，模型越不能容忍错误，越接近硬间隔；C越小，模型越宽容，间隔越大但可能欠拟合。

4.2 软间隔的对偶问题推导

软间隔SVM的对偶问题推导过程和硬间隔类似，只是多了一个关于ξ的约束。构造拉格朗日函数：

L(w,b,ξ,α,β) = (1/2)||w||^2 + C Σ ξ_i + Σ α_i [1 - ξ_i - y_i(w·x_i + b)] - Σ β_i ξ_i

其中α_i >= 0和β_i >= 0都是拉格朗日乘子。对w、b、ξ分别求偏导并令为零：

∂L/∂w = 0 => w = Σ α_i y_i x_i ∂L/∂b = 0 => Σ α_i y_i = 0 ∂L/∂ξ_i = 0 => C - α_i - β_i = 0 => α_i = C - β_i

因为β_i >= 0，所以α_i <= C。结合α_i >= 0，我们得到：

0 <= α_i <= C

这个约束叫做盒约束，它是软间隔SVM对偶问题区别于硬间隔的关键。最终的对偶问题形式是：

max Σ α_i - (1/2) ΣΣ α_i α_j y_i y_j (x_i · x_j) s.t. Σ α_i y_i = 0 0 <= α_i <= C, i = 1,...,N

可以看到，软间隔的对偶问题只比硬间隔多了一个上界C，其他形式完全一样。这个改动虽然小，但带来的影响是巨大的：它让SVM可以处理线性不可分的数据，也让模型对噪声有了鲁棒性。

4.3 软间隔下的KKT条件与支持向量分类

软间隔SVM的KKT条件中，互补松弛条件变成了两组：

α_i [1 - ξ_i - y_i(w·x_i + b)] = 0 β_i ξ_i = 0

结合α_i = C - β_i，我们可以把支持向量分成三类：

这个分类表是我在实际调参时最常用的工具。当你发现模型效果不好的时候，可以统计一下这三类支持向量的比例。如果错误支持向量太多，说明C太小或者数据本身噪声太大；如果边界支持向量太少，说明C太大，模型可能过拟合。

4.4 参数C的选择经验

C是软间隔SVM最重要的超参数。我在多个项目里调过这个参数，总结了一些经验。

C的取值通常在0.001到1000之间，具体取决于数据的尺度和噪声水平。如果特征已经标准化到均值0方差1，C的典型搜索范围是10^-3到10^3，按10倍步长搜索。

一个实用的技巧是：先用交叉验证确定C的大致范围，再在这个范围附近做精细搜索。我一般会先用5折交叉验证跑一遍对数尺度的网格搜索，找到最优C的量级，然后在这个量级附近用更细的步长再搜一次。

还有一个经验是：C和核函数的参数γ需要联合调优。如果用的是RBF核，C和γ的联合搜索空间是一个二维网格。我通常会用指数网格，C取2^-5到2^15，γ取2^-15到2^3，然后用交叉验证找最优组合。这个搜索空间看起来很大，但实际上用坐标下降或者随机搜索可以很快收敛。

注意：不要盲目相信默认参数。sklearn的SVC默认C=1.0，这个值在很多数据集上都不是最优的。我见过太多人直接用默认参数跑模型，然后抱怨SVM效果不好。花点时间调参，效果提升往往比换模型更明显。

5. 从对偶解到预测函数：完整实现流程

5.1 训练阶段的完整步骤

把上面的理论串起来，软间隔SVM的完整训练流程可以分成以下几步：

第一步：数据预处理。对特征做标准化，让每个特征的均值为0、方差为1。这一步对SVM特别重要，因为SVM是基于距离的算法，如果特征尺度差异很大，距离计算会被大尺度特征主导。

第二步：选择核函数和参数。常用的核函数有线性核、多项式核、RBF核和Sigmoid核。RBF核是默认选择，因为它可以逼近任意非线性函数，而且只有一个参数γ需要调。

第三步：求解对偶问题。用SMO算法或者坐标下降法求解对偶问题，得到最优的α向量。

第四步：计算w和b。用支持向量计算w = Σ α_i y_i x_i，用边界支持向量计算b并取平均。

第五步：保存支持向量和对应的α、y值。预测的时候只需要这些信息，不需要保留全部训练数据。

5.2 预测阶段的实现细节

预测的时候，对于一个新的样本x，计算决策函数：

f(x) = Σ α_i y_i K(x_i, x) + b

其中求和只对支持向量进行。如果f(x) > 0，预测为正类；如果f(x) < 0，预测为负类。

这里有一个实现上的细节：核函数的计算是预测阶段的主要开销。如果支持向量有几百个，每次预测都要算几百次核函数。在实时预测场景下，这个开销可能成为瓶颈。我做过一个优化，把支持向量的核函数值预先算好缓存起来，对于线性核可以直接用w·x + b的形式，速度能提升一个数量级。

5.3 一个完整的Python实现示例

下面是我自己写的一个简化版软间隔SVM实现，用SMO算法求解。代码不长，但包含了上面讨论的所有关键步骤。

import numpy as np class SoftMarginSVM: def __init__(self, C=1.0, kernel='rbf', gamma=1.0, tol=1e-3, max_iter=100): self.C = C self.kernel = kernel self.gamma = gamma self.tol = tol self.max_iter = max_iter self.alpha = None self.b = None self.X = None self.y = None self.support_vectors = None def _kernel_func(self, x1, x2): if self.kernel == 'linear': return np.dot(x1, x2) elif self.kernel == 'rbf': diff = x1 - x2 return np.exp(-self.gamma * np.dot(diff, diff)) else: raise ValueError(f"Unknown kernel: {self.kernel}") def _compute_kernel_matrix(self, X): n = X.shape[0] K = np.zeros((n, n)) for i in range(n): for j in range(n): K[i, j] = self._kernel_func(X[i], X[j]) return K def fit(self, X, y): n, d = X.shape self.X = X self.y = y self.alpha = np.zeros(n) self.b = 0.0 K = self._compute_kernel_matrix(X) for iteration in range(self.max_iter): alpha_prev = self.alpha.copy() for i in range(n): # 计算误差 f_i = np.sum(self.alpha * y * K[:, i]) + self.b E_i = f_i - y[i] # 选择第二个变量j if (y[i] * E_i < -self.tol and self.alpha[i] < self.C) or \ (y[i] * E_i > self.tol and self.alpha[i] > 0): # 选择使|E_i - E_j|最大的j E = np.array([np.sum(self.alpha * y * K[:, k]) + self.b - y[k] for k in range(n)]) j = np.argmax(np.abs(E - E_i)) if j == i: continue # 计算上下界 if y[i] != y[j]: L = max(0, self.alpha[j] - self.alpha[i]) H = min(self.C, self.C + self.alpha[j] - self.alpha[i]) else: L = max(0, self.alpha[i] + self.alpha[j] - self.C) H = min(self.C, self.alpha[i] + self.alpha[j]) if L == H: continue # 计算eta eta = 2 * K[i, j] - K[i, i] - K[j, j] if eta >= 0: continue # 更新alpha_j alpha_j_new = self.alpha[j] - y[j] * (E_i - E[j]) / eta alpha_j_new = np.clip(alpha_j_new, L, H) if abs(alpha_j_new - self.alpha[j]) < 1e-5: continue # 更新alpha_i alpha_i_new = self.alpha[i] + y[i] * y[j] * (self.alpha[j] - alpha_j_new) # 更新b b1 = self.b - E_i - y[i] * (alpha_i_new - self.alpha[i]) * K[i, i] \ - y[j] * (alpha_j_new - self.alpha[j]) * K[i, j] b2 = self.b - E[j] - y[i] * (alpha_i_new - self.alpha[i]) * K[i, j] \ - y[j] * (alpha_j_new - self.alpha[j]) * K[j, j] if 0 < alpha_i_new < self.C: self.b = b1 elif 0 < alpha_j_new < self.C: self.b = b2 else: self.b = (b1 + b2) / 2 self.alpha[i] = alpha_i_new self.alpha[j] = alpha_j_new # 检查收敛 if np.allclose(self.alpha, alpha_prev, atol=1e-5): break # 提取支持向量 sv_mask = self.alpha > 1e-5 self.support_vectors = X[sv_mask] self.sv_alpha = self.alpha[sv_mask] self.sv_y = y[sv_mask] return self def predict(self, X): predictions = [] for x in X: result = self.b for alpha_i, y_i, sv in zip(self.sv_alpha, self.sv_y, self.support_vectors): result += alpha_i * y_i * self._kernel_func(sv, x) predictions.append(np.sign(result)) return np.array(predictions)

这段代码虽然简化了很多工程细节，但核心逻辑是完整的。你可以直接拿它跑一些小规模数据集，观察α的分布和支持向量的数量。

5.4 用sklearn验证实现正确性

自己写的实现对不对，最直接的方法是和sklearn的结果对比。下面是一个对比脚本：

from sklearn.svm import SVC from sklearn.datasets import make_classification from sklearn.preprocessing import StandardScaler from sklearn.model_selection import train_test_split # 生成数据 X, y = make_classification(n_samples=200, n_features=2, n_redundant=0, n_clusters_per_class=1, flip_y=0.1, random_state=42) y = np.where(y == 0, -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.3, random_state=42) # 自己的实现 my_svm = SoftMarginSVM(C=1.0, kernel='rbf', gamma=0.5) my_svm.fit(X_train, y_train) my_pred = my_svm.predict(X_test) # sklearn的实现 sk_svm = SVC(C=1.0, kernel='rbf', gamma=0.5) sk_svm.fit(X_train, y_train) sk_pred = sk_svm.predict(X_test) print(f"我的实现准确率: {np.mean(my_pred == y_test):.4f}") print(f"sklearn准确率: {np.mean(sk_pred == y_test):.4f}") print(f"支持向量数量对比: 我的={len(my_svm.support_vectors)}, sklearn={len(sk_svm.support_vectors_)}")

跑下来你会发现，两者的准确率通常很接近，但支持向量的数量可能有差异。这是因为SMO算法的收敛条件和数值精度不同。只要准确率接近，就说明实现是正确的。

6. 常见问题与排查技巧实录

6.1 训练不收敛怎么办

SVM训练不收敛是最常见的问题之一。可能的原因和排查方法如下：

我遇到最多的情况是数据没有标准化。SVM对特征尺度非常敏感，如果有一个特征的取值范围是0到10000，另一个是0到1，那么距离计算会被第一个特征完全主导。标准化之后，问题通常就解决了。

6.2 如何判断模型是否过拟合

过拟合的判断标准是：训练集准确率很高，但测试集准确率明显偏低。对于SVM，过拟合通常和C太大、γ太大有关。

一个实用的排查流程是：先固定γ，画一条C从大到小的学习曲线，观察训练集和测试集准确率的变化。如果C很大时训练集准确率接近100%但测试集很低，说明过拟合了，需要减小C。然后固定C，用同样的方法调γ。

我一般会画一个热力图，横轴是log(C)，纵轴是log(γ)，颜色表示交叉验证准确率。这样一眼就能看出最优参数在哪个区域。

6.3 核函数选择的经验法则

核函数的选择没有绝对的标准，但有一些经验法则可以参考：

• 线性核：特征维度很高（比如文本分类的TF-IDF特征），样本量很大时优先考虑。线性核训练快，不容易过拟合。
• RBF核：特征维度不高，样本量中等，数据非线性可分时首选。RBF核是通用的，但需要调γ。
• 多项式核：数据有明确的多项式关系时使用，比如图像处理中的某些特征。但多项式核的参数多，调参麻烦，实际项目中用得少。
• Sigmoid核：某些神经网络相关的场景可以用，但它的核矩阵不一定正定，理论保证不如前几个。

我的习惯是：先试线性核，如果效果不好再试RBF核。大部分情况下，RBF核都能给出不错的结果。

6.4 处理类别不平衡的技巧

实际项目中经常遇到类别不平衡的问题，比如正类样本占95%，负类只占5%。这时候标准的SVM会倾向于把所有样本都预测为正类，因为这样错误率最低。

解决方法有两种。第一种是调整类权重，给少数类更高的惩罚系数。在sklearn里可以通过class_weight='balanced'自动调整。第二种是对少数类过采样或对多数类欠采样，让两类样本数量接近。

我通常先用class_weight='balanced'试试，如果效果不够好再考虑采样方法。需要注意的是，采样会改变数据的原始分布，可能引入新的偏差，所以采样后要用交叉验证仔细评估。

6.5 大规模数据下的优化策略

当样本量超过几万的时候，标准SVM的训练时间会变得很长。这时候可以考虑以下策略：

使用线性核。线性核的SVM可以用liblinear或SGDClassifier来训练，速度比核SVM快很多。如果数据本身接近线性可分，线性核的效果不一定比RBF核差。

使用随机梯度下降。SGDClassifier支持hinge损失和L2正则，本质上就是一个线性SVM。它通过每次只用一个或一小批样本来更新参数，训练速度极快，适合大规模数据。

使用近似核方法。Nystroem方法可以用一组基向量来近似核矩阵，把核SVM转化成线性SVM来解。这样既保留了核方法的非线性能力，又获得了线性方法的效率。

我在一个几十万样本的项目里用过Nystroem加线性SVM的方案，训练时间从几个小时降到了几分钟，准确率只下降了不到一个百分点。这个 trade-off 在工程上是非常划算的。

6.6 一个容易被忽略的细节：偏置项b的处理

很多教程在推导对偶问题的时候，会把b消掉，然后在预测的时候用支持向量重新算b。这个做法在理论上是正确的，但在实现的时候有一个坑：如果支持向量的数量很少，b的估计会很不稳定。

我遇到过一次，模型只有一个支持向量，算出来的b偏差很大，导致整个模型的预测都偏了。后来我的做法是：如果支持向量少于10个，就用所有支持向量算b然后取平均；如果支持向量很多，就用边界支持向量算b取平均。这样更稳健。

实操心得：在写预测函数的时候，一定要把b的计算和w的计算分开处理。w可以用所有支持向量算，但b最好只用边界支持向量算。这个细节在sklearn的源码里也是这么处理的。

7. 从理论到工程：我的几点体会

拉格朗日对偶和KKT条件这套东西，第一次看的时候会觉得抽象，但真正写代码实现一遍之后，理解会深刻很多。我自己的经验是，不要试图一次性把所有数学细节都搞懂，而是先抓住几个核心结论：对偶问题把约束变成了盒约束，KKT条件告诉我们只有支持向量才重要，软间隔通过松弛变量给了模型容错空间。

这几个结论在实际调参和排查问题的时候，比完整的数学推导更有用。比如当你发现模型效果不好的时候，第一反应应该是去看支持向量的分布，而不是去重新推导对偶问题。支持向量的数量和位置，直接反映了模型对数据的拟合情况。

另外，SVM虽然是一个比较“老”的算法，但在小样本、高维度的场景下，它依然是非常强大的工具。我在文本分类和生物特征识别项目里，多次用SVM取得了比深度学习更好的效果，尤其是在样本量只有几百到几千的时候。所以不要因为深度学习火就忽视SVM，它值得你花时间深入理解。

最后分享一个我常用的调试技巧：把训练好的SVM的支持向量在二维平面上画出来，用不同颜色标记边界支持向量、间隔内支持向量和错误支持向量。这个图能直观地告诉你模型学到了什么，哪里出了问题。很多时候，看一眼图比看一堆指标更有用。