DataWhale基于支持向量机的分类预测

SVM工作原理

支持向量机（Support Vector Machine，SVM）是一个非常优雅的算法，具有非常完善的数学理论，常用于数据分类，也可以用于数据的回归预测中，由于其其优美的理论保证和利用核函数对于线性不可分问题的处理技巧，在上世纪90年代左右，SVM曾红极一时。

解决什么问题

对于下图中的两类数据，我们的目标是找到一个最好的决策边界将两类数据分开。图中L1，L2，L3三条直线都能将两类数据点区分开，但是效果不尽相同。

假设我们要在湖和石山之间规划一条行车的通道，很容易想到，通道越宽越安全。

那么回到上面的数据划分的问题中，我们就应该选择L2作为决策边界，容错能力更强，分类效果自然比窄的好。

线性可分

通俗理解： 在二维空间上，两类点被一条直线完全分开叫做线性可分。
严格定义： $D_0$和$D_1$是n维欧式空间的两个点集。如果存在n维向量$w$和实数$b$，使得所有属于$D_0$的点$x_i$都有$w{x}_i+b>0$，而对于所有属于$D_1$的点$x_j$则有$w{x}_j+b<0$，则我们称$D_0$ 和$D_1$ 线性可分。

距离

对于上述$w{x}_j+b=0$平面，平面上有$x^{’}$和 $x^{"}$两点，$W$ 为平面的法向量，要求点$x$到平面的距离。可先计算$x$点到$x^{’}$的距离，再投影到平面的法向量上，就可以得到距离定义为：
$$distance(x)=|\frac{w^T}{\Vert w\Vert }(x-x^{’})|=\frac{1}{\Vert w\Vert }|w^{T}x+b|$$其中，$\frac{w^T}{\Vert w\Vert }$为平面法向量的方向,$\Vert w\Vert =\sqrt{w_1^2+w_2^2+...+w_n^2}$
从二维扩展到多维空间中时，将 $D_0$和$D_1$完全正确地划分开的 $w{x}_j+b=0$就成了一个超平面。

为了使这个超平面更具鲁棒性，我们会去找最佳超平面，以最大间隔把两类样本分开的超平面，也称之为最大间隔超平面。

• 两类样本分别分割在该超平面的两侧；
• 两侧距离超平面最近的样本点到超平面的距离被最大化了。

支撑向量

样本中距离超平面最近的一些点，这些点叫做支持向量。
图片来源

标签定义

将数据集定义为$(X_1,Y_1)(X_2,Y_2)...(X_n,Y_n)$，其中，$X_n$为数据的特征，$Y_n$为数据中的标签，当$X_n$在$D_0$数据集中时，$Y_n=+1$,当$X_n$在$D_1$数据集中时，$Y_n=-1$，那么最终的决策方程可以化简为
$$y(x)=w^T\psi (x)+b$$
其中$\psi (x)$表示对数据进行某种变换，可不管他，认为仍是$x$，即：
$$y(x)=w^{T}x+b$$
令，$y_{i}y(x)=y_i(w^{T}x+b)=1$，可以得到如下图所示的两个最大间隔超平面的上下两个超平面，距离最大间隔超平面距离为1，重要的的特性是$y_{i}y(x)>0$。

图片来源

目标函数

已知的信息： 数据点和距离计算方式。
要做的事： 寻找一个最优的决策方程也就是$w$和$b$的值。
优化的目标： 使得离决策方程（超平面）最近的点的距离越远越好。
基于$y_{i}y(x_i)>0$，其中$y(x_i)$即$|w^{T}x+b|$，由于标签值只能是±1，所以乘$y_i$不会改变结果，但能直接把绝对值去掉，所以距离公式可以直接化简为：$$distance(x)=\frac{1}{\Vert w\Vert }|w^T\psi (x)+b|=\frac{y_i(w^T\psi (x)+b)}{\Vert w\Vert }$$
所以目标函数可以定义为：
arg ⁡ max ⁡ w , b { 1 ∥ w ∥ min ⁡ i   [ y i ( w T ψ ( x i ) ) + b   ] } \mathop{\arg\max}\limits_{w,b}\{\cfrac{1}{\Vert w \Vert}\mathop{\min}\limits_{i}\ [y_i(w^T\psi(x_i))+b \ ] \} w,bargmax​{∥w∥1​imin​ [yi​(wTψ(xi​))+b ]}
上式首先要求的是距离，目的在于找到里边界最近的样本点，然后再求$\underset{w,b}{\mathrm{argmax}}$,也就是找到最合适的决策边界$w和b$，使其离这个样本点的距离越大越好。
为了方便求解，需要对上式进行化简，因为$y_{i}y(x)>0$，通过缩放变换把要求变得更严，令$y_i(w^T{x}_i+b)\ge 1$，可得$\underset{i}{\min }[y_i(w^T\psi (x_i))+b]$的最小值就是1。因此只需要考虑 arg ⁡ max ⁡ w , b { 1 ∥ w ∥ } \mathop{\arg\max}\limits_{w,b}\{\cfrac{1}{\Vert w \Vert}\} w,bargmax​{∥w∥1​}即可。新的目标函数为：
{ arg ⁡ max ⁡ w , b { 1 ∥ w ∥ } s t .     y i ( w T ψ ( x i ) + b ) ≥ 1 \begin{cases}\mathop{\arg\max}\limits_{w,b}\{\cfrac{1}{\Vert w \Vert}\}\\st. \ \ \ y_i(w^T\psi(x_i)+b)≥1\end{cases} ⎩⎪⎨⎪⎧​w,bargmax​{∥w∥1​}st.   yi​(wTψ(xi​)+b)≥1​
上式是一个极大值问题，但机器学习的常规套路是转换成求极小值问题，求一个数的极大值等同于求它的倒数的极小值，且我们关注的是取得极值点时的$w和b$而非具体的极值，对于公式中的函数变换或加入常数项并不影响$w和b$，因此上式转化为：
{ arg ⁡ min ⁡ w , b { 1 2 ∥ w ∥ 2 } s t .     y i ( w T ψ ( x i ) + b ) ≥ 1 \begin{cases}\mathop{\arg\min}\limits_{w,b}\{\cfrac{1}{2}\Vert w \Vert^2\}\\st. \ \ \ y_i(w^T\psi(x_i)+b)≥1\end{cases} ⎩⎪⎨⎪⎧​w,bargmin​{21​∥w∥2}st.   yi​(wTψ(xi​)+b)≥1​

求解

拉格朗日乘子法

拉格朗日乘子法用于计算有约束条件下函数的极值优化问题：
$$\{\begin{array}{l}\min f_0(x)\\ st.f_i(x)<=0,i=1,2,...,m,h_i(x)=0,i=1,2...,q\end{array}$$
$$\min L(x,\lambda ,v)=f_0(x)+\sum _{i=1}^m{\lambda }_i{f}_i(x)+\sum _{i=1}^q{v}_i{h}_i(x)$$
直接将目标函数和约束条件套用拉格朗日乘子法，此时约束条件只有一个，得到下式：
{ min ⁡ f ( w ) = arg ⁡ min ⁡ w , b { 1 2 ∥ w ∥ 2 } s t .     g i ( w ) = −   [ y i ( w T ψ ( x i ) + b ) − 1   ] ≤ 0 \begin{cases}\mathop{\min}f(w)=\mathop{\arg\min}\limits_{w,b}\{\cfrac{1}{2}\Vert w \Vert^2\}\\st.\ \ \ g_i(w)=-\ [y_i(w^T\psi(x_i)+b)-1\ ]≤0\end{cases} ⎩⎪⎨⎪⎧​minf(w)=w,bargmin​{21​∥w∥2}st.   gi​(w)=− [yi​(wTψ(xi​)+b)−1 ]≤0​
进一步得到$$L(w,b,\alpha )=\frac{1}{2}\Vert w{\Vert }^2-\sum _{i=1}^n{\alpha }_i[y_i(w^T\psi (x_i)+b)-1]$$
对上式种$w,b$求偏导，并令其偏导等于0，得到：
$$\begin{gathered} \frac{\partial L}{\partial w}=0=>w=\sum _{i=1}^n{\alpha }_i{y}_i\psi (x_i) \\ \frac{\partial L}{\partial b}=0=>b=\sum _{i=1}^n{\alpha }_i{y}_i \end{gathered}$$
上述结果代入$L(w,b,\alpha )$，化简如下：
$$\begin{gathered} L(w,b,\alpha )=\frac{1}{2}\Vert w{\Vert }^2-\sum _{i=1}^n{\alpha }_i[y_i(w^T\psi (x_i)+b)-1] \\ =\frac{1}{2}{w}^{T}w-w^T\sum _{i=1}^n{\alpha }_i{y}_i\psi (x_i)-b\sum _{i=1}^n{\alpha }_i{y}_i+\sum _{i=1}^n{\alpha }_i \\ =\sum _{i=1}^n{\alpha }_i-\frac{1}{2}\sum _{i,j=1}^n{\alpha }_i{\alpha }_j{y}_i{y}_j{\psi }^T(x_i)\psi (x_j) \end{gathered}$$
此时目标变为$\alpha$为多少时，$L(w,b,\alpha )$的值最大，转换为求其相反数的最小值：
$$\{\begin{array}{l}\underset{\alpha }{\min }\frac{1}{2}\sum _{i,j=1}^n{\alpha }_i{\alpha }_j{y}_i{y}_j{\psi }^T(x_i)\psi (x_j)-\sum _{i=1}^n{\alpha }_i\\ st.\sum _{i=1}^n{\alpha }_i{y}_i=0,{\alpha }_i>=0\end{array}$$

支持向量机求解

举例：

图中$x_1(3,3)、x_2(3,4)为正例，x_3(1,1)为负例$，将三个点代入$$\{\begin{array}{l}\underset{\alpha }{\min }\frac{1}{2}\sum _{i,j=1}^n{\alpha }_i{\alpha }_j{y}_i{y}_j{\psi }^T(x_i)\psi (x_j)-\sum _{i=1}^n{\alpha }_i\\ st.\sum _{i=1}^n{\alpha }_i{y}_i=0,{\alpha }_i>=0\end{array}$$中，得到：
$$\{\begin{array}{l}\underset{\alpha }{\min }\frac{1}{2}[{\alpha }_1{\alpha }_1\ast 1\ast 1\ast (3\ast 3+3\ast 3)+{\alpha }_1{\alpha }_2\ast 1\ast 1\ast (3\ast 4+3\ast 3)+{\alpha }_1{\alpha }_3\ast 1\ast (-1)\\ +{\alpha }_2\alpha 1\ast 1\ast 1\ast (4\ast 3+3\ast 3)+{\alpha }_2{\alpha }_2\ast 1\ast 1\ast (4\ast 4+3\ast 3)+{\alpha }_2{\alpha }_3\ast 1\ast (-1)\ast (3\ast 1+3\ast 1)\\ +{\alpha }_3{\alpha }_1\ast (-1)\ast 1\ast (1\ast 3+1\ast 3)+{\alpha }_3{\alpha }_2\ast (-1)\ast 1\ast (1\ast 4+1\ast 3)+{\alpha }_3{\alpha }_3\ast (-1)\ast (-1)\ast (1\ast 1+1\ast 1)]\\ -({\alpha }_1+{\alpha }_2+{\alpha }_3)\\ st.{\alpha }_1\ast 1+{\alpha }_2\ast 1+{\alpha }_3\ast (-1)=0,{\alpha }_1,{\alpha }_2,{\alpha }_3>=0,i=1,2,3\end{array}$$
两式联立，对结果中${\alpha }_1,{\alpha }_2$分别求偏导，并令偏导等于0得到：
$$\{\begin{array}{l}{\alpha }_1=0,{\alpha }_2=2/13\\ {\alpha }_1=0.25,{\alpha }_2=0\end{array}$$
将上述两组解分别代入上上式中即可得出所有${\alpha }_{1,2,3}$的值，再计算$w,b$的值，本例解为$w=(0.5,0.5),b=-2$
需要特别注意的是本例中$x_1(3,3)、x_3(1,1)$就叫做支撑向量

调参

软间隔

在之前的分析中，需要寻找的时再将两类数据完全分开的情况下，让决策边界越宽越好，比如：

如果不考虑图中的离群点那么L2应该是我们要寻找的决策边界，但是如果要把这个点考虑进去，那么L1就应该是我们新的决策边界了。但是为了满足个别点模型做出来了较大的牺牲，这些点往往可能是异常值、离群点，这时候，可能模型就会过拟合。
我们引入软间隔允许个别样本点出现在间隔带里面。
具体过程不再阐述，参考本链接

核函数

$y_i(w^T\psi (x_i)+b)\ge 1$中$\psi (x_i)$就是核函数，在逻辑回归中，我们通过相关性分析，主成分分析等方法对数据降维提取主要信息，这里的核函数做的工作却是升维。

对于上面的二维线性不可分数据集，通过一种数据变换方法将其映射到三维空间中：

线性不可分任务就变得可分了。
变换的方法主要是内积运算。常用的核函数是高斯核函数：
$$k(x_1,x_2)=<\psi (x_1),\psi (x_2)>=e^{-\frac{\Vert x_1-x_2{\Vert }^2}{2{\sigma }^2}}$$

实践

Demo实践

Step1:库函数导入

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

Step2:构建数据集并进行模型训练

##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) 

Step3:模型参数查看

## 查看其对应模型的w
print('the weight(w) of Logistic Regression:',svc.coef_)
## 查看其对应模型的b
print('the intercept(b) of Logistic Regression:',svc.intercept_)
#the weight(w) of Logistic Regression: [[0.33364706 0.33270588]]
#the intercept(b) of Logistic Regression: [-0.00031373]

超平面为：$0.33364706\ast x_1+0.33270588\ast x_2-0.00031373=0$

Step4:模型预测

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

Step5:模型可视化

#绘图函数
def plot_svc_decision_function(model, ax=None, plot_support=True):
   
    if ax is None:
        ax = plt.gca()
    xlim = ax.get_xlim()
    ylim = ax.get_ylim()
    
    # 用SVM自带的decision_function函数来绘制
    x = np.linspace(xlim[0], xlim[1], 30)
    y = np.linspace(ylim[0], ylim[1], 30)
    Y, X = np.meshgrid(y, x)
    xy = np.vstack([X.ravel(), Y.ravel()]).T
    P = model.decision_function(xy).reshape(X.shape)
    
    # 绘制决策边界
    ax.contour(X, Y, P, colors='k',
               levels=[-1, 0, 1], alpha=0.5,
               linestyles=['--', '-', '--'])
    
    # 绘制支持向量
    if plot_support:
        ax.scatter(model.support_vectors_[:, 0],
                   model.support_vectors_[:, 1],
                   s=300, linewidth=1, alpha=0.2);
    ax.set_xlim(xlim)
    ax.set_ylim(ylim)
plt.scatter(x_fearures[:, 0], x_fearures[:, 1], c=y_label, s=50, cmap='autumn')
plot_svc_decision_function(svc)

#查看支撑向量
svc.support_vectors_
array([[-1., -2.],
       [-2., -1.],
       [ 2.,  1.]])

支持向量机介绍

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets.samples_generator import make_blobs#引入造数函数，此写法会出现警告
from sklearn.datasets import make_blobs#引入造数函数，推荐
'''
make_blobs造数函数，产生一个数据集和相应的标签
n_samples:表示数据样本点个数,默认值100
n_features:表示数据的维度，默认值是2
centers:产生数据的中心点，默认值3
cluster_std：数据集的标准差，浮点数或者浮点数序列，默认值1.0
center_box：中心确定之后的数据边界，默认值(-10.0, 10.0)
shuffle ：洗乱，默认值是True
random_state:随机生成器的种子
'''
%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)#生成50个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)

可以看到， 蓝色的线最大间隔是大于黑色的线的。所以我们会选择蓝色的线作为我们的分类器。那么，我们现在的分类器是最优分类器吗？或者说，有没有更好的分类器，它具有更大的间隔？答案是有的。为了找出最优分类器，我们需要引入我们今天的主角：SVM。

from sklearn.svm import SVC
# SVM 函数
clf = SVC(kernel='linear')
clf.fit(X, y)
SVC(C=1.0, break_ties=False, cache_size=200, class_weight=None, coef0=0.0,decision_function_shape='ovr', degree=3, gamma='scale', kernel='linear',max_iter=-1, probability=False, random_state=None, shrinking=True,tol=0.001, verbose=False)

参数	说明
C	C-SVC的惩罚参数C默认值是1.0C越大，相当于惩罚松弛变量，希望松弛变量接近0，即对误分类的惩罚增大，趋向于对训练集全分对的情况，这样对训练集测试时准确率很高，但泛化能力弱。C值小，对误分类的惩罚减小，允许容错，将他们当成噪声点，泛化能力较强。
kernel	核函数，默认是rbf，可以是‘linear’, ‘poly’, ‘rbf’, ‘sigmoid’, ‘precomputed’
degree	多项式poly函数的维度，默认是3，选择其他核函数时会被忽略。
gamma	‘rbf’,‘poly’ 和‘sigmoid’的核函数参数。默认是’auto’，则会选择1/n_features
coef0	核函数的常数项。对于‘poly’和 ‘sigmoid’有用。
probability	是否采用概率估计.默认为False决定是否启用概率估计。需要在训练fit()模型时加上这个参数，之后才能用相关的方法：predict_proba和predict_log_proba
shrinking	是否采用shrinking heuristic方法，默认为true
tol	停止训练的误差值大小，默认为1e-3
cache_size	核函数cache缓存大小，默认为200
class_weight	类别的权重，字典形式传递。设置第几类的参数C为weight*C(C-SVC中的C)
verbose	允许冗余输出？
max_iter	最大迭代次数。-1为无限制。
decision_function_shape	‘ovo’, ‘ovr’ or None, default=None
random_state	数据洗牌时的种子值，int值

# 最佳函数
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 在高维空间找到超平面的能力。

# 数据映射
r = np.exp(-(X[:, 0] ** 2 + X[:, 1] ** 2))#高斯核函数
ax = plt.subplot(projection='3d')
ax.scatter3D(X[:, 0], X[:, 1], r, c=y, s=50, cmap=plt.cm.Paired)
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_zlabel('z')
x_1, y_1 = np.meshgrid(np.linspace(-1, 1), np.linspace(-1, 1))
z =  0.01*x_1 + 0.01*y_1 + 0.5
ax.plot_surface(x_1, y_1, z, alpha=0.3)

高斯核函数的解决方法

# 画图
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');

可以看出对比线性核函数，结果发生了变化，不可分任务变得可分了。