本文正在参与人工智能创作者扶持方案 ”

机器学习算法（四）: 根据支撑向量机的分类猜测

1.相关流程

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

本文将不触及十分严厉和杂乱的理论知识，力求于经过直觉来感触 SVM。

引荐参阅：SVM参阅文章

了解支撑向量机的分类标准；
了解支撑向量机的软距离分类；
了解支撑向量机的非线性核函数分类；

Demo实践
- Step1:库函数导入
- Step2:构建数据集并进行模型练习
- Step3:模型参数检查
- Step4:模型猜测
- Step5:模型可视化

2. 算法实战

2.1 Demo实践

首要咱们使用sklearn直接调用 SVM函数进行实践测验

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 of Logistic Regression:',svc.coef_)
## 检查其对应模型的w0
print('the intercept(w0) of Logistic Regression:',svc.intercept_)

the weight of Logistic Regression: [[0.33364706 0.33270588]]
the intercept(w0) of Logistic Regression: [-0.00031373]

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:模型可视化

因为此处挑选的线性核函数，所以在此咱们能够将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轴上的截距），这说明这两个不同在相同数据集上找到的判别线是不同的，而这不同的原因其实是因为两者挑选的最优方针是不一致的。接下来咱们进行SVM的一些简略介绍。

2.2 实践升级

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

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)

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)

# 最佳函数
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')

带黑边的点是距离当时分类器最近的点，咱们称之为支撑向量。

支撑向量机为咱们供给了在众多或许的分类器之间进行挑选的准则，然后保证对不知道数据集具有更高的泛化性。

2.2.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)

这种情况并不容易找到这样的最大距离。

于是咱们就有了软距离，相比于硬距离而言，咱们答应个别数据出现在距离带中。

咱们知道，假如没有一个准则进行束缚，满意软距离的分类器也会出现很多条。

所以需求对分错的数据进行赏罚，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')

2.2.2 超平面

假如咱们遇到这样的数据集，没有办法使用线性分类器进行分类

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

# 数据映射
from mpl_toolkits.mplot3d import Axes3D
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)

在 SVC 中，咱们能够用高斯核函数来实现这以功能：kernel=’rbf’

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

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

3.总结

SVM优缺陷

优点

有严厉的数学理论支撑，可解释性强，不依托核算方法，然后简化了一般的分类和回归问题；
能找出对使命至关重要的要害样本（即：支撑向量）；
选用核技巧之后，能够处理非线性分类/回归使命；
最终决议方案函数只由少数的支撑向量所确认，核算的杂乱性取决于支撑向量的数目，而不是样本空间的维数，这在某种意义上避免了“维数灾祸”。

缺陷

练习时刻长。当选用SMO 算法时，因为每次都需求挑选一对参数，因而刻间杂乱度为 $O(N^2)$ ，其中 $N$ 为练习样本的数量；
当选用核技巧时，假如需求存储核矩阵，则空间杂乱度为 $O(N^2)$ ；
模型猜测时，猜测时刻与支撑向量的个数成正比。当支撑向量的数量较大时，猜测核算杂乱度较高。

因而支撑向量机现在只合适小批量样本的使命，无法适应百万乃至上亿样本的使命

项目参阅： tianchi.aliyun.com/course/278/…

项目链接复现

项目链接www.heywhale.com/home/column…

本文正在参与人工智能创作者扶持方案 ”

机器学习算法（四）: 基于支持向量机的分类预测

机器学习算法（四）: 根据支撑向量机的分类猜测

1.相关流程

2. 算法实战

2.1 Demo实践

2.2 实践升级

2.2.1 软距离

2.2.2 超平面

3.总结

项目链接复现

作者信息

推广

机器学习算法（四）: 基于支持向量机的分类预测

机器学习算法（四）: 根据支撑向量机的分类猜测

1.相关流程

2. 算法实战

2.1 Demo实践

2.2 实践升级

2.2.1 软距离

2.2.2 超平面

3.总结

项目链接复现

相关文章

Sora 目前唯一体验方式，原来藏在了官网里 | 附体验地址

#41 AI-002-十分钟理解ChatGPT的技术逻辑及演进(前世、今生）

chatgpt 几种 model 模型功能及价格简介

目的驱动的微服务设计（附代码示例）

作者信息

推广