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

本文结构

1. 代码流程

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

Step4:模型预测

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

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

2. 算法实践（为了找出最优的分类器引用SVM）

第一类数据：分属于两类

获得了分属两类的数据

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) 

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

# 导入函数 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'); 

此时完成分线性分类

参考：https://developer.aliyun.com/ai/scenario/b6c1ef3172d84236ae10c3b91798a796