支持向量机SVM（附Python实现代码）

1 前备知识

在这里简略讲一下使用方法，具体原理和推导公式不展开讲了。

1.1 拉格朗日乘子法

拉格朗日乘子法就是求函数$f(x1,x2,...)$在约束条件$g(x1,x2,...)=0$下的极值的方法。其主要思想是将约束条件函数与原函数联立，从而求出使原函数取得极值的各个变量的解。

首先看下面的例题：
$$\begin{gathered} minf=2x_1^2+3x_2^2+x_3^2 \\ s.t.2x_1+x_2-1=0 \\ 2x_2+x_3-2=0 \end{gathered}$$
第一步将每个约束条件都分配一个乘子${\alpha }_i$，在将目标函数和所有的约束函数相加，得到函数：
$$L=f+\sum _{i=1}^m{g}_i{\alpha }_i$$
其中每个约束条件$g_i$的右边都是0，所以${\sum }_{i=1}^m{g}_i=0$.
$$L=(2x_1^2+3x_2^2+x_3^2)+{\alpha }_1(2x_1+x_2-1)+{\alpha }_2(2x_2+x_3-2)$$
第二步对$x_i$求偏导：
$$\{\begin{array}{c}\frac{\partial L}{\partial x_1}=4x_1+2{\alpha }_1\\ \frac{\partial L}{\partial x_2}=6x_2+{\alpha }_1+2{\alpha }_2\\ \frac{\partial L}{\partial x_3}=2x_3+{\alpha }_2\end{array}$$
令偏导数等于0，用${\alpha }_i$表示$x$：
$$\{\begin{array}{c}{x}_1=-\frac{{\alpha }_1}{2}\\ x_2=-\frac{{\alpha }_1+2{\alpha }_2}{6}\\ x_3=-\frac{{\alpha }_2}{2}\end{array}$$
将所得$x$代入约束条件$g$中，求得$\alpha$：
$$\{\begin{array}{c}{\alpha }_1=-2/5\\ {\alpha }_2=-72/45\end{array}$$
得到$\alpha$的值，代入上式得到$x$的最优解。

1.2 KKT条件

我们可以发现，1.1讲的拉格朗日乘子法中，它的约束条件都是等式，那么对于约束条件是不等式的应该怎么办呢？

对于一个新的极值问题：
$$\begin{gathered} minf=x_1^2-2x_1+x_2^2+5 \\ s.t.x_1+10x_2>10 \\ 10x_1-x_2<10 \end{gathered}$$
为了统一，首先将约束条件都转化为小于号：

$$\begin{gathered} minf=x_1^2-2x_1+x_2^2+5 \\ s.t.10-x_1-10x_2<0 \\ 10x_1-x_2-10<0 \end{gathered}$$
依旧是分配乘子并求和：
$$L=f+\sum _{i=1}^m{g}_i{\alpha }_i+\sum _{i=1}^m{h}_i{\beta }_i$$
其中$g_i$是不等式约束条件，$h_i$是等式约束条件。(此例中没有等式)
$$L=(x_1^2-2x_1+x_2^2+5)+{\alpha }_1(10-x_1-10x_2)+{\alpha }_2(10x_1-x_2-10)$$
KKT条件就是最优值，KKT条件为：

1. $L$对每个$x$求偏导等于$0$；
2. $h(x)=0$；
3. $g_i(x)<=0$
4. ${\alpha }_i>=0$
5. $\sum {\alpha }_i{g}_i(x)=0$

可以发现，将3、4、5合并就是：
$${\alpha }_i{g}_i(x)=0$$
对于上例题，接下来的操作就是：
一、$L$对每个$x$求偏导等于$0$求出$x$的表达式。
二、将$x$的表达式代入${\alpha }_i{g}_i(x)=0$，求出$\alpha$。
三、将$\alpha$代回，求出$x$。

2 SVM

2.1 简介

支持向量机（support vector machines, SVM）是一种二分类问题模型。
它的目标是找到一个尽可能正确分类，且“确信度”尽可能高的超平面。
其中“确信度”指的是：正确分类的样本点，距离超平面越远，该样本点的确信度就越高。（我对这个样本点分类正确的信任程度）
换而言之，就是该超平面的鲁棒性要好，泛化能力要强。

对于线性可分支持向量机，分类超平面为：
$$w^{\ast }\cdot x+b^{\ast }=0$$
相应的分类决策函数
$$f(x)=sign(w^{\ast }\cdot x+b^{\ast })$$
称为线性可分支持向量机。

2.2 函数间隔与几何间隔

函数间隔和几何间隔是用来描述计算“确信度”的。

2.1.1 函数间隔

在超平面$w\cdot x+b=0$确定的情况下，$|w\cdot x_i+b|$的值可以作为衡量样本点$x_i$确信度的一个指标，$|w\cdot x_i+b|$就是该样本点的函数间隔。
定义（函数间隔）：对于给定的训练数据集$T$和超平面$(w,b)$，定义超平面$(w,b)$关于样本点$(x_i,y_i)$的函数间隔为：
$$\widehat{{\gamma }_i}=|w\cdot x_i+b|$$
超平面$(w,b)$关于样本点$(x_i,y_i)$的函数间隔为所有样本点函数间隔的最小值：
$$\hat{\gamma }=min\widehat{{\gamma }_i},i=1,2,...,N$$
函数间隔虽然可以表示预测的确信度，但是当$w$和$b$成比例增加时，超平面没有改变，但函数间隔却成倍增加。
例如超平面$\lambda w^{\ast }\cdot x+\lambda b^{\ast }=0$与$w^{\ast }\cdot x+b^{\ast }=0$等价，但是$\widehat{{\gamma }_i}=\lambda |w\cdot x_i+b|$。
为了解决这个问题，引入了几何间隔。

2.2.2 几何间隔

在二维坐标系中，点是样本，线是分离超平面，那么点到线的距离就是几何间隔。
点到线的距离公式：
$$d=\frac{|A{x}_0+B{y}_0+C|}{\sqrt{A_2+B_2}}$$
扩展到多维坐标系：
$$d=\frac{|w\cdot x+b|}{||w|{|}_2}$$
其中$||w|{|}_2=\sqrt{{\sum }_{i=1}^{m}w}$为L2范数。
我们记$${\gamma }_i=\frac{|w\cdot x_i+b|}{||w|{|}_2}$$
同样：
$$\gamma =min{\gamma }_i,i=1,2,...,N$$

2.2.3 间隔最大化

回想一下，我们SVM的目标是什么来着？
是寻找一个“确信度”尽可能高的超平面，也就是一个几何间隔尽可能大的超平面。

那么我们可以得到一个约束最优化问题：
使几何间隔最大化的$w$和$b$，并且满足约束条件所有样本的几何间隔大于$\gamma$.
$$\begin{gathered} \underset{w,b}{\max }\gamma \\ s.t.\frac{y_i(w\cdot x_i+b)}{||w|{|}_2}\ge \gamma ,i=1,..,N \end{gathered}$$
又因为函数间隔和几何间隔的关系：
$$\gamma =\frac{\hat{\gamma }}{||w|{|}_2}$$
上述问题可以化为：
$$\begin{gathered} \underset{w,b}{\max }\frac{\hat{\gamma }}{||w|{|}_2} \\ s.t.y_i(w\cdot x_i+b)\ge \hat{\gamma },i=1,..,N \end{gathered}$$
函数间隔$\hat{\gamma }$的取值并不影响最优化问题的解，则可以令$\hat{\gamma }=1$。

这个其实也好理解，我们看上式，$w$和$b$就是两个参数，令$\hat{\gamma }=1$，就相当于将$w^{{}^{\prime }}=\frac{w}{\hat{\gamma }}$和$b^{{}^{\prime }}=\frac{b}{\hat{\gamma }}$，对于该约束最优化问题的解没有任何影响。就好比解方程时等式两边同时除以一个数。

另外，最大化$\frac{1}{||w|{|}_2}$和最小化$\frac{1}{2}||w|{|}^2$是等价的。
所以上面的问题就变成了：
$$\begin{gathered} \underset{w,b}{\min }\frac{1}{2}||w|{|}^2 \\ s.t.y_i(w\cdot x_i+b)-1\ge 0,i=1,..,N \end{gathered}$$
这就是SVM的基本型（对于线性可分问题），后面主要就是这个约束问题的求解。

2.3 对偶问题

我们可以发现上面的约束最优化问题本身就是一个凸二次规划问题，所以我们可以使用更高效的方法去求解，也就是使用拉格朗日乘子法得到其“对偶问题”。
首先稍微做一下调整:
$$\begin{gathered} \underset{w,b}{\min }\frac{1}{2}||w|{|}^2 \\ s.t.1-y_i(w\cdot x_i+b)\le 0,i=1,..,N \end{gathered}$$
定义拉格朗日乘子${\alpha }_i$，根据
$$L=f+\sum _{i=1}^m{g}_i{\alpha }_i+\sum _{i=1}^m{h}_i{\beta }_i$$
得到：
$$L=\frac{1}{2}||w|{|}^2+\sum _{i=1}^m{\alpha }_i[1-y_i(w\cdot x_i+b)]$$
令$L$对$w$和$b$求偏导等于零，得：
$$\{\begin{array}{c}w={\sum }_{i=1}^m{\alpha }_i{y}_i{x}_i\\ \\ 0={\sum }_{i=1}^m{\alpha }_i{y}_i\end{array}$$
虽然把$b$给消去了，但是并没有影响，后续过程中原式的$b$也会消去。
将$w={\sum }_{i=1}^m{\alpha }_i{y}_i{x}_i$代入$L$中，即可用${\alpha }_i$将$w$和$b$替换掉，得到对偶问题：
$$\begin{gathered} \underset{\alpha }{\max }\sum _{i=1}^m{\alpha }_i-\frac{1}{2}\sum _{i=1}^m\sum _{j=1}^m{\alpha }_i{\alpha }_j{y}_i{y}_j{\mathbf{x}}_i^T{\mathbf{x}}_j \\ s.t.\sum _{i=1}^m{\alpha }_i{y}_i=0, \\ {\alpha }_i\ge 0,i=1,...,m \end{gathered}$$
另外，需要注意，这里的约束问题需要用到KKT条件：

1. $L$对$w$和$b$求偏导等于$0$；
2. $y_i(w\cdot x_i+b)-1\ge 0$
3. ${\alpha }_i>=0$
4. ${\alpha }_i[y_i(w\cdot x_i+b)-1]=0$
5. $h(x)=0$； (这里没有等式约束，可以忽略)

整理一下，可简化为两种情况：

1. 当${\alpha }_i=0$时，$y_i(w\cdot x_i+b)-1\ge 0$
2. 当$0<{\alpha }_i<{\xi }_i$时，$y_i(w\cdot x_i+b)-1=0$
   （${\xi }_i$为松弛变量，下面会讲。）

到这里，只要解出${\alpha }_i$，就可以得到$w$和$b$，从而得到分离超平面。
那么如何去求解${\alpha }_i$呢？一种比较高效的方法就是SMO算法。
在此之前需要先讲一下松弛变量和核函数。

2.4 松弛变量和核函数

2.4.1 线性SVM与松弛变量

在此之前所讲的都是数据集时线性可分的，但是还有的数据集是线性不可分的，这两种情况合起来就是线性SVM。
如下图，线性不可分的数据集：

线性不可分意味着某些样本点$(x_i,y_i)$不能满足函数间隔大于等于1的约束条件。为了解决这个问题，给每一个样本点$(x_i,y_i)$引进一个松弛变量${\xi }_i\ge 0$，使函数间隔加上松弛变量大于等于1。这样，约束条件变为：
$$y_i(w\cdot x_i+b)-1+{\xi }_i\ge 0$$
同时，对每个松弛变量${\xi }_i$，需要支付一个代价${\xi }_i$，则目标函数就由原来的$\frac{1}{2}||w|{|}_2$变为：
$$\frac{1}{2}||w|{|}_2+C\sum _{i=1}^N{\xi }_i$$
其中$C>0$称为惩罚参数，用来控制松弛变量的代价高低。
所以对于线性不可分的SVM的基本模型就是：
$$\begin{gathered} \underset{w,b,\xi }{\min }\frac{1}{2}||w|{|}^2+C\sum _{i=1}^N{\xi }_i \\ s.t.y_i(w\cdot x_i+b){\xi }_i\ge 1, \\ {\xi }_i\ge 0,i=1,..,N \end{gathered}$$

2.4.2 非线性SVM与核函数

2.4.2.1 核技巧和核函数

简单说就是，对于非线性问题，可以将样本通过一个$\phi (x)$从原始空间映射到一个更高维的特征空间，使得样本在这个特征空间内线性可分。

如下图，对于异或问题，就是一个非线性问题，原始问题是在一个二维空间中，当我们将样本特征空间做一个映射，提升到三维空间中，就能容易找到一个分离超平面。

非线性SVM的基本模型为：
$$\begin{gathered} \underset{w,b,\xi }{\min }\frac{1}{2}||w|{|}^2 \\ s.t.y_i(w\cdot \phi (x_i)+b)\ge 1,i=1,..,N \end{gathered}$$

其对偶问题为：
$$\begin{gathered} \underset{\alpha }{\max }\sum _{i=1}^m{\alpha }_i-\frac{1}{2}\sum _{i=1}^m\sum _{j=1}^m{\alpha }_i{\alpha }_j{y}_i{y}_j\phi ({\mathbf{x}}_i{)}^T\phi ({\mathbf{x}}_j) \\ s.t.\sum _{i=1}^m{\alpha }_i{y}_i=0, \\ {\alpha }_i\ge 0,i=1,...,m \end{gathered}$$

特征空间的维数可能非常高。如果支持向量机的求解只用到内积运算，而在低维输入空间又存在某个函数 $K(x_i,x_j)$ ，它恰好等于在高维空间中这个内积，即$$K(x_i,x_j)=<\phi (x_i)\cdot \phi (x_j)>=\phi ({\mathbf{x}}_i{)}^T\phi ({\mathbf{x}}_j)$$那么支持向量机就不用计算复杂的非线性变换，而由这个函数 $K(x_i,x_j)$ 直接得到非线性变换的内积，使大大简化了计算。这样的函数 $K(x_i,x_j)$ 称为核函数。
则该对偶问题可以改写为：
$$\begin{gathered} \underset{\alpha }{\max }\sum _{i=1}^m{\alpha }_i-\frac{1}{2}\sum _{i=1}^m\sum _{j=1}^m{\alpha }_i{\alpha }_j{y}_i{y}_{j}K(x_i,x_j) \\ s.t.\sum _{i=1}^m{\alpha }_i{y}_i=0, \\ {\alpha }_i\ge 0,i=1,...,m \end{gathered}$$

2.4.2.2 常用的核函数

3 SMO算法

序列最小最优化（sequential minimal optimization，SMO）算法，可以高效地实现支持向量机问题。SMO算法在这里用来更新优化${\alpha }_i$的值。
算法的基本思想就是，每次挑选出两个变量（假设为${\alpha }_1$和${\alpha }_2$），固定其它的变量（${\alpha }_i$），每次只更新${\alpha }_1$和${\alpha }_2$，循环迭代多次，尽可能接近最优解。

SMO算法其实就做了两件事：

1. 变量的挑选方法：挑选出${\alpha }_1$和${\alpha }_2$。
2. 两个变量二次规划的求解方法：更新${\alpha }_1$和${\alpha }_2$。

3.1 两个变量二次规划的求解方法

假设选择的两个变量为${\alpha }_1$和${\alpha }_2$，其它变量${\alpha }_i，(i=3,...,N)$是固定的，则SMO的最优化问题的子问题可以写成：
$$\begin{gathered} \underset{{\alpha }_1,{\alpha }_2}{\min }W({\alpha }_1,{\alpha }_2)=\frac{1}{2}{K}_{11}{\alpha }_1^2+\frac{1}{2}{K}_{22}{\alpha }_2^2+y_1{y}_2{K}_{12}{\alpha }_1{\alpha }_2 \\ -({\alpha }_1+{\alpha }_2)+y_1{\alpha }_1\sum _{i=3}^N{y}_i{\alpha }_i{K}_{i1}+y_2{\alpha }_2\sum _{i=3}^N{y}_i{\alpha }_i{K}_{i2} \\ s.t.{\alpha }_1{y}_1+{\alpha }_2{y}_2=-\sum _{i=3}^N{y}_i{\alpha }_i=\delta \\ 0\le {\alpha }_i\le C,i=1,2 \end{gathered}$$
其中$\delta$是常数，目标函数中省略了不含${\alpha }_1,{\alpha }_2$的常数项。
接下来，我们从约束条件入手：
$$\begin{gathered} {\alpha }_1{y}_1+{\alpha }_2{y}_2=\delta \\ 0\le {\alpha }_i\le C,i=1,2 \end{gathered}$$

我们假设考虑为变量${\alpha }_2$的最优化问题。
假设问题的初始可行解为${\alpha }_1^{old}$和${\alpha }_2^{old}$，更新后的解为${\alpha }_1^{new}$和${\alpha }_2^{new}$，并记未经剪辑时${\alpha }_2$的最优解为${\alpha }_2^{new\_unc}$。（未经剪辑就是不一定满足$0\le {\alpha }_2^{new\_unc}\le C$）
我们先求${\alpha }_2^{new\_unc}$，再对其约束得到${\alpha }_2^{new}$。
我们假设最优值${\alpha }_2^{new}$必须满足：
$$L\le {\alpha }_2^{new}\le H$$
如上图所示，分两种情况讨论，L、H的值就是线段$l_j$和边界相交的点，可以求出：

1. $y_1=y_2$：
   $$L=max(0,{\alpha }_2^{old}+{\alpha }_1^{old}-C),H=min(C,{\alpha }_2^{old}+{\alpha }_1^{old})$$
2. $y_1\ne y_2$
   $$L=max(0,{\alpha }_2^{old}-{\alpha }_1^{old}),H=min(C,C+{\alpha }_2^{old}-{\alpha }_1^{old})$$

得到$L,H$后，我们先放一放，先去求${\alpha }_2^{new\_unc}$的值：
记
$$\begin{gathered} g(x)=\sum _{i=1}^N{\alpha }_i{y}_{i}K(x_i,x)+b \\ {E}_i=g(x_i)-y_i \end{gathered}$$

$g(x)$为预测值，$E_i$为预测值与真实值之差。
则：
$${\alpha }_2^{new\_unc}={\alpha }_2^{old}+y_2\frac{E1-E2}{\eta }$$
其中，
$$\eta =K_{11}+K_{22}-2K_{12}=||\varphi (x_1)-\varphi (x_2)|{|}^2$$
再求${\alpha }_2^{new}$：
$${\alpha }_2^{new}=\{\begin{array}{c}H,{\alpha }_2^{new\_unc}>H\\ {\alpha }_2^{new\_unc},L\le {\alpha }_2^{new\_unc}\le H\\ L,{\alpha }_2^{new\_unc}<L\end{array}$$

根据
$${\alpha }_1{y}_1+{\alpha }_2{y}_2=\delta$$
得到：
$${\alpha }_1^{new}={\alpha }_1^{old}+y_1{y}_2({\alpha }_2^{old}-{\alpha }_2^{new})$$
于是得到新的${\alpha }_1$和${\alpha }_2$。

3.2 变量的挑选方法

SMO算法要挑选的两个变量，一个(${\alpha }_1$)是违反KKT条件的，另一个(${\alpha }_2$)的选择标准是希望能使${\alpha }_2$有足够大的变化。

3.2.1 第一个变量的选择

SMO称选择第一个变量的过程称为外层循环。外层循环在训练样本中选取违反KKT条件的样本点，并将其对应的${\alpha }_i$作为第一个变量。
KKT条件：

1. 当${\alpha }_i=0$时，$y_i(w\cdot x_i+b)-1\ge 0$
2. 当$0<{\alpha }_i<{\xi }_i$时，$y_i(w\cdot x_i+b)-1=0$
   一般把松弛变量统一为一个量，记为$C$。则：
   当$0<{\alpha }_i<C$时，$y_i(w\cdot x_i+b)-1=0$

在检验选取过程中，外层循环首先遍历符合$0<{\alpha }_i<C$条件的，再遍历符合${\alpha }_i=0$条件的，检验他们是否满足KKT条件，将第一个不满足KKT条件的的作为${\alpha }_1$。

3.2.2 第二个变量的选择

SMO称选择第二个变量的过程称为内层循环。我们的选择标准是希望能使${\alpha }_2$有足够大的变化。
根据公式：
$${\alpha }_2^{new\_unc}={\alpha }_2^{old}+\frac{y_i(E_1-E_2)}{\eta }$$
可知${\alpha }_2^{new}$是依赖于$|E_1-E_2|$的，所以：

1. 当$E_1\ge 0$时，选择所有样本点中最小的$E_i$作为$E_2$；
2. 当$E_1<0$时，选择所有样本点中最大的$E_i$作为$E_2$；

同时将挑选出的$E_i$相对应的${\alpha }_i$作为第二个变量(${\alpha }_2$)

3.2.3 计算并更新阈值$b$和差值$E_i$

4 Python代码实现SVM

import numpy as np

class SVM:
    def init_args(self, max_iter, features, labels):
        self.max_iter = max_iter
        self.m, self.n = features.shape
        self.X = features
        self.Y = labels
        self.b = 0.0
        self.alpha = np.ones(self.m)
        self.E = [self.calc_E(i) for i in range(self.m)]
        self.C = 1.0

    # 核函数，这里选用线性核
    def kernel(self, x1, x2):
        sum = 0
        for i in range(self.n):
            sum += x1[i]*x2[i]
        return sum

    # 计算预测值
    def calc_g(self, i):
        g = self.b
        for j in range(self.m):
            g += self.alpha[j]*self.Y[j]*self.kernel(self.X[i], self.X[j])
        return g

    # 计算预测值与真实值的差值
    def calc_E(self, i):
        return self.calc_g(i) - self.Y[i]

    # 判断是否满足KKT条件
    def judge_KKT(self, i):
        if self.alpha[i]==0 and self.Y[i]*self.calc_g(i)>=1:
            return True
        elif 0<self.alpha[i]<self.C and self.Y[i]*self.calc_g(i)==1:
            return True
        return False

    def get_alpha(self):
        # 外层循环，找第一个变量，遍历样本点，找到第一个不满足KKT条件的
        for i in range(self.m):
            if self.judge_KKT(i) == False:
                # 内层循环，找第二个变量
                E1 = self.E[i]
                if E1 >= 0:
                    j = min(range(self.m), key=lambda index : self.E[index])
                else:
                    j = max(range(self.m), key=lambda index : self.E[index])
                return i, j

    def train(self, max_iter, features, labels):
        # 迭代训练
        self.init_args(max_iter, features, labels)
        for i in range(self.max_iter):
            # 选择 alpha1和alpha1
            i1, i2 = self.get_alpha()

            # 边界
            if self.Y[i1] == self.Y[i2]:
                L = max(0, self.alpha[i2]+self.alpha[i1]-self.C)
                H = min(self.C, self.alpha[i2]+self.alpha[i1])
            else:
                L = max(0, self.alpha[i2]-self.alpha[i1])
                H = min(self.C, self.alpha[i2]+self.alpha[i1]+self.C)
            
            eta = self.kernel(self.X[i1], self.X[i1]) + self.kernel(self.X[i2], self.X[i2]) - 2*self.kernel(self.X[i1], self.X[i2])
            alpha2_new_unc = self.alpha[i2] + self.Y[i2] * (self.E[i1] - self.E[i2]) / eta

            if alpha2_new_unc > H:
                alpha2_new = H
            elif L <= alpha2_new_unc <= H:
                alpha2_new = alpha2_new_unc
            elif alpha2_new_unc < L:
                alpha2_new = L
            alpha1_new = self.alpha[i1] + self.Y[i1] * self.Y[i2] * (self.alpha[i2] - alpha2_new)
            
            b1_new = -self.E[i1] - self.Y[i1] * self.kernel(self.X[i1], self.X[i1]) * (alpha1_new-self.alpha[i1]) - self.Y[i2] * self.kernel(self.X[i2], self.X[i1]) * (alpha2_new-self.alpha[i2])+ self.b 
            b2_new = -self.E[i2] - self.Y[i1] * self.kernel(self.X[i1], self.X[i2]) * (alpha1_new-self.alpha[i1]) - self.Y[i2] * self.kernel(self.X[i2], self.X[i2]) * (alpha2_new-self.alpha[i2])+ self.b 

            if 0 < alpha1_new < self.C:
                b_new = b1_new
            elif 0 < alpha2_new < self.C:
                b_new = b2_new
            else:
                b_new = (b1_new + b2_new) / 2
                
            # 更新参数
            self.alpha[i1] = alpha1_new
            self.alpha[i2] = alpha2_new
            self.b = b_new
            
            self.E[i1] = self.calc_E(i1)
            self.E[i2] = self.calc_E(i2)
        print("Train: {0} iterations have been done.".format(self.max_iter))



from sklearn.svm import SVC
svc = SVC()
svc.fit(X, Y)
svc.score(Xt, Yt)

参考：

• 《统计学习方法》李航
• 《机器学习》周志华
• SVM参考博客