svm的代码实现

目录

代码

代码解读

导入pandas库,并且读取文件

可视化原始数据

使用SVM进行训练

可视化SVM结果

可视化原始数据,选取1维核3维的数据进行可视化

可视化超平面

进行坐标轴限制

找到支持向量[二维数组]可视化支持向量,并绘制图片


代码

import pandas as pd

data = pd.read_csv('iris.csv', header=None)
import matplotlib.pyplot as plt

data1 = data.iloc[:50, :]
data2 = data.iloc[50:, :]
plt.scatter(data1[1], data1[3], marker='+')
plt.scatter(data2[1], data2[3], marker='o')
plt.show()
from sklearn.svm import SVC

x = data.iloc[:, [1, 3]]
y = data.iloc[:, -1]

svc = SVC(kernel='linear', C=float('inf'), random_state=0)
svc.fit(x, y)
scores = svc.score
print('score: ', scores)
w = svc.coef_[0]
b = svc.intercept_[0]
import numpy as np

x1 = np.linspace(0, 7, 300)
x2 = -(w[0] * x1 + b) / w[1]
x3 = (1 - (w[0] * x1 + b)) / w[1]
x4 = (-1 - (w[0] * x1 + b)) / w[1]
plt.scatter(data1[1], data1[3], marker='+', color='r')
plt.scatter(data2[1], data2[3], marker='o', color='b')
plt.plot(x1, x2, linewidth=2, color='r')
plt.plot(x1, x3, linewidth=1, color='r', linestyle='--')
plt.plot(x1, x4, linewidth=1, color='r', linestyle='--')
plt.xlim(4, 7)
plt.ylim(0, 5)
vets = svc.support_vectors_
plt.scatter(vets[:, 0], vets[:, 1], c='r', marker='x')
plt.show()

代码解读

导入pandas库,并且读取文件
import pandas as pd
data = pd.read_csv('iris.csv', header=None)
可视化原始数据
import matplotlib.pyplot as plt:  # 这行代码导入了 matplotlib 库的 pyplot 模块,并将其别名为 plt。
data1 = data.iloc[:50, :]:      # 这行代码从 data DataFrame 中选取前 50 行所有列的数据,并将其存储为新的 DataFrame 对象,名为 data1。
data2 = data.iloc[50:, :]:      #这行代码从 data DataFrame 中选取第 50 行之后的所有行和所有列的数据,并将其存储为新的 DataFrame 对象,名为 data2。
plt.scatter(data1[1], data1[3], marker='+'):      #这行代码使用 matplotlib 的 scatter 函数绘制 data1 DataFrame 中的第 2 列(索引为 1)和第 4 列(索引为 3)的数据点,并使用加号作为标记。
plt.scatter(data2[1], data2[3], marker='o'):      #这行代码使用 matplotlib 的 scatter 函数绘制 data2 DataFrame 中的第 2 列(索引为 1)和第 4 列(索引为 3)的数据点,并使用圆圈作为标记。
plt.show():    #这行代码使用 matplotlib 的 show 函数显示之前绘制的图形。

图片结果为:

使用SVM进行训练
from sklearn.svm import SVC:         #这行代码从 sklearn 库中导入了 SVC 类,它是用于支持向量机(Support Vector Machine)的类。
x = data.iloc[:, [1, 3]]:         #这行代码从 data DataFrame 中选取所有行的第 2 列和第 4 列的数据,并将其存储为新的 DataFrame 对象,名为 x。
y = data.iloc[:, -1]:         #这行代码从 data DataFrame 中选取所有行的最后一列的数据,并将其存储为新的 Series 对象,名为 y。
svc = SVC(kernel='linear', C=float('inf'), random_state=0):            #这行代码创建了一个 SVC 对象,名为 svc。其中,kernel 参数设置为 'linear',表示使用线性核函数;C 参数设置为无穷大,表示对分类错误的惩罚非常大;random_state 参数设置为 0,表示随机种子为 0。
svc.fit(x, y):          #这行代码使用 SVC 的 fit 函数对 x 和 y 进行训练。
可视化SVM结果
w = svm.coef_[0]        # 参数w[原始数据为二维数组]
b = svm.intercept_[0]        # 偏置项b[原始数据为一维数组]
# 超平面方程:w1x1+w2x2+b=0
# ->>x2 = -(w1x1+b)/w2
import numpy as np
x1 = np.linspace(0, 7, 300)  # 在0~7之间产生300个数据
x2 = -(w[0] * x1 + b) / w[1]  # 超平面方程
x3 = (1 - (w[0] * x1 + b)) / w[1]  # 上超平面方程
x4 = (-1 - (w[0] * x1 + b)) / w[1]# 下超平面方程
可视化原始数据,选取1维核3维的数据进行可视化
plt.scatter(data1[1], data1[3], marker='+', color='r'):      #这行代码使用 matplotlib 的 scatter 函数绘制 data1 DataFrame 中的第 2 列(索引为 1)和第 4 列(索引为 3)的数据点,并使用红色作为标记。
plt.scatter(data2[1], data2[3], marker='o', color='b'):      #这行代码使用 matplotlib 的 scatter 函数绘制 data2 DataFrame 中的第 2 列(索引为 1)和第 4 列(索引为 3)的数据点,并使用蓝色作为标记
可视化超平面
plt.plot(x1, x2, linewidth=2, color='r'):    #这行代码使用 matplotlib 的 plot 函数绘制从 x1 到 x2 的直线,并设置线条宽度为2,并使用红色作为线条颜色。
plt.plot(x1, x3, linewidth=1, color='r', linestyle='--'):         #这行代码使用 matplotlib 的 plot 函数绘制从 x1 到 x3 的直线,并设置线条宽度为1,使用红色作为线条颜色,并使用虚线作为线条样式。
plt.plot(x1, x4, linewidth=1, color='r', linestyle='--'):           #这行代码使用 matplotlib 的 plot 函数绘制从 x1 到 x4 的直线,并设置线条宽度为1,使用红色作为线条颜色,并使用虚线作为线条样式。
进行坐标轴限制
plt.xlim(4, 7):       #这行代码设置 x 轴的显示范围为 4 到 7。
plt.ylim(0, 5):       #这行代码设置 y 轴的显示范围为 0 到 5。
找到支持向量[二维数组]可视化支持向量,并绘制图片
vets = svc.support_vectors_:              #这行代码获取 svc 对象中支持向量的数据,并将其存储在变量 vets 中。
plt.scatter(vets[:, 0], vets[:, 1], c='r', marker='x'):            #这行代码使用 matplotlib 的 scatter 函数绘制 vets DataFrame 中的第一列和第二列的数据点,并使用红色作为标记和线条颜色。
plt.show():        #这行代码使用 matplotlib 的 show 函数显示之前绘制的图形。

