SVM算法编程练习

目录

  • 支持向量机
    • 简介
    • 什么是支持向量机
    • Soft Margin SVM
  • SVM算法编程练习
    • 1.未经标准化的原始数据点分布
      • 绘制这个决策边界:
      • 再次实例化一个svc,并传入一个较小的 C
    • 2.使用多项式特征和核函数
      • 绘制下生成的数据
      • 增加一些噪声点
      • 通过多项式特征的SVM来对它进行分类
      • 使用核技巧来对数据进行处理
    • 3.核函数
    • 4.超参数γ
      • 生成数据:
      • 定义一个RBF核的SVM
    • 5.回归问题

支持向量机

简介

支持向量机是一类按监督学习方式对数据进行二元分类的广义线性分类器,其决策边界是对学习样本求解的最大边距超平面

什么是支持向量机

在 感知机 中,我们介绍过,假设存在这样的两类点,我们可以学得一条决策边界将它们分开,比如是条这样的直线:
SVM算法编程练习_第1张图片但是得到的决策边界不唯一,根据选择训练集数据的顺序可以得到不同的决策边界:
SVM算法编程练习_第2张图片

但是这两条决策边界的泛化能力都不好,为什么这么说呢,因为这两条线都离某个类别的点太近了,很可能测试集中未知的点会被错误的分类。
那么什么样的决策边界才是最好的呢?
SVM算法编程练习_第3张图片
这就是一条比较好的决策边界,它离红色样本点和蓝色样本点一样远。在两个类别中,离决策边界最近的那些点都尽可能的远。红色样本有两个点,蓝色样本有一个点,这三个点到决策边界的距离是所有样本点中最近的,且距离是相等的。
SVM算法编程练习_第4张图片
这三个点定义出了两条和决策边界平行的线。这两条平行线之间没有任何的样本点。这就是支持向量机的思想。
SVM尝试找到中间那条最优的决策边界,这个决策边界距离两个类别最近的样本最远。
这些最近的样本点就是支持向量,这也是为什么叫支持向量机

Soft Margin SVM

实际情况中,很多数据是线性不可分的,这时SVM可以通过改进得到 Soft Margin SVM
SVM算法编程练习_第5张图片
在Hard Margin SVM 中本质就是求解一个这样有条件最小化问题。但是如果某类的样本点分布比较奇怪,如
SVM算法编程练习_第6张图片

此时Hard Margin SVM要做的是找出一条直线分开这两种类别:
SVM算法编程练习_第7张图片虽然它正确的分开了蓝色样本和红色样本,但是离红色样本太近的。对于大多数的蓝色样本点都集中在左下角位置,只有一个outlier在右边的位置。很可能这个outlier是错误的点。哪怕它是正确的点,它也不能代表一般的点。
SVM算法编程练习_第8张图片很可能绿色这个决策边界才是比较好的,虽然它错误的分类了outlier的点,但是可能在真实情况下表现的更好。也就是泛化能力更强。
所以我们的SVM算法要有一定的容错能力,在一些情况下可以把某些点进行错误的分类,尽量保证泛化能力较高。
这种SVM就叫Soft Margin SVM,我们上面说Hard Margin SVM的条件是
y i ( w T x i + b ) ≥ 1 y i ( w T x i + b ) ≥ 1 y^i(w^Tx^i+b) \geq 1 y i ( w T x i + b ) ≥ 1 yi(wTxi+b)1yi(wTxi+b)1
它的意思是对于margin区域里,必须是任何数据点都没有的。
现在我们宽松个条件,这个宽松量记为 ζ i ζ i \zeta_i ζ i ζiζi
把条件宽松为:
y i ( w T x i + b ) ≥ 1 − ζ i y i ( w T x i + b ) ≥ 1 − ζ i y^i(w^Tx^i+b) \geq 1 - \zeta_i y i ( w T x i + b ) ≥ 1 − ζ i yi(wTxi+b)1ζiyi(wTxi+b)1ζi

