支持向量机理论+简单代码实现

最新推荐文章于 2024-07-14 21:58:34 发布
最新推荐文章于 2024-07-14 21:58:34 发布
阅读量1.3k 收藏 10
点赞数 2
分类专栏： 人工智能与机器学习 文章标签： python 机器学习 支持向量机 深度学习 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Time_book/article/details/106303658
版权

文章目录

一、支持向量机理论简介

支持向量机是一类按监督学习方式对数据进行二元分类的广义线性分类器，其决策边界是对学习样本求解的最大边距超平面

1.线性分类

线性可分性

在分类问题中给定输入数据和学习目标：X={X1,X2,…,XN}，y={y1,…,yN}，其中输入数据的每个样本都包含多个特征并由此构成特征空间：X=[x1,x2,…,xn]，而学习目标为二元变量
在这里插入图片描述
表示负类和正类

若输入数据所在的特征空间存在作为决策边界的超平面将学习目标按正类和负类分开，并使任意样本的点到平面距离大于等于1

在这里插入图片描述

则称该分类问题具有线性可分性，参数w,b分别为超平面的法向量和截距。

满足该条件的决策边界实际上构造了2个平行的超平面作为间隔边界以判别样本的分类：

在这里插入图片描述

所有在上间隔边界上方的样本属于正类，在下间隔边界下方的样本属于负类。两个间隔边界的距离d=2/||w||被定义为边距（margin），位于间隔边界上的正类和负类样本为支持向量。

在这里插入图片描述

2.核方法

一些线性不可分的问题可能是非线性可分的，即特征空间存在超曲面将正类和负类分开。使用非线性函数可以将非线性可分问题从原始的特征空间映射至更高维的希尔伯特空间，从而转化为线性可分问题，此时作为决策边界的超平面表示如下：

在这里插入图片描述在这里插入图片描述

由于映射函数具有复杂的形式，难以计算其内积，因此可使用核方法，即定义映射函数的内积为核函数：

在这里插入图片描述

以回避内积的显式计算

Mercer定理

核函数的选择需要一定条件，函数
在这里插入图片描述

是核函数的充要条件是，对输入空间的任意向量：
在这里插入图片描述
其核矩阵，即如下形式的格拉姆矩阵

在这里插入图片描述

是半正定矩阵。上述结论被称为Mercer定理

作为充分条件：特征空间内两个函数的内积是一个二元函数，在其核矩阵为半正定矩阵时，该二元函数具有可再生性：

在这里插入图片描述

因此其内积空间是一个赋范向量空间，可以完备化得到希尔伯特空间 ，即再生核希尔伯特空间。作为必要条件，对核函数构造核矩阵后易知：

在这里插入图片描述

常见的核函数

在这里插入图片描述

3.算法

线性SVM

(1)硬边距

给定输入数据和学习目标：X={X1,X2,…,XN}，y={y1,…,yN}，硬边界SVM是在线性可分问题中求解最大边距超平面的算法，约束条件是样本点到决策边界的距离大于等于1。硬边界SVM可以转化为一个等价的二次凸优化问题进行求解：

在这里插入图片描述

由上式得到的决策边界可以对任意样本进行分类：
在这里插入图片描述

我们注意到虽然超平面法向量w是唯一优化目标，但学习数据和超平面的截距通过约束条件影响了该优化问题的求解。硬边距SVM是正则化系数取0时的软边距SVM，下面我们来看一看软边距SVM。

(2)软边距

在线性不可分问题中使用硬边距SVM将产生分类误差，因此可在最大化边距的基础上引入损失函数构造新的优化问题。SVM使用铰链损失函数，沿用硬边界SVM的优化问题形式，软边距SVM的优化问题有如下表示：

在这里插入图片描述

上式表明可知，软边距SVM是一个L2正则化分类器，式中Li表示铰链损失函数。使用松弛变量：ξ≥0处理铰链损失函数的分段取值后，上式可化为：

在这里插入图片描述

求解上述软边距SVM通常利用其优化问题的对偶性

推导：

定义软边距SVM的优化问题为原问题，通过拉格朗日乘子：在这里插入图片描述
可得到其拉格朗日函数：

