Python-支持向量机 决策边界 最大化margin、使用多项式特征和核函数、高斯核函数、超参数 γ、SVM解决回归问题

本博客运行环境为Jupyter Notebook-Python3。

支持向量机(Support Vector Machine)

支持向量机（Support Vector Machine, SVM）是一类按监督学习（supervised learning）方式对数据进行二元分类的广义线性分类器（generalized linear classifier），其决策边界是对学习样本求解的最大边距超平面（maximum-margin hyperplane） 。
SVM使用铰链损失函数（hinge loss）计算经验风险（empirical risk）并在求解系统中加入了正则化项以优化结构风险（structural risk），是一个具有稀疏性和稳健性的分类器 。SVM可以通过核方法（kernel method）进行非线性分类，是常见的核学习（kernel learning）方法之一。

决策边界

一条比较好的决策边界，它离红色样本点和蓝色样本点一样远。在两个类别中，离决策边界最近的那些点都尽可能的远。红色样本有两个点，蓝色样本有一个点，这三个点到决策边界的距离是所有样本点中最近的，且距离是相等的。这三个点定义出了两条和决策边界平行的线。这两条平行线之间没有任何的样本点。这就是支持向量机的思想。
SVM尝试找到中间那条最优的决策边界，这个决策边界距离两个类别最近的样本最远。最近的样本点就是支持向量。

这两条平行线离决策边界的距离相等，记为 d ，margin就是 2d 。SVM就是要最大化margin。
现在看到的都是假设样本点是线性可分的情况，就是存在一条直线(平面)能将这些样本划分。这样的算法通常又称为 Hard Margin SVM 。
但是实际情况中，很多数据是线性不可分的，这时SVM可以通过改进得到 Soft Margin SVM 。

最大化margin

margin =2d ，SVM要最大化margin。主要看重d的值，而d就是点到直线的距离。

式子如上，右边是个分段函数，我们可以用一个式子描述：
$$y^i(w^T{x}^i+b)\ge 1$$
可以代入 y^i 去验证看看。
对于任意支持向量 x ，我们最大化d，就是最大化下面这个式子：
$$max\frac{w^{T}x+b}{||w||}$$
而对于支持向量，它的结果要么等于 1 ，要么等于 -1 。上面取绝对值后就是 1 ，上式可以简写成：
$$max\frac{1}{||w||}=min||w||$$
为了方便求导，通常写成
$$min\frac{1}{2}||w|{|}^2$$
整个支持向量机的最优化问题就变成了，在条件
$$y^i(w^T{x}^i+b)\ge 1$$
的情况下，最优化
$$min\frac{1}{2}||w|{|}^2$$

Soft Margin SVM

在Hard Margin SVM 中本质就是求解一个这样有条件最小化问题。但是如果某类的样本点分布比较奇怪，需要找出一条直线分开这两种类别。

我们的SVM算法要有一定的容错能力，在一些情况下可以把某些点进行错误的分类，尽量保证泛化能力较高。
这种SVM就叫Soft Margin SVM，我们上面说Hard Margin SVM的条件是
$$y^i(w^T{x}^i+b)\ge 1$$
对于margin区域里，必须是任何数据点都没有的。
现在我们宽松个条件，这个宽松量记为$${\zeta }_i$$
把条件宽松定义为：
$$y^i(w^T{x}^i+b)\ge 1-{\zeta }_i$$

宽松条件后，样本点可以出现在虚线与平行于决策边界的直线之间。是 $$w^{T}x+b=1$$与 $$w^{T}x+b=1-\zeta$$之间
同时，这个$$\zeta \ge 0$$
为了防止ζ 设的过大，我们需要对最小化的式子做一个限制，增加一个正则项：
$$min\frac{1}{2}||w|{|}^2+\sum _{i=1}^m{\zeta }_i$$

Soft Margin SVM完整的式子：
增加了一个超参数 C 来控制正则项的重要程度。 C 越小容错空间越大。

未经标准化的原始数据点分布，代码如下：

