共计 6132 个字符，预计需要花费 16 分钟才能阅读完成。
申明：本次撰写以 Datawhale 团队提供的学习材料以自学为主，代码为 Datawhale 团队提供，利用阿里云天池实验室与编辑器 pycharm 实现测试。
反对向量机（Support Vector Machine，SVM）是一个十分优雅的算法，具备十分欠缺的数学实践，罕用于数据分类，也能够用于数据的回归预测中，因为其柔美的实践保障和利用核函数对于线性不可分问题的解决技巧，在上世纪 90 年代左右，SVM 曾红极一时。本文将不波及十分严格和简单的理论知识，力求于通过直觉来感触 SVM。
Demo 实际
- Step1: 库函数导入
- Step2: 构建数据集并进行模型训练
- Step3: 模型参数查看
- Step4: 模型预测
- Step5: 模型可视化
学习指标
* 理解反对向量机的分类规范;
* 理解反对向量机的软距离分类;
* 理解反对向量机的非线性核函数分类;
能够对照之前的逻辑回归模型的决策边界，咱们能够发现两个决策边界是有肯定差别的（能够比照两者在 X,Y 轴 上的截距），这阐明这两个不同在雷同数据集上找到的判断线是不同的，而这不同的起因其实是因为两者抉择的 最优指标是不统一的。接下来咱们进行 SVM 的一些简略介绍。
反对向量机的介绍
咱们经常会碰到这样的一个问题，首先给你一些分属于两个类别的数据
当初须要一个线性分类器，将这些数据离开来。
咱们可能会有多种分法：
那么当初有一个问题，两个分类器，哪一个更好呢？
为了判断好坏，咱们须要引入一个准则：好的分类器不仅仅是可能很好的离开已有的数据集，还能对未知数据集 进行两个的划分。
假如，当初有一个属于红色数据点的新数据（3，2.8）
能够看到，此时彩色的线会把这个新的数据集分错，而蓝色的线不会。
咱们刚刚举的例子可能会带有一些主观性。
那么如何主观的评判两条线的健壮性呢？
此时，咱们须要引入一个十分重要的概念：最大距离。
最大距离刻画着以后分类器与数据集的边界，以这两个分类器为例：
能够看到，蓝色的线最大距离是大于彩色的线的。
所以咱们会抉择蓝色的线作为咱们的分类器。
那么，咱们当初的分类器是最优分类器吗？
或者说，有没有更好的分类器，它具备更大的距离？
答案是有的。
总体代码：
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets 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')
# 画散点图
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)
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')
为了找出最优分类器，咱们须要引入咱们明天的配角：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)
这种状况并不容易找到这样的最大距离。
于是咱们就有了软距离，相比于硬距离而言，咱们容许个别数据呈现在距离带中。
咱们晓得，如果没有一个准则进行束缚，满足软距离的分类器也会呈现很多条。
所以须要对分错的数据进行惩办，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 在高维空间找到超平面的能力。
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');
正文完