在这里插入图片描述

令拉格朗日函数对优化目标w，b，ξ的偏导数为0，可得到一系列包含拉格朗日乘子的表达式：

在这里插入图片描述

将其带入拉格朗日函数后可得原问题的对偶问题：
在这里插入图片描述

对偶问题的约束条件中包含不等关系，因此其存在局部最优的条件是拉格朗日乘子满足条件：

在这里插入图片描述

由上述KKT条件可知，对任意样本（Xi，yi），总有αi=0或yi（w^TXi+b）=1-ξi ，对前者，该样本不会对决策边界wTXi+b=0产生影响，对后者，该样本满足yi（wTXi+b）=1-ξi意味其处于间隔边界上（αi< C）、间隔内部（αi=C）或被错误分类（αi>C），即该样本是支持向量。由此可见，软边距SVM决策边界的确定仅与支持向量有关，使用铰链损失函数使得SVM具有稀疏性

非线性SVM

使用非线性函数将输入数据映射至高维空间后应用线性SVM可得到非线性SVM。非线性SVM有如下优化问题:

在这里插入图片描述

类比软边距SVM，非线性SVM有如下对偶问题：

在这里插入图片描述

注意到式中存在映射函数内积，因此可以使用核方法，即直接选取核函数:在这里插入图片描述
非线性SVM的对偶问题的KKT条件可同样类比软边距线性SVM。

二、代码实现

未经标准化的原始数据点分布

import numpy as np 
import matplotlib.pyplot as plt 
from sklearn import datasets 
from sklearn.preprocessing import StandardScaler 
from sklearn.svm import LinearSVC 
iris = datasets.load_iris() 
X = iris.data 
y = iris.target 
# X = X[y<2,:2] #只取y<2的类别，也就是0 1 并且只取前两个特征 y = y[y<</span>2] 
plt.scatter(X[y==0,0],X[y==0,1],color='red') 
plt.scatter(X[y==1,0],X[y==1,1],color='blue') 
plt.show()
# 标准化 
standardScaler = StandardScaler() 
standardScaler.fit(X) #计算训练数据的均值和方差 
X_standard = standardScaler.transform(X) #再用scaler中的均值和方差来转换X，使X标准化 
svc = LinearSVC(C=1e9) #线性SVM分类器 
svc.fit(X_standard,y) # 训练svm

在这里插入图片描述

在这里插入图片描述

from sklearn.preprocessing import PolynomialFeatures,StandardScaler 
from sklearn.svm import LinearSVC 
from sklearn.pipeline import Pipeline 
def PolynomialSVC(degree,C=1.0): 
    return Pipeline([ ("poly",PolynomialFeatures(degree=degree)),#生成多项式 
                     ("std_scaler",StandardScaler()),#标准化 
                     ("linearSVC",LinearSVC(C=C))#最后生成svm 
                    ])

from matplotlib.colors import ListedColormap
def plot_decision_boundary(model, axis): 
    x0, x1 = np.meshgrid( np.linspace(axis[0], axis[1], int((axis[1]-axis[0])*100)).reshape(-1,1), np.linspace(axis[2], axis[3], int((axis[3]-axis[2])*100)).reshape(-1,1) ) 
    X_new = np.c_[x0.ravel(), x1.ravel()] 
    y_predict = model.predict(X_new) 
    zz = y_predict.reshape(x0.shape) 
    custom_cmap = ListedColormap(['#EF9A9A','#FFF59D','#90CAF9']) 
    plt.contourf(x0, x1, zz, linewidth=5, cmap=custom_cmap) 
    # 绘制决策边界 
# plot_decision_boundary(svc,axis=[-3,3,-3,3]) 
#     # x,y轴都在-3到3之间 
#     # 绘制原始数据 
# plt.scatter(X_standard[y==0,0],X_standard[y==0,1],color='red') 
# plt.scatter(X_standard[y==1,0],X_standard[y==1,1],color='blue') 
# plt.show()

使用多项式特征和核函数

