【机器学习】SVM支持向量机算法和实现

MAYDAY01520

已于 2024-05-01 10:42:53 修改

阅读量2.4k

点赞数 100

分类专栏：算法文章标签：机器学习 python

于 2024-05-01 00:19:42 首次发布

本文链接：https://blog.csdn.net/MAYDAY01520/article/details/138353984

版权

算法专栏收录该内容

3 篇文章 0 订阅

订阅专栏

系列文章目录

【机器学习】朴素贝叶斯算法及实现

文章目录

系列文章目录
实验介绍
一、实验原理
二、实验
三、实验总结

实验介绍

实验内容
本实验介绍SVM支持向量机原理，并通过三个实验逐步深入的了解如何实现该算法。

实验目标
通过本实验掌握SVM相关算法原理，了解算法的实现。

实验知识点
SVM支持向量机原理

实验环境
python 3.6.5

预备知识
概率论与数理统计
Linux命令基本操作
Python编程基础

一、实验原理

1.什么是SVM

SVM 的全称是 Support Vector Machine，即支持向量机，主要用于解决模式识别领域中的数据分类问题，属于有监督学习算法的一种。SVM要解决的问题可以用一个经典的二分类问题加以描述。
我们以一个红蓝球分类的问题开始SVM的学习。

下方图片中有红蓝两色球，让你用一根棍分开它们。要求：“即便再放更多球之后，仍然能将它们分开。”
在这里插入图片描述

很明显，我们可以将棍如下图这么放。
在这里插入图片描述

但如果我们加了一个红球在蓝色阵营中，此时要怎么放呢？

在这里插入图片描述

我们稍微调整一下棍子。可以看到目前棍仍然是一个好的分界线。

在这里插入图片描述

SVM就是试图把棍放在最佳位置，好让在棍的两边有尽可能大的间隙。

在这里插入图片描述

但是如果是这样的球呢？我们看不出来怎么放可以很好的把两个颜色的球分开。

在这里插入图片描述
灵光一闪。
想想一下，如果我们将这些球放在桌子上，然后桌子一拍，所有球飞到空中。然后，在空中抓起一张纸，插到了两种球的中间。

在这里插入图片描述
现在，在二维平面上看这些球，这些球看起来像是被一条曲线分开了。

在这里插入图片描述
而且，这个方法理论上几乎通用于所有分类。在机器学习中，把这些球叫做「data」（数据源），把棍子叫做「classifier」（分类器）, 最大间隙trick 叫做「optimization」（最优化），拍桌子叫做「kernelling」（建立核函数）, 那张纸叫做「hyperplane」（超平面）。

在这里插入图片描述

2.如何求解线性SVM

在上一节我们简单认识了什么是SVM，即支持向量机。
在上节的红蓝点的例子中，我们一开始看到的数据称为线性可分数据。而将数据集分隔开来的那根棍叫做分隔超平面。由于数据都在二维平面上，所以此时分隔超平面为一条直线。
但如果所给数据集是三维的，那么此时用来分隔数据的就是一个平面。显而易见，如果数据集是N维的，那么分隔超平面为N-1维。
分隔超平面，也就是分类的决策边界，分布在超平面一侧的数据都属于某个类别，而分布在另一侧的所有数据都属于另一个类别。

（1）分隔超平面

我们首先来看下分隔超平面的数学公式表达，二维空间下一条直线的方式如下所示：
在这里插入图片描述
现在我们做个小小的改变，让原来的x轴变成x1，y轴变成x2

移项得：

将公式向量化得：

在这里插入图片描述
进一步向量化，用w列向量和x列向量和标量γ进一步向量化：

其中，向量w和x分别为：

这里w1=a，w2=-1。我们都知道，最初的那个直线方程a和b的几何意义，a表示直线的斜率，b表示截距，a决定了直线与x轴正方向的夹角，b决定了直线与y轴交点位置。那么向量化后的直线的w和r的几何意义是什么呢？

现在假设：

在这里插入图片描述
可得：

在坐标轴上画出直线和向量w：
在这里插入图片描述

蓝色的线代表向量w，红色的线代表直线y。我们可以看到向量w和直线的关系为垂直关系。这说明了向量w也控制这直线的方向，只不过是与这个直线的方向是垂直的。标量γ的作用也没有变，依然决定了直线的截距。此时，我们称w为直线的法向量。
二维空间的直线方程已经推导完成，将其推广到n维空间，就变成了超平面方程。(一个超平面，在二维空间的例子就是一个直线)但是它的公式没变，依然是：
在这里插入图片描述

我们已经顺利推导出了"决策面"方程，它就是我们的超平面方程，之后，我们统称其为超平面方程。

（2）函数间隔

现在，我们依然对于一个二维平面的简单例子进行推导。

在这里插入图片描述
我们已经知道间隔的大小实际上就是支持向量对应的样本点到决策面的距离的二倍。那么图中的距离d我们怎么求？我们高中都学过，点到直线的距离距离公式如下：

在这里插入图片描述
公式中的直线方程为Ax0+By0+C=0，点P的坐标为(x0,y0)。现在，将直线方程扩展到多维，求得我们现在的超平面方程，对公式进行如下变形：

这个d就是"分类间隔"。其中||w||表示w的二范数，求所有元素的平方和，然后再开方。比如对于二维平面：
在这里插入图片描述
那么，

我们目的是为了找出一个分类效果好的超平面作为分类器。分类器的好坏的评定依据是分类间隔W=2d的大小，即分类间隔w越大，我们认为这个超平面的分类效果越好。此时，求解超平面的问题就变成了求解分类间隔W最大化的为题。W的最大化也就是d最大化的。
[注]此处我们的d的定义是函数的几何间隔，即我们真正评价超平面好坏的间隔度量。
我们现在知道了超平面方程以及函数的几何间隔，那么这些是要干什么的呢？
在对数据进行分类时，如果数据离我们的超平面越远，即越能明确的表示该数据是属于哪一类，分类结果也越可信。因为在超平面附近的数据极易被划分错误。那么，基于这个原则，我们应该寻找一个最大间隔的分隔超平面，也就是我们需要找到离分隔超平面最近的数据点，确保它们离分隔超平面的距离尽可能的远，这样会让我们的分类器尽可能健壮。
支持向量就是离分隔超平面最近的那些数据点。
那么我们的问题就转化为，找到支持向量，并试着将所有支持向量到分隔面的距离最大化。即ω最大

（3）寻找最大间隔

为了求解w的最大值。我们不得不面对如下问题：
　　我们如何判断超平面是否将样本点正确分类？
　　我们知道要求距离d的最大值，我们首先需要找到支持向量上的点，怎么在众多的点中选出支持向量上的点呢？
上述我们需要面对的问题就是约束条件，也就是说我们优化的变量d的取值范围受到了限制和约束。事实上约束条件一直是最优化问题里最让人头疼的东西。但既然我们已经知道了这些约束条件确实存在，就不得不用数学语言对他们进行描述。但SVM算法通过一些巧妙的小技巧，将这些约束条件融合到一个不等式里面。再看我们的目标函数：

在这里插入图片描述
我们的优化目标是是d最大化。还记得我们的问题是用支持向量上的样本点求解d的最大化的问题的。那么支持向量上的样本点有什么特点呢？

如下图所示，中间的实线便是寻找到的最优超平面（Optimal Hyper Plane），其到两条虚线边界的距离相等，这个距离便是几何间隔，两条虚线间隔边界之间的距离等于2d，而虚线间隔边界上的点则是支持向量。由于这些支持向量刚好在虚线间隔边界上，所以它们满足

在这里插入图片描述
,而对于所有不是支持向量的点，则显然有

现在我们就可以将我们的目标函数进一步化简：

因为，我们只关心支持向量上的点。随后我们求解d的最大化问题变成了||w||的最小化问题。进而||w||的最小化问题等效于
在这里插入图片描述
为什么要做这样的等效呢？这是为了在进行最优化的过程中对目标函数求导时比较方便，但这绝对不影响最优化问题最后的求解。我们将最终的目标函数和约束条件放在一起进行描述：

在这里插入图片描述
这里n是样本点的总个数，缩写s.t.表示"Subject to"，是"服从某某条件"的意思。上述公式描述的是一个典型的不等式约束条件下的二次型函数优化问题，同时也是支持向量机的基本数学模型。

（4）求解线性SVM问题

从我们的目标函数可以看出，我们其实是在求解一个不等式约束条件下的二次型函数优化问题。
在开始求解之前，我们先来了解两个概念——拉格朗日函数和KKT条件。
首先，我们先要从宏观的视野上了解一下拉格朗日对偶问题出现的原因和背景。
我们知道我们要求解的是最小化问题，所以一个直观的想法是如果我能够构造一个函数，使得该函数在可行解区域内与原目标函数完全一致，而在可行解区域外的数值非常大，甚至是无穷大，那么这个没有约束条件的新目标函数的优化问题就与原来有约束条件的原始目标函数的优化问题是等价的问题。这就是使用拉格朗日方程的目的，它将约束条件放到目标函数中，从而将有约束优化问题转换为无约束优化问题。
随后，人们又发现，使用拉格朗日获得的函数，使用求导的方法求解依然困难。进而，需要对问题再进行一次转换，即使用一个数学技巧：拉格朗日对偶。
所以，显而易见的是，我们在拉格朗日优化我们的问题这个道路上，需要进行下面二个步骤：
将有约束的原始目标函数转换为无约束的新构造的拉格朗日目标函数
使用拉格朗日对偶性，将不易求解的优化问题转化为易求解的优化

下面，进行第一步：将有约束的原始目标函数转换为无约束的新构造的拉格朗日目标函数
公式变形如下：
在这里插入图片描述
其中αi是拉格朗日乘子，αi大于等于0，是我们构造新目标函数时引入的系数变量(我们自己设置)。现在我们令：

在这里插入图片描述
当样本点不满足约束条件时，即在可行解区域外：

此时，我们将αi设置为正无穷，此时θ(w)显然也是正无穷。当样本点满足约束条件时，即在可行解区域内：

在这里插入图片描述
此时，显然θ(w)为原目标函数本身。我们将上述两种情况结合一下，就得到了新的目标函数：

此时，再看我们的初衷，就是为了建立一个在可行解区域内与原目标函数相同，在可行解区域外函数值趋近于无穷大的新函数，现在我们做到了。
现在，我们的问题变成了求新目标函数的最小值，即：

在这里插入图片描述
这里用p表示这个问题的最优值，且和最初的问题是等价的。
接下来，我们进行第二步：将不易求解的优化问题转化为易求解的优化
我们看一下我们的新目标函数，先求最大值，再求最小值。这样的话，我们首先就要面对带有需要求解的参数w和b的方程，而αi又是不等式约束，这个求解过程不好做。所以，我们需要使用拉格朗日函数对偶性，将最小和最大的位置交换一下，这样就变成了：

在这里插入图片描述
交换以后的新问题是原始问题的对偶问题，这个新问题的最优值用d来表示。而且d≤p。
[注]证明一下为何d≤p：令d=max f,p=min g; f=min L(w,b,α)≤L(w,b,α)≤max L(w,b,α)=g => f≤g => max f ≤ min g => d≤p
我们关心的是d=p的时候，这才是我们要的解。需要什么条件才能让d=p呢，即何时满足强对偶关系？
　　首先必须满足这个优化问题是凸优化问题。
　　其次，需要满足KKT条件。
凸优化问题的定义是：求取最小值的目标函数为凸函数的一类优化问题。目标函数是凸函数我们已经知道，这个优化问题又是求最小值。所以我们的最优化问题就是凸优化问题。
接下里，就是探讨是否满足KKT条件了。
我们已经使用拉格朗日函数对我们的目标函数进行了处理，生成了一个新的目标函数。通过一些条件，可以求出最优值的必要条件，这个条件就是接下来要说的KKT条件。一个最优化模型能够表示成下列标准形式：
在这里插入图片描述
KKT条件的全称是Karush-Kuhn-Tucker条件，KKT条件是说最优值条件必须满足以下条件：
　　条件一：经过拉格朗日函数处理之后的新目标函数L(w,b,α)对x求导为零：
　　条件二：h(x) = 0；
　　条件三：α*g(x) = 0；
对于我们的优化问题：
在这里插入图片描述
现在，凸优化问题和KKT都满足了，问题转换成了对偶问题。
而求解这个对偶学习问题，可以分为三个步骤：首先要让L(w,b,α)关于w和b最小化，然后求对α的极大，最后利用SMO算法求解对偶问题中的拉格朗日乘子。现在，我们继续推导。

