支持向量机

Demo实践

首先利用sklearn直接调用SVM函数进行实践尝试

Step 1 库函数导入

#基础函数库
import numpy as np 
#导入画图库
import matplotlib.pyplot as plt
import seaborn as sns
#导入逻辑回归模型函数
from sklearn  import svm

Step 2 构建数据集并进行模型训练

#Demo演示LogisticRegression分类
#构造数据集
x_fearures = np.array([[-1, -2], [-2, -1], [-3, -2], [1, 3], [2, 1], [3, 2]])
y_label = np.array([0, 0, 0, 1, 1, 1])
#调用SVC模型 （支持向量机分类）
svc = svm.SVC(kernel='linear')
#用SVM模型拟合构造的数据集
svc = svc.fit(x_fearures, y_label) 

Step 3 模型参数查看

#查看其对应模型的w
print('the weight of Logistic Regression:',svc.coef_)
#查看其对应模型的w0
print('the intercept(w0) of Logistic Regression:',svc.intercept_)

Step 4 模型预测

#模型预测
y_train_pred = svc.predict(x_fearures)
print('The predction result:',y_train_pred)

Step 5 模型可视化

由于此处选择的线性核函数，所以在此我们可以将svm进行可视化

#最佳函数
x_range = np.linspace(-3, 3)
w = svc.coef_[0]
a = -w[0] / w[1]
y_3 = a*x_range - (svc.intercept_[0]) / w[1]
#可视化决策边界
plt.figure()
plt.scatter(x_fearures[:,0],x_fearures[:,1], c=y_label, s=50, cmap='viridis')
plt.plot(x_range, y_3, '-c')
plt.show()

可以对照之前的逻辑回归模型的决策边界，我们可以发现两个决策边界是有一定差异的（可以对比两者在X,Y轴上的截距），这说明这两个不同在相同数据集上找到的判别线是不同的，而这不同的原因其实是由于两者选择的最
优目标是不一致的。

支持向量机的介绍

我们常常会碰到这样的一个问题，首先给你一些分属于两个类别的数据

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets.samples_generator import make_blobs
%matplotlib inline
#画图
X, y = make_blobs(n_samples=60, centers=2, random_state=0, cluster_std=0.4)
plt.scatter(X[:, 0], X[:, 1], c=y, s=60, cmap=plt.cm.Paired)

现在需要一个线性分类器，将这些数据分开，我们可能会有很多种分法。

#画散点图
X, y = make_blobs(n_samples=60, centers=2, random_state=0, cluster_std=0.4)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap=plt.cm.Paired)
x_fit = np.linspace(0, 3)
#画函数
y_1 = 1 * x_fit + 0.8
plt.plot(x_fit, y_1, '-c')
y_2 = -0.3 * x_fit + 3
plt.plot(x_fit, y_2, '-k')

那么现在有个问题，两种分类器，哪种最好呢？为了判断好坏，我们需要引入一个准则：好的分类器不仅仅是能够很好的分开已有的数据集，还能对未知数据集进行两个的划分。
假设，现在有一个属于红色数据点的新数据(3,2.8)

#画散点图
X, y = make_blobs(n_samples=60, centers=2, random_state=0, cluster_std=0.4)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap=plt.cm.Paired)
plt.scatter([3], [2.8], c='#cccc00', marker='<', s=100, cmap=plt.cm.Paired)
x_fit = np.linspace(0, 3)
#画函数
y_1 = 1 * x_fit + 0.8
plt.plot(x_fit, y_1, '-c')
y_2 = -0.3 * x_fit + 3
plt.plot(x_fit, y_2, '-k')

此时两条线一条会分对而另一条分错，这只是我们的主观感觉，为了客观的评判两条线的健壮性，引入最大间隔这个概念。
最大间隔刻画着当前分类器与数据集的边界，以这两个分类器为例：

#画散点图
X, y = make_blobs(n_samples=60, centers=2, random_state=0, cluster_std=0.4)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap=plt.cm.Paired)
x_fit = np.linspace(0, 3)
#画函数
y_1 = 1 * x_fit + 0.8
plt.plot(x_fit, y_1, '-c')
#画边距
plt.fill_between(x_fit, y_1 - 0.6, y_1 + 0.6, edgecolor='none', color='#AAAAAA', alpha=0.4)
y_2 = -0.3 * x_fit + 3
plt.plot(x_fit, y_2, '-k')
plt.fill_between(x_fit, y_2 - 0.4, y_2 + 0.4, edgecolor='none', color='#AAAAAA', alpha=0.4)