import numpy as np 
import matplotlib.pyplot as plt 
from sklearn import datasets 
X, y = datasets.make_moons() 
#使用生成的数据 
print(X.shape) 
# (100,2) 
print(y.shape) 
# (100,)

(100, 2)
(100,)

plt.scatter(X[y==0,0],X[y==0,1]) 
plt.scatter(X[y==1,0],X[y==1,1]) 
plt.show()

在这里插入图片描述

增加噪声点

X, y = datasets.make_moons(noise=0.15,random_state=777) 
#随机生成噪声点，random_state是随机种子，noise是方差 
plt.scatter(X[y==0,0],X[y==0,1]) 
plt.scatter(X[y==1,0],X[y==1,1]) 
plt.show()

在这里插入图片描述

利用多项式特征的SVM来进行分类


from sklearn.linear_model import LogisticRegressionCV
poly_svc = PolynomialSVC(degree=3) 
poly_svc.fit(X,y) 
plot_decision_boundary(poly_svc,axis=[-1.5,2.5,-1.0,1.5]) 
plt.scatter(X[y==0,0],X[y==0,1]) 
plt.scatter(X[y==1,0],X[y==1,1]) 
plt.show()

在这里插入图片描述

利用核对数据进行处理，使其维度提升，使原本线性不可分的数据，在高维空间变成线性可分的。再用线性SVM来进行处理。

from sklearn.svm import SVC 
def PolynomialKernelSVC(degree,C=1.0): 
    return Pipeline([ ("std_scaler",StandardScaler()), ("kernelSVC",SVC(kernel="poly")) # poly代表多项式特征 
                    ]) 
poly_kernel_svc = PolynomialKernelSVC(degree=3) 
poly_kernel_svc.fit(X,y) 
plot_decision_boundary(poly_kernel_svc,axis=[-1.5,2.5,-1.0,1.5]) 
plt.scatter(X[y==0,0],X[y==0,1]) 
plt.scatter(X[y==1,0],X[y==1,1]) 
plt.show()

在这里插入图片描述

模拟升维

import numpy as np 
import matplotlib.pyplot as plt 
x = np.arange(-4,5,1)
#生成测试数据 
y = np.array((x >= -2 ) & (x <= 2),dtype='int') 
plt.scatter(x[y==0],[0]*len(x[y==0]))
# x取y=0的点, y取0，有多少个x，就有多少个y 
plt.scatter(x[y==1],[0]*len(x[y==1]))
plt.show()

在这里插入图片描述

利用高斯核函数，进行数据映射

# 高斯核函数 
def gaussian(x,l): 
    gamma = 1.0 
    return np.exp(-gamma * (x -l)**2) 
l1,l2 = -1,1 
X_new = np.empty((len(x),2)) 
#len(x) ,2 
for i,data in enumerate(x): 
    X_new[i,0] = gaussian(data,l1) 
    X_new[i,1] = gaussian(data,l2) 
plt.scatter(X_new[y==0,0],X_new[y==0,1]) 
plt.scatter(X_new[y==1,0],X_new[y==1,1]) 
plt.show()

在这里插入图片描述

超参数

生成数据

import numpy as np 
import matplotlib.pyplot as plt 
from sklearn import datasets 
X,y = datasets.make_moons(noise=0.15,random_state=777) 
plt.scatter(X[y==0,0],X[y==0,1]) 
plt.scatter(X[y==1,0],X[y==1,1]) 
plt.show()

在这里插入图片描述

定义一个RBF核的SVM

from sklearn.preprocessing import StandardScaler 
from sklearn.svm import SVC 
from sklearn.pipeline import Pipeline 
def RBFKernelSVC(gamma=1.0): 
    return Pipeline([ ('std_scaler',StandardScaler()), ('svc',SVC(kernel='rbf',gamma=gamma)) ]) 
svc = RBFKernelSVC() 
svc.fit(X,y) 
plot_decision_boundary(svc,axis=[-1.5,2.5,-1.0,1.5]) 
plt.scatter(X[y==0,0],X[y==0,1]) 
plt.scatter(X[y==1,0],X[y==1,1]) 
plt.show()

在这里插入图片描述

改变svc = RBFKernelSVC() 中的参数为100

