ML: SVM

• Support Vector Machines
• 本文使用最流行的一种实现方法完成 SVM，该算法为序列最小优化（Sequential Minimal Optimization, SMO）算法
• 优点：泛化错误率低，计算开销不大，结果易解释
• 缺点：对参数调节和核函数的选择敏感，原始分类器不加修改仅适用于处理二类问题
• 适用数据类型：数值型和标称型数据

1. 基于最大间隔分隔数据

• 超平面（hyperplane）：对于二维数据，需要用一条直线来分隔，三维数据用一个平面来分隔，以此类推，N 维数据需要 N-1 维的对象来分隔，该对象为超平面
• 间隔（margin）：间隔指离分隔超平面最近的点与分隔面的距离，该距离越大，分类器越好，或者说越健壮
• 支持向量（support vector）：即离分隔超平面最近的那些点

2. 寻找最大间隔

• 假设分隔超平面为 ${\mathbf{w}}^T\mathbf{x}+b=0$，则点 $\mathbf{A}$ 到该超平面的距离为$$\frac{|{\mathbf{w}}^T\mathbf{A}+b|}{||\mathbf{w}||}$$

2.1分类器求解的优化问题：

1. 超平面首先要满足能够正确分类，即：
   $$\{\begin{array}{l}{\mathbf{w}}^T{\mathbf{x}}_{\mathbf{i}}+b>0y_i=1\\ {\mathbf{w}}^T{\mathbf{x}}_{\mathbf{i}}+b<0y_i=-1\end{array}$$
2. 其次，我们要找的超平面，应该是间隔区域的中轴线，假设支持向量与超平面的距离为 d，则：
   $$\{\begin{array}{l}\frac{{\mathbf{w}}^T{\mathbf{x}}_{\mathbf{i}}+b}{||\mathbf{w}||}\ge d\forall y_i=1\\ \frac{{\mathbf{w}}^T{\mathbf{x}}_{\mathbf{i}}+b}{||\mathbf{w}||}\le -d\forall y_i=-1\end{array}$$
   两边除以 d，得到：
   $$\{\begin{array}{l}{\mathbf{w}}_d^T{\mathbf{x}}_{\mathbf{i}}+b_d\ge 1\forall y_i=1\\ {\mathbf{w}}_d^T{\mathbf{x}}_{\mathbf{i}}+b_d\le -1\forall y_i=-1\end{array}$$
   其中 $${\mathbf{w}}_d^T=\frac{{\mathbf{w}}^T}{||\mathbf{w}||d},b_d=\frac{b}{||\mathbf{w}||d}$$
   其实是在原 $\mathbf{w}$ 和 $b$ 的基础上除以了一个标量，因此 ${\mathbf{w}}_d^T{\mathbf{x}}_{\mathbf{i}}+b_d=0$ 和 ${\mathbf{w}}^T{\mathbf{x}}_{\mathbf{i}}+b=0$ 为同一个平面，因此可以直接表示为：
   $$\{\begin{array}{l}{\mathbf{w}}^T{\mathbf{x}}_{\mathbf{i}}+b\ge 1\forall y_i=1\\ {\mathbf{w}}^T{\mathbf{x}}_{\mathbf{i}}+b\le -1\forall y_i=-1\end{array}$$
3. 假设我们的输出类别分别为 -1 和 +1，则上式可以表示为：
   $$y_i({\mathbf{w}}^T{\mathbf{x}}_{\mathbf{i}}+b)\ge 1\forall {\mathbf{x}}_{\mathbf{i}}$$
4. 对于我们的支持向量（离超平面最近的点），有：$$|{\mathbf{w}}^T{\mathbf{x}}_{\mathbf{i}}+b|=1$$
   所以我们要最大化的距离：$$d=\frac{1}{||\mathbf{w}||}$$
   即求 $||\mathbf{w}||$ 的最小值，为了方便求导，可等效于求
   $$\begin{array}{l}min\frac{1}{2}||\mathbf{w}|{|}^2\\ s.t{y}_i({\mathbf{w}}^T{\mathbf{x}}_{\mathbf{i}}+b)\ge 1i=1,2,..,n\end{array}$$
   以上即为支持向量机的基本数学模型

2.2 拉格朗日乘子法

1. 上述问题为具有约束条件的最小化问题，且约束条件为不等式，对于这种问题，一般采用拉格朗日乘子法求解，其基本思想为构造一个函数，使得该函数在可行解区域内与原目标函数完全一致，而在可行解区域外的数值非常大，甚至是无穷大，这样的话就将其转换为与原问题等价的无约束条件最小化问题。构造的函数如下：
   $$L(x,\alpha )=f(x)+\alpha g(x)$$
   其中 $f(x)$ 为原函数，$g(x)$ 为满足约束条件的函数，约束条件为 $g(x)\le 0$，对于支持向量机的基本数学模型，构造函数如下：
   $$L(\mathbf{w},\alpha ,b)=\frac{1}{2}||\mathbf{w}|{|}^2-\sum _{i=1}^n{\alpha }_i(y_i({\mathbf{w}}^T{\mathbf{x}}_{\mathbf{i}}+b)-1)$$
   其中 ${\alpha }_i\ge 0$。设：
   $$\theta (\mathbf{w})=\underset{{\alpha }_i\ge 0}{\max }L(\mathbf{w},\alpha ,b)$$
   当 $y_i({\mathbf{w}}^T{\mathbf{x}}_{\mathbf{i}}+b)\ge 1$ 时，显然该函数等于原函数，当$y_i({\mathbf{w}}^T{\mathbf{x}}_{\mathbf{i}}+b)\le 1$ 时，我们将 $\alpha$ 设置为无穷大，那么该函数值也为无穷大，于是就满足了上面提到的转换为无约束最小化问题的条件。于是我们的问题转换为求解：
   $$\underset{\mathbf{w},b}{\min }\underset{{\alpha }_i\ge 0}{\max }L(\mathbf{w},\alpha ,b)=p\ast$$
2. 上式求解起来比较困难，因为首先要面对关于 $\mathbf{w},b$ 的方程，而 ${\alpha }_i$ 又是不等式约束。于是我们利用拉格朗日函数的对偶性，将最小和最大的位置交换一下：
   $$\underset{{\alpha }_i\ge 0}{\max }\underset{\mathbf{w},b}{\min }L(\mathbf{w},\alpha ,b)=d\ast$$
   满足 $p\ast =d\ast$ 的条件一是求取最小值的函数是凸函数（这一点很明显满足），二是满足 KKT 条件，全称是 Karush-Kuhn-Tucker 条件，它表示我们的最优值必须满足：
   • 经过拉格朗日函数处理之后的新目标函数 $L(\mathbf{w},b,\alpha )$ 对 $\mathbf{w},b$ 求导为零；
   • $h(x)=0$（$h(x)$ 为等式约束，在我们的问题中显然满足该条件）；
   • $\alpha \ast g(x)=0$；
     针对第一个条件，对 $\mathbf{w},b$ 分别求偏导：
     $$\frac{\partial L}{\partial \mathbf{w}}=0⟺\mathbf{w}=\sum _{i=1}^n{\alpha }_i{y}_i{\mathbf{x}}_i$$
     $$\frac{\partial L}{\partial b}=0⟺\sum _{i=1}^n{\alpha }_i{y}_i=0$$
     代回原式得到：
     $$L(\mathbf{w},b,\alpha )=\sum _{i=1}^n{\alpha }_i-\frac{1}{2}\sum _{i,j=1}^n({\alpha }_i{\alpha }_j{y}_i{y}_j{\mathbf{x}}_i^T{\mathbf{x}}_j)$$
     于是上述问题转换为：
     $$\underset{\alpha }{\max }\left[\sum _{i=1}^n{\alpha }_i-\frac{1}{2}\sum _{i,j=1}^n({\alpha }_i{\alpha }_j{y}_i{y}_j{\mathbf{x}}_i^T{\mathbf{x}}_j)\right]$$$$s.t.{\alpha }_i\ge 0,i=1,2,3,...,n$$$$\sum _{i=1}^n{\alpha }_i\cdot y_i=0$$

3. SMO 高效优化算法

3.1 Platt 的 SMO 算法

• 将大优化问题分解为多个小优化问题来求解小优化问题往往很容易求解，并且对它们进行顺序求解的结果与将它们作为整体来求解的结果完全一致的。在结果完全相同的同时，SMO算法的求解时间短很多。
• SMO算法的目标是求出一系列 $\alpha$ 和 b，一旦求出了这些 $\alpha$，就很容易计算出权重向量 $\mathbf{w}$ 并得到分隔超平面。
• SMO算法的工作原理是：每次循环中选择两个 $\alpha$ 进行优化处理。一旦找到了一对合适的 $\alpha$ ，那么就增大其中一个同时减小另一个。这里所谓的“合适”就是指两个 $\alpha$ 必须符合以下两个条件，条件之一就是两个 $\alpha$ 必须要在间隔边界之外，而且第二个条件则是这两个 $\alpha$ 还没有进行过区间化处理或者不在边界上。
• 令$$u={\mathbf{w}}^T\mathbf{x}+b=\sum _{i=1}^n{\alpha }_i{y}_i{\mathbf{x}}_i^T\mathbf{x}+b$$
  我们的目标函数：
  $$\underset{\alpha }{\max }\left[\sum _{i=1}^n{\alpha }_i-\frac{1}{2}\sum _{i,j=1}^n({\alpha }_i{\alpha }_j{y}_i{y}_j{\mathbf{x}}_i^T{\mathbf{x}}_j)\right]$$$$s.t.{\alpha }_i\ge 0,i=1,2,3,...,n$$$$\sum _{i=1}^n{\alpha }_i\cdot y_i=0$$
  变换为求最小值：
  $$\underset{\alpha }{\min }\left[\frac{1}{2}\sum _{i=1}^n\sum _{j=1}^n({\alpha }_i{\alpha }_j{y}_i{y}_j{\mathbf{x}}_i^T{\mathbf{x}}_j)-\sum _{i=1}^n{\alpha }_i\right]$$$$s.t.{\alpha }_i\ge 0,i=1,2,3,...,n$$$$\sum _{i=1}^n{\alpha }_i\cdot y_i=0$$
  实际上我们的数据并非完全线性可分，所以可以引入一个松弛变量（slack variable），来允许有些数据点可以处于分隔面的错误一侧，此时的约束条件变为：
  $$s.t.C\ge {\alpha }_i\ge 0,i=1,2,3,...,n$$$$\sum _{i=1}^n{\alpha }_i\cdot y_i=0$$
  根据 KKT条件以及松弛变量定义（具体可参考知乎，尤其是第三个理解起来比较困难，个人任务该问答比较有帮助）可以得出其中 ${\alpha }_i$ 取值的意义为：
  $${\alpha }_i=0⟹y_i{u}_i\ge 1⟺该点在边界内部或边界上$$$$0<{\alpha }_i<C⟹y_i{u}_i=1⟺该点在边界上$$$${\alpha }_i=C⟹y_i{u}_i\le 1⟺该点在边界外或边界上(允许错分的样本点)$$
  当 ${\alpha }_i$ 不满足上面的条件时，需要更新 ${\alpha }_i$，与此同时它还应满足第二个约束条件 ${\sum }_{i=1}^n{\alpha }_i\cdot y_i=0$，因此我们同时更新两个 $\alpha$ 值，因为只有成对更新，才能保证更新之后的值仍然满足和为 0 的约束，假设我们选择的两个乘子为 ${\alpha }_1$ 和 ${\alpha }_2$：
  $${\alpha }_1^{new}{y}_1+{\alpha }_2^{new}{y}_2={\alpha }_1^{old}{y}_1+{\alpha }_2^{old}{y}_2=\zeta$$
  其中 $\zeta$ 为常数，假设：$$L\le {\alpha }_2^{new}\le H$$
  由：$$C\ge {\alpha }_i\ge 0,i=1,2,3,...,n$$$${\alpha }_1^{new}{y}_1+{\alpha }_2^{new}{y}_2={\alpha }_1^{old}{y}_1+{\alpha }_2^{old}{y}_2=\zeta$$
  当 $y_1$ 和 $y_2$ 不同时：$${\alpha }_1^{new}-{\alpha }_2^{new}={\alpha }_1^{old}-{\alpha }_2^{old}=\zeta$$
  当 $y_1$ 和 $y_2$ 相同时：$${\alpha }_1^{new}+{\alpha }_2^{new}={\alpha }_1^{old}+{\alpha }_2^{old}=\zeta$$
  得到$$\{\begin{array}{l}H=max(0,-\zeta ),L=min(C,C-\zeta )y_1\ne y_2\\ H=max(0,\zeta -C),L=min(C,\zeta )y_1=y_2\end{array}$$
  这个界限就是编程的时候需要用到的。已经确定了边界，接下来，就是推导迭代式，用于更新 α值。
  对于目标函数，将 ${\alpha }_1$ 和 ${\alpha }_2$ 提取出来：
  $$W({\alpha }_2)=\sum _{i=1}^n{\alpha }_i-\frac{1}{2}\sum _{i=1}^n\sum _{j=1}^n({\alpha }_i{\alpha }_j{y}_i{y}_j{\mathbf{x}}_i^T{\mathbf{x}}_j)$$$$={\alpha }_1+{\alpha }_2+\sum _{i=3}^n{\alpha }_i-\frac{1}{2}\sum _{i=1}^n\left[\sum _{j=1}^2({\alpha }_i{\alpha }_j{y}_i{y}_j{\mathbf{x}}_i^T{\mathbf{x}}_j)+\sum _{j=3}^n({\alpha }_i{\alpha }_j{y}_i{y}_j{\mathbf{x}}_i^T{\mathbf{x}}_j)\right]$$$$={\alpha }_1+{\alpha }_2+\sum _{i=3}^n{\alpha }_i-\frac{1}{2}\sum _{i=1}^2\left[\sum _{j=1}^2({\alpha }_i{\alpha }_j{y}_i{y}_j{\mathbf{x}}_i^T{\mathbf{x}}_j)+\sum _{j=3}^n({\alpha }_i{\alpha }_j{y}_i{y}_j{\mathbf{x}}_i^T{\mathbf{x}}_j)\right]$$$$-\frac{1}{2}\sum _{i=3}^n\left[\sum _{j=1}^2({\alpha }_i{\alpha }_j{y}_i{y}_j{\mathbf{x}}_i^T{\mathbf{x}}_j)+\sum _{j=3}^n({\alpha }_i{\alpha }_j{y}_i{y}_j{\mathbf{x}}_i^T{\mathbf{x}}_j)\right]$$$$={\alpha }_1+{\alpha }_2+\sum _{i=3}^n{\alpha }_i-\frac{1}{2}\sum _{i=1}^2\sum _{j=1}^2({\alpha }_i{\alpha }_j{y}_i{y}_j{\mathbf{x}}_i^T{\mathbf{x}}_j)-\sum _{i=1}^2\sum _{j=3}^n({\alpha }_i{\alpha }_j{y}_i{y}_j{\mathbf{x}}_i^T{\mathbf{x}}_j)$$$$-\frac{1}{2}\sum _{i=3}^n\sum _{j=3}^n({\alpha }_i{\alpha }_j{y}_i{y}_j{\mathbf{x}}_i^T{\mathbf{x}}_j)$$$$={\alpha }_1+{\alpha }_2-\frac{1}{2}({\alpha }_1^2{\mathbf{x}}_1^T{\mathbf{x}}_1)-\frac{1}{2}({\alpha }_2^2{\mathbf{x}}_2^T{\mathbf{x}}_2)-{\alpha }_1{\alpha }_2{y}_1{y}_2{\mathbf{x}}_1^T{\mathbf{x}}_2-{\alpha }_1{y}_1\sum _{j=3}^n({\alpha }_j{y}_j{\mathbf{x}}_1^T{\mathbf{x}}_j)$$$$-{\alpha }_2{y}_2\sum _{j=3}^n({\alpha }_j{y}_j{\mathbf{x}}_2^T{\mathbf{x}}_j)-\sum _{i=3}^n{\alpha }_i-\frac{1}{2}\sum _{i=3}^n\sum _{j=3}^n({\alpha }_i{\alpha }_j{y}_i{y}_j{\mathbf{x}}_i^T{\mathbf{x}}_j)$$
  定义：
  $$f({\mathbf{x}}_i)=\sum _{j=1}^n{\alpha }_j{y}_j{\mathbf{x}}_i^T{\mathbf{x}}_j+b$$$$v_i=\sum _{j=3}^n{\alpha }_j{y}_j{\mathbf{x}}_i^T{\mathbf{x}}_j=f({\mathbf{x}}_i)-\sum _{j=1}^2{\alpha }_j{y}_j{\mathbf{x}}_i^T{\mathbf{x}}_j-b$$
  则目标函数为：
  $$W({\alpha }_2)={\alpha }_1+{\alpha }_2-\frac{1}{2}({\alpha }_1^2{\mathbf{x}}_1^T{\mathbf{x}}_1)-\frac{1}{2}({\alpha }_2^2{\mathbf{x}}_2^T{\mathbf{x}}_2)-{\alpha }_1{\alpha }_2{y}_1{y}_2{\mathbf{x}}_1^T{\mathbf{x}}_2-{\alpha }_1{y}_1{v}_1-{\alpha }_2{y}_2{v}_2+constant$$
  由于$$\sum _{i=1}^n{\alpha }_i\cdot y_i=0$$
  所以$${\alpha }_1{y}_1+{\alpha }_2{y}_2=-\sum _{i=3}^n{\alpha }_i{y}_i=B$$同时乘以 $y_1$：
  $${\alpha }_1=B{y}_1-y_1{y}_2{\alpha }_2=\gamma -s{\alpha }_2$$
  代入目标函数：
  $$W({\alpha }_2)=\gamma -s{\alpha }_2+{\alpha }_2-\frac{1}{2}(\gamma -s{\alpha }_2{)}^2{\mathbf{x}}_1^T{\mathbf{x}}_1-\frac{1}{2}({\alpha }_2^2{\mathbf{x}}_2^T{\mathbf{x}}_2)-(\gamma -s{\alpha }_2){\alpha }_{2}s{\mathbf{x}}_1^T{\mathbf{x}}_2$$$$-(\gamma -s{\alpha }_2)y_1{v}_1-{\alpha }_2{y}_2{v}_2+constant$$
  对 ${\alpha }_2$求导：
  $$\frac{\partial W({\alpha }_2)}{{\alpha }_2}=-s+1+\gamma s{\mathbf{x}}_1^T{\mathbf{x}}_1-{\alpha }_2{\mathbf{x}}_1^T{\mathbf{x}}_1-{\alpha }_2{\mathbf{x}}_2^T{\mathbf{x}}_2-\gamma s{\mathbf{x}}_1^T{\mathbf{x}}_2+2{\alpha }_2{\mathbf{x}}_1^T{\mathbf{x}}_2+y_2{v}_1-y_2{v}_2=0$$
  将 $s=y_1{y}_2$ 代入上式，得到：
  $${\alpha }_2^{new}=\frac{y_2[y_2-y_1+\gamma y_1({\mathbf{x}}_1^T{\mathbf{x}}_1-{\mathbf{x}}_1^T{\mathbf{x}}_2)+v_1-v_2]}{{\mathbf{x}}_1^T{\mathbf{x}}_1+{\mathbf{x}}_2^T{\mathbf{x}}_2-2{\mathbf{x}}_1^T{\mathbf{x}}_2}$$
  令：
  $$E_i=f(x_i)-y_i$$$$\eta ={\mathbf{x}}_1^T{\mathbf{x}}_1+{\mathbf{x}}_2^T{\mathbf{x}}_2-2{\mathbf{x}}_1^T{\mathbf{x}}_2$$
  $E_i$ 为误差项，$\eta$ 为学习速率
  已知：
  $$\gamma ={\alpha }_1^{old}+s{\alpha }_2^{old}$$$$v_i=\sum _{j=3}^n{\alpha }_j{y}_j{\mathbf{x}}_i^T{\mathbf{x}}_j=f({\mathbf{x}}_i)-\sum _{j=1}^2{\alpha }_j{y}_j{\mathbf{x}}_i^T{\mathbf{x}}_j-b$$
  代入化简最终得到：
  $${\alpha }_2^{new}={\alpha }_2^{old}+\frac{y_2(E_1-E_2)}{\eta }$$
  根据之前推导的 ${\alpha }_2$ 的范围，得到修剪后的 ${\alpha }_2$：
  $${\alpha }_2^{new,clipped}=\{\begin{array}{l}H,{\alpha }_2^{new}>H\\ {\alpha }_2^{new},L\le {\alpha }_2^{new}\le H\\ L,{\alpha }_2^{new}<L\end{array}$$
  对于 ${\alpha }_1$，由 ${\alpha }_1$ 和 ${\alpha }_2$ 的关系，可以得到：
  $${\alpha }_1^{new}={\alpha }_1^{old}+y_1{y}_2({\alpha }_2^{old}-{\alpha }_2^{new,clipped})$$
  由此我们得到了 $\alpha$ 的求解公式，接下来看常数 b，我们要根据 $\alpha$ 的取值范围，去更正 b 的值，使间隔最大化。当 ${\alpha }_1^{new}$ 在 0 和 C 之间的时候，根据 KKT 条件可知，这个点是支持向量上的点。因此，满足下列公式：
  $$y_1({\mathbf{w}}^T{\mathbf{x}}_1+b)=1$$
  公式两边同时乘以y1得(y1y1=1)：
  $${\mathbf{w}}^T{\mathbf{x}}_1+b=y_1$$即$$\sum _{i=1}^n{\alpha }_i{y}_i{\mathbf{x}}_i^T{\mathbf{x}}_1+b=y_1$$$$⟹b_1^{new}=y_1-{\alpha }_1^{new}{y}_1{\mathbf{x}}_1^T{\mathbf{x}}_1-{\alpha }_2^{new}{y}_2{\mathbf{x}}_2^T{\mathbf{x}}_1-\sum _{i=3}^n{\alpha }_i{y}_i{\mathbf{x}}_i^T{\mathbf{x}}_1$$$$=-E_1+{\alpha }_1^{old}{y}_1{\mathbf{x}}_1^T{\mathbf{x}}_1+{\alpha }_2^{old}{y}_1{\mathbf{x}}_2^T{\mathbf{x}}_1+b^{old}-{\alpha }_1^{new}{y}_1{\mathbf{x}}_1^T{\mathbf{x}}_1-{\alpha }_2^{new}{y}_2{\mathbf{x}}_2^T{\mathbf{x}}_1$$$$=b^{old}-E_1+y_1{\mathbf{x}}_1^T{\mathbf{x}}_1({\alpha }_1^{old}-{\alpha }_1^{new})+y_2{\mathbf{x}}_2^T{\mathbf{x}}_1({\alpha }_2^{old}-{\alpha }_2^{new})$$
  同理可得：
  $$b_2^{new}=b^{old}-E_2+y_1{\mathbf{x}}_1^T{\mathbf{x}}_2({\alpha }_1^{old}-{\alpha }_1^{new})+y_2{\mathbf{x}}_2^T{\mathbf{x}}_2({\alpha }_2^{old}-{\alpha }_2^{new})$$
  当 $b_1$ 和 $b_2$ 都有效的时候，它们是相等的，即：
  $$b^{new}=b_1^{new}=b_2^{new}$$
  当两个乘子都在边界上，则 $b$ 阈值和 KKT 条件一致。当不满足的时候，SMO 算法选择他们的中点作为新的阈值：
  $$b=\{\begin{array}{l}{b}_1,0<{\alpha }_1^{new}<C\\ b_2,0<{\alpha }_2^{new}<C\\ \frac{b_1+b_2}{2},otherwise\end{array}$$

3.2 求解步骤

1. 计算误差：$$E_i=f({\mathbf{x}}_i)-y_i=\sum _{j=1}^n{\alpha }_j{y}_j{\mathbf{x}}_i^T{\mathbf{x}}_j+b-y_i$$
2. 计算上下界 $L$ 和 $H$：$$\{\begin{array}{l}H=max(0,{\alpha }_j^{old}-{\alpha }_i^{old}),L=min(C,C+{\alpha }_j^{old}-{\alpha }_i^{old})y_1\ne y_2\\ H=max(0,{\alpha }_j^{old}+{\alpha }_i^{old}-C),L=min(C,{\alpha }_j^{old}+{\alpha }_i^{old})y_1=y_2\end{array}$$
3. 计算 $\eta$：$$\eta ={\mathbf{x}}_i^T{\mathbf{x}}_i+{\mathbf{x}}_j^T{\mathbf{x}}_j-2{\mathbf{x}}_i^T{\mathbf{x}}_j$$
4. 更新${\alpha }_j$：$${\alpha }_j^{new,clipped}=\{\begin{array}{l}H,{\alpha }_j^{new}>H\\ {\alpha }_j^{old}+\frac{y_j(E_i-E_j)}{\eta },L\le {\alpha }_j^{new}\le H\\ L,{\alpha }_j^{new}<L\end{array}$$
5. 更新${\alpha }_i$：$${\alpha }_i^{new}={\alpha }_i^{old}+y_i{y}_j({\alpha }_j^{old}-{\alpha }_j^{new,clipped})$$
6. 更新 $b_1$ 和 $b_2$：$$b_1^{new}=b^{old}-E_i+y_i{\mathbf{x}}_i^T{\mathbf{x}}_i({\alpha }_i^{old}-{\alpha }_i^{new})+y_j{\mathbf{x}}_j^T{\mathbf{x}}_i({\alpha }_j^{old}-{\alpha }_j^{new})$$$$b_2^{new}=b^{old}-E_j+y_i{\mathbf{x}}_i^T{\mathbf{x}}_j({\alpha }_i^{old}-{\alpha }_i^{new})+y_j{\mathbf{x}}_j^T{\mathbf{x}}_j({\alpha }_j^{old}-{\alpha }_j^{new})$$
7. 根据 $b_1$ 和 $b_2$ 更新 $b$：$$b=\{\begin{array}{l}{b}_1,0<{\alpha }_1^{new}<C\\ b_2,0<{\alpha }_2^{new}<C\\ \frac{b_1+b_2}{2},otherwise\end{array}$$

以上推导过程转载自大神的文章：Python3《机器学习实战》学习笔记（八）：支持向量机原理篇之手撕线性SVM

3.3 应用简化版 SMO 算法处理小规模数据集

'''SMO 算法中的辅助函数'''

import numpy as np

def loadDataSet(filename):
    dataMat = []
    labelMat = []
    with open(filename) as f:
        for line in f.readlines():
            lineArr = line.strip().split('\t')
            dataMat.append([float(lineArr[0]), float(lineArr[1])])
            labelMat.append(float(lineArr[2]))
    return dataMat, labelMat

def selectJrand(i, m):
    '''
    i: 第一个 alpha 的下标
    m: 所有 alpha 的数目
    '''
    j = i    # j: 输出随机值，但该随机值不等于 i
    while (j==i):
        j = int(np.random.uniform(0, m))
    return j

def clipAlpha(aj, H, L):
    '''
    用于调整 alpha 值，使其小于 H，且大于 L
    '''
    if aj > H:
        aj = H
    if L > aj:
        aj = L
    return aj

'''简化 SMO 算法'''

def smoSimple(dataMatIn, classLabels, C, toler, maxIter):
    '''
    dataMatIn: 数据集
    classLabels: 类别标签
    C: 常数
    toler: 松弛变量
    maxIter: 最大循环次数
    '''
    dataMatrix = np.mat(dataMatIn)    # 数据集转换为矩阵
    labelMat = np.mat(classLabels).T    # 类别标签转换为矩阵
    b = 0    # b 初始化为 0
    m, n = np.shape(dataMatrix)    # 数据集大小
    alphas = np.mat(np.zeros((m, 1)))    # 初始化 alpha 为 0
    iternum = 0    # 在没有任何 alpha 改变的情况下遍历数据集的次数
    while (iternum < maxIter):    # iternum 达到 maxIter 时函数允许结束并退出
        alphaPairsChanged = 0    # 用于记录 alpha 对是否变化
        for i in range(m):    # 第 i 个样本
            y_i = float(np.multiply(alphas, labelMat).T * dataMatrix * dataMatrix[i, :].T) + b    
            # yi = w.T*xi + b, w = sum(aj*yj*xj)
            # (1,1) = (m,1)dot(m,1).T * (m,n) * (1,n).T + (1,1)
            e_i = y_i - float(labelMat[i])    # 步骤1：预测值 i 与实际值 i 的误差
            if ((labelMat[i]*e_i < -toler) and (alphas[i] < C)) or ((labelMat[i]*e_i > toler) and (alphas[i] > 0)):
                # 检查是否满足容错率以及是否在边界上，若在边界上则不需要优化
                j = selectJrand(i, m)    # 随机选择一个 j，与 i 成对更新
                y_j = float(np.multiply(alphas, labelMat).T * (dataMatrix * dataMatrix[j, :].T)) + b    # 计算 yj
                e_j = y_j - float(labelMat[j])    # 步骤1：预测值 j 与实际值 j 的误差
                alpha_i_old = alphas[i].copy()    # 深拷贝得到更新前的值
                alpha_j_old = alphas[j].copy()
                if (labelMat[i] != labelMat[j]):    # 步骤2：计算上下界
                    L = max(0, alphas[j] - alphas[i])
                    H = min(C, C + alphas[j] - alphas[i])
                else:
                    L = max(0, alphas[j] + alphas[i] - C)
                    H = min(C, alphas[j] + alphas[i])
                if L == H:
                    print('L==H')
                    continue
                # 步骤3：计算 eta
                eta = 2.0 * dataMatrix[i,:] * dataMatrix[j,:].T - \
                      dataMatrix[i,:] * dataMatrix[i,:].T - dataMatrix[j,:] * dataMatrix[j,:].T
                if eta >= 0:
                    print('eta>=0')
                    continue
                # 步骤4：更新 alpha_j
                alphas[j] -= labelMat[j] * (e_i - e_j) / eta
                alphas[j] = clipAlpha(alphas[j], H, L)
                if (abs(alphas[j] - alpha_j_old) < 0.00001):
                    print('j not moving enough')
                    continue
                # 步骤5：更新 alpha_i
                alphas[i] += labelMat[i] * labelMat[j] * (alpha_j_old - alphas[j])
                # 步骤6：更新 b1 和 b2
                b1 = b - e_i - labelMat[i] * (alphas[i] - alpha_i_old) * dataMatrix[i,:] * dataMatrix[i,:].T -\
                     labelMat[j] * (alphas[j] - alpha_j_old) * dataMatrix[i,:] * dataMatrix[j,:].T
                b2 = b - e_j - labelMat[i] * (alphas[i] - alpha_i_old) * dataMatrix[i,:] * dataMatrix[j,:].T -\
                     labelMat[j] * (alphas[j] - alpha_j_old) * dataMatrix[j,:] * dataMatrix[j,:].T
                # 步骤7：根据 b1 和 b2 更新 b：
                if (0 < alphas[i]) and (C > alphas[i]):
                    b = b1
                elif (0 < alphas[j]) and (C > alphas[j]):
                    b = b2
                else:
                    b = (b1 + b2) / 2.0
                alphaPairsChanged += 1    # 改变次数 +１
                print('iter: %d i: %d, pairs changed %d' % (iternum, i, alphaPairsChanged))
        if (alphaPairsChanged == 0):    # alpha 未更新，iternum + 1
            iternum += 1
        else:
            iternum = 0    # alpha 更新，iternum = 0
        print('iteration number: %d' % iternum)
    return b, alphas

[In]: dataMat, labelMat = loadDataSet('Ch06/testSet.txt')
[In]: b, alphas = smoSimple(dataMat, labelMat, 0.6, 0.001, 40)
[In]: b
[Out]: matrix([[-3.73041522]])
[In]: alphas[alphas>0]
[Out]: matrix([[0.12876353, 0.23408636, 0.36284989]])

'''计算 w'''
def get_w(dataMat, labelMat, alphas):
    dataMat, labelMat = np.array(dataMat), np.array(labelMat)
    # w = sum(alpha_i*y_i*x_i)
    w = np.multiply(alphas,(labelMat.reshape(100,1))).T * dataMat
    return w

[In]: w = get_w(dataMat, labelMat, alphas)
[Out]: matrix([[ 0.7972711 , -0.28038632]])

划分结果如下图所示：

4. 利用完整 Platt SMO 算法加速优化

• 完整的 Platt SMO 算法在速度上会优于简化版
• 两者唯一的不同点在于 alpha 的选择方式
• Platt SMO 算法是通过一个外循环来选择第一个 alpha 值的，并且其选择过程会在两种方式之间进行交替：一种方式是在所有数据集上进行单遍扫描，另一种方式则是在非边界 alpha （不等于 0 或 C）中实现单遍扫描。
• 在选择第一个 alpha 值后，算法会通过一个内循环来选择第二个 alpha 值。在优化过程中，会通过最大化步长的方式来获得第二个 alpha 值。根据 alpha 的更新公式，我们选择使得 Ei-Ej 最大的 alpha 值。

4.1 完整版 Platt SMO 的支持函数

1. 构建一个仅包含 init 方法的 optStruct 类，将其作为一个数据结构来使用，方便我们对于重要数据的维护

class optStruct:
    def __init__(self, dataMatIn, classLabels, C, toler):
        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)))
        self.b = 0
        self.eCache = np.mat(np.zeros((self.m, 2)))    # 用于缓存误差

2. 对于给定的 alpha 值，计算 E 值并返回

'''给定 alpha，计算 E'''
def calcEk(oS, k):
    yk = float(np.multiply(oS.alphas, oS.labelMat).T * oS.X * oS.X[k, :].T) + oS.b    
    Ek = yk - float(oS.labelMat[k])
    return Ek

3. 使用启发式方法选择第二个 alpha

'''使用启发式方法选择第二个 alpha'''
def selectJ(i, oS, Ei):
    maxK = -1
    maxDeltaE = 0
    Ej = 0
    os.eCache[i] = [1, Ei]    # 将 Ei 在缓存中设置为有效
    validEcacheList = np.nonzero(oS.eCache[:,0].A)[0]    # np.nonzero(a)返回数组a中非零元素的索引值元组，这里返回非零 E 对应的索引值
    if len(validEcacheList) > 1:    # 存在有效的 Ei
        for k in validEcacheList:
            if k == i:
                continue
            Ek = calcEk(oS, k)
            deltaE = abs(Ei - Ek)
            if (deltaE > maxDeltaE):
                maxK = k
                maxDeltaE = deltaE
                Ej = Ek
        return maxK, Ej
    else:    # 第一次循环，随机选择一个 alpha
        j = selectJrand(i, oS.m)
        Ej = calcEk(oS, j)
    return j, Ej

4. 计算误差值并存入缓存，在对 alpha 进行优化后会用到该值

'''计算误差值并存入缓存'''
def updateEk(oS, k):
    Ek = calcEk(oS, k)
    oS.eCache[k] = [1, Ek]

4.2 完整 Platt SMO 算法中的优化例程

1. 内循环

def innerL(i, oS):
    Ei = calcEk(oS, i)
    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)):
        j, Ej = selectJ(i, oS, Ei)    # 使用启发式方法选择第二个 alpha
        alpha_i_old = oS.alphas[i].copy()
        alpha_j_old = oS.alphas[j].copy()
        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:
            print('L==H')
            return 0
        eta = 2.0 * oS.X[i,:] * oS.X[j,:].T - \
                oS.X[i,:] * oS.X[i,:].T - oS.X[j,:] * oS.X[j,:].T
        if eta >= 0:
            print('eta>=0')
            return 0
        oS.alphas[j] -= oS.labelMat[j] * (Ei - Ej) / eta
        oS.alphas[j] = clipAlpha(oS.alphas[j], H, L)
        updateEk(oS, j)    # 更新误差缓存
        if (abs(oS.alphas[j] - alpha_j_old) < 0.00001):
            print('j not moving enough')
            return 0
        oS.alphas[i] += oS.labelMat[i] * oS.labelMat[j] * (alpha_j_old - oS.alphas[j])
        updateEk(oS, i)    # 更新误差缓存
        b1 = oS.b - Ei - oS.labelMat[i] * (oS.alphas[i] - alpha_i_old) * oS.X[i,:] * oS.X[i,:].T -\
                oS.labelMat[j] * (oS.alphas[j] - alpha_j_old) * oS.X[i,:] * oS.X[j,:].T
        b2 = oS.b - Ej - oS.labelMat[i] * (oS.alphas[i] - alpha_i_old) * oS.X[i,:] * oS.X[j,:].T -\
                oS.labelMat[j] * (oS.alphas[j] - alpha_j_old) * oS.X[j,:] * oS.X[j,:].T
        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

2. 外循环

'''完整版 Platt SMO 的外循环代码'''

def smoP(dataMatIn, classLabels, C, toler, maxIter, kTup=('lin', 0)):
    oS = optStruct(np.mat(dataMatIn), np.mat(classLabels).T, C, toler)
    iter_num = 0
    entireSet = True
    alphaPairsChanged = 0
    # 迭代次数超过指定最大值，或者遍历整个集合都未对任何 alpha 对进行修改时，退出循环
    while (iter_num < maxIter) and ((alphaPairsChanged > 0) or (entireSet)):
        alphaPairsChanged = 0
        if entireSet:    # 全集遍历
            for i in range(oS.m):
                alphaPairsChanged += innerL(i, oS)
                print('fullSet, iter: %d i: %d, pairs changed %d' % (iter_num, i, alphaPairsChanged))
            iter_num += 1
        else:    # 遍历非边界
            nonBoundIs = np.nonzero((oS.alphas.A > 0) * (oS.alphas.A < C))[0]
            for i in nonBoundIs:
                alphaPairsChanged += innerL(i, oS)
                print('non-bound, iter: %d i: %d, pairs changed %d' % (iter_num, i, alphaPairsChanged))
            iter_num += 1
        if entireSet:    # 一次全集遍历后变为非边界遍历
            entireSet = False
        elif (alphaPairsChanged == 0):    # 如果非边界遍历 alpha 没有更新，重新转换为全集遍历
            entireSet = True
        print('iteration number: %d' % iter_num)
    return oS.b, oS.alphas

[In]: dataArr, labelArr = loadDataSet('Ch06/testSet.txt')
[In]: b, alphas = smoP(dataArr, labelArr, 0.6, 0.001, 40)
[In]: b
[Out]: matrix([[-2.89901748]])
[In]: alphas[alphas > 0]
[Out]: matrix([[0.06961952, 0.0169055 , 0.0169055 , 0.0272699 , 0.04522972,
         0.0272699 , 0.0243898 , 0.06140181, 0.06140181]])

两种方法对比图如下，左图为完整版，右图为简化版

5. 在复杂数据上应用核函数

• 前面使用的数据都是线性可分的情况。对于某些非线性可分，但是存在某种可识别的方式，比如分类边界为一个圆，圆内部为一类，圆外部为另一类，对于人眼来说这种情况很容易分辨，但对于分类器，就无法直接识别了。
• 这种情况下，我们需要使用一种称为核函数的工具将数据转换成易于分类器理解的形式。

5.1 利用核函数将数据映射到高维空间

• 上述问题的解决方法为将数据从一个特征空间映射到另一个特征空间。一般情况下是从低维特征空间映射到高维空间，该过程通过核函数完成，这里核函数可以看做是一个包装器或者是接口
• SVM 中的所有运算都可以写成内积，我们可以把内积运算替换成核函数，而不必做简化处理，该方式称为核技巧或者核变电。其含义具体就是：对于核函数 $k$，对所有 $x_i,x_j\in X$，满足 $k(x_i,x_j)=⟨\varphi (x_i),\varphi (x_j)⟩$，其中 $\varphi (x)$ 为映射函数，这样避免了先计算映射值，再计算内积这种复杂运算。

5.2 径向基核函数

• 对于简单的例子，我们可以手动构造对应映射的核函数，如果对于任意一个映射，要构造出对应的核函数就很困难了。因此，通常，人们会从一些常用的核函数中进行选择，根据问题和数据的不同，选择不同的参数，得到不同的核函数。其中一个非常流行的核函数就是径向基核函数。径向基函数的高斯版本如下：
  $$k(x,y)=exp\left(\frac{-||x-y|{|}^2}{2{\sigma }^2}\right)$$其中，$\sigma$ 是用户自定义的用于确定到达率(reach)或者说函数值跌落到0的速度参数。
• 核转换函数：该函数定义为计算单条数据的核函数值，然后在数据结构类中添加核函数值属性，并且在该类中计算每条数据的核函数值。最终的核函数值矩阵大小为(m, m)

'''核转换函数'''
import numpy as np

def kernelTrans(X, A, kTup):
    '''
    X: 输入矩阵
    A: 单个数据的向量
    kTup: 核函数的信息，为二元元组，第一个元素为核函数类型，第二个元素为核函数的可选参数
    
    Return 转换结果 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))
    else:
        print('raise NameError(''Houston We Have a Problem -- That Kernel is not recognized'')')
    return K

class optStruct:
    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)))
        self.b = 0
        self.eCache = np.mat(np.zeros((self.m, 2)))    # 用于缓存误差
        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)

• 使用了核转换函数后，之前有针对 X 的内积运算都需要修改，包括两个函数，内循环函数和 Ek 计算函数：

'''使用核函数的 innerL() 和 calcEk()'''

def innerL(i, oS):
    Ei = calcEk(oS, i)
    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)):
        j, Ej = selectJ(i, oS, Ei)    # 使用启发式方法选择第二个 alpha
        alpha_i_old = oS.alphas[i].copy()
        alpha_j_old = oS.alphas[j].copy()
        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:
            print('L==H')
            return 0
        # 原来为eta = 2.0 * oS.X[i,:] * oS.X[j,:].T - oS.X[i,:] * oS.X[i,:].T - oS.X[j,:] * oS.X[j,:].T
        eta = 2.0 * oS.K[i,j] - oS.K[i,i] - oS.K[j,j]
        if eta >= 0:
            print('eta>=0')
            return 0
        oS.alphas[j] -= oS.labelMat[j] * (Ei - Ej) / eta
        oS.alphas[j] = clipAlpha(oS.alphas[j], H, L)
        updateEk(oS, j)    # 更新误差缓存
        if (abs(oS.alphas[j] - alpha_j_old) < 0.00001):
            print('j not moving enough')
            return 0
        oS.alphas[i] += oS.labelMat[i] * oS.labelMat[j] * (alpha_j_old - oS.alphas[j])
        updateEk(oS, i)    # 更新误差缓存
        # b1 = oS.b - Ei - oS.labelMat[i] * (oS.alphas[i] - alpha_i_old) * oS.X[i,:] * oS.X[i,:].T -\
                # oS.labelMat[j] * (oS.alphas[j] - alpha_j_old) * oS.X[i,:] * oS.X[j,:].T
        # b2 = oS.b - Ej - oS.labelMat[i] * (oS.alphas[i] - alpha_i_old) * oS.X[i,:] * oS.X[j,:].T -\
                # oS.labelMat[j] * (oS.alphas[j] - alpha_j_old) * oS.X[j,:] * oS.X[j,:].T
        b1 = oS.b - Ei - oS.labelMat[i] * (oS.alphas[i] - alpha_i_old) * oS.K[i,i] -\
                oS.labelMat[j] * (oS.alphas[j] - alpha_j_old) * oS.K[i,j]
        b2 = oS.b - Ej - oS.labelMat[i] * (oS.alphas[i] - alpha_i_old) * oS.K[i,j] -\
                oS.labelMat[j] * (oS.alphas[j] - alpha_j_old) * oS.K[j,j]
        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 calcEk(oS, k):
    # yk = float(np.multiply(oS.alphas, oS.labelMat).T * oS.X * oS.X[k, :].T) + oS.b
    yk = float(np.multiply(oS.alphas, oS.labelMat).T * oS.K[:, k]) + oS.b
    Ek = yk - float(oS.labelMat[k])
    return Ek

5.3 在测试中使用核函数

'''利用核函数进行分类的径向基测试函数'''
def testRbf(k1=1.3):
    dataArr, labelArr = loadDataSet('Ch06/testSetRBF.txt')
    b, alphas = smoP(dataArr, labelArr, 200, 0.0001, 10000, ('rbf', k1))
    dataMat = np.mat(dataArr)
    labelMat = np.mat(labelArr).T
    svInd = np.nonzero(alphas.A > 0)[0]
    sVs = dataMat[svInd]
    labelSV = labelMat[svInd]
    print('there are %d Support Vectors' % np.shape(sVs)[0])
    m, n = np.shape(dataMat)
    errorCount = 0
    # 利用核函数进行分类
    for i in range(m):
        kernelEval = kernelTrans(sVs, dataMat[i,:], ('rbf', k1))    # 得到转换后的数据
        predict = kernelEval.T * np.multiply(labelSV, alphas[svInd]) + b    # 计算预测值
        if np.sign(predict) != np.sign(labelArr[i]):
            errorCount += 1
    print('the training error rate is :%f' % (float(errorCount) / m))
    # 对测试集进行分类
    dataArr, labelArr = loadDataSet('Ch06/testSetRBF2.txt')
    errorCount = 0
    dataMat = np.mat(dataArr)
    labelMat = np.mat(labelArr).T
    m, n = np.shape(dataMat)
    for i in range(m):
        kernelEval = kernelTrans(sVs, dataMat[i,:], ('rbf', k1))    # 得到转换后的数据
        predict = kernelEval.T * np.multiply(labelSV, alphas[svInd]) + b    # 计算预测值
        if np.sign(predict) != np.sign(labelArr[i]):
            errorCount += 1
    print('the test error rate is :%f' % (float(errorCount) / m))

[In]: testRbf()
[Out]: there are 26 Support Vectors
[Out]: the training error rate is :0.090000
[Out]: the test error rate is :0.180000

• 改变 k1 的值，可以发现 k1 越小，支持向量越多，训练错误率越低，但测试错误率升高，即出现过拟合。k1 存在一个最优值，对于不同类型的数据集，该值可能差异很大

参考资料：

• [1] 机器学习实战第六章
• [2] Python3《机器学习实战》学习笔记（八）：支持向量机原理篇之手撕线性SVM
• [3] Python3《机器学习实战》学习笔记（九）：支持向量机实战篇之再撕非线性SVM