SVM算法编程练习_第9张图片也就是说,宽松条件后,样本点可以出现在虚线与平行于决策边界的直线之间。上面是 w T x + b = 1 w T x + b = 1 w^Tx+b =1 w T x + b = 1 wTx+b=1wTx+b=1 w T x + b = 1 − ζ w T x + b = 1 − ζ w^Tx+b = 1 -\zeta w T x + b = 1 − ζ wTx+b=1ζwTx+b=1ζ之间。
同时,这个 ζ ≥ 0 ζ ≥ 0 \zeta \geq 0 ζ ≥ 0 ζ0ζ0
为了防止 ζ ζ \zeta ζ ζζ 设的过大,我们需要对最小化的式子做一个限制,增加一个正则项:
m i n 1 2 ∣ ∣ w ∣ ∣ 2 + ∑ i = 1 m ζ i m i n 21 w 2 + i = 1 ∑ m ζ i min\frac{1}{2}||w||^2 + \sum_{i=1}^m \zeta_i m i n 2 1 w 2 + i = 1 ∑ mζ i min21w2+i=1mζimin21w2+i=1mζi
这就是Soft Margin SVM完整的式子:
SVM算法编程练习_第10张图片这里增加了一个超参数 C C 来控制正则项的重要程度。 C C 越小容错空间越大。

SVM算法编程练习

1.未经标准化的原始数据点分布

import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets
from sklearn.preprocessing import StandardScaler
from sklearn.svm import LinearSVC 
iris=datasets.load_iris()
X=iris.data 
y=iris.target 
#只取y<2的类别,也就是0 1 并且只取前两个特征
X=X[y<2,:2]
# 只取y<2的类别 # 分别画出类别01的点 
y=y[y<2]
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()
# 标准化 
standardScaler=StandardScaler()
#计算训练数据的均值和方差 
standardScaler.fit(X)
X_standard=standardScaler.transform(X)#再用scaler中的均值和方差来转换X,使X标准化 
#线性SVM分类器 
svc=LinearSVC(C=1e9)
# 训练svm
svc.fit(X_standard,y)

SVM算法编程练习_第11张图片

绘制这个决策边界:

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轴都在-33之间
# 绘制原始数据即散点图
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()

SVM算法编程练习_第12张图片

再次实例化一个svc,并传入一个较小的 C

#C越小容错空间越大
svc2 = LinearSVC(C=0.01)
svc2.fit(X_standard,y)
plot_decision_boundary(svc2,axis=[-3,3,-3,3]) # x,y轴都在-33之间
# 绘制原始数据
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()

SVM算法编程练习_第13张图片可以很明显的看到和第一个决策边界的不同,在这个决策边界汇总,有一个红点是分类错误的,C 越小容错空间越大。

2.使用多项式特征和核函数

处理非线性的数据

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

在这里插入图片描述

绘制下生成的数据

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

SVM算法编程练习_第14张图片

增加一些噪声点

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算法编程练习_第15张图片

通过多项式特征的SVM来对它进行分类

from sklearn.preprocessing import PolynomialFeatures,StandardScaler
from sklearn.svm import LinearSVC
from sklearn.pipeline import Pipeline
def PolynomialSVC(degree,C=1.0):
    return Pipeline([
        ("poly",PolynomialFeatures(degree=degree)),#生成多项式
        ("std_scaler",StandardScaler()),#标准化
        ("linearSVC",LinearSVC(C=C))#最后生成svm
    ])
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算法编程练习_第16张图片

使用核技巧来对数据进行处理

使其维度提升,使原本线性不可分的数据,在高维空间变成线性可分的。再用线性SVM来进行处理。

from sklearn.svm import SVC
def PolynomialKernelSVC(degree,C=1.0):
    return Pipeline([
        ("std_scaler",StandardScaler()),
        ("kernelSVC",SVC(kernel="poly")) # 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算法编程练习_第17张图片
可以看到这种方式也生成了一个非线性的边界。
这里 SVC(kernel=“poly”) 有个参数是 kernel ,就是核函数。下面介绍下核函数。

3.核函数

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

SVM算法编程练习_第18张图片接下来使用高斯核函数,看如何将一个一维的数据映射到二维的空间。

# 高斯核函数
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()

SVM算法编程练习_第19张图片可以看出是线性可分的

4.超参数γ

生成数据:

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

SVM算法编程练习_第20张图片

定义一个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()

SVM算法编程练习_第21张图片这是我们设置 γ = 1.0 \gamma=1.0 γ=1.0时所得到的决策边界。我们调整下它的值再试下:

svc = RBFKernelSVC(100)

SVM算法编程练习_第22张图片
再修改svc = RBFKernelSVC(10)
SVM算法编程练习_第23张图片再修改svc = RBFKernelSVC(0,001)

SVM算法编程练习_第24张图片此时它是欠拟合的。
因此,我们可以看出 γ \gamma γ 值相当于在调整模型的复杂度。

5.回归问题

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.6989278257702748


在这里插入图片描述

你可能感兴趣的:(支持向量机,python,机器学习,算法)