from sklearn.preprocessing import StandardScaler 
from sklearn.svm import SVC 
from sklearn.pipeline import Pipeline 
def RBFKernelSVC(gamma=1.0): 
    return Pipeline([ ('std_scaler',StandardScaler()), ('svc',SVC(kernel='rbf',gamma=gamma)) ]) 
svc = RBFKernelSVC(100) 
svc.fit(X,y) 
plot_decision_boundary(svc,axis=[-1.5,2.5,-1.0,1.5]) 
plt.scatter(X[y==0,0],X[y==0,1]) 
plt.scatter(X[y==1,0],X[y==1,1]) 
plt.show()

在这里插入图片描述

改成10

from sklearn.preprocessing import StandardScaler 
from sklearn.svm import SVC 
from sklearn.pipeline import Pipeline 
def RBFKernelSVC(gamma=1.0): 
    return Pipeline([ ('std_scaler',StandardScaler()), ('svc',SVC(kernel='rbf',gamma=gamma)) ]) 
svc = RBFKernelSVC(10) 
svc.fit(X,y) 
plot_decision_boundary(svc,axis=[-1.5,2.5,-1.0,1.5]) 
plt.scatter(X[y==0,0],X[y==0,1]) 
plt.scatter(X[y==1,0],X[y==1,1]) 
plt.show()

在这里插入图片描述

改成0.1

from sklearn.preprocessing import StandardScaler 
from sklearn.svm import SVC 
from sklearn.pipeline import Pipeline 
def RBFKernelSVC(gamma=1.0): 
    return Pipeline([ ('std_scaler',StandardScaler()), ('svc',SVC(kernel='rbf',gamma=gamma)) ]) 
svc = RBFKernelSVC(0.1) 
svc.fit(X,y) 
plot_decision_boundary(svc,axis=[-1.5,2.5,-1.0,1.5]) 
plt.scatter(X[y==0,0],X[y==0,1]) 
plt.scatter(X[y==1,0],X[y==1,1]) 
plt.show()

在这里插入图片描述
SVM解决回归问题

import numpy as np 
import matplotlib.pyplot as plt 
from sklearn import datasets 
boston = datasets.load_boston() 
X = boston.data 
y = boston.target 
from sklearn.model_selection import train_test_split 
X_train,X_test,y_train,y_test = train_test_split(X,y,random_state=777) 
# 把数据集拆分成训练数据和测试数据 
from sklearn.svm import LinearSVR 
from sklearn.svm import SVR 
from sklearn.preprocessing import StandardScaler 
def StandardLinearSVR(epsilon=0.1): 
    return Pipeline([ ('std_scaler',StandardScaler()), ('linearSVR',LinearSVR(epsilon=epsilon)) ]) 
svr = StandardLinearSVR() 
svr.fit(X_train,y_train) 
svr.score(X_test,y_test)

0.6991720760289629

三、参考文章

http://blog.sina.com.cn/s/blog_6c3438600102yn9x.html

百度百科