**
可以看出，蓝色线的最大间隔大于黑色线，所以会选择蓝色线作为我们的分类器.

#画散点图
X, y = make_blobs(n_samples=60, centers=2, random_state=0, cluster_std=0.4)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap=plt.cm.Paired)
#画图
y_1 = 1 * x_fit + 0.8
plt.plot(x_fit, y_1, '-c')
#画边距
plt.fill_between(x_fit, y_1 - 0.6, y_1 + 0.6, edgecolor='none', color='#AAAAAA', alpha=0.4)

那么，我们现在的分类器是最优的吗？间隔是最大的吗？
为了找出最优分类器，引出SVM

from sklearn.svm import SVC
#SVM 函数
clf = SVC(kernel='linear')
clf.fit(X, y)

#最佳函数
w = clf.coef_[0]
a = -w[0] / w[1]
y_3 = a*x_fit - (clf.intercept_[0]) / w[1]
#最大边距 下届
b_down = clf.support_vectors_[0]
y_down = a* x_fit + b_down[1] - a * b_down[0]
#最大边距 上届
b_up = clf.support_vectors_[-1]
y_up = a* x_fit + b_up[1] - a * b_up[0]
#画散点图
X, y = make_blobs(n_samples=60, centers=2, random_state=0, cluster_std=0.4)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap=plt.cm.Paired)
#画函数
plt.plot(x_fit, y_3, '-c')
#画边距
plt.fill_between(x_fit, y_down, y_up, edgecolor='none', color='#AAAAAA', alpha=0.4)
#画支持向量
plt.scatter(clf.support_vectors_[:, 0], clf.support_vectors_[:, 1], edgecolor='b',
s=80, facecolors='none')

带黑边的点数距离当前分类器最近的点，我们称之为支持向量。
支持向量机为我们提供了在众多可能的分类器之间进行选择的原则，从而确保对未知数据集具有更高的泛化性。

软间隔

但很多时候，我们拿到的数据是这样子的

#画散点图
X, y = make_blobs(n_samples=60, centers=2, random_state=0, cluster_std=0.9)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap=plt.cm.Paired)

这种情况并不容易找到这样的最大间隔。
于是我们就有了软间隔，相比于硬间隔而言，我们允许个别数据出现在间隔带中。
我们知道，如果没有一个原则进行约束，满足软间隔的分类器也会出现很多条。
所以需要对分错的数据进行惩罚，SVC 函数中，有一个参数 C 就是惩罚参数。
惩罚参数越小，容忍性就越大。
以 C=1 为例子，比如说：

#画散点图
X, y = make_blobs(n_samples=60, centers=2, random_state=0, cluster_std=0.9)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap=plt.cm.Paired)
#惩罚参数：C=1 
clf = SVC(C=1, kernel='linear')
clf.fit(X, y)
#最佳函数
w = clf.coef_[0]
a = -w[0] / w[1]
y_3 = a*x_fit - (clf.intercept_[0]) / w[1]
#最大边距 下届
b_down = clf.support_vectors_[0]
y_down = a* x_fit + b_down[1] - a * b_down[0]
#最大边距 上届
b_up = clf.support_vectors_[-1]
y_up = a* x_fit + b_up[1] - a * b_up[0]
#画散点图
X, y = make_blobs(n_samples=60, centers=2, random_state=0, cluster_std=0.4)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap=plt.cm.Paired)
#画函数
plt.plot(x_fit, y_3, '-c')
#画边距
plt.fill_between(x_fit, y_down, y_up, edgecolor='none', color='#AAAAAA', alpha=0.4)
#画支持向量
plt.scatter(clf.support_vectors_[:, 0], clf.support_vectors_[:, 1], edgecolor='b',
            s=80, facecolors='none')

惩罚参数 C=0.2 时，SVM 会更具包容性，从而兼容更多的错分样本：

