Python3：《机器学习实战》之支持向量机（2）简化版SMO

最新推荐文章于 2022-10-28 20:50:48 发布
最新推荐文章于 2022-10-28 20:50:48 发布
阅读量3.9k 收藏 15
点赞数 5
分类专栏： 机器学习 机器学习实战 文章标签： 机器学习实战 python3 SMO SVM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011475210/article/details/78183648
版权

Python3：《机器学习实战》之支持向量机（2）简化版SMO

前言

  SVM有很多实现，但我们只关注其中最流行的一种实现，即序列最小优化（ Sequential MInimal Optimization，SMO ）算法。

  下面我们就开始讨论SMO算法，本篇博文先给出一个简化的版本，以便我们能够正确理解它的工作流程。

Platt的SMO算法

  1996年，伟大的John Platt发布了一个称为SMO的强大算法，用于训练SVM。Platt的SMO算法是将大优化问题分解为多个小优化问题来求解的。这些小优化问题往往很容易求解，并且对它们进行顺序来求解的结果与将他们作为整体来求解的结果是完全一致的，但是求解时间却大大缩短。

  SMO算法的目标是求出一系列alpha和b，一旦求出了这些alpha，就很容易计算出权重向量w并得到分隔超平面。

  SMO的工作原理是：每次循环中选择两个alpha进行优化处理。一旦找到一对合适的alpha，那么就增大其中一个同时减小另一个。这里所谓的“合适”就是指两个alpha必须要符合一定的条件，条件之一就是这两个alpha必须要在间隔边界之外，另一个条件则是这两个alpha还没有进行过区间化处理或者不在边界上。

应用简化版SMO算法处理小规模数据集

  Platt SMO算法中的外循环确定要优化的最佳alpha对。而简化版会跳过这一部分，首先在数据集上遍历每一个alpha，然后在剩下的alpha集合中随机选择另一个alpha来构成alpha对。这里有一点相当重要，就是我们要同时改变两个alpha，因为我们需要满足一个约束条件：

$$
\sum \alpha_i · label^{(i)} = 0
$$

  由于改变一个alpha可能会导致该约束条件失效，因为需要同时改变两个alpha，一增一减，改变的量相同。

  在实现简化版SMO之前，我们需要先构造几个辅助函数。打开文本编辑器，将下面的代码加入svmMLiA.py中。

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Date    : 2017-09-21 21:02:51
# @Author  : WordZzzz (wordzzzz@foxmail.com)
# @Link    : http://blog.csdn.net/u011475210

from numpy import *
from time import sleep

def loadDataSet(fileName):
    """
    Function：   加载数据集

    Input：      fileName：数据集

    Output： dataMat：数据矩阵
                labelMat：类别标签矩阵
    """ 
    #初始化数据列表
    dataMat = []
    #初始化标签列表
    labelMat = []
    #打开文件
    fr = open(fileName)
    #遍历每一行数据，读取数据和标签
    for line in fr.readlines():
        #strip删除头尾空白字符，然后再进行分割
        lineArr = line.strip().split('\t')
        #填充数据集
        dataMat.append([float(lineArr[0]), float(lineArr[1])])
        #填充类别标签
        labelMat.append(float(lineArr[2]))
    #返回数据集和标签列表
    return dataMat, labelMat

def selectJrand(i, m):
    """
    Function：   随机选择

    Input：      i：alpha下标
                m：alpha数目

    Output： j：随机选择的alpha下标
    """ 
    #初始化下标j
    j = i
    #随机化产生j，直到不等于i
    while (j == i):
        j = int(random.uniform(0,m))
    #返回j的值
    return j

def clipAlpha(aj, H, L):
    """
    Function：   设定alpha阈值

    Input：      aj：alpha的值
                H：alpha的最大值
                L：alpha的最小值

    Output： aj：处理后的alpha的值
    """ 
    #如果输入alpha的值大于最大值，则令aj=H
    if aj > H:
        aj = H
    #如果输入alpha的值小于最小值，则令aj=L
    if L > aj:
        aj = L
    #返回处理后的alpha的值
    return aj

  首先是我们熟悉的老哥loadDataSet()，用来打开文件并对其进行解析，从而得到每行的类别标签和整个数据矩阵；然后是selectJrand()，用来随机选择第二个alpha的下标（只要和第一个alpha下标不一样就行）；最后一个是clipAlpha()函数，用于设定阈值，限制alpha的值。