图片结果为:

  • 1
    点赞
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
以下是基于PSO算法的SVM代码实现Python版本): ```python import numpy as np class PSO_SVM: def __init__(self, c1=1, c2=1, w=0.6, max_iter=100, num_particles=10, kernel='linear'): self.c1 = c1 self.c2 = c2 self.w = w self.max_iter = max_iter self.num_particles = num_particles self.kernel = kernel self.X = None self.y = None self.n_samples = None self.n_features = None self.alpha = None self.b = None self.particles_alpha = None self.particles_b = None self.particles_v_alpha = None self.particles_v_b = None self.particles_loss = None self.gbest_alpha = None self.gbest_b = None self.gbest_loss = float('inf') def fit(self, X, y): self.X = X self.y = y self.n_samples, self.n_features = X.shape self.alpha = np.zeros(self.n_samples) self.b = 0 self.particles_alpha = np.zeros((self.num_particles, self.n_samples)) self.particles_b = np.zeros(self.num_particles) self.particles_v_alpha = np.zeros((self.num_particles, self.n_samples)) self.particles_v_b = np.zeros(self.num_particles) self.particles_loss = np.zeros(self.num_particles) for i in range(self.num_particles): self.particles_alpha[i] = np.random.uniform(low=0, high=1, size=self.n_samples) self.particles_b[i] = np.random.uniform(low=0, high=1) self.particles_v_alpha[i] = np.zeros(self.n_samples) self.particles_v_b[i] = 0 self.particles_loss[i] = self.loss(self.particles_alpha[i], self.particles_b[i]) if self.particles_loss[i] < self.gbest_loss: self.gbest_alpha = self.particles_alpha[i] self.gbest_b = self.particles_b[i] self.gbest_loss = self.particles_loss[i] for _ in range(self.max_iter): for i in range(self.num_particles): r1 = np.random.uniform(low=0, high=1, size=self.n_samples) r2 = np.random.uniform(low=0, high=1) self.particles_v_alpha[i] = self.w * self.particles_v_alpha[i] \ + self.c1 * r1 * (self.particles_alpha[i] - self.gbest_alpha) \ + self.c2 * r2 * (self.particles_alpha[i] - self.alpha) self.particles_v_b[i] = self.w * self.particles_v_b[i] \ + self.c1 * r1 * (self.particles_b[i] - self.gbest_b) \ + self.c2 * r2 * (self.particles_b[i] - self.b) self.particles_alpha[i] = np.clip(self.particles_alpha[i] + self.particles_v_alpha[i], 0, 1) self.particles_b[i] += self.particles_v_b[i] self.particles_loss[i] = self.loss(self.particles_alpha[i], self.particles_b[i]) if self.particles_loss[i] < self.gbest_loss: self.gbest_alpha = self.particles_alpha[i] self.gbest_b = self.particles_b[i] self.gbest_loss = self.particles_loss[i] self.alpha = self.gbest_alpha self.b = self.gbest_b def predict(self, X_test): y_pred = np.zeros(len(X_test)) if self.kernel == 'linear': for i in range(len(X_test)): y_pred[i] = np.sign(np.dot(self.alpha * self.y, np.dot(self.X, X_test[i])) + self.b) return y_pred def loss(self, alpha, b): if self.kernel == 'linear': y_pred = np.dot(self.alpha * self.y, np.dot(self.X, self.X.T)) + b loss = np.sum(alpha) - 0.5 * np.sum((alpha * self.y)[:, None] * (self.y * y_pred)) return loss ``` 其中,PSO算法的核心部分在`fit`方法中,其中`r1`和`r2`分别代表随机因子,`particles_v_alpha`和`particles_v_b`分别代表粒子的速度,`particles_alpha`和`particles_b`分别代表粒子的位置,`self.gbest_alpha`和`self.gbest_b`分别代表全局最优位置,`self.particles_loss`代表粒子的损失函数值。其中,损失函数的实现采用的是线性核函数。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值