（5）对偶问题求解

第一步：
根据上述推导已知：
在这里插入图片描述
首先固定α，要让L(w,b,α)关于w和b最小化，我们分别对w和b偏导数，令其等于0，即：

在这里插入图片描述
将上述结果带回L(w,b,α)得到：

在这里插入图片描述
从上面的最后一个式子，我们可以看出，此时的L(w,b,α)函数只含有一个变量，即αi。
第二步：
现在内侧的最小值求解完成，我们求解外侧的最大值，从上面的式子得到

现在我们的优化问题变成了如上的形式。对于这个问题，我们有更高效的优化算法，即序列最小优化（SMO）算法。我们通过这个优化算法能得到α，再根据α，我们就可以求解出w和b，进而求得我们最初的目的：找到超平面，即"决策平面"。

3.什么是SMO算法

现在，我们已经得到了可以用SMO算法求解的目标函数，但是对于怎么编程实现SMO算法还是感觉无从下手。那么现在就聊聊如何使用SMO算法进行求解。
(1）Platt的SMO算法
1996年，John Platt发布了一个称为SMO的强大算法，用于训练SVM。SM表示序列最小化(Sequential Minimal Optimizaion)。Platt的SMO算法是将大优化问题分解为多个小优化问题来求解的。这些小优化问题往往很容易求解，并且对它们进行顺序求解的结果与将它们作为整体来求解的结果完全一致的。在结果完全相同的同时，SMO算法的求解时间短很多。
SMO算法的目标是求出一系列alpha和b，一旦求出了这些alpha，就很容易计算出权重向量w并得到分隔超平面。
SMO算法的工作原理是：每次循环中选择两个alpha进行优化处理。一旦找到了一对合适的alpha，那么就增大其中一个同时减小另一个。这里所谓的"合适"就是指两个alpha必须符合以下两个条件，条件之一就是两个alpha必须要在间隔边界之外，而且第二个条件则是这两个alpha还没有进行过区间化处理或者不在边界上。
（2）SMO算法的解法
先来定义特征到结果的输出函数为：
在这里插入图片描述
接着，我们回忆一下原始优化问题，如下：

在求解线性SVM中对w求偏导得，其中Xi为向量：

将上述公式带入输出函数中：

我们已经知道拉格朗日对偶后得到最终的目标化函数以及约束条件：

在这里插入图片描述
将目标函数变形，在前面增加一个符号，将最大值问题转换成最小值问题：

实际上，对于上述目标函数，是存在一个假设的，即数据100%线性可分。但是，目前为止，我们知道几乎所有数据都不那么"干净"。这时我们就可以通过引入所谓的松弛变量(slack variable)，来允许有些数据点可以处于超平面的错误的一侧。这样我们的优化目标就能保持仍然不变，但是此时我们的约束条件有所改变：
在这里插入图片描述
根据KKT条件可以得出其中αi取值的意义为：

在这里插入图片描述
对于第1种情况，表明αi是正常分类，在边界内部；对于第2种情况，表明αi是支持向量，在边界上；
对于第3种情况，表明αi是在两条边界之间。
而最优解需要满足KKT条件，对于以下条件，即违背KKT条件的，则需要对αi进行优化：

在这里插入图片描述
也就是说，如果存在不能满足KKT条件的αi，那么需要更新这些αi，这是第一个约束条件。此外，更新的同时还要受到第二个约束条件的限制，即：

因为这个条件，我们同时更新两个α值，因为只有成对更新，才能保证更新之后的值仍然满足和为0的约束，假设我们选择的两个乘子为α1和α2：
在这里插入图片描述
其中， ksi为常数。因为两个因子不好同时求解，所以可以先求第二个乘子α2的解（α2 new），得到α2的解（α2 new）之后，再用α2的解（α2 new）表示α1的解（α1 new ）。为了求解α2 new ，得先确定α2 new的取值范围。假设它的上下边界分别为H和L，那么有：

在这里插入图片描述
接下来，综合下面两个条件：

在这里插入图片描述
当y1不等于y2时，即一个为正1，一个为负1的时候，可以得到：

所以有：

此时，取值范围如下图所示：

在这里插入图片描述
据y1和y2异号或同号，可以得出α2 new的上下界分别为：

这个界限就是编程的时候需要用到的。已经确定了边界，接下来，就是推导迭代式，用于更新 α值。
为了描述方便，我们定义如下符号，这个很重要：

在这里插入图片描述
注意我们第一个约束条件：

我们在求α1和α2的时候，可以将α3,α4,…,αn和y3,y4,…,yn看作常数项。因此有：

在这里插入图片描述
我们不必关心常数B的大小，现在将上述等式两边同时乘以y1，得到(y1y1=1)：

在这里插入图片描述
其中γ为常数By1，s=y1y2，我们不关心γ值。

我们令：（此处f(xi),η的定义可向上看）为误差项，η为学习速率。

在这里插入图片描述

再根据我们已知的公式：

在这里插入图片描述

将α2 new继续化简得：

在这里插入图片描述

这样，我们就得到了最终需要的迭代公式。这个是没有经过修剪的解，需要考虑约束：

在这里插入图片描述

根据之前推导的α取值范围，我们得到最终的解析解为：

在这里插入图片描述
又因为：

在这里插入图片描述

消去γ得：

在这里插入图片描述
这样，我们就知道了怎样计算α1和α2了，也就是如何对选择的α进行更新。
当我们更新了α1和α2之后，需要重新计算阈值b，因为b关系到了我们f(x)的计算，也就关系到了误差Ei的计算。
我们要根据α的取值范围，去更正b的值，使间隔最大化。当α1 new在0和C之间的时候，根据KKT条件可知，这个点是支持向量上的点。因此，满足下列公式：
在这里插入图片描述
公式两边同时乘以y1得(y1y1=1)：

因为我们是根据α1和α2的值去更新b，得：

同理可得b2 new为：

当b1和b2都有效的时候，它们是相等的，即：

在这里插入图片描述
当两个乘子都在边界上，则b阈值和KKT条件一致。当不满足的时候，SMO算法选择他们的中点作为新的阈值：

最后，更新所有的α和b，这样模型就出来了，从而即可求出我们的分类函数。
现在，让我们梳理下SMO算法的步骤：
步骤1：计算误差：
在这里插入图片描述
步骤2：计算上下界L和H：

在这里插入图片描述
步骤3：计算η：

在这里插入图片描述
步骤4：更新αj：

在这里插入图片描述
步骤5：根据取值范围修剪αj：

步骤6：更新αi：

在这里插入图片描述
步骤7：更新b1和b2：

步骤8：根据b1和b2更新b：

在这里插入图片描述

4.非线性SVM的利器——核函数

1、核技巧
我们已经了解到，SVM如何处理线性可分的情况，而对于非线性的情况，SVM的处理方式就是选择一个核函数。简而言之：在线性不可分的情况下，SVM通过某种事先选择的非线性映射（核函数）将输入变量映到一个高维特征空间，将其变成在高维空间线性可分，在这个高维空间中构造最优分类超平面。
根据上节线性可分的情况下，可知最终的超平面方程为：
在这里插入图片描述
将上述公式用内积来表示：

对于线性不可分，我们使用一个非线性映射，将数据映射到特征空间，在特征空间中使用线性学习器，分类函数变形如下：

其中ϕ从输入空间(X)到某个特征空间(F)的映射，这意味着建立非线性学习器分为两步：
　　首先使用一个非线性映射将数据变换到一个特征空间F；
　　然后在特征空间使用线性学习器分类。
如果有一种方法可以在特征空间中直接计算内积 <ϕ(xi),ϕ(x)>，就像在原始输入点的函数中一样，就有可能将两个步骤融合到一起建立一个分线性的学习器，这样直接计算的方法称为核函数方法。
这里直接给出一个定义：核是一个函数k，对所有x,z∈X，满足k(x,z)=<ϕ(xi),ϕ(x)>，这里ϕ(·)是从原始输入空间X到内积空间F的映射。
简而言之：如果不是用核技术，就会先计算线性映ϕ(x1)和ϕ(x2)，然后计算这它们的内积，使用了核技术之后，先把ϕ(x1)和ϕ(x2)的一般表达式<ϕ(x1),ϕ(x2)>=k(<ϕ(x1),ϕ(x2) >)计算出来，这里的<·，·>表示内积，k(·，·)就是对应的核函数，这个表达式往往非常简单，所以计算非常方便。
这种将内积替换成核函数的方式被称为核技巧(kernel trick)。

2、非线性数据处理
已经知道了核技巧是什么，但是为什么要这样做呢？我们先举一个简单的例子，进行说明。假设二维平面x-y上存在若干点，其中点集A服从 {x,y|x^2+y2=1}，点集B服从{x,y|x^2+y2=9}，那么这些点在二维平面上的分布是这样的：
在这里插入图片描述
蓝色的是点集A，红色的是点集B，他们在xy平面上并不能线性可分，即用一条直线分割（虽然肉眼是可以识别的）。采用映射(x,y)->(x,y,x^2+y2)后，在三维空间的点的分布为：

在这里插入图片描述
可见红色和蓝色的点被映射到了不同的平面，在更高维空间中是线性可分的（用一个平面去分割）。
上述例子中的样本点的分布遵循圆的分布。继续推广到椭圆的一般样本形式：

在这里插入图片描述
可见红色和蓝色的点被映射到了不同的平面，在更高维空间中是线性可分的（用一个平面去分割）。
我们举个简单的计算例子，现在假设已知的映射函数为：

在这里插入图片描述
是一个从2维映射到5维的例子。如果没有使用核函数，根据上一小节的介绍，我们需要先结算映射后的结果，然后再进行内积运算。那么对于两个向量a1=(x1,x2)和a2=(y1,y2)有：

在这里插入图片描述
另外，如果我们不进行映射计算，直接运算下面的公式：

你会发现，这两个公式的计算结果是相同的。区别在于什么呢？
　　一个是根据映射函数，映射到高维空间中，然后再根据内积的公式进行计算，计算量大；
　　另一个则直接在原来的低维空间中进行计算，而不需要显式地写出映射后的结果，计算量小。

其实，在这个例子中，核函数就是：

在这里插入图片描述
我们通过k(x1,x2)的低维运算得到了先映射再内积的高维运算的结果，这就是核函数的神奇之处，它有效减少了我们的计算量。在这个例子中，我们对一个2维空间做映射，选择的新的空间是原始空间的所以一阶和二阶的组合，得到了5维的新空间；如果原始空间是3维的，那么我们会得到19维的新空间，这个数目是呈爆炸性增长的。如果我们使用ϕ(·)做映射计算，难度非常大，而且如果遇到无穷维的情况，就根本无从计算了。所以使用核函数进行计算是非常有必要的。

3、核技巧的实现

通过核技巧的转变，我们的分类函数变为：
在这里插入图片描述
我们的对偶问题变成了：

在这里插入图片描述

这样，我们就避开了高纬度空间中的计算。当然，我们刚刚的例子是非常简单的，我们可以手动构造出来对应映射的核函数出来，如果对于任意一个映射，要构造出对应的核函数就很困难了。因此，通常，人们会从一些常用的核函数中进行选择，根据问题和数据的不同，选择不同的参数，得到不同的核函数。接下来，要介绍的就是一个非常流行的核函数，那就是径向基核函数。
径向基核函数是SVM中常用的一个核函数。径向基核函数采用向量作为自变量的函数，能够基于向量举例运算输出一个标量。径向基核函数的高斯版本的公式如下：

在这里插入图片描述
其中，σ是用户自定义的用于确定到达率(reach)或者说函数值跌落到0的速度参数。上述高斯核函数将数据从原始空间映射到无穷维空间。关于无穷维空间，我们不必太担心。高斯核函数只是一个常用的核函数，使用者并不需要确切地理解数据到底是如何表现的，而且使用高斯核函数还会得到一个理想的结果。如果σ选得很大的话，高次特征上的权重实际上衰减得非常快，所以实际上（数值上近似一下）相当于一个低维的子空间；反过来，如果σ选得很小，则可以将任意的数据映射为线性可分——当然，这并不一定是好事，因为随之而来的可能是非常严重的过拟合问题。不过，总的来说，通过调控参数σ，高斯核实际上具有相当高的灵活性，也是使用最广泛的核函数之一。

二、实验

1.简化SMO算法处理小规模数据

我们已经知道svm的主要工作就是求解alphas，那么为了得到alphas的最优值。1996年，Platt发布了一个称为SMO的强大算法，用于训练SVM。SMO(sequence minimal optimization)序列最小化，该算法将大优化问题分解为多个小优化问题。

1.SMO算法目标
求出一系列的alphas和b，根据这些值可以很容易的计算出权重向量w，并得到分隔超平面。

2.SMO算法工作原理
每次循环选择两个合适的alpha进行处理，增大其中一个的同时减小另外一个。这里的合适是指：两个alpha必须要在间隔边界之外，且这两个alphas都没有进行过区间化处理或者不在边界上。我们之所以要同时改变两个alphas，是因为我们的约束条件：∑α·label=0。本节实验中，我们将会对SMO算法进行简化处理，完整版的SMO算法需要在外循环中寻找最优的alphas对，简化版会在数据集上遍历每一个alpha后，在剩余的alpha集合中随机选择另一个alpha。为此，我们需要构建辅助函数，用于在某区间返回随机数。同时需要另外一个辅助函数，对alpha数值进行区间化。
我们先来看下我们使用的数据集长什么样子：

在这里插入图片描述

示例代码：

In [4]:
#!/usr/bin/env python
#-*- coding:utf-8 -*-

import numpy as np
import matplotlib.pyplot as plt

"""
Desc：
    打开文件对其进行逐行解析
Parameters:
    fileName  文件名
Return:
    dataMat 数据矩阵
    labelMat 数据标签矩阵
"""
def loadDataSet(fileName):
    dataMat = [];labelMat = []
    fr = open(fileName)
    for line in fr.readlines():
        lineArr = line.strip().split('\t') #过滤数据的空格，并以tab键分割
        dataMat.append([float(lineArr[0]),float(lineArr[1])]) #x，y
        labelMat.append(float(lineArr[2])) #第三列标签数据
    return dataMat,labelMat

"""
Desc:
    数据可视化
Parameters:
    dataMat 数据矩阵
    labelMat 数据标签矩阵
Return:
    NULL
"""
def showDataSet(dataMat,labelMat):
    dataPlus = [];dataMinus = []    #定义正负样本
    for i in range(len(dataMat)):
        if labelMat[i] > 0: dataPlus.append(dataMat[i]) #对数据进行分类
        else: dataMinus.append(dataMat[i])
    dataPlusNp = np.array(dataPlus)  #构建np数组
    dataMinusNp = np.array(dataMinus) 
    plt.scatter(np.transpose(dataPlusNp)[0],np.transpose(dataPlusNp)[1]) #绘制图像
    plt.scatter(np.transpose(dataMinusNp)[0],np.transpose(dataMinus)[1])
    plt.show()

if __name__ == "__main__":
    dataMat, labelMat = loadDataSet('svm_algo/testSet.txt')
    showDataSet(dataMat, labelMat)

在这里插入图片描述
即我们目前使用的数据集。

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

4.简单版的SMO算法实现
接下来，我们根据伪代码开始实现SMO算法，编写以下代码:

示例代码：

In [5]:
# -*- coding:UTF-8 -*-
import random

"""
函数说明:随机选择alpha

Parameters:
    i - alpha_i的索引值
    m - alpha参数个数
Returns:
    j - alpha_j的索引值
"""
def selectJrand(i, m):
    j = i                                 #选择一个不等于i的j
    while (j == i):
        j = int(random.uniform(0, m))
    return j

"""
函数说明:修剪alpha

Parameters:
    aj - alpha_j值
    H - alpha上限
    L - alpha下限
Returns:
    aj - alpah值
"""
def clipAlpha(aj,H,L):
    if aj > H: 
        aj = H
    if L > aj:
        aj = L
    return aj


"""
函数说明:简化版SMO算法

Parameters:
    dataMatIn - 数据矩阵
    classLabels - 数据标签
    C - 松弛变量
    toler - 容错率
    maxIter - 最大迭代次数
Returns:
    无
"""
def smoSimple(dataMatIn, classLabels, C, toler, maxIter):
    #转换为numpy的mat存储
    dataMatrix = np.mat(dataMatIn); labelMat = np.mat(classLabels).transpose()
    #初始化b参数，统计dataMatrix的维度
    b = 0; m,n = np.shape(dataMatrix)
    #初始化alpha参数，设为0
    alphas = np.mat(np.zeros((m,1)))
    #初始化迭代次数
    iter_num = 0
    #最多迭代matIter次
    while (iter_num < maxIter):
        alphaPairsChanged = 0
        for i in range(m):
            #步骤1：计算误差Ei
            fXi = float(np.multiply(alphas,labelMat).T*(dataMatrix*dataMatrix[i,:].T)) + b
            Ei = fXi - float(labelMat[i])
            #优化alpha，设定一定的容错率。
            if ((labelMat[i]*Ei < -toler) and (alphas[i] < C)) or ((labelMat[i]*Ei > toler) and (alphas[i] > 0)):
                #随机选择另一个与alpha_i成对优化的alpha_j
                j = selectJrand(i,m)
                #步骤1：计算误差Ej
                fXj = float(np.multiply(alphas,labelMat).T*(dataMatrix*dataMatrix[j,:].T)) + b
                Ej = fXj - float(labelMat[j])
                #保存更新前的aplpha值，使用深拷贝
                alphaIold = alphas[i].copy(); alphaJold = alphas[j].copy();
                #步骤2：计算上下界L和H
                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
                #步骤3：计算eta
                eta = 2.0 * dataMatrix[i,:]*dataMatrix[j,:].T - dataMatrix[i,:]*dataMatrix[i,:].T - dataMatrix[j,:]*dataMatrix[j,:].T
                if eta >= 0: print("eta>=0"); continue
                #步骤4：更新alpha_j
                alphas[j] -= labelMat[j]*(Ei - Ej)/eta
                #步骤5：修剪alpha_j
                alphas[j] = clipAlpha(alphas[j],H,L)
                if (abs(alphas[j] - alphaJold) < 0.00001): print("alpha_j变化太小"); continue
                #步骤6：更新alpha_i
                alphas[i] += labelMat[j]*labelMat[i]*(alphaJold - alphas[j])
                #步骤7：更新b_1和b_2
                b1 = b - Ei- labelMat[i]*(alphas[i]-alphaIold)*dataMatrix[i,:]*dataMatrix[i,:].T - labelMat[j]*(alphas[j]-alphaJold)*dataMatrix[i,:]*dataMatrix[j,:].T
                b2 = b - Ej- labelMat[i]*(alphas[i]-alphaIold)*dataMatrix[i,:]*dataMatrix[j,:].T - labelMat[j]*(alphas[j]-alphaJold)*dataMatrix[j,:]*dataMatrix[j,:].T
                #步骤8：根据b_1和b_2更新b
                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
                #统计优化次数
                alphaPairsChanged += 1
                #打印统计信息
                print("第%d次迭代 样本:%d, alpha优化次数:%d" % (iter_num,i,alphaPairsChanged))
        #更新迭代次数
        if (alphaPairsChanged == 0): iter_num += 1
        else: iter_num = 0
        print("迭代次数: %d" % iter_num)
    return b,alphas

"""
函数说明:分类结果可视化

Parameters:
    dataMat - 数据矩阵
    w - 直线法向量
    b - 直线解决
Returns:
    无
"""
def showClassifer(dataMat, w, b):
    #绘制样本点
    data_plus = []                                  #正样本
    data_minus = []                                 #负样本
    for i in range(len(dataMat)):
        if labelMat[i] > 0:
            data_plus.append(dataMat[i])
        else:
            data_minus.append(dataMat[i])
    data_plus_np = np.array(data_plus)              #转换为numpy矩阵
    data_minus_np = np.array(data_minus)            #转换为numpy矩阵
    plt.scatter(np.transpose(data_plus_np)[0], np.transpose(data_plus_np)[1], s=30, alpha=0.7)   #正样本散点图
    plt.scatter(np.transpose(data_minus_np)[0], np.transpose(data_minus_np)[1], s=30, alpha=0.7) #负样本散点图
    #绘制直线
    x1 = max(dataMat)[0]
    x2 = min(dataMat)[0]
    a1, a2 = w
    b = float(b)
    a1 = float(a1[0])
    a2 = float(a2[0])
    y1, y2 = (-b- a1*x1)/a2, (-b - a1*x2)/a2
    plt.plot([x1, x2], [y1, y2])
    #找出支持向量点
    for i, alpha in enumerate(alphas):
        if abs(alpha) > 0:
            x, y = dataMat[i]
            plt.scatter([x], [y], s=150, c='none', alpha=0.7, linewidth=1.5, edgecolor='red')
    plt.show()


"""
函数说明:计算w

Parameters:
    dataMat - 数据矩阵
    labelMat - 数据标签
    alphas - alphas值
Returns:
    无
"""
def get_w(dataMat, labelMat, alphas):
    alphas, dataMat, labelMat = np.array(alphas), np.array(dataMat), np.array(labelMat)
    w = np.dot((np.tile(labelMat.reshape(1, -1).T, (1, 2)) * dataMat).T, alphas)
    return w.tolist()


if __name__ == '__main__':
    dataMat, labelMat = loadDataSet('svm_algo/testSet.txt')
    b,alphas = smoSimple(dataMat, labelMat, 0.6, 0.001, 40)
    w = get_w(dataMat, labelMat, alphas)
    showClassifer(dataMat, w, b)

运行结果： L== H
第0次迭代样本:1, alpha优化次数:1
第0次迭代样本:2, alpha优化次数:2
第0次迭代样本:3, alpha优化次数:3
alpha_j变化太小
alpha_j变化太小
L = = H
第0次迭代样本:11, alpha优化次数:4
alpha_j变化太小
第0次迭代样本:18, alpha优化次数:5
第0次迭代样本:23, alpha优化次数:6
L = = H
alpha_j变化太小
L= =H
L= =H
L= =H
L= =H
alpha_j变化太小
L= =H
L= =H
L= =H
L= =H
L= =H
alpha_j变化太小
L= =H
第0次迭代样本:54, alpha优化次数:7
第0次迭代样本:55, alpha优化次数:8
alpha_j变化太小
L= =H
L= =H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
L= =H
alpha_j变化太小
L= =H
L= =H
迭代次数: 0
第0次迭代样本:0, alpha优化次数:1
alpha_j变化太小
第0次迭代样本:2, alpha优化次数:2
第0次迭代样本:3, alpha优化次数:3
第0次迭代样本:5, alpha优化次数:4
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
L= =H
第0次迭代样本:23, alpha优化次数:5
alpha_j变化太小
L= =H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
第0次迭代样本:46, alpha优化次数:6
alpha_j变化太小
L= =H
alpha_j变化太小
alpha_j变化太小
L= =H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
第0次迭代样本:23, alpha优化次数:1
alpha_j变化太小
alpha_j变化太小
第0次迭代样本:52, alpha优化次数:2
alpha_j变化太小
第0次迭代样本:55, alpha优化次数:3
alpha_j变化太小
第0次迭代样本:76, alpha优化次数:4
第0次迭代样本:85, alpha优化次数:5
alpha_j变化太小
第0次迭代样本:95, alpha优化次数:6
第0次迭代样本:96, alpha优化次数:7
L= =H
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
第0次迭代样本:54, alpha优化次数:1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 0
第0次迭代样本:0, alpha优化次数:1
第0次迭代样本:2, alpha优化次数:2
alpha_j变化太小
alpha_j变化太小
L= =H
alpha_j变化太小
L= =H
alpha_j变化太小
alpha_j变化太小
L= =H
alpha_j变化太小
alpha_j变化太小
L= = H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
第0次迭代样本:54, alpha优化次数:3
alpha_j变化太小
第0次迭代样本:76, alpha优化次数:4
alpha_j变化太小
第0次迭代样本:97, alpha优化次数:5
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
L= =H
L= =H
第1次迭代样本:31, alpha优化次数:1
alpha_j变化太小
第1次迭代样本:46, alpha优化次数:2
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
L= =H
alpha_j变化太小
alpha_j变化太小
迭代次数: 0
第0次迭代样本:2, alpha优化次数:1
alpha_j变化太小
alpha_j变化太小
L= =H
第0次迭代样本:8, alpha优化次数:2
L= =H
L= =H
alpha_j变化太小
第0次迭代样本:27, alpha优化次数:3
alpha_j变化太小
alpha_j变化太小
第0次迭代样本:34, alpha优化次数:4
L= =H
alpha_j变化太小
alpha_j变化太小
第0次迭代样本:52, alpha优化次数:5
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
第0次迭代样本:2, alpha优化次数:1
alpha_j变化太小
alpha_j变化太小
L= =H
alpha_j变化太小
alpha_j变化太小
第0次迭代样本:52, alpha优化次数:2
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
L= =H
alpha_j变化太小
L= =H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 2
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
L= =H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 3
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
第3次迭代样本:46, alpha优化次数:1
第3次迭代样本:52, alpha优化次数:2
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
第3次迭代样本:96, alpha优化次数:3
alpha_j变化太小
迭代次数: 0
L= =H
alpha_j变化太小
alpha_j变化太小
L= =H
第0次迭代样本:17, alpha优化次数:1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
第0次迭代样本:52, alpha优化次数:2
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
第0次迭代样本:97, alpha优化次数:3
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
L= =H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
L= =H
alpha_j变化太小
alpha_j变化太小
第0次迭代样本:54, alpha优化次数:1
L= =H
L= =H
L= =H
L= =H
L= =H
alpha_j变化太小
第0次迭代样本:97, alpha优化次数:2
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
第0次迭代样本:17, alpha优化次数:1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
第0次迭代样本:29, alpha优化次数:2
alpha_j变化太小
L= =H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
L= =H
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
第0次迭代样本:46, alpha优化次数:1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
L= =H
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
第1次迭代样本:54, alpha优化次数:1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
第1次迭代样本:95, alpha优化次数:2
L= =H
alpha_j变化太小
迭代次数: 0
L= =H
alpha_j变化太小
第0次迭代样本:8, alpha优化次数:1
第0次迭代样本:17, alpha优化次数:2
alpha_j变化太小
alpha_j变化太小
第0次迭代样本:25, alpha优化次数:3
alpha_j变化太小
第0次迭代样本:29, alpha优化次数:4
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
第0次迭代样本:52, alpha优化次数:1
alpha_j变化太小
第0次迭代样本:55, alpha优化次数:2
alpha_j变化太小
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
L= =H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
L= =H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
L= =H
第1次迭代样本:97, alpha优化次数:1
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
L= =H
alpha_j变化太小
第0次迭代样本:29, alpha优化次数:1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
第0次迭代样本:17, alpha优化次数:1
L= =H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
第0次迭代样本:46, alpha优化次数:2
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
L= =H
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
第1次迭代样本:17, alpha优化次数:1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
第0次迭代样本:29, alpha优化次数:1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
第0次迭代样本:97, alpha优化次数:1
迭代次数: 0
alpha_j变化太小
L= =H
alpha_j变化太小
L= =H
第0次迭代样本:29, alpha优化次数:1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
第0次迭代样本:55, alpha优化次数:1
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 2
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 3
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 4
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 5
第5次迭代样本:5, alpha优化次数:1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
L= =H
alpha_j变化太小
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
L= =H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
L= =H
L= =H
L= =H
L= =H
L= =H
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
L= =H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
L= =H
迭代次数: 2
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
L= =H
L= =H
L= =H
迭代次数: 3
alpha_j变化太小
L= =H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
L= =H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 4
alpha_j变化太小
L= =H
L= =H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
L= =H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
L= =H
迭代次数: 5
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
L= =H
alpha_j变化太小
alpha_j变化太小
迭代次数: 6
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
L= =H
L= =H
L= =H
alpha_j变化太小
L== H
迭代次数: 7
alpha_j变化太小
L= = H
alpha_j变化太小
第7次迭代样本:29, alpha优化次数:1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 2
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 3
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 4
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 5
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 6
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 7
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 8
alpha_j变化太小
alpha_j变化太小
第8次迭代样本:54, alpha优化次数:1
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
L== H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 2
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 3
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 4
L= = H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 5
alpha_j变化太小
alpha_j变化太小
第5次迭代样本:52, alpha优化次数:1
alpha_j变化太小
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
第0次迭代样本:55, alpha优化次数:1
迭代次数: 0
L== H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
L= =H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 2
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 3
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 4
L== H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 5
L== H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 6
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 7
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 8
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 9
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 10
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 11
L== H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 12
L== H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 13
L== H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 14
L== H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 15
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 16
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 17
L== H
第17次迭代样本:29, alpha优化次数:1
alpha_j变化太小
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 2
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 3
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 4
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 5
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 6
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 7
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 8
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 9
alpha_j变化太小
第9次迭代样本:54, alpha优化次数:1
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 2
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 3
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 4
alpha_j变化太小
alpha_j变化太小
第4次迭代样本:55, alpha优化次数:1
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 2
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 3
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 4
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 5
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 6
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 7
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 8
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 9
alpha_j变化太小
第9次迭代样本:52, alpha优化次数:1
alpha_j变化太小
第9次迭代样本:55, alpha优化次数:2
迭代次数: 0
L== H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
L== H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 2
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 3
L== H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 4
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 5
alpha_j变化太小
alpha_j变化太小
第5次迭代样本:52, alpha优化次数:1
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 2
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 3
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 4
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 5
第5次迭代样本:17, alpha优化次数:1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 2
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 3
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 4
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 5
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 6
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 7
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 8
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 9
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 10
alpha_j变化太小
第10次迭代样本:52, alpha优化次数:1
alpha_j变化太小
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
第0次迭代样本:55, alpha优化次数:1
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 2
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 3
alpha_j变化太小
第3次迭代样本:52, alpha优化次数:1
alpha_j变化太小
迭代次数: 0
第0次迭代样本:17, alpha优化次数:1
第0次迭代样本:29, alpha优化次数:2
alpha_j变化太小
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 2
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 3
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 4
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 5
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 6
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 7
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 8
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 9
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 10
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 11
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 12
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 13
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 14
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 15
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 16
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 17
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 18
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 19
第19次迭代样本:17, alpha优化次数:1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
第1次迭代样本:29, alpha优化次数:1
alpha_j变化太小
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 2
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 3
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 4
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 5
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 6
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 7
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 8
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 9
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 10
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 11
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 12
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 13
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 14
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 15
第15次迭代样本:17, alpha优化次数:1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 2
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 3
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 4
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 5
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 6
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 7
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 8
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 9
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 10
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 11
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 12
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 13
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 14
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 15
alpha_j变化太小
alpha_j变化太小
第15次迭代样本:54, alpha优化次数:1
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 2
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 3
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 4
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 5
alpha_j变化太小
alpha_j变化太小
第5次迭代样本:55, alpha优化次数:1
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
第1次迭代样本:54, alpha优化次数:1
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
第1次迭代样本:29, alpha优化次数:1
第1次迭代样本:52, alpha优化次数:2
alpha_j变化太小
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 2
alpha_j变化太小
第2次迭代样本:54, alpha优化次数:1
第2次迭代样本:55, alpha优化次数:2
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
L== H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 2
L== H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 3
L== H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 4
L== H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 5
L== H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 6
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 7
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 8
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 9
L== H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 10
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 11
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 12
L== H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 13
L== H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 14
L== H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 15
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 16
L== H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 17
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 18
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 19
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 20
L==H
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 21
第21次迭代样本:23, alpha优化次数:1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 2
alpha_j变化太小
第2次迭代样本:29, alpha优化次数:1
第2次迭代样本:52, alpha优化次数:2
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 2
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 3
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 4
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 5
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 6
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 7
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 8
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 9
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 10
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 11
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 12
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 13
第13次迭代样本:17, alpha优化次数:1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 2
alpha_j变化太小
alpha_j变化太小
第2次迭代样本:54, alpha优化次数:1
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 2
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 3
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
第3次迭代样本:52, alpha优化次数:1
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
第0次迭代样本:23, alpha优化次数:1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 2
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 3
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 4
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 5
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 6
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 7
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 8
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 9
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 10
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 11
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 12
第12次迭代样本:17, alpha优化次数:1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 2
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 3
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 4
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 5
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 6
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 7
alpha_j变化太小
第7次迭代样本:29, alpha优化次数:1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 2
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 3
alpha_j变化太小
alpha_j变化太小
第3次迭代样本:54, alpha优化次数:1
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 2
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 3
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 4
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 5
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 6
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 7
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 8
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 9
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 10
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 11
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 12
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 13
alpha_j变化太小
第13次迭代样本:23, alpha优化次数:1
alpha_j变化太小
alpha_j变化太小
第13次迭代样本:54, alpha优化次数:2
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 2
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 3
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 4
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 5
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 6
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 7
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 8
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 9
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 10
第10次迭代样本:17, alpha优化次数:1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
第1次迭代样本:54, alpha优化次数:1
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 2
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 3
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 4
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 5
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 6
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 7
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 8
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 9
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 10
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 11
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 12
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 13
第13次迭代样本:17, alpha优化次数:1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 2
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 3
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 4
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 5
alpha_j变化太小
第5次迭代样本:54, alpha优化次数:1
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 2
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 3
alpha_j变化太小
alpha_j变化太小
第3次迭代样本:55, alpha优化次数:1
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 2
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 3
第3次迭代样本:17, alpha优化次数:1
alpha_j变化太小
第3次迭代样本:52, alpha优化次数:2
alpha_j变化太小
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 2
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 3
alpha_j变化太小
alpha_j变化太小
第3次迭代样本:54, alpha优化次数:1
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 2
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 3
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 4
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 5
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 6
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 7
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 8
第8次迭代样本:23, alpha优化次数:1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 2
第2次迭代样本:17, alpha优化次数:1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
第0次迭代样本:29, alpha优化次数:1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
第0次迭代样本:55, alpha优化次数:1
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
第1次迭代样本:17, alpha优化次数:1
alpha_j变化太小
第1次迭代样本:29, alpha优化次数:2
alpha_j变化太小
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 2
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 3
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 4
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 5
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 6
第6次迭代样本:17, alpha优化次数:1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 2
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 3
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 4
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 5
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 6
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 7
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 8
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 9
alpha_j变化太小
alpha_j变化太小
第9次迭代样本:55, alpha优化次数:1
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 2
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 3
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 4
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 5
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 6
alpha_j变化太小
第6次迭代样本:52, alpha优化次数:1
第6次迭代样本:54, alpha优化次数:2
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 2
alpha_j变化太小
第2次迭代样本:29, alpha优化次数:1
alpha_j变化太小
alpha_j变化太小
迭代次数: 0
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 1
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 2
alpha_j变化太小
alpha_j变化太小
alpha_j变化太小
迭代次数: 3
alpha_j变化太小
alpha_j变化太小
迭代次数: 4
alpha_j变化太小
alpha_j变化太小
迭代次数: 5
alpha_j变化太小
alpha_j变化太小
迭代次数: 6
alpha_j变化太小
alpha_j变化太小
迭代次数: 7
alpha_j变化太小
alpha_j变化太小
迭代次数: 8
alpha_j变化太小
alpha_j变化太小
迭代次数: 9
alpha_j变化太小
alpha_j变化太小
迭代次数: 10
alpha_j变化太小
alpha_j变化太小
迭代次数: 11
alpha_j变化太小
alpha_j变化太小
迭代次数: 12
alpha_j变化太小
alpha_j变化太小
迭代次数: 13
alpha_j变化太小
alpha_j变化太小
迭代次数: 14
alpha_j变化太小
alpha_j变化太小
迭代次数: 15
alpha_j变化太小
alpha_j变化太小
迭代次数: 16
alpha_j变化太小
alpha_j变化太小
迭代次数: 17
alpha_j变化太小
alpha_j变化太小
迭代次数: 18
alpha_j变化太小
alpha_j变化太小
迭代次数: 19
alpha_j变化太小
alpha_j变化太小
迭代次数: 20
alpha_j变化太小
alpha_j变化太小
迭代次数: 21
alpha_j变化太小
alpha_j变化太小
迭代次数: 22
alpha_j变化太小
alpha_j变化太小
迭代次数: 23
alpha_j变化太小
alpha_j变化太小
迭代次数: 24
alpha_j变化太小
alpha_j变化太小
迭代次数: 25
alpha_j变化太小
alpha_j变化太小
迭代次数: 26
alpha_j变化太小
alpha_j变化太小
迭代次数: 27
alpha_j变化太小
alpha_j变化太小
迭代次数: 28
alpha_j变化太小
alpha_j变化太小
迭代次数: 29
alpha_j变化太小
alpha_j变化太小
迭代次数: 30
alpha_j变化太小
alpha_j变化太小
迭代次数: 31
alpha_j变化太小
alpha_j变化太小
迭代次数: 32
alpha_j变化太小
alpha_j变化太小
迭代次数: 33
alpha_j变化太小
alpha_j变化太小
迭代次数: 34
alpha_j变化太小
alpha_j变化太小
迭代次数: 35
alpha_j变化太小
alpha_j变化太小
迭代次数: 36
alpha_j变化太小
alpha_j变化太小
迭代次数: 37
alpha_j变化太小
alpha_j变化太小
迭代次数: 38
alpha_j变化太小
alpha_j变化太小
迭代次数: 39
alpha_j变化太小
alpha_j变化太小
迭代次数: 40

5.运行结果

其中，中间的蓝线为求出来的分类器，用红圈圈出的点为支持向量点。
在算法实现过程中，我们选择alpha时候选择了随机方式，这使得该算法在执行时存在一定的时间提升空间，下一节实验我们使用完整的SMO算法来进行加速优化。
进入下一个实验吧！

2.完整SMO算法加速优化

在几百个点组成的小规模数据集上，简化版SMO算法的运行是没有什么问题的，但是在更大的数据集上的运行速度就会变慢。
接下来，我们讨论完整的PlattSMO算法。

1.启发方法
完整的smo算法中，实现α的更改和代数运算的优化环节一模一样。在优化过程，唯一不同的是选择α的方式。完整版的smo算法应用了一些能够提速的启发方法。
那么什么是启发方法呢？

在我们讲解SMO算法时，提到过
在这里插入图片描述
在实现SMO算法的时候，先计算η，再更新αj。为了加快第二个αj乘子的迭代速度，需要让直线的斜率增大，对于αj的更新公式，其中η值没有什么文章可做，于是只能令:

在这里插入图片描述
采用启发式选择，主要思想是先选择最有可能需要优化，也就是违反KKT条件最严重的αi，再针对这样的αi选择最有可能取得较大修正步长的αj。
在简化版smo算法中，我们会在选择第二个αj乘子后计算错误率Ej，但在完整版中，我们会建立一个全局的缓存用于保存误差值，并从中选择使得步长或者Ei-Ej最大的α值。

2.完整版SMO算法

完整版Platt SMO算法是通过一个外循环来选择第一个α，并且其选择过程会在这两种方式之间进行交替：
在所有数据集上进行单遍扫描
在非边界α中实现单遍扫描
非边界α指的就是那些不等于边界0或C的α值，并且跳过那些已知的不会改变的α值。所以我们要先建立这些α的列表，用于才能出α的更新状态。在算法中使用这两种方式进行交替选择是因为：非边界α极容易随着优化发生改变，直到遍历整个样本集后，没有违反KKT条件αi，然后退出。

3.算法实现

我们首先构建一个仅包含init方法的optStruct类，将其作为一个数据结构来使用，方便我们对于重要数据的维护。代码思路和之前的简化版SMO算法是相似的，不同之处在于增加了优化方法。

编写以下代码：

In [6]:
# -*-coding:utf-8 -*-
import matplotlib.pyplot as plt
import numpy as np
import random

class optStruct:
    """
    数据结构，维护所有需要操作的值
    Parameters：
        dataMatIn - 数据矩阵
        classLabels - 数据标签
        C - 松弛变量
        toler - 容错率
    """
    def __init__(self, dataMatIn, classLabels, C, toler):
        self.X = dataMatIn                              #数据矩阵
        self.labelMat = classLabels                     #数据标签
        self.C = C                                      #松弛变量
        self.tol = toler                                #容错率
        self.m = np.shape(dataMatIn)[0]                 #数据矩阵行数
        self.alphas = np.mat(np.zeros((self.m,1)))      #根据矩阵行数初始化alpha参数为0 
        self.b = 0                                      #初始化b参数为0
        self.eCache = np.mat(np.zeros((self.m,2)))      #根据矩阵行数初始化虎误差缓存，第一列为是否有效的标志位，第二列为实际的误差E的值。

def loadDataSet(fileName):
    """
    读取数据
    Parameters:
        fileName - 文件名
    Returns:
        dataMat - 数据矩阵
        labelMat - 数据标签
    """
    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 calcEk(oS, k):
    """
    计算误差
    Parameters：
        oS - 数据结构
        k - 标号为k的数据
    Returns:
        Ek - 标号为k的数据误差
    """
    fXk = float(np.multiply(oS.alphas,oS.labelMat).T*(oS.X*oS.X[k,:].T) + oS.b)
    Ek = fXk - float(oS.labelMat[k])
    return Ek

def selectJrand(i, m):
    """
    函数说明:随机选择alpha_j的索引值

    Parameters:
        i - alpha_i的索引值
        m - alpha参数个数
    Returns:
        j - alpha_j的索引值
    """
    j = i                                 #选择一个不等于i的j
    while (j == i):
        j = int(random.uniform(0, m))
    return j

def selectJ(i, oS, Ei):
    """
    内循环启发方式2
    Parameters：
        i - 标号为i的数据的索引值
        oS - 数据结构
        Ei - 标号为i的数据误差
    Returns:
        j, maxK - 标号为j或maxK的数据的索引值
        Ej - 标号为j的数据误差
    """
    maxK = -1; maxDeltaE = 0; Ej = 0                        #初始化
    oS.eCache[i] = [1,Ei]                                   #根据Ei更新误差缓存
    validEcacheList = np.nonzero(oS.eCache[:,0].A)[0]       #返回误差不为0的数据的索引值
    if (len(validEcacheList)) > 1:                          #有不为0的误差
        for k in validEcacheList:                           #遍历,找到最大的Ek
            if k == i: continue                             #不计算i,浪费时间
            Ek = calcEk(oS, k)                              #计算Ek
            deltaE = abs(Ei - Ek)                           #计算|Ei-Ek|
            if (deltaE > maxDeltaE):                        #找到maxDeltaE
                maxK = k; maxDeltaE = deltaE; Ej = Ek
        return maxK, Ej                                     #返回maxK,Ej
    else:                                                   #没有不为0的误差
        j = selectJrand(i, oS.m)                            #随机选择alpha_j的索引值
        Ej = calcEk(oS, j)                                  #计算Ej
    return j, Ej                                            #j,Ej

def updateEk(oS, k):
    """
    计算Ek,并更新误差缓存
    Parameters：
        oS - 数据结构
        k - 标号为k的数据的索引值
    Returns:
        无
    """
    Ek = calcEk(oS, k)                                      #计算Ek
    oS.eCache[k] = [1,Ek]                                   #更新误差缓存


def clipAlpha(aj,H,L):
    """
    修剪alpha_j
    Parameters:
        aj - alpha_j的值
        H - alpha上限
        L - alpha下限
    Returns:
        aj - 修剪后的alpah_j的值
    """
    if aj > H: 
        aj = H
    if L > aj:
        aj = L
    return aj

def innerL(i, oS):
    """
    优化的SMO算法
    Parameters：
        i - 标号为i的数据的索引值
        oS - 数据结构
    Returns:
        1 - 有任意一对alpha值发生变化
        0 - 没有任意一对alpha值发生变化或变化太小
    """
    #步骤1：计算误差Ei
    Ei = calcEk(oS, i)
    #优化alpha,设定一定的容错率。
    if ((oS.labelMat[i] * Ei < -oS.tol) and (oS.alphas[i] < oS.C)) or ((oS.labelMat[i] * Ei > oS.tol) and (oS.alphas[i] > 0)):
        #使用内循环启发方式2选择alpha_j,并计算Ej
        j,Ej = selectJ(i, oS, Ei)
        #保存更新前的aplpha值，使用深拷贝
        alphaIold = oS.alphas[i].copy(); alphaJold = oS.alphas[j].copy();
        #步骤2：计算上下界L和H
        if (oS.labelMat[i] != oS.labelMat[j]):
            L = max(0, oS.alphas[j] - oS.alphas[i])
            H = min(oS.C, oS.C + oS.alphas[j] - oS.alphas[i])
        else:
            L = max(0, oS.alphas[j] + oS.alphas[i] - oS.C)
            H = min(oS.C, oS.alphas[j] + oS.alphas[i])
        if L == H: 
            print("L==H")
            return 0
        #步骤3：计算eta
        eta = 2.0 * oS.X[i,:] * oS.X[j,:].T - oS.X[i,:] * oS.X[i,:].T - oS.X[j,:] * oS.X[j,:].T
        if eta >= 0: 
            print("eta>=0")
            return 0
        #步骤4：更新alpha_j
        oS.alphas[j] -= oS.labelMat[j] * (Ei - Ej)/eta
        #步骤5：修剪alpha_j
        oS.alphas[j] = clipAlpha(oS.alphas[j],H,L)
        #更新Ej至误差缓存
        updateEk(oS, j)
        if (abs(oS.alphas[j] - alphaJold) < 0.00001): 
            print("alpha_j变化太小")
            return 0
        #步骤6：更新alpha_i
        oS.alphas[i] += oS.labelMat[j]*oS.labelMat[i]*(alphaJold - oS.alphas[j])
        #更新Ei至误差缓存
        updateEk(oS, i)
        #步骤7：更新b_1和b_2
        b1 = oS.b - Ei- oS.labelMat[i]*(oS.alphas[i]-alphaIold)*oS.X[i,:]*oS.X[i,:].T - oS.labelMat[j]*(oS.alphas[j]-alphaJold)*oS.X[i,:]*oS.X[j,:].T
        b2 = oS.b - Ej- oS.labelMat[i]*(oS.alphas[i]-alphaIold)*oS.X[i,:]*oS.X[j,:].T - oS.labelMat[j]*(oS.alphas[j]-alphaJold)*oS.X[j,:]*oS.X[j,:].T
        #步骤8：根据b_1和b_2更新b
        if (0 < oS.alphas[i]) and (oS.C > oS.alphas[i]): oS.b = b1
        elif (0 < oS.alphas[j]) and (oS.C > oS.alphas[j]): oS.b = b2
        else: oS.b = (b1 + b2)/2.0
        return 1
    else: 
        return 0

def smoP(dataMatIn, classLabels, C, toler, maxIter):
    """
    完整的线性SMO算法
    Parameters：
        dataMatIn - 数据矩阵
        classLabels - 数据标签
        C - 松弛变量
        toler - 容错率
        maxIter - 最大迭代次数
    Returns:
        oS.b - SMO算法计算的b
        oS.alphas - SMO算法计算的alphas
    """
    oS = optStruct(np.mat(dataMatIn), np.mat(classLabels).transpose(), C, toler)                    #初始化数据结构
    iter = 0                                                                                        #初始化当前迭代次数
    entireSet = True; alphaPairsChanged = 0
    while (iter < maxIter) and ((alphaPairsChanged > 0) or (entireSet)):                            #遍历整个数据集都alpha也没有更新或者超过最大迭代次数,则退出循环
        alphaPairsChanged = 0
        if entireSet:                                                                               #遍历整个数据集                        
            for i in range(oS.m):        
                alphaPairsChanged += innerL(i,oS)                                                   #使用优化的SMO算法
                print("全样本遍历:第%d次迭代 样本:%d, alpha优化次数:%d" % (iter,i,alphaPairsChanged))
            iter += 1
        else:                                                                                       #遍历非边界值
            nonBoundIs = np.nonzero((oS.alphas.A > 0) * (oS.alphas.A < C))[0]                       #遍历不在边界0和C的alpha
            for i in nonBoundIs:
                alphaPairsChanged += innerL(i,oS)
                print("非边界遍历:第%d次迭代 样本:%d, alpha优化次数:%d" % (iter,i,alphaPairsChanged))
            iter += 1
        if entireSet:                                                                               #遍历一次后改为非边界遍历
            entireSet = False
        elif (alphaPairsChanged == 0):                                                              #如果alpha没有更新,计算全样本遍历 
            entireSet = True  
        print("迭代次数: %d" % iter)
    return oS.b,oS.alphas                                                                           #返回SMO算法计算的b和alphas


def showClassifer(dataMat, classLabels, w, b):
    """
    分类结果可视化
    Parameters:
        dataMat - 数据矩阵
        w - 直线法向量
        b - 直线解决
    Returns:
        无
    """
    #绘制样本点
    data_plus = []                                  #正样本
    data_minus = []                                 #负样本
    for i in range(len(dataMat)):
        if classLabels[i] > 0:
            data_plus.append(dataMat[i])
        else:
            data_minus.append(dataMat[i])
    data_plus_np = np.array(data_plus)              #转换为numpy矩阵
    data_minus_np = np.array(data_minus)            #转换为numpy矩阵
    plt.scatter(np.transpose(data_plus_np)[0], np.transpose(data_plus_np)[1], s=30, alpha=0.7)   #正样本散点图
    plt.scatter(np.transpose(data_minus_np)[0], np.transpose(data_minus_np)[1], s=30, alpha=0.7) #负样本散点图
    #绘制直线
    x1 = max(dataMat)[0]
    x2 = min(dataMat)[0]
    a1, a2 = w
    b = float(b)
    a1 = float(a1[0])
    a2 = float(a2[0])
    y1, y2 = (-b- a1*x1)/a2, (-b - a1*x2)/a2
    plt.plot([x1, x2], [y1, y2])
    #找出支持向量点
    for i, alpha in enumerate(alphas):
        if alpha > 0:
            x, y = dataMat[i]
            plt.scatter([x], [y], s=150, c='none', alpha=0.7, linewidth=1.5, edgecolor='red')
    plt.show()


def calcWs(alphas,dataArr,classLabels):
    """
    计算w
    Parameters:
        dataArr - 数据矩阵
        classLabels - 数据标签
        alphas - alphas值
    Returns:
        w - 计算得到的w
    """
    X = np.mat(dataArr); labelMat = np.mat(classLabels).transpose()
    m,n = np.shape(X)
    w = np.zeros((n,1))
    for i in range(m):
        w += np.multiply(alphas[i]*labelMat[i],X[i,:].T)
    return w

if __name__ == '__main__':
    dataArr, classLabels = loadDataSet('svm_algo/testSet.txt')
    b, alphas = smoP(dataArr, classLabels, 0.6, 0.001, 40)
    w = calcWs(alphas,dataArr, classLabels)
    showClassifer(dataArr, classLabels, w, b)

运行结果：
全样本遍历:第0次迭代样本:0, alpha优化次数:1
全样本遍历:第0次迭代样本:1, alpha优化次数:1
全样本遍历:第0次迭代样本:2, alpha优化次数:2
全样本遍历:第0次迭代样本:3, alpha优化次数:3
全样本遍历:第0次迭代样本:4, alpha优化次数:4
全样本遍历:第0次迭代样本:5, alpha优化次数:5
全样本遍历:第0次迭代样本:6, alpha优化次数:6
全样本遍历:第0次迭代样本:7, alpha优化次数:6
全样本遍历:第0次迭代样本:8, alpha优化次数:7
全样本遍历:第0次迭代样本:9, alpha优化次数:7
全样本遍历:第0次迭代样本:10, alpha优化次数:7
全样本遍历:第0次迭代样本:11, alpha优化次数:7
全样本遍历:第0次迭代样本:12, alpha优化次数:7
L= =H
全样本遍历:第0次迭代样本:13, alpha优化次数:7
全样本遍历:第0次迭代样本:14, alpha优化次数:7
L= =H
全样本遍历:第0次迭代样本:15, alpha优化次数:7
全样本遍历:第0次迭代样本:16, alpha优化次数:7
L= =H
全样本遍历:第0次迭代样本:17, alpha优化次数:7
全样本遍历:第0次迭代样本:18, alpha优化次数:8
全样本遍历:第0次迭代样本:19, alpha优化次数:8
全样本遍历:第0次迭代样本:20, alpha优化次数:8
全样本遍历:第0次迭代样本:21, alpha优化次数:8
全样本遍历:第0次迭代样本:22, alpha优化次数:8
L= =H
全样本遍历:第0次迭代样本:23, alpha优化次数:8
全样本遍历:第0次迭代样本:24, alpha优化次数:8
alpha_j变化太小
全样本遍历:第0次迭代样本:25, alpha优化次数:8
L= =H
全样本遍历:第0次迭代样本:26, alpha优化次数:8
全样本遍历:第0次迭代样本:27, alpha优化次数:8
全样本遍历:第0次迭代样本:28, alpha优化次数:8
L= =H
全样本遍历:第0次迭代样本:29, alpha优化次数:8
全样本遍历:第0次迭代样本:30, alpha优化次数:8
全样本遍历:第0次迭代样本:31, alpha优化次数:8
全样本遍历:第0次迭代样本:32, alpha优化次数:8
全样本遍历:第0次迭代样本:33, alpha优化次数:8
全样本遍历:第0次迭代样本:34, alpha优化次数:8
全样本遍历:第0次迭代样本:35, alpha优化次数:8
全样本遍历:第0次迭代样本:36, alpha优化次数:8
全样本遍历:第0次迭代样本:37, alpha优化次数:8
全样本遍历:第0次迭代样本:38, alpha优化次数:8
全样本遍历:第0次迭代样本:39, alpha优化次数:8
全样本遍历:第0次迭代样本:40, alpha优化次数:8
全样本遍历:第0次迭代样本:41, alpha优化次数:8
全样本遍历:第0次迭代样本:42, alpha优化次数:8
全样本遍历:第0次迭代样本:43, alpha优化次数:8
全样本遍历:第0次迭代样本:44, alpha优化次数:8
alpha_j变化太小
全样本遍历:第0次迭代样本:45, alpha优化次数:8
L = = H
全样本遍历:第0次迭代样本:46, alpha优化次数:8
全样本遍历:第0次迭代样本:47, alpha优化次数:8
全样本遍历:第0次迭代样本:48, alpha优化次数:8
全样本遍历:第0次迭代样本:49, alpha优化次数:8
全样本遍历:第0次迭代样本:50, alpha优化次数:8
全样本遍历:第0次迭代样本:51, alpha优化次数:8
L = = H
全样本遍历:第0次迭代样本:52, alpha优化次数:8
全样本遍历:第0次迭代样本:53, alpha优化次数:8
L = =H
全样本遍历:第0次迭代样本:54, alpha优化次数:8
L= =H
全样本遍历:第0次迭代样本:55, alpha优化次数:8
全样本遍历:第0次迭代样本:56, alpha优化次数:8
L= =H
全样本遍历:第0次迭代样本:57, alpha优化次数:8
全样本遍历:第0次迭代样本:58, alpha优化次数:8
全样本遍历:第0次迭代样本:59, alpha优化次数:8
全样本遍历:第0次迭代样本:60, alpha优化次数:8
全样本遍历:第0次迭代样本:61, alpha优化次数:8
L= = H
全样本遍历:第0次迭代样本:62, alpha优化次数:8
全样本遍历:第0次迭代样本:63, alpha优化次数:8
全样本遍历:第0次迭代样本:64, alpha优化次数:8
全样本遍历:第0次迭代样本:65, alpha优化次数:8
全样本遍历:第0次迭代样本:66, alpha优化次数:8
全样本遍历:第0次迭代样本:67, alpha优化次数:8
全样本遍历:第0次迭代样本:68, alpha优化次数:8
L= = H
全样本遍历:第0次迭代样本:69, alpha优化次数:8
全样本遍历:第0次迭代样本:70, alpha优化次数:8
全样本遍历:第0次迭代样本:71, alpha优化次数:8
全样本遍历:第0次迭代样本:72, alpha优化次数:8
全样本遍历:第0次迭代样本:73, alpha优化次数:8
全样本遍历:第0次迭代样本:74, alpha优化次数:8
全样本遍历:第0次迭代样本:75, alpha优化次数:8
全样本遍历:第0次迭代样本:76, alpha优化次数:8
全样本遍历:第0次迭代样本:77, alpha优化次数:8
全样本遍历:第0次迭代样本:78, alpha优化次数:8
L= = H
全样本遍历:第0次迭代样本:79, alpha优化次数:8
全样本遍历:第0次迭代样本:80, alpha优化次数:8
全样本遍历:第0次迭代样本:81, alpha优化次数:8
L= =H
全样本遍历:第0次迭代样本:82, alpha优化次数:8
全样本遍历:第0次迭代样本:83, alpha优化次数:8
全样本遍历:第0次迭代样本:84, alpha优化次数:8
全样本遍历:第0次迭代样本:85, alpha优化次数:8
全样本遍历:第0次迭代样本:86, alpha优化次数:8
全样本遍历:第0次迭代样本:87, alpha优化次数:8
全样本遍历:第0次迭代样本:88, alpha优化次数:8
全样本遍历:第0次迭代样本:89, alpha优化次数:8
全样本遍历:第0次迭代样本:90, alpha优化次数:8
全样本遍历:第0次迭代样本:91, alpha优化次数:8
全样本遍历:第0次迭代样本:92, alpha优化次数:8
全样本遍历:第0次迭代样本:93, alpha优化次数:8
全样本遍历:第0次迭代样本:94, alpha优化次数:8
全样本遍历:第0次迭代样本:95, alpha优化次数:8
全样本遍历:第0次迭代样本:96, alpha优化次数:8
全样本遍历:第0次迭代样本:97, alpha优化次数:8
全样本遍历:第0次迭代样本:98, alpha优化次数:8
全样本遍历:第0次迭代样本:99, alpha优化次数:8
迭代次数: 1
alpha_j变化太小
非边界遍历:第1次迭代样本:0, alpha优化次数:0
非边界遍历:第1次迭代样本:2, alpha优化次数:1
非边界遍历:第1次迭代样本:4, alpha优化次数:2
非边界遍历:第1次迭代样本:5, alpha优化次数:3
非边界遍历:第1次迭代样本:6, alpha优化次数:4
非边界遍历:第1次迭代样本:8, alpha优化次数:5
alpha_j变化太小
非边界遍历:第1次迭代样本:17, alpha优化次数:5
alpha_j变化太小
非边界遍历:第1次迭代样本:18, alpha优化次数:5
迭代次数: 2
alpha_j变化太小
非边界遍历:第2次迭代样本:0, alpha优化次数:0
非边界遍历:第2次迭代样本:8, alpha优化次数:0
alpha_j变化太小
非边界遍历:第2次迭代样本:17, alpha优化次数:0
alpha_j变化太小
非边界遍历:第2次迭代样本:18, alpha优化次数:0
非边界遍历:第2次迭代样本:55, alpha优化次数:0
迭代次数: 3
alpha_j变化太小
全样本遍历:第3次迭代样本:0, alpha优化次数:0
全样本遍历:第3次迭代样本:1, alpha优化次数:0
全样本遍历:第3次迭代样本:2, alpha优化次数:0
全样本遍历:第3次迭代样本:3, alpha优化次数:0
全样本遍历:第3次迭代样本:4, alpha优化次数:0
全样本遍历:第3次迭代样本:5, alpha优化次数:0
全样本遍历:第3次迭代样本:6, alpha优化次数:0
全样本遍历:第3次迭代样本:7, alpha优化次数:0
全样本遍历:第3次迭代样本:8, alpha优化次数:0
全样本遍历:第3次迭代样本:9, alpha优化次数:0
alpha_j变化太小
全样本遍历:第3次迭代样本:10, alpha优化次数:0
全样本遍历:第3次迭代样本:11, alpha优化次数:0
全样本遍历:第3次迭代样本:12, alpha优化次数:0
全样本遍历:第3次迭代样本:13, alpha优化次数:0
全样本遍历:第3次迭代样本:14, alpha优化次数:0
全样本遍历:第3次迭代样本:15, alpha优化次数:0
全样本遍历:第3次迭代样本:16, alpha优化次数:0
alpha_j变化太小
全样本遍历:第3次迭代样本:17, alpha优化次数:0
alpha_j变化太小
全样本遍历:第3次迭代样本:18, alpha优化次数:0
全样本遍历:第3次迭代样本:19, alpha优化次数:0
全样本遍历:第3次迭代样本:20, alpha优化次数:0
全样本遍历:第3次迭代样本:21, alpha优化次数:0
全样本遍历:第3次迭代样本:22, alpha优化次数:0
alpha_j变化太小
全样本遍历:第3次迭代样本:23, alpha优化次数:0
全样本遍历:第3次迭代样本:24, alpha优化次数:0
全样本遍历:第3次迭代样本:25, alpha优化次数:0
全样本遍历:第3次迭代样本:26, alpha优化次数:0
全样本遍历:第3次迭代样本:27, alpha优化次数:0
全样本遍历:第3次迭代样本:28, alpha优化次数:0
alpha_j变化太小
全样本遍历:第3次迭代样本:29, alpha优化次数:0
alpha_j变化太小
全样本遍历:第3次迭代样本:30, alpha优化次数:0
全样本遍历:第3次迭代样本:31, alpha优化次数:0
全样本遍历:第3次迭代样本:32, alpha优化次数:0
全样本遍历:第3次迭代样本:33, alpha优化次数:0
全样本遍历:第3次迭代样本:34, alpha优化次数:0
全样本遍历:第3次迭代样本:35, alpha优化次数:0
全样本遍历:第3次迭代样本:36, alpha优化次数:0
全样本遍历:第3次迭代样本:37, alpha优化次数:0
全样本遍历:第3次迭代样本:38, alpha优化次数:0
全样本遍历:第3次迭代样本:39, alpha优化次数:0
全样本遍历:第3次迭代样本:40, alpha优化次数:0
全样本遍历:第3次迭代样本:41, alpha优化次数:0
全样本遍历:第3次迭代样本:42, alpha优化次数:0
全样本遍历:第3次迭代样本:43, alpha优化次数:0
全样本遍历:第3次迭代样本:44, alpha优化次数:0
全样本遍历:第3次迭代样本:45, alpha优化次数:0
全样本遍历:第3次迭代样本:46, alpha优化次数:0
全样本遍历:第3次迭代样本:47, alpha优化次数:0
全样本遍历:第3次迭代样本:48, alpha优化次数:0
全样本遍历:第3次迭代样本:49, alpha优化次数:0
全样本遍历:第3次迭代样本:50, alpha优化次数:0
全样本遍历:第3次迭代样本:51, alpha优化次数:0
L==H
全样本遍历:第3次迭代样本:52, alpha优化次数:0
全样本遍历:第3次迭代样本:53, alpha优化次数:0
全样本遍历:第3次迭代样本:54, alpha优化次数:0
全样本遍历:第3次迭代样本:55, alpha优化次数:0
全样本遍历:第3次迭代样本:56, alpha优化次数:0
全样本遍历:第3次迭代样本:57, alpha优化次数:0
全样本遍历:第3次迭代样本:58, alpha优化次数:0
全样本遍历:第3次迭代样本:59, alpha优化次数:0
全样本遍历:第3次迭代样本:60, alpha优化次数:0
全样本遍历:第3次迭代样本:61, alpha优化次数:0
全样本遍历:第3次迭代样本:62, alpha优化次数:0
全样本遍历:第3次迭代样本:63, alpha优化次数:0
全样本遍历:第3次迭代样本:64, alpha优化次数:0
全样本遍历:第3次迭代样本:65, alpha优化次数:0
全样本遍历:第3次迭代样本:66, alpha优化次数:0
全样本遍历:第3次迭代样本:67, alpha优化次数:0
全样本遍历:第3次迭代样本:68, alpha优化次数:0
全样本遍历:第3次迭代样本:69, alpha优化次数:0
alpha_j变化太小
全样本遍历:第3次迭代样本:70, alpha优化次数:0
全样本遍历:第3次迭代样本:71, alpha优化次数:0
全样本遍历:第3次迭代样本:72, alpha优化次数:0
全样本遍历:第3次迭代样本:73, alpha优化次数:0
全样本遍历:第3次迭代样本:74, alpha优化次数:0
全样本遍历:第3次迭代样本:75, alpha优化次数:0
alpha_j变化太小
全样本遍历:第3次迭代样本:76, alpha优化次数:0
全样本遍历:第3次迭代样本:77, alpha优化次数:0
全样本遍历:第3次迭代样本:78, alpha优化次数:0
全样本遍历:第3次迭代样本:79, alpha优化次数:0
全样本遍历:第3次迭代样本:80, alpha优化次数:0
全样本遍历:第3次迭代样本:81, alpha优化次数:0
全样本遍历:第3次迭代样本:82, alpha优化次数:0
全样本遍历:第3次迭代样本:83, alpha优化次数:0
全样本遍历:第3次迭代样本:84, alpha优化次数:0
全样本遍历:第3次迭代样本:85, alpha优化次数:0
全样本遍历:第3次迭代样本:86, alpha优化次数:0
全样本遍历:第3次迭代样本:87, alpha优化次数:0
全样本遍历:第3次迭代样本:88, alpha优化次数:0
全样本遍历:第3次迭代样本:89, alpha优化次数:0
全样本遍历:第3次迭代样本:90, alpha优化次数:0
全样本遍历:第3次迭代样本:91, alpha优化次数:0
全样本遍历:第3次迭代样本:92, alpha优化次数:0
全样本遍历:第3次迭代样本:93, alpha优化次数:0
alpha_j变化太小
全样本遍历:第3次迭代样本:94, alpha优化次数:0
全样本遍历:第3次迭代样本:95, alpha优化次数:0
全样本遍历:第3次迭代样本:96, alpha优化次数:0
alpha_j变化太小
全样本遍历:第3次迭代样本:97, alpha优化次数:0
全样本遍历:第3次迭代样本:98, alpha优化次数:0
全样本遍历:第3次迭代样本:99, alpha优化次数:0
迭代次数: 4

在这里插入图片描述
从运行后的绘制图中，可以看出完整版的smo算法得到的支持向量会更多，运行速度明显提升。

现在，我们可以成功训练出分类器，从图中我们已经大概可以得到两类的分割线形状。但倘若两类数据点分别分布在一个圆的内部和外部，我们的分隔超平面又该是怎样的呢？

3.应用核函数训练复杂数据

我们再来回顾一下径向基核函数的高斯版本的公式：

在这里插入图片描述
其中，σ是用户自定义的用于确定到达率(reach)或者说函数值跌落到0的速度参数。

编程实现非线性SVM
接下来，我们将使用testSetRBF.txt和testSetRBF2.txt，前者作为训练集，后者作为测试集。
我们根据公式，编写核函数，并增加初始化参数kTup用于存储核函数有关的信息，同时我们只要将之前的内积运算变成核函数的运算即可。最后编写testRbf()函数，用于测试。

编写代码如下：

In [7]:
# -*-coding:utf-8 -*-
import matplotlib.pyplot as plt
import numpy as np
import random

class optStruct:
    """
    数据结构，维护所有需要操作的值
    Parameters：
        dataMatIn - 数据矩阵
        classLabels - 数据标签
        C - 松弛变量
        toler - 容错率
        kTup - 包含核函数信息的元组,第一个参数存放核函数类别，第二个参数存放必要的核函数需要用到的参数
    """
    def __init__(self, dataMatIn, classLabels, C, toler, kTup):
        self.X = dataMatIn                                #数据矩阵
        self.labelMat = classLabels                        #数据标签
        self.C = C                                         #松弛变量
        self.tol = toler                                 #容错率
        self.m = np.shape(dataMatIn)[0]                 #数据矩阵行数
        self.alphas = np.mat(np.zeros((self.m,1)))         #根据矩阵行数初始化alpha参数为0   
        self.b = 0                                         #初始化b参数为0
        self.eCache = np.mat(np.zeros((self.m,2)))         #根据矩阵行数初始化虎误差缓存，第一列为是否有效的标志位，第二列为实际的误差E的值。
        self.K = np.mat(np.zeros((self.m,self.m)))        #初始化核K
        for i in range(self.m):                            #计算所有数据的核K
            self.K[:,i] = kernelTrans(self.X, self.X[i,:], kTup)
KernelTrans函数首先构建了一个列向量，然后检查元组以确定核函数的类型。
In [*]:
def kernelTrans(X, A, kTup):
    """
    通过核函数将数据转换更高维的空间
    Parameters：
        X - 数据矩阵
        A - 单个数据的向量
        kTup - 包含核函数信息的元组
    Returns:
        K - 计算的核K
    """
    m,n = np.shape(X)
    K = np.mat(np.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
    else: raise NameError('核函数无法识别')
    return K                                             #返回计算的核K

def loadDataSet(fileName):
    """
    读取数据
    Parameters:
        fileName - 文件名
    Returns:
        dataMat - 数据矩阵
        labelMat - 数据标签
    """
    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 calcEk(oS, k):
    """
    计算误差
    Parameters：
        oS - 数据结构
        k - 标号为k的数据
    Returns:
        Ek - 标号为k的数据误差
    """
    fXk = float(np.multiply(oS.alphas,oS.labelMat).T*oS.K[:,k] + oS.b)    #将内积换成核函数oS.K[:,k]
    Ek = fXk - float(oS.labelMat[k])
    return Ek

def selectJrand(i, m):
    """
    函数说明:随机选择alpha_j的索引值

    Parameters:
        i - alpha_i的索引值
        m - alpha参数个数
    Returns:
        j - alpha_j的索引值
    """
    j = i                                 #选择一个不等于i的j
    while (j == i):
        j = int(random.uniform(0, m))
    return j

def selectJ(i, oS, Ei):
    """
    内循环启发方式2
    Parameters：
        i - 标号为i的数据的索引值
        oS - 数据结构
        Ei - 标号为i的数据误差
    Returns:
        j, maxK - 标号为j或maxK的数据的索引值
        Ej - 标号为j的数据误差
    """
    maxK = -1; maxDeltaE = 0; Ej = 0                         #初始化
    oS.eCache[i] = [1,Ei]                                      #根据Ei更新误差缓存
    validEcacheList = np.nonzero(oS.eCache[:,0].A)[0]        #返回误差不为0的数据的索引值
    if (len(validEcacheList)) > 1:                            #有不为0的误差
        for k in validEcacheList:                           #遍历,找到最大的Ek
            if k == i: continue                             #不计算i,浪费时间
            Ek = calcEk(oS, k)                                #计算Ek
            deltaE = abs(Ei - Ek)                            #计算|Ei-Ek|
            if (deltaE > maxDeltaE):                        #找到maxDeltaE
                maxK = k; maxDeltaE = deltaE; Ej = Ek
        return maxK, Ej                                        #返回maxK,Ej
    else:                                                   #没有不为0的误差
        j = selectJrand(i, oS.m)                            #随机选择alpha_j的索引值
        Ej = calcEk(oS, j)                                    #计算Ej
    return j, Ej                                             #j,Ej

def updateEk(oS, k):
    """
    计算Ek,并更新误差缓存
    Parameters：
        oS - 数据结构
        k - 标号为k的数据的索引值
    Returns:
        无
    """
    Ek = calcEk(oS, k)                                        #计算Ek
    oS.eCache[k] = [1,Ek]                                    #更新误差缓存

def clipAlpha(aj,H,L):
    """
    修剪alpha_j
    Parameters:
        aj - alpha_j的值
        H - alpha上限
        L - alpha下限
    Returns:
        aj - 修剪后的alpah_j的值
    """
    if aj > H:
        aj = H
    if L > aj:
        aj = L
    return aj

def innerL(i, oS):
    """
    优化的SMO算法
    Parameters：
        i - 标号为i的数据的索引值
        oS - 数据结构
    Returns:
        1 - 有任意一对alpha值发生变化
        0 - 没有任意一对alpha值发生变化或变化太小
    """
    #步骤1：计算误差Ei
    Ei = calcEk(oS, i)
    #优化alpha,设定一定的容错率。
    if ((oS.labelMat[i] * Ei < -oS.tol) and (oS.alphas[i] < oS.C)) or ((oS.labelMat[i] * Ei > oS.tol) and (oS.alphas[i] > 0)):
        #使用内循环启发方式2选择alpha_j,并计算Ej
        j,Ej = selectJ(i, oS, Ei)
        #保存更新前的aplpha值，使用深拷贝
        alphaIold = oS.alphas[i].copy(); alphaJold = oS.alphas[j].copy();
        #步骤2：计算上下界L和H
        if (oS.labelMat[i] != oS.labelMat[j]):
            L = max(0, oS.alphas[j] - oS.alphas[i])
            H = min(oS.C, oS.C + oS.alphas[j] - oS.alphas[i])
        else:
            L = max(0, oS.alphas[j] + oS.alphas[i] - oS.C)
            H = min(oS.C, oS.alphas[j] + oS.alphas[i])
        if L == H:
            print("L==H")
            return 0
        #步骤3：计算eta
        eta = 2.0 * oS.K[i,j] - oS.K[i,i] - oS.K[j,j]   #将内积换成核函数oS.K[i,j]
        if eta >= 0:
            print("eta>=0")
            return 0
        #步骤4：更新alpha_j
        oS.alphas[j] -= oS.labelMat[j] * (Ei - Ej)/eta
        #步骤5：修剪alpha_j
        oS.alphas[j] = clipAlpha(oS.alphas[j],H,L)
        #更新Ej至误差缓存
        updateEk(oS, j)
        if (abs(oS.alphas[j] - alphaJold) < 0.00001):
            print("alpha_j变化太小")
            return 0
        #步骤6：更新alpha_i
        oS.alphas[i] += oS.labelMat[j]*oS.labelMat[i]*(alphaJold - oS.alphas[j])
        #更新Ei至误差缓存
        updateEk(oS, i)
        #步骤7：更新b_1和b_2
        b1 = oS.b - Ei- oS.labelMat[i]*(oS.alphas[i]-alphaIold)*oS.K[i,i] - oS.labelMat[j]*(oS.alphas[j]-alphaJold)*oS.K[i,j]  #将内积换成核函数oS.K[i,j]
        b2 = oS.b - Ej- oS.labelMat[i]*(oS.alphas[i]-alphaIold)*oS.K[i,j]- oS.labelMat[j]*(oS.alphas[j]-alphaJold)*oS.K[j,j]   #将内积换成核函数oS.K[i,j]
        #步骤8：根据b_1和b_2更新b
        if (0 < oS.alphas[i]) and (oS.C > oS.alphas[i]): oS.b = b1
        elif (0 < oS.alphas[j]) and (oS.C > oS.alphas[j]): oS.b = b2
        else: oS.b = (b1 + b2)/2.0
        return 1
    else:
        return 0

def smoP(dataMatIn, classLabels, C, toler, maxIter, kTup = ('lin',0)):
    """
    完整的线性SMO算法
    Parameters：
        dataMatIn - 数据矩阵
        classLabels - 数据标签
        C - 松弛变量
        toler - 容错率
        maxIter - 最大迭代次数
        kTup - 包含核函数信息的元组
    Returns:
        oS.b - SMO算法计算的b
        oS.alphas - SMO算法计算的alphas
    """
    oS = optStruct(np.mat(dataMatIn), np.mat(classLabels).transpose(), C, toler, kTup)                #初始化数据结构
    iter = 0                                                                                         #初始化当前迭代次数
    entireSet = True; alphaPairsChanged = 0
    while (iter < maxIter) and ((alphaPairsChanged > 0) or (entireSet)):                            #遍历整个数据集都alpha也没有更新或者超过最大迭代次数,则退出循环
        alphaPairsChanged = 0
        if entireSet:                                                                                #遍历整个数据集                           
            for i in range(oS.m):       
                alphaPairsChanged += innerL(i,oS)                                                    #使用优化的SMO算法
                print("全样本遍历:第%d次迭代 样本:%d, alpha优化次数:%d" % (iter,i,alphaPairsChanged))
            iter += 1
        else:                                                                                         #遍历非边界值
            nonBoundIs = np.nonzero((oS.alphas.A > 0) * (oS.alphas.A < C))[0]                        #遍历不在边界0和C的alpha
            for i in nonBoundIs:
                alphaPairsChanged += innerL(i,oS)
                print("非边界遍历:第%d次迭代 样本:%d, alpha优化次数:%d" % (iter,i,alphaPairsChanged))
            iter += 1
        if entireSet:                                                                                #遍历一次后改为非边界遍历
            entireSet = False
        elif (alphaPairsChanged == 0):                                                                #如果alpha没有更新,计算全样本遍历
            entireSet = True 
        print("迭代次数: %d" % iter)
    return oS.b,oS.alphas                                                                             #返回SMO算法计算的b和alphas

def testRbf(k1 = 1.2):
    """
    测试函数
    Parameters:
        k1 - 使用高斯核函数的时候表示到达率
    Returns:
        无
    """
    dataArr,labelArr = loadDataSet('svm_algo/testSetRBF.txt')                        #加载训练集
    b,alphas = smoP(dataArr, labelArr, 200, 0.0001, 100, ('rbf', k1))        #根据训练集计算b和alphas
    datMat = np.mat(dataArr); labelMat = np.mat(labelArr).transpose()
    svInd = np.nonzero(alphas.A > 0)[0]                                        #获得支持向量
    sVs = datMat[svInd]                                                     
    labelSV = labelMat[svInd];
    print("支持向量个数:%d" % np.shape(sVs)[0])
    m,n = np.shape(datMat)
    errorCount = 0
    for i in range(m):
        kernelEval = kernelTrans(sVs,datMat[i,:],('rbf', k1))                #计算各个点的核
        predict = kernelEval.T * np.multiply(labelSV,alphas[svInd]) + b     #根据支持向量的点，计算超平面，返回预测结果
        if np.sign(predict) != np.sign(labelArr[i]): errorCount += 1        #返回数组中各元素的正负符号，用1和-1表示，并统计错误个数
    print("训练集错误率: %.2f%%" % ((float(errorCount)/m)*100))             #打印错误率
    dataArr,labelArr = loadDataSet('svm_algo/testSetRBF2.txt')                         #加载测试集
    errorCount = 0
    datMat = np.mat(dataArr); labelMat = np.mat(labelArr).transpose()         
    m,n = np.shape(datMat)
    for i in range(m):
        kernelEval = kernelTrans(sVs,datMat[i,:],('rbf', k1))                 #计算各个点的核           
        predict=kernelEval.T * np.multiply(labelSV,alphas[svInd]) + b         #根据支持向量的点，计算超平面，返回预测结果
        if np.sign(predict) != np.sign(labelArr[i]): errorCount += 1        #返回数组中各元素的正负符号，用1和-1表示，并统计错误个数
    print("测试集错误率: %.2f%%" % ((float(errorCount)/m)*100))             #打印错误率

if __name__ == '__main__':
    testRbf()

我们可以尝试更换不同的K1参数以观察测试错误率、训练错误率，支持向量个数和K1的关系。

三、实验总结

SVM优点：
对数据进行高效分类

SVM缺点：
对数据敏感。如果支持向量太少，可能会得到一个很差的决策边界；相反，就相当于每次都利用整个数据集进行分类，等同于K邻近算法，计算量过大。

通过本实验，您应该能达到以下两个目标：
1.掌握SVM算法原理。
2.熟悉SVN算法的初步应用。

参考文献及延伸阅读
参考资料：
1.哈林顿，李锐. 机器学习实战 : Machine learning in action[M]. 人民邮电出版社, 2013.
2.http://cuijiahua.com/blog/2017/11/ml_8_svm_1.html
延伸阅读：
1.李航. 统计学习方法[M]. 清华大学出版社, 2012.

MAYDAY01520

关注

100
点赞
踩
11

收藏

觉得还不错? 一键收藏
0
评论
【机器学习】SVM支持向量机算法和实现

实验内容本实验介绍SVM支持向量机原理，并通过三个实验逐步深入的了解如何实现该算法。实验目标通过本实验掌握SVM相关算法原理，了解算法的实现。实验知识点SVM支持向量机原理实验环境预备知识概率论与数理统计Linux命令基本操作Python编程基础SVM的全称是，即支持向量机，主要用于解决模式识别领域中的数据分类问题，属于有监督学习算法的一种。SVM要解决的问题可以用一个经典的二分类问题加以描述。我们以一个红蓝球分类的问题开始SVM的学习。
复制链接

扫一扫