>>> reload(svmMLiA)
<module 'svmMLiA' from 'E:\\机器学习实战\\mycode\\Ch06\\svmMLiA.py'>
>>> dataArr, labelArr = svmMLiA.loadDataSet('testSet.txt')
>>> labelArr
[-1.0, -1.0, 1.0, -1.0, 1.0, 1.0, 1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, 1.0, -1.0, 1.0, 1.0, -1.0, 1.0, -1.0, -1.0, -1.0, 1.0, -1.0, -1.0, 1.0, 1.0, -1.0, -1.0, -1.0, -1.0, 1.0, 1.0, 1.0, 1.0, -1.0, 1.0, -1.0, -1.0, 1.0, -1.0, -1.0, -1.0, -1.0, 1.0, 1.0, 1.0, 1.0, 1.0, -1.0, 1.0, 1.0, -1.0, -1.0, 1.0, 1.0, -1.0, 1.0, -1.0, -1.0, -1.0, -1.0, 1.0, -1.0, 1.0, -1.0, -1.0, 1.0, 1.0, 1.0, -1.0, 1.0, 1.0, -1.0, -1.0, 1.0, -1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, -1.0, -1.0, -1.0, -1.0, 1.0, -1.0, 1.0, 1.0, 1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0]
>>>

  简化版SMO伪代码：

创建一个alpha向量并将其初始化为0向量
当迭代次数小于最大迭代次数时（外循环）：
    对数据集中的每个数据向量（内循环）：
        如果该数据向量可以被优化：
            随机选择另外一个数据向量
            同时优化这两个向量
            如果两个向量都不能被优化，退出内循环
    如果所有向量都没被优化，则增加迭代数目，继续下一次循环

  下述代码是SMO算法中的一个有效版本，如果看不懂，可以先找SVM的公式推导看看。打开文本编辑器，将下面的代码加入svmMLiA.py中。

def smoSimple(dataMatIn, classLabels, C, toler, maxIter):
    """
    Function：   简化版SMO算法

    Input：      dataMatIn：数据集
                classLabels：类别标签
                C：常数C
                toler：容错率
                maxIter：最大的循环次数

    Output： b：常数项
                alphas：数据向量
    """ 
    #将输入的数据集和类别标签转换为NumPy矩阵
    dataMatrix = mat(dataMatIn); labelMat = mat(classLabels).transpose()
    #初始化常数项b，初始化行列数m、n
    b = 0; m,n = shape(dataMatrix)
    #初始化alphas数据向量为0向量
    alphas = mat(zeros((m,1)))
    #初始化iter变量，存储的是在没有任何alpha改变的情况下遍历数据集的次数
    iter = 0
    #外循环，当迭代次数小于maxIter时执行
    while (iter < maxIter):
        #alpha改变标志位每次都要初始化为0
        alphaPairsChanged = 0
        #内循环，遍历所有数据集
        for i in range(m):
            #multiply将alphas和labelMat进行矩阵相乘，求出法向量w(m,1),w`(1,m)
            #dataMatrix * dataMatrix[i,:].T，求出输入向量x(m,1)
            #整个对应输出公式f(x)=w`x + b
            fXi = float(multiply(alphas, labelMat).T * (dataMatrix * dataMatrix[i,:].T)) + b
            #计算误差
            Ei = fXi - float(labelMat[i])
            #如果标签与误差相乘之后在容错范围之外，且超过各自对应的常数值，则进行优化
            if ((labelMat[i]*Ei < -toler) and (alphas[i] < C)) or ((labelMat[i] * Ei > toler) and (alphas[i] > 0)):
                #随机化选择另一个数据向量
                j = selectJrand(i, m)
                #对此向量进行同样的计算
                fXj = float(multiply(alphas, labelMat).T * (dataMatrix * dataMatrix[j,:].T)) + b
                #计算误差
                Ej = fXj - float(labelMat[j])
                #利用copy存储刚才的计算值，便于后期比较
                alphaIold = alphas[i].copy(); alpahJold = alphas[j].copy()
                #保证alpha在0和C之间
                if (labelMat[i] != labelMat[j]):
                    L = max(0, alphas[j] - alphas[i])
                    H = min(C, C + alphas[j] - alphas[i])
                else:
                    L = max(0, alphas[j] + alphas[i] - C)
                    H = min(C, alphas[j] + alphas[i])
                #如果界限值相同，则不做处理直接跳出本次循环
                if L == H: print("L == H"); continue
                #最优修改量，求两个向量的内积（核函数）
                eta = 2.0 * dataMatrix[i,:] * dataMatrix[j,:].T - dataMatrix[i,:] * dataMatrix[i,:].T - dataMatrix[j,:] * dataMatrix[j,:].T
                #如果最优修改量大于0，则不做处理直接跳出本次循环，这里对真实SMO做了简化处理
                if eta >= 0: print("eta >= 0"); continue
                #计算新的alphas[j]的值
                alphas[j] -= labelMat[j] * (Ei - Ej) / eta
                #对新的alphas[j]进行阈值处理
                alphas[j] = clipAlpha(alphas[j], H, L)
                #如果新旧值差很小，则不做处理跳出本次循环
                if (abs(alphas[j] - alpahJold) < 0.00001): print("j not moving enough"); continue
                #对i进行修改，修改量相同，但是方向相反
                alphas[i] += labelMat[j] * labelMat[i] * (alpahJold - alphas[j])
                #新的常数项
                b1 = b - Ei - labelMat[i] * (alphas[i] - alphaIold) * dataMatrix[i,:] * dataMatrix[i,:].T - labelMat[i] * (alphas[j] - alpahJold) * dataMatrix[i,:] * dataMatrix[j,:].T
                b2 = b - Ej - labelMat[i] * (alphas[i] - alphaIold) * dataMatrix[i,:] * dataMatrix[j,:].T - labelMat[j] * (alphas[j] - alpahJold) * dataMatrix[j,:] * dataMatrix[j,:].T
                #谁在0到C之间，就听谁的，否则就取平均值
                if (0 < alphas[i]) and (C > alphas[i]): b = b1
                elif (0 < alphas[j]) and (C > alphas[j]): b = b2
                else: b = (b1 + b2) / 2.0
                #标志位加1
                alphaPairsChanged += 1
                #输出迭代次数，alphas的标号以及标志位的值
                print("iter: %d i: %d, pairs changed %d" % (iter, i, alphaPairsChanged))
        #如果标志位没变，即没有进行优化，那么迭代值加1
        if (alphaPairsChanged == 0): iter += 1
        #否则迭代值为0
        else: iter = 0
        #打印迭代次数
        print("iteration number: %d" % iter)
    #返回常数项和alphas的数据向量
    return b, alphas

  运行结果如下：