Time ??
关注
  • 2
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
支持向量机（SVM）---代码实现
weixin_51347879的博客
07-26 495
2.2 根据误分类点计算：w_new = w_old -alpha * 对w的梯度， b_new = b_old - alpha * 对b的梯度。E:\myprogram\anaconda\envs\python3.6\python.exe E:/XX/机器学习课程/L-SVM/svm.py。= sign(wx+b) 或者 y*(wx+b) x2=-(w1*x1+b)/w2。3.直到没有误分类点或者达到迭代次数停止迭代.
支持向量机代码实现
03-14
里面有二元支持向量机算法实现过程，基本是用R语言写成
机器学习代码——支持向量机（SVM）
weixin_67870062的博客
07-14 261
支持向量机（SVM）
支持向量机简单实现
huamingshen
05-28 756
目前使用了SMO+RBF的方法实现了SVM，希望大家积极测试并反馈 界面如图所示
支持向量机的代码实现
baoFeng_Li的博客
08-01 4964
前言： 本篇文章主要实现了《机器学习实战》的支持向量机部分，我在代码中也尽量描述了对应公式的哪些变量。我建议搭配《统计学习方法》进行实战，下面这篇博文对于公式推导也是很不错的。 https://blog.csdn.net/u011067360/article/details/26503719 另外本篇依赖于jupyter notebook。故在代码后面会出现相应的结果。 正文： ...
第7章 支持向量机(SVM)代码实现
breeze_blows的博客
02-11 4933
=============================== 【回到目录】=============================== 第7章 支持向量机(SVM)代码实现 SVM实现（利用SMO求解） import numpy as np import pandas as pd from sklearn.datasets import load_iris from sklear...
支持向量机理论
weixin_44132485的博客
06-11 244
点到平面的距离问题 这里的公式出现在书的第122页. 在样本空间中, 划分超平面可通过如下线性方程来描述: wTx+b=0 w^Tx+b=0 wTx+b=0 其中w=(w1;w2;...;wd)w=(w_1;w_2;...;w_d)w=(w1​;w2​;...;wd​)为法向量, 决定了超平面的方向; bbb为位移项, 决定了超平面与原点之间的距离. 显然, 划分超平面可以被法向量www和位移bbb确定. 试证明样本空间中任意点xxx到超平面的距离可写为: r=∣wTx+b∣∣∣w∣∣ r=\frac{|w
基于python的粒子群算法PSO优化支持向量机SVM设计与实现
04-29
在压缩包中的"基于python的粒子群算法PSO优化支持向量机SVM设计与实现"文件中，很可能是详细介绍了如何结合Python编程语言和PSO算法来优化SVM模型的实现步骤，包括代码示例和可能的结果分析。读者可以通过阅读这份...
支持向量机及Python代码实现.pdf
09-30
整体来看，支持向量机的理论和Python代码实现涉及了复杂的数学理论和编程技巧。从数学优化的角度来看，SVM是对线性分类问题的优雅解决，而SMO算法则将SVM的求解问题降维简化为多个小规模的子问题。在实践中，这些...
支持向量机实战代码（全）
10-12
提供的"Chapter6"文件可能包含了关于SVM的详细代码实现，包括上述的简易SMO、完整SMO以及引入核函数的SMO。这些代码可以帮助读者更好地理解SVM的工作原理，并动手实践，提升编程技能。 总之，支持向量机作为一种...
支持向量机及Python代码实现.docx
最新发布
07-20
### 支持向量机（SVM）及Python代码实现 #### 1. 支持向量机（SVM）理论概述 支持向量机（Support Vector Machine, SVM）是一种非常强大的监督学习算法，主要用于分类和回归分析。它在解决小样本、非线性以及高维...
支持向量机代码
05-09
#include <math.h> #include <stdio.h> #include <stdlib.h> #include <ctype.h> #include <float.h> #include <string.h> #include <stdarg.h> #include <limits.h> #include <locale.h> #include "svm.h" int libsvm_version = LIBSVM_VERSION; typedef float Qfloat; typedef signed char schar; #ifndef min template <class T> static inline T min(T x,T y) { return (x<y)?x:y; } #endif #ifndef max template <class T> static inline T max(T x,T y) { return (x>y)?x:y; } #endif template <class T> static inline void swap(T& x, T& y) { T t=x; x=y; y=t; } template <class S, class T> static inline void clone(T*& dst, S* src, int n) { dst = new T[n]; memcpy((void *)dst,(void *)src,sizeof(T)*n); } static inline double powi(double base, int times) { double tmp = base, ret = 1.0; for(int t=times; t>0; t/=2) { if(t%2==1) ret*=tmp; tmp = tmp * tmp; } return ret; } #define INF HUGE_VAL #define TAU 1e-12 #define Malloc(type,n) (type *)malloc((n)*sizeof(type)) static void print_string_stdout(const char *s) { fputs(s,stdout); fflush(stdout); } static void (*svm_print_string) (const char *) = &print_string_stdout; #if 1 static void info(const char *fmt,...) { char buf[BUFSIZ]; va_list ap; va_start(ap,fmt); vsprintf(buf,fmt,ap); va_end(ap); (*svm_print_string)(buf); } #else static void info(const char *fmt,...) {} #endif // // Kernel Cache // // l is the number of total data items // size is the cache size limit in bytes // class Cache { public: Cache(int l,long int size); ~Cache(); // request data [0,len) // return some position p where [p,len) need to be filled // (p >= len if nothing needs to be filled) int get_data(const int index, Qfloat **data, int len); void swap_index(int i, int j); private: int l; long int size; struct head_t { head_t *prev, *next; // a circular list Qfloat *data; int len; // data[0,len) is cached in this entry }; head_t *head; head_t lru_head; void lru_delete(head_t *h); void lru_insert(head_t *h); }; Cache::Cache(int l_,long int size_):l(l_),size(size_) { head = (head_t *)calloc(l,sizeof(head_t)); // initialized to 0 size /= sizeof(Qfloat); size -= l * sizeof(head_t) / sizeof(Qfloat); size = max(size, 2 * (long int) l); // cache must be large enough for two columns lru_head.next = lru_head.prev = &lru_head; } Cache::~Cache() { for(head_t *h = lru_head.next; h != &lru_head; h=h->next) free(h->data); free(head); } void Cache::lru_delete(head_t *h) { // delete from current location h->prev->next = h->next; h->next->prev = h->prev; } void Cache::lru_insert(head_t *h) { // insert to last position h->next = &lru_head; h->prev = lru_head.prev; h->prev->next = h; h->next->prev = h; } int Cache::get_data(const int index, Qfloat **data, int len) { head_t *h = &head[index]; if(h->len) lru_delete(h); int more = len - h->len; if(more > 0) { // free old space while(size < more) { head_t *old = lru_head.next; lru_delete(old); free(old->data); size += old->len; old->data = 0; old->len = 0; } // allocate new space h->data = (Qfloat *)realloc(h->data,sizeof(Qfloat)*len); size -= more; swap(h->len,len); }
支持向量机matlab代码
08-15
支持向量机svm代码 matlab代码 用于分类的 比传统bp神经网络好
matlab支持向量机源代码
09-20
matlab支持向量机源代码 matlab支持向量机源代码 matlab支持向量机源代码
一文速学数模-分类模型(一)SVM(Support Vector Machines)支持向量机算法原理以及应用详解+Python代码实现
master_hunter的博客
07-11 4632
博主大大小小参与过数十场数学建模比赛，SVM经常在各种建模比赛的优秀论文上见到该模型，一般直接使用SVM算法是比较少的，现在都是在此基础理论之上提出优化算法。但是SVM的基础理论是十分重要的思想，放眼整个分类算法中，SVM是最好的现成的分类器。这里说的‘现成’指的是分类器不加修改即可直接使用。在神经网络没有出现之前，SVM的优化模型可以算得上是预测分类神器了，在机器学习中SVM仍旧是最为出名的算法之一了，本篇博客将致力于将SVM算法以及原理每一个知识点都讲明白，希望没有讲明白的点大家可以在评论区指出。...
支持向量机(SVM)代码
兢飞
06-10 279
目录： 1.决策树 决策树模型结构 决策树递归思想 2.信息增益 学习信息增益 学习信息增益率 3.决策树算法 ID3算法 C4.5算法 C4.5算法在连续值上的处理 4.数据处理 划分数据集代码 1.决策树定义 定义 分类决策树模型是一种描述对实例进行分类的树形结构。一棵决策树包含一个根节点，若干个内部节点和若干个叶节点，叶节点对应于决策结果。 决策树的示意图 树的递归思想 ...
支持向量机（SVM）代码
weixin_56229359的博客
05-23 382
【代码】支持向量机（SVM）代码。
支持向量机实现编码
hhy518518的专栏
11-17 1022
文章摘要： 对于非线性可分的复杂数据，我们在支持向量机的基础上可以引入核的概念来辅助，可以将数据转换成分类器易于理解的数据形式 核函数    我们可以发现核函数的用处就是如图所示在低维不可分的数据映射到高维以后就可以划分了。这个过程是从一个特征空间映射到另外一个特征空间，就是通过核函数实现。我们能把核函数想象成一个包装器或者接口，它把数据从某个很难处理形式转换成比较容易处理的形式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值