import numpy as np 
import matplotlib.pyplot as plt 
from sklearn import datasets 
from sklearn.preprocessing import StandardScaler 
from sklearn.svm import LinearSVC 

iris = datasets.load_iris() 
X = iris.data 
y = iris.target 
X = X [y<2,:2] #只取y<2的类别，也就是0 1 并且只取前两个特征
y = y[y<2] # 只取y<2的类别 
# 分别画出类别0和1的点 
plt.scatter(X[y==0,0],X[y==0,1],color='red') 
plt.scatter(X[y==1,0],X[y==1,1],color='blue') 
plt.show() 

运行结果如下：

绘制决策边界，代码如下：

from sklearn.preprocessing import StandardScaler
from sklearn.svm import LinearSVC

# 标准化 
standardScaler = StandardScaler() 
standardScaler.fit(X) #计算训练数据的均值和方差 
X_standard = standardScaler.transform(X) #再用scaler中的均值和方差来转换X，使X标准化 
svc = LinearSVC(C=1e9) #线性SVM分类器 
svc.fit(X_standard,y) # 训练svm

def plot_decision_boundary(model, axis):
    x0, x1 = np.meshgrid( np.linspace(axis[0], axis[1], int((axis[1]-axis[0])*100)).reshape(-1,1), np.linspace(axis[2], axis[3], int((axis[3]-axis[2])*100)).reshape(-1,1) )
    X_new = np.c_[x0.ravel(), x1.ravel()] 
    y_predict = model.predict(X_new) 
    zz = y_predict.reshape(x0.shape)
    from matplotlib.colors import ListedColormap
    custom_cmap = ListedColormap(['#EF9A9A','#FFF59D','#90CAF9'])
    plt.contourf(x0, x1, zz, linewidth=5, cmap=custom_cmap) # 绘制决策边界 
plot_decision_boundary(svc,axis=[-3,3,-3,3]) # x,y轴都在-3到3之间 
# 绘制原始数据 
plt.scatter(X_standard[y==0,0],X_standard[y==0,1],color='red') 
plt.scatter(X_standard[y==1,0],X_standard[y==1,1],color='blue') 
plt.show()   

运行结果如下：

我们再次实例化一个svc，并传入一个较小的 C=0.01。代码如下：

svc2 = LinearSVC(C=0.01)
svc2.fit(X_standard, y)
plot_decision_boundary(svc2, axis=[-3, 3, -3, 3])
plt.scatter(X_standard[y==0, 0], X_standard[y==0, 1], color='red')
plt.scatter(X_standard[y==1, 0], X_standard[y==1, 1], color='blue')
plt.show()

运行结果如下：
看到和第一个决策边界的不同，在这个决策边界汇总，有一个红点是分类错误的。C 越小容错空间越大。

获取学习到的权重系数，代码如下：

 svc.coef_  #获取学习到的权重系数

运行结果如下：
array([[ 4.03243457, -2.50701458]])

获取偏差，代码如下：

svc.intercept_ #获取偏差

运行结果如下：
array([0.92734446])

画出除了决策边界以外的两条跟支持向量相关的直线。
代码如下：

def plot_svc_decision_boundary(model, axis):
    x0, x1 = np.meshgrid(np.linspace(axis[0], axis[1], int((axis[1] - axis[0])*100)).reshape(1, -1),np.linspace(axis[2], axis[3], int((axis[3] - axis[2])*100)).reshape(1, -1),)
    x_new = np.c_[x0.ravel(), x1.ravel()]
    y_predict = model.predict(x_new)
    zz = y_predict.reshape(x0.shape)
    from matplotlib.colors import ListedColormap
    custom_cmap = ListedColormap(['#EF9A9A', '#FFF59D', '#90CAF9'])
    plt.contourf(x0, x1, zz, linewidth=5, cmap=custom_cmap)
    w = model.coef_[0]
    b = model.intercept_[0]
    # w0*x0 + w1*x1 + b = 0
    # x1 = -w0/w1 * x0 - b/w1
    plot_x = np.linspace(axis[0], axis[1], 200)
    up_y = -w[0]/w[1] * plot_x - b/w[1] + 1/w[1]
    down_y = -w[0]/w[1] * plot_x - b/w[1] - 1/w[1]
    up_index = (up_y >= axis[2]) & (up_y <= axis[3])
    down_index = (down_y >= axis[2]) & (down_y <= axis[3])
    plt.plot(plot_x[up_index], up_y[up_index], color='black')
    plt.plot(plot_x[down_index], down_y[down_index], color='black')