X, y = make_blobs(n_samples=60, centers=2, random_state=0, cluster_std=0.9)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap=plt.cm.Paired)
#惩罚参数：C=0.2 
clf = SVC(C=0.2, kernel='linear')
clf.fit(X, y)
x_fit = np.linspace(-1.5, 4)
#最佳函数
w = clf.coef_[0]
a = -w[0] / w[1]
y_3 = a*x_fit - (clf.intercept_[0]) / w[1]
#最大边距 下届
b_down = clf.support_vectors_[10]
y_down = a* x_fit + b_down[1] - a * b_down[0]
#最大边距 上届
b_up = clf.support_vectors_[1]
y_up = a* x_fit + b_up[1] - a * b_up[0]
#画散点图
X, y = make_blobs(n_samples=60, centers=2, random_state=0, cluster_std=0.4)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap=plt.cm.Paired)
#画函数
plt.plot(x_fit, y_3, '-c')
#画边距
plt.fill_between(x_fit, y_down, y_up, edgecolor='none', color='#AAAAAA', alpha=0.4)
#画支持向量
plt.scatter(clf.support_vectors_[:, 0], clf.support_vectors_[:, 1], edgecolor='b',
            s=80, facecolors='none')

超平面

如果我们遇到这样的数据集，没有办法利用线性分类器进行分类

from sklearn.datasets.samples_generator import make_circles
#画散点图
X, y = make_circles(100, factor=.1, noise=.1, random_state=2019)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap=plt.cm.Paired)
clf = SVC(kernel='linear').fit(X, y)
#最佳函数
x_fit = np.linspace(-1.5, 1.5)
w = clf.coef_[0]
a = -w[0] / w[1]
y_3 = a*X - (clf.intercept_[0]) / w[1]
plt.plot(X, y_3, '-c')

我们可以将二维（低维）空间的数据映射到三维（高维）空间中。
此时，我们便可以通过一个超平面对数据进行划分
所以，我们映射的目的在于使用 SVM 在高维空间找到超平面的能力。

#画图
X, y = make_circles(100, factor=.1, noise=.1, random_state=2019)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap=plt.cm.Paired)
clf = SVC(kernel='rbf')
clf.fit(X, y)
ax = plt.gca()
x = np.linspace(-1, 1)
y = np.linspace(-1, 1)
x_1, y_1 = np.meshgrid(x, y)
P = np.zeros_like(x_1)
for i, xi in enumerate(x):
    for j, yj in enumerate(y):
        P[i, j] = clf.decision_function(np.array([[xi, yj]]))
ax.contour(x_1, y_1, P, colors='k', levels=[-1, 0, 0.9], alpha=0.5,
            linestyles=['--', '-', '--'])
plt.scatter(clf.support_vectors_[:, 0], clf.support_vectors_[:, 1], edgecolor='b',
            s=80, facecolors='none');

此时便完成了非线性分类。

思考与讨论

1.什么是支持向量
假设超平面$(w,b)$能将训练样本正确分类，即对于$(x_i,y_i)\in D$，若$y_i=+1$，则有$w^T{x}_i+b>0$；若$y_i=-1$，则有$w^T{x}_i+b<0$.令
$$\begin{gathered} w^T{x}_i+b\ge +1,y_i=+1 \\ {w}^T+x_i+b\le -1,y_i=-1 \end{gathered}$$
如下图所示，

距离超平面（黑色实线）最近的这几个训练样本点使得上式的等号成立，它们被称为“支持向量”（support vector），两个异类支持向量到超平面的距离之和为：
$$\gamma =\frac{2}{||w||}$$
它被称为“间隔”（margin）.
注意：R语言生成上图的代码为：

#绘制所有点
if( ! require("ISLR") ){ install.packages("ISLR") }
if( ! require("e1071") ){ install.packages("e1071") }
set.seed(0)
DF = data.frame( x1=c(3,2,4,1,2,4,4), x2=c(4,2,4,4,1,3,1),
                y=as.factor(c(rep(1,4),rep(0,3))) )
colors = c( rep('red',4), rep('blue',3) )
plot( DF$x1, DF$x2, col=colors, pch=19, cex=2.0, xlab='X_1', ylab='X_2', main='' )
grid()
#超平面斜率
slope = ( 3.5 - 1.5 ) / ( 4 - 2 )
#超平面截距
intercept = -2 * slope + 1.5
#上边界
slope_m_upper = slope
intercept_m_upper = -2 * slope_m_upper + 2 
#下边界
slope_m_lower = slope
intercept_m_lower = -2 * slope_m_lower + 1 
#画图
plot( DF$x1, DF$x2, col=colors, pch=19, cex=2.0, xlab='X_1', ylab='X_2', main='' )
grid()
#画边界线及超平面
abline(a=intercept,b=slope,col='black')
abline(a=intercept_m_upper,b=slope_m_upper,col='gray',lty=2,lwd=2)
abline(a=intercept_m_lower,b=slope_m_lower,col='gray',lty=2,lwd=2)
grid()