>>> reload(svmMLiA)
<module 'svmMLiA' from 'E:\\机器学习实战\\mycode\\Ch06\\svmMLiA.py'>
>>> b, alphas = svmMLiA.smoSimple(dataArr, labelArr, 0.6, 0.001, 40)
iter: 0 i: 0, pairs changed 1
j not moving enough
j not moving enough
iter: 0 i: 5, pairs changed 2
j not moving enough
j not moving enough
iter: 0 i: 17, pairs changed 3
j not moving enough
j not moving enough
j not moving enough
j not moving enough
j not moving enough
j not moving enough
j not moving enough
iter: 0 i: 54, pairs changed 4
j not moving enough
j not moving enough
L == H
j not moving enough
L == H
j not moving enough
iteration number: 0
j not moving enough
iter: 0 i: 5, pairs changed 1
···
···
iteration number: 0
j not moving enough
j not moving enough
j not moving enough
iteration number: 1
j not moving enough
j not moving enough
j not moving enough
···
···
j not moving enough
j not moving enough
j not moving enough
iteration number: 39
j not moving enough
j not moving enough
j not moving enough
iteration number: 40

  上述过程可能需要几分钟才会收敛，一旦运行结束，我们就可以对结果进行查看：

>>> b
matrix([[-3.87260031]])
>>> alphas[alphas > 0]
matrix([[ 0.10195497,  0.25933768,  0.0240785 ,  0.33721415]])
>>> from numpy import *
>>> shape(alphas[alphas > 0])
(1, 4)
>>> for i in range(100):
...     if alphas[i] > 0.0: print(dataArr[i], labelArr[i])
... 
[4.658191, 3.507396] -1.0
[3.457096, -0.082216] -1.0
[5.286862, -2.358286] 1.0
[6.080573, 0.418886] 1.0
>>>

  由于SMO算法的随机性，每次运行之后得到的结果不尽相同。alphas[alphas > 0]命令是数组过滤的一个实例，得到仅仅包含大于0的值的矩阵，而且它只对NumPy类型有用，却并不适用于Python中的正则表。

  我们在数据集上把这些支持向量画出来：

  希望通过本篇博文，大家对SMO的工作流程有了一定得了解，至于完成版的SMO，WordZzzz将会在下一篇博文介绍给大家。