plot_svc_decision_boundary(svc, axis=[-3, 3, -3, 3])
plt.scatter(X_standard[y==0, 0], X_standard[y==0, 1], color='red')
plt.scatter(X_standard[y==1, 0], X_standard[y==1, 1], color='blue')
plt.show()

运行结果如下：

c=0.01时，代码如下：

plot_svc_decision_boundary(svc2, axis=[-3, 3, -3, 3])
plt.scatter(X_standard[y==0, 0], X_standard[y==0, 1], color='red')
plt.scatter(X_standard[y==1, 0], X_standard[y==1, 1], color='blue')
plt.show()

运行结果如下：

c=0.1时，代码如下：

svc3 = LinearSVC(C=0.1)
svc3.fit(X_standard, y)
# 从上述结果可以看出sklearn中对于svm封装的linearSVC默认对于多分类使用ovr，L2正则。
plot_svc_decision_boundary(svc3, axis=[-3, 3, -3, 3])
plt.scatter(X_standard[y==0, 0], X_standard[y==0, 1], color='red')
plt.scatter(X_standard[y==1, 0], X_standard[y==1, 1], color='blue')
plt.show()

运行结果如下：

使用多项式特征和核函数

数据处理

处理非线性的数据，代码如下：

import numpy as np 
import matplotlib.pyplot as plt 
from sklearn import datasets 

X, y = datasets.make_moons() #使用生成的数据 
print(X.shape) # (100,2) 
print(y.shape) # (100,)

运行结果如下：
(100, 2)
(100,)

绘制生成的数据，代码如下：

plt.scatter(X[y==0,0],X[y==0,1])
plt.scatter(X[y==1,0],X[y==1,1])
plt.show()

运行结果如下：

给数据集增加一些噪声点，代码如下：

X, y = datasets.make_moons(noise=0.15,random_state=777) #随机生成噪声点，random_state是随机种子，noise是方差 
plt.scatter(X[y==0,0],X[y==0,1]) 
plt.scatter(X[y==1,0],X[y==1,1]) 
plt.show()

运行结果如下：

分类

通过多项式特征的SVM来对它进行分类，代码如下：

from sklearn.preprocessing import PolynomialFeatures,StandardScaler 
from sklearn.svm import LinearSVC 
from sklearn.pipeline import Pipeline 
def PolynomialSVC(degree,C=1.0): 
    #生成多项式 \ 标准化 \最后生成svm
    return Pipeline([ ("poly",PolynomialFeatures(degree=degree)),("std_scaler",StandardScaler()), ("linearSVC",LinearSVC(C=C)) ])
#引入了管道，它可以将许多算法模型串联起来，比如将特征提取、归一化、分类组织在一起形成一个典型的机器学习问题工作流。
poly_svc = PolynomialSVC(degree=3) 
poly_svc.fit(X,y) 
plot_decision_boundary(poly_svc,axis=[-1.5,2.5,-1.0,1.5]) 
plt.scatter(X[y==0,0],X[y==0,1]) 
plt.scatter(X[y==1,0],X[y==1,1]) 
plt.show()

运行结果如下：

使用核技巧来对数据进行处理，使其维度提升，使原本线性不可分的数据，在高维空间变成线性可分的。再用线性SVM来进行处理。
代码如下：