2.支持向量机的推导
欲找到具有“最大间隔”（maximum margin）的划分超平面，也就是要找到能满足1中式中约束的参数$w$和$b$，使得$\gamma$最大，即
$$\begin{array}{rl}& ma{x}_{w,b}\frac{2}{||w||}\\ & s.t.y_i(w^T{x}_i+b)\ge 1,i=1,2,\dots ,m\end{array}$$
显然，为了最大化间隔，仅需最大化$||w|{|}^{-1}$，这等价于最小化$||w|{|}^2$.于是，1中的式子可以重写为
$$\begin{array}{rl}& mi{n}_{w,b}\frac{1}{2}||w|{|}^2\\ & s.t.y_i(w^T{x}_i+b)\ge 1,i=1,2,\dots ,m\end{array}$$
这就是支持向量机（Spuuort Vector Machine，简称SVM）的基本型。
这是一个凸二次规划问题，最优解在边界上达到，支持向量仍然存在。由于训练集是线性可分的，所以可行域非空，该问题有解。
3.SVM的损失函数
SVM的损失函数为
①合页损失(hinge loss)，损失函数定义如下：
$$L_i=\sum _{j\ne y_i}max(0,s_j-s_{y_i}+\Delta )$$
其中，$i$表示第$i$个样品，$j$表示第$j$个种类，那么$y_i$表示第$i$个样品的真实种类。常用的数学表达式为：$s_j=w_T^j{x}_i$.
例如：有3个分类，并且得到了分值，$s=[13,-7,11]$。其中，第一个类别是正确类别，即$y_i=0$。同时假设$\Delta =10$，因此该SVM的损失函数就是两个部分的不正确分类加起来，即为
$$L_i=max(0,-7-13+10)+max(0,11-13+10)=8$$

② 指数损失(exponential loss)：$l_{exp}(z)=exp(-z)$
③ 对率损失(logistic loss)：$l_{log}(z)=log(1+exp(-z))$
从损失加罚的角度看，支持向量机被看作正则化的函数估计问题，其合页损失下的最优估计的概率意义为
$$f(x)=sgn[Pr(Y=+1|x)-\frac{1}{2}]$$
即为，给定$x$，对于$Y=1$的预测超过一半则取1，小于一半则取-1

