一、引言
支持向量机（SVM, Support Vector Machines）是一种监督学习模型，主要用于分类和回归分析。支持向量机是一种强大而灵活的机器学习方法，通过最大化间隔并利用核技巧处理非线性问题，能够在高维数据中寻找最佳分类或回归边界。
二、核心思想
1.最大间隔：
SVM的基本目标是在两类数据中找到一个最优的超平面（对于高维数据，即是一个超平面；在二维空间中可理解为一条直线），使得两类样本尽可能被正确分开，并且两类样本到这个超平面的边际距离最大化。这样可以提高分类的泛化能力。
2.支持向量：
距离超平面最近的数据点称为支持向量。SVM模型的决策边界仅由这些支持向量决定，而非所有训练数据，这使得SVM对异常值不敏感。
3.核函数（Kernel Trick）：
对于线性不可分的数据，SVM通过使用核函数将输入数据从原始特征空间映射到一个更高维度的特征空间，使得数据在这个新空间中变得线性可分。常见的核函数有线性核、多项式核、高斯核（RBF）等。
4.软间隔：
实际问题中数据往往存在一定的噪声或重叠，SVM允许一定程度的误分类，通过引入松弛变量和正则化参数C来控制模型的复杂度和对误分类的容忍度，实现软间隔分类。
5.分类与回归：
SVM最初用于二分类问题，通过一对多或多对多策略可扩展到多分类问题。另外，通过修改损失函数，SVM也可以用于回归分析，如支持向量回归（SVR）。
三、代码
两个版本
（第一个是SVC可视化函数）
import numpy
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn import svm
from sklearn import metrics
from sklearn.datasets import make_blobs
# 生成数据集
X, y = make_blobs(n_samples=50, n_features=2, centers=2, random_state=0,
cluster_std=0.6) # 50个样本,2维特征,2个类别,随机种子0号,数据散落程度0.6
print(X.shape) # 由n_samples=50,n_features=2决定
# print(X)
print(y.shape) # 由centers=2决定
print(numpy.unique(y)) # 由centers=2决定
# print(y)
# 划分训练集和测试集
train_data, text_data = train_test_split(X, random_state=1, train_size=0.7, test_size=0.3)
train_lable, text_lable = train_test_split(y, random_state=1, train_size=0.7, test_size=0.3)
# SVC可视化函数
def plot_svc_decision_function(model, ax=None):
if ax is None:
ax = plt.gca() # 获取当前坐标轴对象,即横纵坐标取值范围
# plt.xticks([])#不显示x轴坐标
# plt.yticks([])#不显示y轴坐标
# 获取平面坐标轴的范围
xlim = ax.get_xlim() # 得到x轴取值范围
ylim = ax.get_ylim() # 得到y轴取值范围
# 在坐标轴范围中生成网格点
axisx = np.linspace(xlim[0], xlim[1], 30) # 生成30个点,从横坐标范围xlim[0]到xlim[1]
axisy = np.linspace(ylim[0], ylim[1], 30) # 生成30个点,从纵坐标范围ylim[0]到ylim[1]
axisx, axisy = np.meshgrid(axisx, axisy) # 生成网格点
xy = np.c_[axisx.ravel(), axisy.ravel()] # 将网格点拼接成二维数组,即30*30个点
# plt.scatter(xy[:,0],xy[:,1],c="k",alpha=0.5,s=1)#绘制网格点,颜色为黑色,色彩饱和度为0.5,大小为1
Z = model.decision_function(xy).reshape(axisx.shape) # 计算决策边界,reshape将二维数组转换为三维数组,即30*30个点
ax.contour(axisx, axisy, Z, colors="k", levels=[-1, 0, 1], alpha=0.5,
linestyles=["--", "-", "--"]) # 绘制决策边界,颜色为黑色,水平线为-1,水平线为0,水平线为1,色彩饱和度为0.5,线类型为虚线,实线,虚线
plt.show()
# 建模通过fit计算出对应的决策边界
clf = svm.SVC(C=2, kernel='linear', gamma=10, decision_function_shape='ovr').fit(train_data, train_lable.ravel())
# 根据决策边界对样本进行模型预测
pre_train = clf.predict(train_data) # 训练集预测
pre_text = clf.predict(text_data) # 测试集预测
# 模型评估
print("训练集准确率：", metrics.accuracy_score(train_lable, pre_train))
print("测试集准确率：", metrics.accuracy_score(text_lable, pre_text))
# 绘制散点图
plt.scatter(train_data[:, 0], train_data[:, 1], c=train_lable, s=50,
cmap="rainbow") # train_data[:,0]表示第一个特征作为横坐标,train_data[:,1]表示第二个特征作为纵坐标,c=train_lable表示颜色类别,s=50表示点的大小,cmap="rainbow"表示颜色
plt.scatter(text_data[:, 0], text_data[:, 1], c=text_lable, s=50, cmap="rainbow", marker='*')
# 绘制决策边界
plot_svc_decision_function(clf)
执行结果
（第二个是SVM函数重写）
import numpy
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_blobs
from sklearn import svm
class SVM2:
# 该函数是一个初始化函数，用于创建一个对象并给对象的属性赋值
def __init__(self, max_iter=100, kernel='linear'): # max_iter表示最大迭代次数，默认为100，kernel表示核函数类型，默认为'poly'。
self.max_iter = max_iter
self._kernel = kernel
# 初始化逻辑回归算法中的参数
def init_args(self, features, labels):
self.m, self.n = features.shape # 获取特征矩阵的行数m和列数n
self.X = features # 将features赋值给self.X
self.Y = labels # 将labels赋值给self
self.b = 0.0 # 偏置项b初始化为0.0
# 将Ei保存在一个列表里
self.alpha = np.ones(self.m) # 创建一个长度为m的全1向量self.alpha
self.E = [self._E(i) for i in range(self.m)] # 列表推导式计算每个样本的误差self.E
# 松弛变量
self.C = 1.0 # 将松弛变量self.C初始化为1.0。
# 判断给定数据点是否满足KKT条件
def _KKT(self, i):
y_g = self._g(i) * self.Y[i]
if self.alpha[i] == 0:
return y_g >= 1
elif 0 < self.alpha[i] < self.C:
return y_g == 1
else:
return y_g <= 1
# g(x)预测值，输入xi（X[i]）
def _g(self, i):
r = self.b
for j in range(self.m):
r += self.alpha[j] * self.Y[j] * self.kernel(self.X[i], self.X[j])
return r
# 核函数
def kernel(self, x1, x2):
return sum([x1[k] * x2[k] for k in range(self.n)])
# E（x）为g(x)对输入x的预测值和y的差
def _E(self, i):
return self._g(i) - self.Y[i]
def _init_alpha(self):
# 外层循环首先遍历所有满足0<a<C的样本点，检验是否满足KKT
index_list = [i for i in range(self.m) if 0 < self.alpha[i] < self.C]
# 否则遍历整个训练集
non_satisfy_list = [i for i in range(self.m) if i not in index_list]
index_list.extend(non_satisfy_list)
for i in index_list:
if self._KKT(i):
continue
E1 = self.E[i]
# 如果E2是+，选择最小的；如果E2是负的，选择最大的
if E1 >= 0:
j = min(range(self.m), key=lambda x: self.E[x])
else:
j = max(range(self.m), key=lambda x: self.E[x])
return i, j
def _compare(self, _alpha, L, H):
if _alpha > H:
return H
elif _alpha < L:
return L
else:
return _alpha
def fit(self, features, labels):
self.init_args(features, labels)
for t in range(self.max_iter):
# train
i1, i2 = self._init_alpha()
# 边界
if self.Y[i1] == self.Y[i2]:
L = max(0, self.alpha[i1] + self.alpha[i2] - self.C)
H = min(self.C, self.alpha[i1] + self.alpha[i2])
else:
L = max(0, self.alpha[i2] - self.alpha[i1])
H = min(self.C, self.C + self.alpha[i2] - self.alpha[i1])
E1 = self.E[i1]
E2 = self.E[i2]
# eta=K11+K22-2K12
eta = self.kernel(self.X[i1], self.X[i1]) + self.kernel(self.X[i2], self.X[i2]) - 2 * self.kernel(
self.X[i1], self.X[i2])
if eta <= 0:
# print('eta <= 0')
continue
alpha2_new_unc = self.alpha[i2] + self.Y[i2] * (E2 - E1) / eta
alpha2_new = self._compare(alpha2_new_unc, L, H)
alpha1_new = self.alpha[i1] + self.Y[i1] * self.Y[i2] * (self.alpha[i2] - alpha2_new)
b1_new = -E1 - self.Y[i1] * self.kernel(self.X[i1], self.X[i1]) * (alpha1_new - self.alpha[i1]) - self.Y[
i2] * self.kernel(self.X[i2], self.X[i1]) * (alpha2_new - self.alpha[i2]) + self.b
b2_new = -E2 - self.Y[i1] * self.kernel(self.X[i1], self.X[i2]) * (alpha1_new - self.alpha[i1]) - self.Y[
i2] * self.kernel(self.X[i2], self.X[i2]) * (alpha2_new - self.alpha[i2]) + self.b
if 0 < alpha1_new < self.C:
b_new = b1_new
elif 0 < alpha2_new < self.C:
b_new = b2_new
else:
# 选择中点
b_new = (b1_new + b2_new) / 2
# 更新参数
self.alpha[i1] = alpha1_new
self.alpha[i2] = alpha2_new
self.b = b_new
self.E[i1] = self._E(i1)
self.E[i2] = self._E(i2)
return 'train done!'
def predict(self, data):
r = self.b # 初始化预测结果r为模型的偏置项self.b
# 计算其与输入数据data的核函数值self.kernel(data, self.X[i])，并乘以对应的权重self.alpha[i]和标签值self.Y[i]，累加到r中；
for i in range(self.m):
r += self.alpha[i] * self.Y[i] * self.kernel(data, self.X[i])
# 根据r的值判断预测结果，如果r大于0，则预测结果为1，否则为-1。
return 1 if r > 0 else -1
# 计算模型在测试集上的准确率
def score(self, X_test, y_test):
right_count = 0
for i in range(len(X_test)):
result = self.predict(X_test[i])
if result == y_test[i]:
right_count += 1
return right_count / len(X_test)
# SVC可视化函数
def plot_svc_decision_function(model, ax=None):
if ax is None:
ax = plt.gca() # 获取当前坐标轴对象,即横纵坐标取值范围
# plt.xticks([])#不显示x轴坐标
# plt.yticks([])#不显示y轴坐标
# 获取平面坐标轴的范围
xlim = ax.get_xlim() # 得到x轴取值范围
ylim = ax.get_ylim() # 得到y轴取值范围
# 在坐标轴范围中生成网格点
axisx = np.linspace(xlim[0], xlim[1], 30) # 生成30个点,从横坐标范围xlim[0]到xlim[1]
axisy = np.linspace(ylim[0], ylim[1], 30) # 生成30个点,从纵坐标范围ylim[0]到ylim[1]
axisx, axisy = np.meshgrid(axisx, axisy) # 生成网格点
xy = np.c_[axisx.ravel(), axisy.ravel()] # 将网格点拼接成二维数组,即30*30个点
# plt.scatter(xy[:,0],xy[:,1],c="k",alpha=0.5,s=1)#绘制网格点,颜色为黑色,色彩饱和度为0.5,大小为1
Z = model.decision_function(xy).reshape(axisx.shape) # 计算决策边界,reshape将二维数组转换为三维数组,即30*30个点
ax.contour(axisx, axisy, Z, colors="k", levels=[-1, 0, 1], alpha=0.5,
linestyles=["--", "-", "--"]) # 绘制决策边界,颜色为黑色,水平线为-1,水平线为0,水平线为1,色彩饱和度为0.5,线类型为虚线,实线,虚线
plt.show()
# 生成数据集
X, y = make_blobs(n_samples=50, n_features=2, centers=2, random_state=0,
cluster_std=0.6) # 50个样本,2维特征,2个类别,随机种子0号,数据散落程度0.6
print(X.shape) # 由n_samples=50,n_features=2决定
# print(X)
print(y.shape) # 由centers=2决定
print(numpy.unique(y)) # 由centers=2决定
# print(y)
# 划分训练集和测试集
train_data, text_data = train_test_split(X, random_state=1, train_size=0.7, test_size=0.3)
train_lable, text_lable = train_test_split(y, random_state=1, train_size=0.7, test_size=0.3)
svm2 = SVM2(max_iter=800)
print(svm2.fit(train_data, train_lable))
print(svm2.score(train_data, train_lable))
print(svm2.score(text_data, text_lable))
clf = svm.SVC(kernel="linear").fit(train_data, train_lable)
# 绘制散点图
plt.scatter(train_data[:, 0], train_data[:, 1], c=train_lable, s=50,
cmap="rainbow") # train_data[:,0]表示第一个特征作为横坐标,train_data[:,1]表示第二个特征作为纵坐标,c=train_lable表示颜色类别,s=50表示点的大小,cmap="rainbow"表示颜色
plt.scatter(text_data[:, 0], text_data[:, 1], c=text_lable, s=50, cmap="rainbow", marker='*')
# 绘制决策边界
plot_svc_decision_function(clf)
这里精度出现问题了，用的是随机生成的数据，猜想是核函数建立出问题
四、总结
支持向量机（SVM）作为一种流行的机器学习算法，在解决分类和回归问题上展现出独特的优势，同时也存在一些局限性。下面是其主要的优缺点概述：
优点：
处理高维数据能力强：SVM能够有效处理具有大量特征的数据集，即便特征数远超样本数时仍能保持良好的性能。
泛化能力强：通过最大化间隔，SVM旨在最小化结构风险，从而在新数据上的预测表现稳定，减少过拟合现象。
核技巧：通过使用核函数，SVM能够将非线性可分的数据转换到高维空间中变得线性可分，无需显式地计算高维映射，大大简化了处理过程。
缺点
计算复杂度：对于大规模数据集，SVM的训练时间可能较长，特别是在选择非线性核函数时，因为需要求解复杂的二次规划问题。
参数选择敏感：模型性能高度依赖于核函数的选择、正则化参数C以及（对于某些核函数）核函数参数（如高斯核的γ）。不当的参数选择可能导致性能不佳。
不直接提供概率输出：虽然可以通过一些方法（如Platt Scaling）后处理得到概率估计，但SVM本身并不直接提供概率预测。
扫一扫
3225
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