from sklearn.svm import SVC 
def PolynomialKernelSVC(degree,C=1.0): 
    # poly代表多项式特征
    return Pipeline([ ("std_scaler",StandardScaler()), ("kernelSVC",SVC(kernel="poly")) ]) 
poly_kernel_svc = PolynomialKernelSVC(degree=3) 
poly_kernel_svc.fit(X,y) 
plot_decision_boundary(poly_kernel_svc,axis=[-1.5,2.5,-1.0,1.5]) 
plt.scatter(X[y==0,0],X[y==0,1]) 
plt.scatter(X[y==1,0],X[y==1,1]) 
plt.show()

运行结果如下：

核函数

通过对偶形式可以将SVM求解转换一下

变成核函数的式子：

在(二次)多项式核函数中，它的定义是这样的：
$$K(x,y)=(x\cdot y+1{)}^2$$
这两个向量的点乘写成求和的形式，展开后其实是这个式子若干项相乘再相加。

我们可以直接用原来的式子 $$K(x,y)=(x\cdot y+1{)}^2$$进行计算，这就是核技巧，大大降低了计算的复杂度。
如果是多项式(大于二项)，它的式子就是这样的：
$$K(x,y)=(x\cdot y+c{)}^d$$
d 就是上面程序中 degree 的值。这里的 c 是另外一个超参数。
我们也可以用核函数来表示原来的线性SVM，此时的核函数很简单，就是 $$K(x,y)=x\cdot y$$

RBF核函数(高斯核函数)

它的式子如下：
$$K(x,y)=e^{-\gamma ||x-y|{|}^2}$$

高斯核函数的本质是将每个样本点映射到一个无穷多维度的特征空间中。
核函数都是依靠升维使得原本线性不可分的数据变得线性可分。
在多项式特征中，假如原本的数据是 x 的话，我们把原来的数据都变成 x^2 ，这样就变得线性可分了。
原本的数据，是一维的，它是线性不可分的，我们无法只画一条直线将它们分开，就需要进行升维。

代码如下：

import numpy as np 
import matplotlib.pyplot as plt 
x = np.arange(-4,5,1)#生成测试数据 
y = np.array((x >= -2 ) & (x <= 2),dtype='int') 
plt.scatter(x[y==0],[0]*len(x[y==0]))# x取y=0的点, y取0，有多少个x，就有多少个y 
plt.scatter(x[y==1],[0]*len(x[y==1]))
plt.show()

运行结果如下：

使用高斯核函数，将一维的数据映射到二维的空间。代码如下：

# 高斯核函数 
def gaussian(x,l): 
    gamma = 1.0 
    return np.exp(-gamma * (x -l)**2) 
l1,l2 = -1,1 
X_new = np.empty((len(x),2)) #len(x) ,2 
for i,data in enumerate(x): 
    X_new[i,0] = gaussian(data,l1) 
    X_new[i,1] = gaussian(data,l2) 
plt.scatter(X_new[y==0,0],X_new[y==0,1]) 
plt.scatter(X_new[y==1,0],X_new[y==1,1]) 
plt.show()

超参数 γ

核函数中的 γ 类似于$$\frac{1}{2{\sigma }^2}$$
所以，γ 越大，高斯分布越窄；γ 越小，高斯分布越宽。
用代码来演示下 γ 的取值对结果的影响。
生成我们的数据，代码如下：

import numpy as np 
import matplotlib.pyplot as plt 
from sklearn import datasets 

X,y = datasets.make_moons(noise=0.15,random_state=777) 
plt.scatter(X[y==0,0],X[y==0,1]) 
plt.scatter(X[y==1,0],X[y==1,1])
plt.show()

运行结果如下：

接下来定义一个RBF核的SVM，代码如下：

from sklearn.preprocessing import StandardScaler 
from sklearn.svm import SVC 
from sklearn.pipeline import Pipeline 
def RBFKernelSVC(gamma=1.0): 
    return Pipeline([ ('std_scaler',StandardScaler()), ('svc',SVC(kernel='rbf',gamma=gamma)) ]) 
