精华内容
下载资源
问答
  • 遗传算法_粒子群算法优化支持向量机分类预测-附代码
    千次阅读 多人点赞
    2021-12-07 13:17:10

    遗传算法/粒子群算法优化支持向量机分类预测-附代码

    1. 支持向量机简介与参数优化的原理

    1.1 支持向量机SVM简介

    SVM 通过建立输入特征向量和输出的标签向量间的映射模型,来实现分类。即在给定一个样本输入后,能够得到该映射关系下对应输出标签的估计类型。SVM建立模型,通过核函数将低维的输入x输出y转化为高维空间的内积。常见的核函数有线性核函数、RBF 核函数、多项式核函数。由于,相较于线性核函数和多项式核函数,RBF 核函数具有映射维度广、需确定参数少、运算相对简单等优点。所以RBF 核函数是应用最广的核函数。

    1.2 优化参数的选取

    优化SVM的参数通常是惩罚参数C与核函数参数gamma。惩罚参数 C 的选取可使模型复杂度和训练误差之间达到一种折中。核函数的参数 gamma主要反映训练样本数据的范围特性,直接影响支持向量机模型的学习能力。C的值一般取为1,对于gamma参数的取值,一般默认取1/k,k为总类别数。这两个参数的取值与支持向量机模型学习能力的关系如下图所示:

    C取值gamma取值SVM模型的学习能力
    欠学习
    过学习

    为了提高支持向量机的学习能力,提升识别的准确率,通常会采用智能优化算法进行范围内的参数寻优。常用的优化SVM的智能算法比如遗传算法,粒子群算法,布谷鸟搜索算法,鲸鱼算法等。

    1.3 交叉验证(CV)

    交叉验证(cross validation)是机器学习中选择模型、评估模型好坏常用的一种方法,主要思想是 :在给定的训练样本中,利用其中大部分样本来建立模型,取剩下小部分的样本对建立的模型进行预测,得到这小部分预测结果的预测误差,最后选择预测误差小的模型作为最优的模型。

    2. 数据集介绍和采用的优化算法

    数据集源自意大利葡萄酒种类的数据,支持向量机为libsvm。采用SVM、遗传算法优化SVM、粒子群算法优化SVM优化c、g参数,进行分类识别的结果对比。

    读取EXCEL数据的代码:

    %% 读取数据
    data=xlsread('数据.xlsx','Sheet1','A1:N178');  %使用xlsread函数读取EXCEL中对应范围的数据即可  
    
    %输入输出数据
    input=data(:,1:end-1);    %data的第一列-倒数第二列为特征指标
    output_labels=data(:,end);  %data的最后面一列为标签类型
    

    2.1 遗传算法GA优化SVM

    选取惩罚参数C与核参数g作为优化变量,用5折交叉验证,得到不同模型的最佳准确率作为适应度函数。

    GA参数设置:

     ga_option = struct('maxgen',50,'sizepop',20,'ggap',0.9,...
            'cbound',[0,100],'gbound',[0,1000],'v',5);
    % maxgen:最大的进化代数,默认为50,一般取值范围为[100,500]
    % sizepop:种群最大数量,默认为20,一般取值范围为[20,100]
    % cbound = [cmin,cmax],参数c的变化范围,默认为(0,100]
    % gbound = [gmin,gmax],参数g的变化范围,默认为[0,1000]
    % v:SVM Cross Validation交叉验证参数,默认为5
    

    GA优化后的c、g参数给到SVM:

    %% 利用最佳的参数进行SVM网络训练
    cmd = ['-c ',num2str(bestc),' -g ',num2str(bestg)];
    model = libsvmtrain(train_output_labels,train_input,cmd);
    

    建立遗传算法GA优化的SVM模型,流程图如下:
    在这里插入图片描述

    2.2 粒子群算法PSO优化SVM

    选取惩罚参数C与核参数g作为优化变量,用5折交叉验证,得到不同模型的最佳准确率作为适应度函数。

    PSO参数设置:

    pso_option = struct('c1',1.5,'c2',1.7,'maxgen',100,'sizepop',20, ...
            'k',0.6,'wV',1,'wP',1,'v',5, ...
            'popcmax',10^2,'popcmin',10^(-1),'popgmax',10^3,'popgmin',10^(-2));
    % c1:初始为1.5,pso参数局部搜索能力
    % c2:初始为1.7,pso参数全局搜索能力
    % maxgen:初始为200,最大进化数量
    % sizepop:初始为20,种群最大数量
    % k:初始为0.6(k belongs to [0.1,1.0]),速率和x的关系(V = kX)
    % wV:初始为1(wV best belongs to [0.8,1.2]),速率更新公式中速度前面的弹性系数
    % wP:初始为1,种群更新公式中速度前面的弹性系数
    % v:初始为5,SVM Cross Validation参数
    % popcmax:初始为100,SVM 参数c的变化的最大值.
    % popcmin:初始为0.1,SVM 参数c的变化的最小值.
    % popgmax:初始为1000,SVM 参数g的变化的最大值.
    % popgmin:初始为0.01,SVM 参数g的变化的最小值.
    

    PSO优化后的c、g参数给到SVM:

    %% 利用最佳的参数进行SVM网络训练
    cmd = ['-c ',num2str(bestc),' -g ',num2str(bestg)];
    model = libsvmtrain(train_output_labels,train_input,cmd);
    

    建立粒子群算法PSO优化的SVM模型,流程图如下:

    在这里插入图片描述

    3. 程序结果和算法的对比

    3.1 SVM

    在这里插入图片描述

    3.2 遗传算法GA优化SVM

    1. 遗传算法的收敛曲线和优化后的c、g参数值,交叉验证CV准确率
      在这里插入图片描述
    2. 遗传算法优化后的实际类型与识别类型对比图像和准确率
      在这里插入图片描述

    3.3 粒子群算法PSO优化SVM

    1. 粒子群算法的收敛曲线和优化后的c、g参数值,交叉验证CV准确率
      在这里插入图片描述

    2. 粒子群算法优化后的实际类型与识别类型对比图像和准确率
      在这里插入图片描述

    3.4 算法结果的对比

    SVMGA-SVMPSO-SVM
    准确率97.7528%98.8764%98.8764%
    收敛代数-1610

    对比算法的结果,SVM准确率为97.7528%,遗传算法GA与粒子群算法PSO都起到了一定的优化效果,优化后准确率都是98.8764%。优化时采用的交叉验证方法,降低了结果的偶然性。相较于遗传算法GA,粒子群算法PSO在第10代达到了收敛,收敛后的CV准确率为98.8764%,说明PSO收敛速度更快,在SVM的优化过程中寻优能力(体现为优化速度)也更强。

    4. 小结

    1. 优化的本质是选取准确率最高的时候对应的c、g参数,抓住这点,可以用任意智能优化算法来寻优做对比。
    2. SVM也可以用来做回归预测,其优化原理与分类一致,都归于使用算法求解两个决策变量+一个目标函数的问题。

    利用遗传算法等智能优化算法,优化支持向量机回归预测的设计原理与算法步骤,请参考我的另一篇博客:基于麻雀搜索算法优化的支持向量机回归预测

    5. MATLAB代码

    以下介绍了常用的支持向量机分类和预测模型及编写相应的代码,相关模型原理和代码见博客主页。

    支持向量机回归预测模型
    支持向量机回归预测MATLAB程序
    粒子群算法优化支持向量机回归预测的MATLAB代码
    遗传算法优化支持向量机回归预测的MATLAB代码
    麻雀搜素算法SSA优化支持向量机回归预测的MATLAB代码
    支持向量机分类模型
    最小二乘支持向量机分类模型
    最小二乘支持向量机分类MATLAB代码
    遗传算法GA优化最小二乘支持向量机分类MATLAB代码
    灰狼优化算法GWO优化最小二乘支持向量机分类MATLAB代码
    支持向量机分类及优化算法模型
    支持向量机分类算法MATLAB代码
    粒子群优化算法PSO优化支持向量机分类MATLAB代码
    遗传算法GA优化支持向量机分类MATLAB代码
    鲸鱼优化算法WOA优化支持向量机分类MATLAB代码
    麻雀搜索算法SSA优化支持向量机分类MATLAB代码
    蝗虫优化算法GOA优化支持向量机分类MATLAB代码
    灰狼优化算法GWO优化支持向量机分类MATLAB代码

    代码见博客主页

    更多相关内容
  • 通过GEE平台调用Landsat8影像数据对土地覆被进行分类,并且计算其总体精度
  • 支持向量机(Support Vector Machine, SVM)是一类按监督学习(supervised learning)方式对数据进行二元分类的广义线性分类器(generalized linear classifier),其决策边界是对学习样本求解的最大边距超平面...
  • SVM支持向量机分类鸢尾花数据集iris及代码,数据集有Excel、data、txt文件格式,代码有data、txt格式演示
  • matlab支持向量机分类实例(十分详细)附数据
  • SVM支持向量机分类

    2018-05-31 17:18:45
    用matlab编程实现支持向量机分类,核函数选取,超平面建立等
  • 支持向量机分类——基于乳腺组织电阻抗特性的乳腺癌诊断的Matlab程序代码 本资源仅供学习交流,侵删
  • 1、掌握支持向量机的原理 2、能够理解支持向量机分类算法; 3、掌握sklearn的支持向量机分类算法;
  • 介绍了支持向量机理论、常用的支持向量机内积核函数以及最小二乘支持向量机算法.采用最小二乘法实现了支持向量机分类算法.数字仿真结果表明,该算法的识别正确率可达100%.
  • 使用基于 SVM 的机器学习对 2 类和 3 类问题进行一维矩阵分类。 它还包含一个基于矩阵的 AND 门示例和大小为 12 和 3 的输入样本
  • 为提高多类支持向量机分类效率,提出了一种基于混合二叉树结构的多类支持向量机分类算法。该混合二叉树中的每个内部结点对应一个分割超平面,该超平面通过计算两个距离最远的类的质心而获得,即该超平面为连接两...
  • 采用支持向量机SVM分类葡萄酒,完整代码,无错误,下载即可运行。
  • 在计算机上验证和测试莺尾花数据的支持向量机分类实验,sklearn的支持向量机分类算法。 实验目的 1、掌握支持向量机的原理 2、能够理解支持向量机分类算法; 3、掌握sklearn的支持向量机分类算法; 三、实验内容...

    一、实验要求

    在计算机上验证和测试莺尾花数据的支持向量机分类实验,sklearn的支持向量机分类算法。

    • 实验目的

    1、掌握支持向量机的原理

    2、能够理解支持向量机分类算法;

    3、掌握sklearn的支持向量机分类算法;

    三、实验内容

    实验步骤

    1. 请参考LinearSVC.pdf文档,将莺尾花的数据替换为make_blobs自动生成两个测试数据集(一个是两个类别数据完全分离,另一个是两个类别数据有很少部分的交叉),对比KNN,贝叶斯,决策树,随机森林还有LinearSVC的分界边界线的区别。

    没有最好的分类器,只有最合适的分类器。

    1. 数据完全分离
      数据:

     

     

    1. 数据部分交叉:
      数据:

     

     

    1. 请详细测试LinearSVC中的C超参数对分类分界边界线的影响

     

     

    C越大,即对分错样本的惩罚程度越大,因此在训练样本中准确率越高,但是泛化能力降低,也就是对测试数据的分类准确率降低。减小C的话,容许训练样本中有一些误分类错误样本,泛化能力强。

    3.请同时对比,LinearSVC和SVC,三者在莺尾花数据集,make_blobs生成的数据集,还有makemoons生成的数据集,还有makecircles生成的数据集,对比差异。

     

     

    (2)三种SVM分类方法和四组数据综合对比:
    备注:三种分类方法纵向对比,四组数组横向对比
    数据:图3-1 莺尾花数据、图3-2 make_blobs生成的数据、图3-3 makemoons生成的数据、图3-4 makecircles生成的数据。

     

    1.对于SVC, NuSVC,和LinearSVC 3个分类的类,SVC和 NuSVC差不多,区别仅仅在于对损失的度量方式不同,而LinearSVC是线性分类,也就是不支持各种低维到高维的核函数,仅仅支持线性核函数,对线性不可分的数据不能使用。

    2,LinearSVC使用的是平方hinge loss,SVC使用的是绝对值hinge loss,我们知道,绝对值hinge loss是非凸的,不能用GD去优化,而平方hinge loss可以;

    3.LinearSVC使用的是One-vs-All(也称One-vs-Rest)的优化方法,而SVC使用的是One-vs-One;

    4.对于多分类问题,如果分类的数量是N,则LinearSVC适合N模型,而SVC适合N(N-1)/2模型;

    四、实验总结
           1、掌握了支持向量机的原理
           2、理解了支持向量机分类算法;
           3、掌握了sklearn的支持向量机分类算法;
           4、SVM对数据的处理效果要好于KNN,贝叶斯和随机森林。当数据分类界限明显且能用直线分割时,可以用LinearSVC;当数据类别分界线呈包围或者半包围状态时,用SVC最好。

    展开全文
  • matlab源码集锦-基于matlab的支持向量机分类、回归问题
  • 提出了一种基于高斯混合模型核的半监督支持向量机(SVM)分类算法.通过构造高斯混合模型核SVM分类器提供未标示样本信息,使得SVM算法在学习标示样本信息的同时,能够兼顾整个训练样本集合的聚类假设.实验部分将该算法同...
  • 然后,利用基准数据集,在相同的训练集和测试集上对L-infinity SVC,1-范数度量的支持向量分类(L1-SVC)和2-范数度量的支持向量分类(L2-SVC)进行了比较实验。实验结果显示,L-infinity SVC的测试
  • AI-支持向量机分类预测

    千次阅读 2020-08-26 21:05:57
    基于支持向量机分类预测 1.简介 支持向量机(support vector machines, SVM)是一种二分类模型,它的基本模型是定义在特征空间上的间隔最大的线性分类器,间隔最大使它有别于感知,其决策边界是对学习样本求解的...

    基于支持向量机的分类预测

    1.简介

    支持向量机(support vector machines, SVM)是一种二分类模型,它的基本模型是定义在特征空间上的间隔最大的线性分类器,间隔最大使它有别于感知机,其决策边界是对学习样本求解的最大边距超平面。
    SVM还包括核技巧,这使它成为实质上的非线性分类器。SVM的的学习策略就是间隔最大化,*即从决策边界到各个数据集的距离越大,分类操作出错率越小。*可形式化为一个求解凸二次规划的问题,也等价于正则化的合页损失函数的最小化问题。SVM的的学习算法就是求解凸二次规划的最优化算法。

    • 当训练样本线性可分时,通过硬间隔最大化,学习一个线性可分支持向量机。
    • 当训练样本近似线性可分时,通过软间隔最大化,学习一个线性支持向量机。
    • 当训练样本线性不可分时,通过核技巧和软间隔最大化,学习一个非线性支持向量机。

    2. 学习重点

    在这里插入图片描述

    3.基本原理

    3.1 支持向量

    3.1.1 线性可分性

    什么是线性可分?
    在这里插入图片描述

    • 决策边界:在具有两个类的统计分类问题中,决策边界或决策表面是超曲面,其将基础向量空间划分为两个集合。如果决策表面是超平面,那么分类问题是线性的,并且类是线性可分的。
    • 超平面:超平面是n维欧氏空间中余维度等于一的线性子空间,也就是必须是(n-1)维度。

    在这里插入图片描述
    换一种简单的说法,就是在二分空间上,有两类点被一条直线完全分开叫做线性可分。
    在这里插入图片描述

    3.1.2 最大间隔超平面

    在这里插入图片描述
    简单点说:
    在这里插入图片描述
    为了使这个超平面更具鲁棒性,会去找最佳超平面,以最大间隔把两类样本分开的超平面,也称之为最大间隔超平面

    • 两类样本分别分割在该超平面的两侧;
    • 两侧距离超平面最近的样本点到超平面的距离被最大化了。

    3.1.3 支持向量

    样本中距离超平面最近的一些点就叫作支持向量,如下图所示
    在这里插入图片描述

    3.1.3 SVM最优化

    SVM 想要的就是找到各类样本点到超平面的距离最远,也就是找到最大间隔超平面。任意超平面可以用下面这个线性方程来描述:
    在这里插入图片描述
    如上图所示:

    • 根据支持向量的定义知道,支持向量到超平面的距离为 d,其他点到超平面的距离大于 d。
    • 而在超平面两边的点,一类是为正类,一类为负类,各自离超平面距离大于d则可表示为:
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述
      注:这里的“s.t.”意为 subject to,使满足。

    3.2 对偶问题

    3.2.1 拉格朗日乘数法

    在数学最优问题中,拉格朗日乘数法是一种寻找变量受一个或多个条件所限制的多元函数的极值的方法。这种方法将一个有n 个变量与k 个约束条件的最优化问题转换为一个有n + k个变量的方程组的极值问题,其变量不受任何约束。这种方法引入了一种新的标量未知数,即拉格朗日乘数:约束方程的梯度(gradient)的线性组合里每个向量的系数。

    A.等式约束优化问题:
    在这里插入图片描述
    B. 不等式约束优化问题
    现在面对的是不等式优化问题,针对这种情况其主要思想是将不等式约束条件转变为等式约束条件,引入松弛变量,将松弛变量也是为优化变量,即
    不等式约束优化⇒ 引入松弛变量(优化变量)⇒ 等式约束优化 ⇒ 引入Lagrange乘子(优化变量)⇒ 无约束优化(将Lagrange函数对所有优化变量求偏导令其值为零)
    在这里插入图片描述
    在这里插入图片描述

    这个式子告诉了什么事情呢?(下面依旧半懂状态,需要琢磨)
    在这里插入图片描述
    或另一种方程解:
    在这里插入图片描述

    3.2.2 强对偶性

    在这里插入图片描述

    3.3 SVM优化

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

    在这里插入图片描述
    没法一次只变动一个参数。所以选择了一次选择两个参数。具体步骤为:
    在这里插入图片描述
    在这里插入图片描述

    3.4 软间隔

    前面我们是假定所有的训练样本在样本空间或特征空间中是严格线性可分的,即存在一个超平面能把不同类的样本完全分开,然而现实任务中很难确定这样的超平面(不管是线性超平面还是经过核变换到高维空间的超平面),所以引入松弛变量,允许一些样本出错,但我们希望出错的样本越少越好,所以松弛变量也有限制(注:公式中的松弛变量不是单单一个数,每个样本都有对应的松弛变量)。引入松弛变量的间隔问题成为软间隔。
    在这里插入图片描述
    在这里插入图片描述

    3.4.2 优化目标及求解

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

    3.5 核函数

    3.5.1 线性不可分

    刚刚讨论的硬间隔和软间隔都是在说样本的完全线性可分或者大部分样本点的线性可分。而现实任务中很可能遇到这样的情况,即不存在一个能够正确划分两个类别样本的超平面,对这样的问题,可以将样本从原始空间映射到一个更高维的特征空间中,使得样本在这个特征空间中线性可分。数学上可以证明,如果原始空间是有限维,即属性数有限,则一定存在一个高维特征空间使样本可分。
    在这里插入图片描述
    对于在有限维度向量空间中线性不可分的样本,我们将其映射到更高维度的向量空间里,再通过间隔最大化的方式,学习得到支持向量机,就是非线性 SVM。
    在这里插入图片描述

    3.5.2 核函数的作用

    为什么要有核函数的呢?

    这是因为低维空间映射到高维空间后维度可能会很大,如果将全部样本的点乘全部计算好,这样的计算量太大了。
    在这里插入图片描述
    然后在进行内积计算,才能与多项式核函数达到相同的效果。

    可见核函数的引入一方面减少了我们计算量,另一方面也减少了我们存储数据的内存使用量。

    3.5.3 常见核函数

    在这里插入图片描述
    这三个常用的核函数中只有高斯核函数是需要调参的。

    3.6 优缺点

    优点

    • 有严格的数学理论支持,可解释性强,不依靠统计方法,从而简化了通常的分类和回归问题;
    • 能找出对任务至关重要的关键样本(即:支持向量);
    • 采用核技巧之后,可以处理非线性分类/回归任务;
    • 最终决策函数只由少数的支持向量所确定,计算的复杂性取决于支持向量的数目,而不是样本空间的维数,这在某种意义上避免了“维数灾难”。

    缺点
    在这里插入图片描述
    因此,支持向量机目前只适合小批量样本的任务,无法适应百万甚至上亿样本的任务。

    4. Demo实践

    import numpy as np 
    import matplotlib.pyplot as plt
    import seaborn as sns
    ## 导入逻辑回归模型函数
    from sklearn  import svm
    
    ## 构造数据集
    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) 
    
    ## 查看其对应模型的w
    print('the weight of Logistic Regression:',svc.coef_)
    
    ## 查看其对应模型的w0
    print('the intercept(w0) of Logistic Regression:',svc.intercept_)
    

    在这里插入图片描述

    ## 模型预测
    y_train_pred = svc.predict(x_fearures)
    print('The predction result:',y_train_pred)
    #The predction result: [0 0 0 1 1 1]
    # 最佳函数
    x_range = np.linspace(-3, 3)
    
    #结合SVM的距离公式
    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=30, cmap='viridis')
    plt.plot(x_range, y_3, '-c')
    plt.show()
    

    在这里插入图片描述
    上述只是一个简单的样本,告知SVM可以做什么,就是简单的二分类案例。下面稍微切入正题,代入SVM解决三种分类问题,即支持向量,软间隔和核函数。

    5. 支持向量机代码介绍

    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=30, 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=30, 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=30, 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)
    

    在这里插入图片描述
    暂时选择蓝色最为分类器,但是不一定是最优,所以引入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')
    

    在这里插入图片描述

    # 数据映射
    from mpl_toolkits.mplot3d import Axes3D
    r = np.exp(-(X[:, 0] ** 2 + X[:, 1] ** 2))
    
    fig = plt.figure()
    ax = Axes3D(fig)
    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://zhuanlan.zhihu.com/p/31886934

    https://baike.baidu.com/item/%E6%94%AF%E6%8C%81%E5%90%91%E9%87%8F%E6%9C%BA/9683835?fr=aladdin

    https://baike.baidu.com/item/%E6%8B%89%E6%A0%BC%E6%9C%97%E6%97%A5%E4%B9%98%E6%95%B0%E6%B3%95

    https://zhuanlan.zhihu.com/p/77750026?utm_source=wechat_session

    https://blog.csdn.net/sinat_20177327/article/details/79729551

    https://blog.csdn.net/Dominic_S/article/details/83002153

    https://blog.csdn.net/gwb281386172/article/details/102942156

    展开全文
  • 最小二乘支持向量机分类程序实例,使用lssvm工具箱,安装好后,直接可以运行,包含注释,matlab程序源代码,简单易懂的分类例子,.m文件格式
  • 首先, 利用自适应的荷尔蒙调节遗传算法(HMGA), 对支持向量机分类器进行建模参数优化; 然后, 通过构建MultiBoost 集成学习方法将多个基分类器集成, 建立以多分类器优化集成为核心的故障诊断系统. 实验结果表明, 所...
  • 支持向量机分类

    2014-12-09 12:43:51
    一个基于.net平台的支持向量机开发源代码,有兴趣的可以下载看看
  • 最小二乘支持向量机分类器1.支持向量机分类2.最小二乘支持向量机3.LSSVM的Python实现 在这篇文章中,我们讨论支持向量机(SVM)分类器的最小二乘版本。由于公式中的相等类型约束。解是由解一组线性方程得出的。而不是...

    在这篇文章中,我们讨论支持向量机(SVM)分类器的最小二乘版本。由于公式中的相等类型约束。解是由解一组线性方程得出的。而不是经典的支持向量机的二次规划。
    本文针对两类分类问题,提出了支持向量机的最小二乘模型。对于函数估计问题,支持向量解释边缘回归。在(Saunders et al., 1998)中,它考虑了等式类型的约束,而不是经典的支持向量机方法中的不等式。在这里,我们也考虑了在最小二乘意义下的公式分类问题的等式约束。因此,求解直接遵循求解一组线性方程,而不是二次规划。在经典的支持向量机中,许多支持值为零(非零值对应于支持向量),而在最小二乘支持向量机中,支持值与误差成正比。

    1.支持向量机分类

    给定N个点的训练集
    在这里插入图片描述,Xk是第K个输入模式,Yk是第K个输出模式,支持向量机方法旨在构建一种分类器:
    在这里插入图片描述
    αk 是正常量,b是实常量,对于
    在这里插入图片描述
    有下列选择:
    在这里插入图片描述
    在这里插入图片描述
    构建如下分类器:
    假定
    在这里插入图片描述
    这个式子等同于
    在这里插入图片描述
    在这里插入图片描述
    是非线性函数,它映射输入空间到更高维空间。
    然而,这个函数不是显式构造的。为了有违反(3)的可能性,在这个高维空间中不存在一个分离的超平面时,引入了这样的变量
    在这里插入图片描述
    在这里插入图片描述
    根据结构风险最小化原则,将优化问题公式化,使风险界最小化:
    在这里插入图片描述
    它满足(4)。同时通过引入拉格朗日乘数
    在这里插入图片描述
    ,我们构建了拉格朗日方程
    在这里插入图片描述
    通过计算
    在这里插入图片描述
    获得拉格朗日点的解。
    一个解是:
    在这里插入图片描述
    它会影响下面这个二次规划问题的答案:
    在这里插入图片描述
    比如:
    在这里插入图片描述
    在这里插入图片描述
    这是由默瑟定理提出的。需要注意的是,对于两层神经支持向量机,Mercer‘s ’条件仅支持K和theta 的特定参数值。
    通过解决
    在这里插入图片描述
    设计分类器(1),它满足(9)中的条件。为了确定决定决策面,没有计算w和ф(x)。
    因为矩阵与这个二次规划问题不是无限期的,(11)的解决方案将是全局的。
    并且,超平面(3)满足
    在这里插入图片描述,VC-维度h满足:
    在这里插入图片描述
    [ . ]表示整数部分和r是包含点的半径最小的球中φ(x1)、…φ(xN)。通过定义拉格朗日函数就可以找到这个球

    在这里插入图片描述
    q表示球心,
    在这里插入图片描述 是正拉格朗日变量。
    与(5)中发现与
    在这里插入图片描述
    等同的球心相似的方式,从
    在这里插入图片描述
    找到拉格朗日变量,其中
    在这里插入图片描述
    根据(10),Q2也可以表示为
    (x,x7)
    最后,通过求解(11)并从(14)中计算(12)来选择一个VC维最小的支持向量机。

    2.最小二乘支持向量机用于分类任务

    (1)优化目标
    这里我们将最小二乘版本引入SVM分类器,将分类问题表述为:
    在这里插入图片描述
    它满足平等的限制:
    在这里插入图片描述
    (2)拉格朗日乘子法

    定义拉格朗日函数:
    在这里插入图片描述
    其中 aK 是拉格朗日乘数的等式约束,现在可以是正的或负的)。
    (3)求解最优化条件
    约束优化:
    在这里插入图片描述
    (4)求解对偶问题
    上式可以直接写成以下一组线性方程的解(Fletcher, 1987):
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    Mercer’s 的条件可以再次应用到矩阵
    Q = ZZ中
    其中,
    在这里插入图片描述
    因此,分类器(1)是通过求解线性方程组(20)(21)而不是二次规划得到的。如RBF核的σ等核的参数可根据(12)进行优化选择。支持值 αk 与数据点(18)的误差成比例,而在(14)的情况下,大多数值等于零。因此,在最小二乘情况下,人们更愿意说一个支持值谱。
    LLSVM通过求解上述线性方程组,得到优化变量a aa和b bb的值,这种求解方式比求解QP问题更加简便。
    最小二乘支持向量机求解时,计算成本低,并且没有许多局部最小值,是一个凸优化问题的解决方案。
    并且泛化性能较好。
    (5)与标准SVM的区别

    a. 使用等式约束,而不是不等式约束;
    b. 由于对每个样本点采用了等式约束,因此对松弛向量不施加任何约束,这也是LSSVM丢失稀疏性的重要原因;
    c. 通过解决等式约束以及最小二乘问题,使得问题得到进一步简化。

    3.最小二乘支持向量机用于回归

    在这里插入图片描述

    4.LSSVM分析

    特性:
    1) 同样是对原始对偶问题进行求解,但是通过求解一个线性方程组(优化目标中的线性约束导致的)来代替SVM中的QP问题(简化求解过程),对于高维输入空间中的分类以及回归任务同样适用;
    2) 实质上是求解线性矩阵方程的过程,与高斯过程(Gaussian processes),正则化网络(regularization networks)和费雪判别分析(Fisher discriminant analysis)的核版本相结合;
    3) 使用了稀疏近似(用来克服使用该算法时的弊端)与稳健回归(稳健统计);
    4) 使用了贝叶斯推断(Bayesian inference);
    5) 可以拓展到非监督学习中:核主成分分析(kernel PCA)或密度聚类;
    6) 可以拓展到递归神经网络中。
    缺点:
    (1)解决分类任务时,全部训练样本都会被作为支持向量来看待,这就会导致其丧失SVM原有的稀疏性质,但是还可以通过对训练集进行基于支持度的“减枝”(pruning)处理来达到稀疏化的目的,这一步也可以看做是一种稀疏近似(sparse approximate)操作。
    (2)

    5.LSSVM的Python实现

    // 
    from numpy import *
    
    def loadDataSet(filename):
        '''导入数据
        input: filename:文件名
    	output:dataMat(list)样本特征
    	       labelMat(list)样本标签
        '''
        dataMat = []
        labelMat = []
        fr = open(filename)
        for line in fr.readlines():
            lineArr = line.strip().split('\t')
            dataMat.append([float(lineArr[0]),float(lineArr[1])])
            labelMat.append(float(lineArr[2]))
        return dataMat,labelMat
               
    
    def kernelTrans(X,A,kTup):
        '''数据集中每一个数据向量与数据A的核函数值
        input: X--特征数据集
               A--输入向量
               kTup--核函数参量定义
        output: K--数据集中每一个数据向量与A的核函数值组成的矩阵
        '''
        X = mat(X)
        m,n = shape(X)
        K = mat(zeros((m,1)))
        if kTup[0] == 'lin':
            K = X * A.T
        elif kTup[0] == 'rbf':
            for j in range(m):
                deltaRow = X[j,:] - A
                K[j] = deltaRow * deltaRow.T
            K = exp(K/(-1 * kTup[1] ** 2))
        else: raise NameError('Houston We Have a Problem -- That Kernel is not recognized')
        return K
        
    class optStruct:
        def __init__(self,dataMatIn,classLabels,C,kTup):
            self.X = dataMatIn
            self.labelMat = classLabels
            self.C = C
            self.m = shape(dataMatIn)[0]
            self.alphas = mat(zeros((self.m,1)))
            self.b = 0
            self.K = mat(zeros((self.m,self.m)))  #特征数据集合中向量两两核函数值组成的矩阵,[i,j]表示第i个向量与第j个向量的核函数值
            for i in range(self.m):
                self.K[:,i] = kernelTrans(self.X, self.X[i,:], kTup)
                
    
    def leastSquares(dataMatIn,classLabels,C,kTup):
        '''最小二乘法求解alpha序列
        input:dataMatIn(list):特征数据集
              classLabels(list):分类标签集
              C(float):参数,(松弛变量,允许有些数据点可以处于分隔面的错误一侧)
              kTup(string): 核函数类型和参数选择 
        output:b(float):w.T*x+b=y中的b
               alphas(mat):alphas序列      
        '''
        oS = optStruct(mat(dataMatIn),mat(classLabels).transpose(),C,kTup)
    	##1.参数设置
        unit = mat(ones((oS.m,1)))  #[1,1,...,1].T
        I = eye(oS.m)
        zero = mat(zeros((1,1)))
        upmat = hstack((zero,unit.T))
        downmat = hstack((unit,oS.K + I/float(C)))
    	##2.方程求解
        completemat = vstack((upmat,downmat))  #lssvm中求解方程的左边矩阵
        rightmat = vstack((zero,oS.labelMat))    # lssvm中求解方程的右边矩阵
        b_alpha = completemat.I * rightmat
        oS.b = b_alpha[0,0]
        for i in range(oS.m):
            oS.alphas[i,0] = b_alpha[i+1,0]
        return oS.alphas,oS.b,oS.K
    
    def predict(alphas,b,dataMat,testVec):
        '''预测结果
        input:alphas(mat):Lagrange乘子序列
              b(float):分隔超平面的偏置
              dataMat()
              
        output:sign(float(predict_value))(int):预测样本的类别
        '''
        Kx = kernelTrans(dataMat,testVec,kTup)   #可以对alphas进行稀疏处理找到更准确的值
        predict_value =  Kx.T * alphas + b
    #    print('预测值为:%f'%predict_value)
    #    print('分类结果为:%f'%sign(float(predict_value)))
        return sign(float(predict_value))
    
     
    
    
    if __name__ == '__main__':
        ##1.导入数据
        print('-----------------------------1.Load Data-------------------------------')
        dataMat,labelMat = loadDataSet('testSetRBF.txt')
        C = 0.6
        k1 = 0.3
        kernel = 'rbf'
        kTup = (kernel,k1)
        ##2.训练模型
        print('----------------------------2.Train Model------------------------------')
        alphas,b,K = leastSquares(dataMat,labelMat,C,kTup)
        ##3.计算训练误差
        print('----------------------------3.Calculate Train Error--------------------')
        error = 0.0
        for i in range(len(dataMat)):
            test = predict(alphas,b,dataMat,dataMat[i])
            if test != float(labelMat[i]):
                error +=1.0
        errorRate = error/len(dataMat)
        print('---------------训练误差为:%f-------------------'%errorRate)
    
    

    参考:
    文章
    源码
    博客

    展开全文
  • 文章目录一、支持向量机:线性分类器的“王者”1. 距离2. 支持向量3. 从更高维度看“线性不可分”二、支持向量机分类的算法原理1. 基本思路(1) 最大间隔(2) 高维映射(3) 核函数(4) 支持向量机的真正运行机制(5) 核...
  • 一维支持向量机SVM代码(MATLAB),包括支持向量机分类支持向量机回归SVC&SVR;。另外还包括与BP神经网络的比较结果。
  • 支持向量机(support vector machines, SVM)是一种二分类模型,它的基本模型是定义在特征空间上的间隔最大的线性分类器,间隔最大使它有别于感知;SVM还包括核技巧,这使它成为实质上的非线性分类器。SVM的的学习...
  • 为了在标记样本数目有限时尽可能地提高支持向量机分类精度, 提出了一种基于聚类核的半监督支持向量机分类方法。该算法依据聚类假设, 即属于同一类的样本点在聚类中被分为同一类的可能性较大的原则去对核函数进行...
  • 对手写数字采用支持向量机算法进行识别分类,并能进行参数调优等功能
  • 文章提出一种数据预处理的方法对学习样本进行聚类,以此为基础得到一种模糊支持向量机,计算机仿真结果表明本文提出的算法与传统的支持向量机训练算法相比,在不降低分类精度的情况下,大大缩短了支持向量机的学习训练...
  • 使用并行粒子群优化策略的最优支持向量机分类
  • 使用SVM支持向量机进行鸢尾花分类_Python实现-附件资源

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 101,497
精华内容 40,598
关键字:

支持向量机分类

友情链接: music01.zip