4.SVM的核函数有哪些，核函数的作用是什么
常见的核函数有
① 线性核 $k(x,x^{{}^{\prime }})=<x,x^{{}^{\prime }}>$
② 多项式核 $k(x,x^{{}^{\prime }})=(1+<x,x^{{}^{\prime }}>{)}^d$
③ 径向基核 $k(x,x^{{}^{\prime }})=exp(-\gamma ||x-x-x^{{}^{\prime }}||{)}^2$
④ 高斯核 $k(x,x^{{}^{\prime }})=exp(\frac{-||x-x^{{}^{\prime }}|{|}^2}{2{\sigma }^2})$
⑤ 神经网络核 $k(x,x^{{}^{\prime }})=tanh(k,<x,x^{{}^{\prime }}+k_2>)$
核技巧可以用线性方法解决非线性可分的情况。核技巧的想法是，在学习和预测中只定义核函数，而不显示的定义映射函数。映射函数将输入空间映射到特征空间，而特征空间一般是高维的，甚至是无穷维的。
5.硬间隔和软间隔
硬间隔：所有样本均满足1的约束，即所有样本都必须划分正确。
软间隔：允许某些样本不满足约束
$$y_i(w^T{x}_i+b)\ge 1$$
当然，在最大化间隔的同时，不满足约束的样本应尽可能少。于是，优化目标可写为
$$mi{n}_{w,b}\frac{1}{2}||w|{|}^2+C\sum _{i=1}^m{l}_{0/1}(y_i(w^T{x}_i+b)-1)$$
其中，$C>0$是一个常数，$l_{0/1}$是“0/1损失函数“
$$\begin{array}{rl}{l}_{0/1}(z)=& 1,ifz>0\\ & 0,otherwise\end{array}$$
如果采用hinge损失，则优化目标式变为
$$mi{n}_{w,b}\frac{1}{2}||w|{|}^2+C\sum _{i=1}^{m}max(0,1-y_i(w^T{x}_i+b))$$
引入”松弛变量“(slack variables) ${\xi }_i\ge 0$，可将上式重写为
$$mi{n}_{w,b,{\xi }_i}\frac{1}{2}||w|{|}^2+C\sum _{i=1}^m{\xi }_i$$
因此
$$\begin{array}{rl}s.t.& y_i(w^T{x}_i+b)\ge 1-{\xi }_i\\ & {\xi }_i\ge 0,i=1,2,\dots ,m\end{array}$$
这就是常用的”软间隔支持向量机“.
6.SVM可以做多分类吗，怎么做
可以，方法如下所示。
①直接法：直接在目标函数上进行修改，将多个分类面的参数求解合并到一个最优化问题中，通过求解该最优化问题“一次性”实现多分类。这种方法看似简单，但其计算复杂度比较高，实现起来比较困难，只适合用于小型问题中；
②间接法：通过组合多个二分类器来实现多分类器的构造，常见的方法有一对一和一对多两种。
1)一对一为在任意两类样本之间设计一个SVM，当对一个未知样本进行分类时，得票最多的类别为该未知样本的类别；
2)一对多为训练时依次把某个类别的样本归为一类，其他剩余的归为另一类，分类时将未知样本分类为具有最大分类函数值的那一类。
7.SVM可以做回归吗，怎么做
对于样本$(x,y)$，传统回归模型通常直接基于模型输出$f(x)$与真实输出$y$之间的差别来计算损失，当且仅当$f(x)$与$y$完全相同时候，损失才为零。与此不同，支持向量回归(Support Vector Regression，简称SVR)假设我们能容忍$f(x)$与$y$之间最多有$ϵ$的偏差，即仅当$f(x)$与$y$之间的差别绝对值大于$ϵ$时才计算损失。
就相当于以$f(x)$为中心，构建一个宽度为$2ϵ$的间隔带，若训练样本落入此间隔带，则认为是被预测正确的。
8.SVM的对偶问题，为什么要把原问题转化为对偶问题
因为转化为对偶形式之后，解法和预测时的复杂度降低了，可以通过二次规划算法很快的算出最优解。
9.KKT限制条件有哪些
首先，明确对于拉格朗日乘子函数(${\alpha }_i,{\mu }_i$ 为非负对偶变量)
$$L_p=\frac{1}{2}||w|{|}^2+C\sum _{i=1}^n{\xi }_i-\sum _{i=1}^n{\alpha }_i[y_i(w^T{x}_i+w_0)-(1-{\xi }_i)]-\sum {i=1}^n{\mu }_i{\xi }_i$$
对应的KKT条件为
$$\begin{array}{rl}& w=\sum ^n{\alpha }_i{y}_i{x}_i,0=\sum ^n{\alpha }_i{y}_i,{\alpha }_i=c-{\mu }_i\\ & {\alpha }_i[y_i(w^T{x}_i+w_0)-(1-{\xi }_i)]=0\\ & {\mu }_i{\xi }_i=0\\ & y_i(w^T{x}_i+w_0)\ge 1-{\xi }_i,{\xi }_i\ge 0\\ & {\alpha }_i\ge 0,{\mu }_i\ge 0\end{array}$$
因此KKT条件为
$$\begin{array}{rl}& {\alpha }_i=0y_{i}g(x_i)\ge 1\\ & 0<{\alpha }_i<C{y}_{i}g(x_i)=1\\ & x_j=C{y}_{i}g(x_i)\le 1\end{array}$$
其中，$g(x_i)={\sum }_{j=1}^n{\alpha }_j{y}_j{x}_j\cdot x_i+bb=w_0$
10.假如你在训练SVM时发现模型过拟合了，应该怎样调参数？
调节正则化参数C，一般C越大越容易过拟合，C越小越容易欠拟合。
11.LDA与SVM什么条件下等价？
线性SVM和LDA求出的w互相垂直时，两者是等价的。因为LDA的思想是投影，投影过程和偏置是没有任何关系的，所以SVM这个时候比LDA仅多了个偏移b。
LDA是从多分类出发提出的，其求解有不同方法，但都是一个优化的结果。有的教材是贝叶斯定理，本质上是最大化后验概率，周志华书上是一个二次规划思想。在二分类情形与SVM很相近，但由于优化目标函数不同，结果通常是不同的。两个优化问题的解系数成比例时，二者的分类结果就是等价的。