svc = RBFKernelSVC() 
svc.fit(X,y) 
plot_decision_boundary(svc,axis=[-1.5,2.5,-1.0,1.5]) 
plt.scatter(X[y==0,0],X[y==0,1]) 
plt.scatter(X[y==1,0],X[y==1,1]) 
plt.show()

运行结果如下：

上述是设置 γ = 1 . 0 时所得到的决策边界。我们调整下它的值为100，代码如下：

from sklearn.preprocessing import StandardScaler 
from sklearn.svm import SVC 
from sklearn.pipeline import Pipeline 
def RBFKernelSVC(gamma=1.0): 
    return Pipeline([ ('std_scaler',StandardScaler()), ('svc',SVC(kernel='rbf',gamma=gamma)) ]) 
svc = RBFKernelSVC(100) #修改了此处
svc.fit(X,y) 
plot_decision_boundary(svc,axis=[-1.5,2.5,-1.0,1.5]) 
plt.scatter(X[y==0,0],X[y==0,1]) 
plt.scatter(X[y==1,0],X[y==1,1]) 
plt.show()

运行结果如下：

γ 取值越大，就是高斯分布的钟形图越窄，这里相当于每个样本点都形成了钟形图。
很明显这样是过拟合的，我们再设一下 γ。
代码如下：

from sklearn.preprocessing import StandardScaler 
from sklearn.svm import SVC 
from sklearn.pipeline import Pipeline 
def RBFKernelSVC(gamma=1.0): 
    return Pipeline([ ('std_scaler',StandardScaler()), ('svc',SVC(kernel='rbf',gamma=gamma)) ]) 
svc = RBFKernelSVC(10) #修改了此处
svc.fit(X,y) 
plot_decision_boundary(svc,axis=[-1.5,2.5,-1.0,1.5]) 
plt.scatter(X[y==0,0],X[y==0,1]) 
plt.scatter(X[y==1,0],X[y==1,1]) 
plt.show()

运行结果如下：

再小一点时，此时它是欠拟合的。
因此，我们可以看出 γ 值相当于在调整模型的复杂度。
代码如下：

from sklearn.preprocessing import StandardScaler 
from sklearn.svm import SVC 
from sklearn.pipeline import Pipeline 
def RBFKernelSVC(gamma=1.0): 
    return Pipeline([ ('std_scaler',StandardScaler()), ('svc',SVC(kernel='rbf',gamma=gamma)) ]) 
svc = RBFKernelSVC(0.1) #修改了此处
svc.fit(X,y) 
plot_decision_boundary(svc,axis=[-1.5,2.5,-1.0,1.5]) 
plt.scatter(X[y==0,0],X[y==0,1]) 
plt.scatter(X[y==1,0],X[y==1,1]) 
plt.show()

运行结果如下：

SVM解决回归问题

我们回归问题的本质是找到这样一条线能尽可能的拟合我们的数据点。对于SVM来说，对于拟合的定义是指定margin值，期望在margin范围里包含的数据点越多越好。我们取中间的直线作为回归的结果。与解决分类问题是一个相反的思路。
代码如下：

import numpy as np
import matplotlib.pyplot as plt 
from sklearn import datasets 
boston = datasets.load_boston() 
X = boston.data 
y = boston.target 
from sklearn.model_selection import train_test_split 
X_train,X_test,y_train,y_test = train_test_split(X,y,random_state=777) # 把数据集拆分成训练数据和测试数据 
from sklearn.svm import LinearSVR 
from sklearn.svm import SVR 
from sklearn.preprocessing import StandardScaler 
def StandardLinearSVR(epsilon=0.1): 
    return Pipeline([ ('std_scaler',StandardScaler()), ('linearSVR',LinearSVR(epsilon=epsilon)) ]) 
svr = StandardLinearSVR() 
svr.fit(X_train,y_train) 
svr.score(X_test,y_test) 

运行结果如下：
0.6989147490236325

参考教程：http://blog.sina.com.cn/s/blog_6c3438600102yn9x.html