系列教程持续发布中，欢迎订阅、关注、收藏、评论、点赞哦～～(￣▽￣～)～

完的汪(∪｡∪)｡｡｡zzz

WordZzzz
关注
  • 5
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
使用Python实现支持向量机 -------文章中有源码
2401_83816794的博客
04-09 1057
（5）如果将线性SVM模型看作原始特征的函数，那么它实际上已经不是线性的了。它不是一条直线，而是一个椭圆。代码：from sklearn.datasets import make_blobsimport mglearnimport matplotlib.pyplot as pltimport numpy as npfrom sklearn.svm import LinearSVCfrom mpl_toolkits.mplot3d import Axes3D,axes3dX,y = make_blobs(ce
支持向量机（SVM）的SMO算法详解
zhu2856061的博客
04-22 2228
1.对于SVM的基本理论不做解释，以及对公式的转换不做分析，直接进入SMO算法中对拉格朗日乘子的求解。 求解过程为：                   1.选择两个乘子a1和a2。                   2.对乘子a2求其上下界                   3.求出新的乘子a2                   4.依据其上下界对新乘子a2进行剪辑      
SMO(Sequential Minimal Optimization) 伪代码（注释）
12-13 378
Algorithm: Simplified SMO 这个版本是简化版的，并没有采用启发式选择，但是比较容易理解。 输入： C: 调和系数 tol: 容差 (tolerance) max passes: $\alpha$ 不改变时的最大迭代次数 $(x^{(1)}, y^{(1)}), . . . , (x^{(m)}, y^{(m)})$: 训练样本 输出： ...
机器学习实战刻意练习-- Task 5 支持向量机
Jupiker的博客
12-04 545
Week 3 支持向量机（Support Vector Machine，SVM） 下面介绍支持向量机，首先我们提出几个问题： 什么是SVM？ 首先，支持向量机不是一种机器，而是一种机器学习算法。 SVM - Support Vector Machine ，俗称支持向量机，是一种 supervised learning （监督学习）算法，属于 classification（分类）的范畴。 在数据挖...
《机器学习实战》6.支持向量机（SVM）
豆豆豆豆芽的博客
10-28 1331
本章涉及到的向SVM有很多种实现方法，但是这里学习最流行的一种，即序列最小化（SMO）算法。在此之后，将介绍如何使用一种称为核函数的方式奖SVM拓展到更多数据集上。
【机器学习详解】SMO算法剖析
热门推荐
勿在浮砂筑高台
04-27 7万+
本文力求简化SMO的算法思想，毕竟自己理解有限，无奈还是要拿一堆公式推来推去，但是静下心看完本篇并随手推导，你会迎刃而解的。推荐参看SMO原文中的伪代码。 **1.SMO概念** =========== 上一篇博客已经详细介绍了[SVM原理](http://blog.csdn.net/luoshixian099/article/details/51073885)，为了方便求解，把原始最优化问题转化成了其对偶问题，因
python机器学习理论与实战（五）支持向量机
09-20
支持向量机（Support Vector Machine, SVM）是机器学习领域中一种重要的监督学习算法，尤其在分类和回归问题上表现出色。它基于间隔最大化（Margin Maximization）的概念，旨在找到一个能够将不同类别的样本分开的...
机器学习实战(第六章-支持向量机-所有代码与详细注解-python3.7)
12-18
在本资源中，我们主要探讨的是机器学习领域中的一个重要算法——支持向量机（Support Vector Machine，SVM），这是《机器学习实战》一书第六章的内容。支持向量机是一种监督学习模型，常用于分类和回归分析。它通过...
机器学习之支持向量机理论与代码实践
06-13
该课程是目前讲解SVM的最详细的课程，详细的讲解了SVM的数学推导过程，SMO算法的数学推导过程，并根据最终推导的公式使用python原生代码进行了实现，公式与代码一一对应。把最难理解的SVM讲解的非常透彻。
Python分别通过SMO和QP实现SVM支持向量机的实例
最新发布
06-16
支持向量机（Support Vector Machine, SVM）是一种广泛应用于分类和回归分析的机器学习模型。在本主题中，我们将深入探讨如何使用Python语言通过两种不同的算法实现SVM：Sequential Minimal Optimization（SMO）和...
SVM支持向量机浅入深出+python实现SMO算法
06-30
结合《统计学习方法》以及一些资料，写出自己对SVM算法的理解，并且用Python+Numpy实现了SMO算法
【机器学习实战】6.支持向量机——简化SMO算法
changeforeve的博客
03-20 811
主体是书上的程序，添加了一个画图函数，查看分类结果。实际上，按照书上的程序，分类结果并不一定好。书上图6-4只是理想结果。程序后附上结果。# -*- coding: utf-8 -*- """ Created on Thu Mar 15 10:26:20 2018 @author: ### """ import numpy as np import matplotlib.pyplot as p...
【机器学习算法-python实现】svm支持向量机(2)—简化版SMO算法
Garvin的专栏
05-04 4114
(转载请注明出处：http://blog.csdn.net/buptgshengod) 1.背景知识       通过上一节我们通过引入拉格朗日乗子得到支持向量机变形公式。详细变法可以参考这位大神的博客——地址   参照拉格朗日公式F(x1,x2,...λ)=f(x1,x2,...)-λg(x1,x2...)。我们把上面的式子变型为：  约束条件就变成了：
【机器学习实战】支持向量机SMO算法详解
lyl771857509的博客
03-03 1729
SMO算法 # 加载数据 def loadDataSet(fileName): dataMat = [];labelMat = [] fr = open(fileName) for line in fr.readlines(): lineArr = line.strip
[机器学习实战] 支持向量机
Joker_Ha_Ha_Ha的博客
12-26 934
一、概述 支持向量机是常用的一类分类模型，它通过在两类数据之间寻找一个超平面来分隔不同类的数据。支持向量机最后对应一个二次规划模型（其最优化问题的对偶问题），可以使用通常二次规划求解方法求解，也可以使用Platt在1996年提出的SMO（Sequential Minimal Optimization），它通过一种启发式的误差修正方法求解。 二、算法介绍 支持向量机（support vector machines, SVM）是一种二分类模型，它的基本模型是定义在特征空间上的间隔最大的线性分类器，间隔.
机器学习实战 简化SMO算法 对第一个alpha选择条件的解读
sky_kkk的博客
03-13 1895
在看简化版SMO算法的时候，刚开始没懂第一个变量的选择依据，在网上也没有找到解释。所以在搞懂后把选择依据分享出来~~~ 1.第一个变量的选择方法 这里不再叙述公式推导及证明，只是简单给出SMO算法第一个变量的选择方法。 SMO称选择第一个变量的过程为外层循环，外层循环在训练样本中选择违反KKT条件最严重的样本点，其KKT条件为： αi=0⇔yig(xi)≥1αi=0⇔yig(xi)≥1...
机器学习实战 SVM python3实现 R语言实现
weixin_41206770的博客
03-25 1396
我很少说原理，但是一些有趣的，可以帮助我们理解算法的小故事再喜欢不过了。这里引用了一个知乎的回答，太让人喜欢了。觉得把高深的东西讲的小孩子都懂得才是真正的大神。这里附上R语言的SVM代码，感兴趣的同学们可以看一下。（在最后面哦。）1.引例在学习SVM时在知乎上看到了一篇有趣的SVM介绍。下面我把它复制过来作为SVM算法的引入案例。作者：简之链接：https://www.zhihu.com/ques...
Pandas属性错误：AttributeError: 'Series' object has no attribute 'reshape' 解决办法
XIAOGUANG_的博客
12-21 2万+
AttributeError: ‘Series’ object has no attribute ‘reshape’ 解决办法 Python 3 w = [1.0i/k for i in range(k+1)] w = data.describe(percentiles=w)[4:4+k+1] w[0] = w[0](1-1e-10) d2 = pd.cut(data, w, labels=r...
SMO算法最通俗易懂的解释
Machine Learning with Tutors
06-18 7万+
SVM通常用对偶问题来求解，这样的好处有两个：1、变量只有N个（N为训练集中的样本个数），原始问题中的变量数量与样本点的特征个数相同，当样本特征非常多时，求解难度较大。2、可以方便地引入核函数，求解非线性SVM。求解对偶问题，常用的算法是SMO，彻底地理解这个算法对初学者有一定难度，本文尝试模拟算法作者发明该算法的思考过程，让大家轻轻松松理解SMO算法。文中的“我”拟指发明算法的大神。
支持向量机-码农场1
08-03
此外，本文还附带了《机器学习实战》中支持向量机的Python代码，并对代码进行了整理和注释，方便读者理解和实践。 总之，本文全面介绍了支持向量机的原理和算法，并通过注解和补充背景知识的方式，帮助读者更深入地...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值