SVM_huang.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ZpVfPosXpDwd"
   },
   "source": [
    "**一 SVM简单介绍** \n",
    "\n",
    "支持向量机(Support Vector Machine，SVM)是Corinna Cortes和Vapnik等于1995年首先提出的，它在解决小样本、非线性及高维模式识别中表现出许多特有的优势，并能够推广应用到函数拟合等其他机器学习问题中。 在机器学习中，支持向量机是与相关的学习算法有关的监督学习模型，可以分析数据、识别模式，用于分类和回归分析。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "bW4VBEbBpDwg"
   },
   "source": [
    "**二 函数间隔与几何间隔**  \n",
    "\n",
    "对一个数据点进行分类，当超平面离数据点的“间隔”越大，分类的确信度（confidence）也越大。所以，为了使得分类的确信度尽量高，需要让所选择的超平面能够最大化这个“间隔”值。这个间隔就是下图中的Gap的一半。\n",
    "![2.png](image/2.png)\n",
    "\n",
    "\n",
    "\n",
    "**2.1 函数间隔**<br>\n",
    "定义函数间隔为：\n",
    "$$\\hat\\gamma=y(w^Tx+b)=yf(x)$$\n",
    "而超平面(w，b)关于T中所有样本点($x_i$，$y_i$)的函数间隔最小值（其中，x是特征，y是结果标签，i表示第i个样本），便为超平面(w, b)关于训练数据集T的函数间隔。 但这样定义的函数间隔有问题，即如果成比例的改变w和b（如将它们改成2w和2b），则函数间隔的值f(x)却变成了原来的2倍（虽然此时超平面没有改变），所以只有函数间隔还不够，我们要引入几何间隔。\n",
    "![1.png](image/1.png) \n",
    "\n",
    "**2.2 几何间隔**<br>\n",
    "在几何学里，点($x_i$，$y_i$)到直线$ax+by+c=0$的距离公式:\n",
    "$$d(x_i, y_i) = \\frac{|ax_i+by_i+c|}{\\sqrt{a^{2}+b^{2}}}$$\n",
    "所以在二维空间中，几何间隔就是点到直线的距离；在三维空间中，几何间隔是点到空间上一平面的距离；而在SVM中，平面变成了超平面，几何间隔便是样本点到超平面的距离：\n",
    "$$\\gamma_{i}=y_{i}(\\frac{w^T}{\\Vert w\\Vert}x_{i}+\\frac{b}{\\Vert w\\Vert})$$\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "_XtDLxHBpDwh"
   },
   "source": [
    "**三 最大间隔分类器**  \n",
    "\n",
    "\n",
    "如下图所示，中间的实线便是寻找到的最优超平面（Optimal Hyper Plane），其到两条虚线边界的距离相等，虚线边界上的点到最优超平面的距离便是几何间隔，两条虚线间隔边界之间的距离等于2倍的几何间隔，而虚线间隔边界上的点则是支持向量。而对于所有不是支持向量的点，有如下关系：\n",
    "$y(w^Tx+b)>1$\n",
    "![3.png](image/3.png)\n",
    "\n",
    "函数间隔不适合用来最大化间隔值，因为在超平面固定以后，可以等比例地缩放w的长度和b的值，这样可以使得的值任意大，亦即函数间隔可以在超平面保持不变的情况下被取得任意大。但几何间隔因为除上了${\\Vert w\\Vert}$，使得在缩放w和b的时候几何间隔的值是不会改变的，它只随着超平面的变动而变动，因此，这是更加合适的一个间隔。换言之，这里要找的最大间隔分类超平面中的“间隔”指的是几何间隔。 于是最大间隔分类器（maximum margin classifier）的目标函数可以定义为： 同时需满足一些条件，根据间隔的定义，有\n",
    "$$y_i(w^Tx_i+b)=\\hat\\gamma_i>=\\hat\\gamma,i=1,2,...,n$$\n",
    "距离超平面最近的这几个训练样本点使得等式成立，它们被称为**支持向量**，这些支持向量到到超平面的距离是$\\frac{1}{w}$\n",
    "从而上述目标函数转化成了：\n",
    "$$max\\frac{1}{\\Vert w\\Vert},s.t.\\ y_i(w^Tx_i+b)>=1,i=1,2,...,n$$\n",
    "\n",
    "相当于在相应的约束条件下，最大化这个$\\frac{1}{\\Vert w\\Vert}$值，而$\\frac{1}{\\Vert w\\Vert}$便是要求解的几何间隔。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "itajtXgSpDwj"
   },
   "source": [
    "**通过以上的介绍，我们得出支持向量机的目标函数，但往往这个问题不是那么容易解决，所以需要将其转化为其对偶形式求解，往往对对偶形式求解会比直接对原问题求解方便很多。**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Q1qERHrRpDwk"
   },
   "source": [
    "**四 原始问题到对偶问题的求解**   \n",
    "\n",
    "接着考虑之前得到的目标函数：\n",
    "$$max\\frac{1}{\\Vert w\\Vert}$$ \n",
    "$$s.t.\\ y_i(w^Tx_i+b)>=1,i=1,2,...,n$$\n",
    "由于求$\\frac{1}{\\Vert w\\Vert}$的最大值相当于求${\\Vert w\\Vert}$的最小值，也相当于求$\\frac{1}{2}{\\Vert w\\Vert}^2$的最小值，所以上述目标函数等价于：\n",
    "$$min\\frac{1}{2}{\\Vert w\\Vert}^2$$ \n",
    "$$s.t.\\ y_i(w^Tx_i+b)>=1,i=1,2,...,n$$\n",
    "\n",
    "此外，由于这个问题的特殊结构，还可以通过拉格朗日对偶性（Lagrange Duality）变换到对偶变量 (dual variable) 的优化问题，即通过求解与原问题等价的对偶问题（dual problem）得到原始问题的最优解，这就是线性可分条件下支持向量机的对偶算法，这样做的优点在于：一者对偶问题往往更容易求解；二者可以自然的引入核函数，进而推广到非线性分类问题。 那什么是拉格朗日对偶性呢？简单来讲，通过给每一个约束条件加上一个**拉格朗日乘子**（Lagrange multiplier），定义拉格朗日函数（通过拉格朗日函数将约束条件融合到目标函数里去，从而只用一个函数表达式便能清楚的表达出我们的问题）：\n",
    "$$L\\left(w,b,\\alpha\\right)=\\frac{1}{2}{\\Vert w\\Vert}^2-\\sum_{i=1}^{n}\\alpha_i{\\lgroup}y_i\\left(w^Tx_i+b\\right)-1\\rgroup$$\n",
    "然后令：\n",
    "$$\\theta\\left(w\\right)=max\\ L\\left(w,b,\\alpha\\right),\\alpha_i>=0$$  \n",
    "\n",
    "容易验证，当某个约束条件不满足时，例如$y_i\\left(w^Tx_i+b\\right)<1$，那么显然有$\\theta\\left(w\\right)=\\infty$（只要令$\\alpha_i=\\infty$即可）。而当所有约束条件都满足时，则最优值为$\\theta\\left(w\\right)=\\frac{1}{2}{w}^2$，亦即最初要最小化的量。 因此，在要求约束条件得到满足的情况下最小化$\\frac{1}{2}{w}^2$，实际上等价于直接最小化$\\theta\\left(w\\right)$（当然，这里也有约束条件，就是$\\alpha_i>=0,i=1,...,n)$，因为如果约束条件没有得到满足，会等于无穷大，自然不会是我们所要求的最小值。 具体写出来，目标函数变成了：\n",
    "$$\\min\\limits_{w,b}\\theta\\left(w\\right)=\\min\\limits_{w,b}                              \\max\\limits_{\\alpha_i>=0}L\\left(w,b,\\alpha\\right)=p^*$$\n",
    "这里用$p^*$表示这个问题的最优值，且和最初的问题是等价的。如果直接求解，那么一上来便得面对w和b两个参数，而又是不等式约束，这个求解过程不好做。不妨把最小和最大的位置交换一下，变成：\n",
    "$$\\max\\limits_{\\alpha_i>=0}\\min\\limits_{w,b}L\\left(w,b,\\alpha\\right)=d^*$$\n",
    "\n",
    "交换以后的新问题是原始问题的对偶问题，这个新问题的最优值用来$d^*$来表示。而且有$d^*≤p^*$，在满足某些条件的情况下，这两者相等，这个时候就可以通过求解对偶问题来间接地求解原始问题。  \n",
    "\n",
    "换言之，之所以从min max的原始问题$p^*$，转化为max min的对偶问题$d^*$，一者因为是近似解，二者，转化为对偶问题后，更容易求解。 下面可以先求L对w、b的极小，再求L对$\\alpha$的极大。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "0GDW6Tp-pDwl"
   },
   "source": [
    "**五 对偶问题的求解**  \n",
    "\n",
    "$$L\\left(w,b,\\alpha\\right)=\\frac{1}{2}{\\Vert w\\Vert}^2-\\sum_{i=1}^{n}\\alpha_i{\\lgroup}y_i\\left(w^Tx_i+b\\right)-1\\rgroup$$\n",
    "\n",
    "首先固定$\\alpha$,要让L关于w和b最小化，我们分别对w,b求偏导数，即令：\n",
    "\n",
    "$$\\frac{\\partial{L}}{\\partial{w}}=0$$\n",
    "$$\\frac{\\partial{L}}{\\partial{b}}=0$$\n",
    "\n",
    "$$\\frac{\\partial{L}}{\\partial{w}}=0\\Rightarrow \\parallel w \\parallel =\\sum_{i=1}^{n}\\alpha_iy_ix_i$$\n",
    "$$\\frac{\\partial{L}}{\\partial{b}}=0\\Rightarrow\\sum_{i=1}^{n}\\alpha_iy_i=0$$\n",
    "将以上结果带入之前的$L\\left(w,b,\\alpha\\right)$：\n",
    "$$L(w,b,\\alpha)=\\frac{1}{2}{w}^2-\\sum_{i=1}^{n}\\alpha_i{\\lgroup}y_i\\left(w^Tx_i+b\\right)-1{\\rgroup}$$\n",
    "\n",
    "得到：\n",
    "$$L(w,b,\\alpha)=\\frac{1}{2}\\sum_{i,j=1}^{n}\\alpha_i\\alpha_jy_iy_j{x_i}^Tx_j-\\sum_{i,j=1}^{n}\\alpha_i\\alpha_jy_iy_j{x_i}^Tx_j-b\\sum_{i=1}^{n}\\alpha_iy_i+\\sum_{i=1}^{n}\\alpha_i=\\sum_{i=1}^{n}\\alpha_i-\\frac{1}{2}\\sum_{i,j=1}^{n}\\alpha_i\\alpha_j{y_iy_j{x_i}^Tx_j}$$\n",
    "\n",
    "求对$\\alpha$的极大，即是关于对偶问题的最优化问题。经过上面一个步骤的求w和b，得到的拉格朗日式子已经没有了变量w,b，只有$\\alpha$。从上面的式子得到：\n",
    "$$\\max\\limits_{\\alpha}\\sum_{i=1}^{n}\\alpha_i-\\frac{1}{2}\\sum_{i,j=1}^{n}\\alpha_i\\alpha_jy_iy_j{x_i}^Tx_j$$\n",
    "$$s.t.,\\alpha_i>=0,i=1,...,n$$\n",
    "$$\\sum_{i=1}^{n}\\alpha_iy_i=0$$\n",
    "\n",
    "这样，求出了$\\alpha_i$，根据:$$w=\\sum_{i=1}^{n}\\alpha_iy_ix_i$$\n",
    "即可求出w，然后通过\n",
    "$$b^*=-\\frac{\\max_{i:y^i = -1}w^Tx^i+\\min_{i:y^i = 1}w^Tx^i}{2}$$\n",
    "即可求出b，最终得出分离超平面和分类决策函数。  \n",
    "\n",
    "\n",
    "在求得$L(w,b,\\alpha)$关于w和b最小化，以及对$\\alpha$的极大之后，最后一步可以利用SMO算法求解对偶问题中的拉格朗日乘子$\\alpha$。\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UPMXXwsZpDwn"
   },
   "source": [
    "**在我们刚开始讨论支持向量机时，我们就假定数据是线性可分的，也就是我们可以找到一个可行的超平面将数据完全分开。但是如果数据有噪音，而不是因为数据本身不是非线性结构。对于这种偏离正常位置很远的数据点，我们称之为outlier。**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "DLUOyOd1pDwp"
   },
   "source": [
    "**五 使用松弛变量处理outliers方法**  \n",
    "\n",
    "在原先的SVM模型中，outlier的存在可能造成很大的影响，因为超平面本身就是只有少数几个support vector组成，如果这些support vector里又存在outlier的话，其影响就很大了。例如下图：\n",
    "![4.png](image/4.png)\n",
    "\n",
    "用黑圈圈起来的那个蓝点是一个 outlier ，它偏离了自己原本所应该在的那个半空间，如果直接忽略掉它的话，原来的分隔超平面还是挺好的，但是由于这个 outlier 的出现，导致分隔超平面不得不被挤歪了，变成途中黑色虚线所示（这只是一个示意图，并没有严格计算精确坐标），同时 margin 也相应变小了。当然，更严重的情况是，如果这个 outlier 再往右上移动一些距离的话，我们将无法构造出能将数据分开的超平面来。  \n",
    "\n",
    "为了处理这种情况，SVM 允许数据点在一定程度上偏离一下超平面。例如上图中，黑色实线所对应的距离，就是该 outlier 偏离的距离，如果把它移动回来，就刚好落在原来的超平面蓝色间隔边界上，而不会使得超平面发生变形了。  \n",
    "\n",
    "我们原来的约束条件变成了：\n",
    "$$y_i(w^Tx_i+b)>=1,i=1,...,n$$\n",
    "现在考虑outlier的问题，约束条件变成了：\n",
    "$$y_i(w^Tx_i+b)>=1-\\varepsilon_i,i=1,...n$$\n",
    "\n",
    "其中$\\varepsilon_i>=0$称为松弛变量，对应数据点$x_i$允许偏离的function margin的量。当然，如果我们运行$\\varepsilon_i$任意大的话，那任意的超平面都是符合条件的了。所以，我们在原来的目标函数后面加上一项，使得这些$\\varepsilon_i$的总和也要最下：\n",
    "$$\\min\\frac{1}{2}{\\parallel w\\parallel}^2+C\\sum_{i=1}^{n}\\varepsilon_i$$\n",
    "\n",
    "其中C是一个参数，用于控制目标函数中两项(“寻找margin最大的超平面和保证数据点偏差量最小”）之间的权重。注意，其中$\\varepsilon$是需要优化的变量之一，而C是一个事先确定好的常量。完整地写出来是这个样子：\n",
    "$$\\min\\frac{1}{2}{\\parallel w\\parallel}^2+C\\sum_{i=1}^{n}\\varepsilon_i$$\n",
    "$$s.t\\ y_i(w^Tx_i+b)>=1-\\varepsilon_i,i=1,...n$$\n",
    "$$\\varepsilon_i>=0,i=1,...,n$$\n",
    "\n",
    "用之前的方法将约束条件加入到目标函数中，得到的新的拉格朗日函数，如下所示：\n",
    "$$L(w,b,\\varepsilon,\\alpha,\\gamma)=\\frac{1}{2}{\\parallel w\\parallel}^2+C\\sum_{i=1}^{n}\\varepsilon_i-\\sum_{i=1}^{n}\\alpha_i{\\lgroup}y_i\\left(w^Tx_i+b\\right)-1+\\varepsilon_i\\rgroup-\\sum_{i=1}^{n}\\gamma_i\\varepsilon_i$$\n",
    "\n",
    "分析方法和前面一样，转换为另一个问题后，我们先让L针对$w,b和\\varepsilon$最小化：\n",
    "$$\\frac{{\\partial}L}{\\partial w}=0\\Rightarrow w=\\sum_{i=1}{n}\\alpha_iy_ix_i$$\n",
    "\n",
    "$$\\frac{{\\partial}L}{\\partial{b}}=0\\Rightarrow\\sum_{i=1}^{n}\\alpha_iy_i=0$$\n",
    "\n",
    "$$\\frac{{\\partial}L}{\\partial\\varepsilon_i}=0{\\Rightarrow}C-\\alpha_i-\\gamma_i=0,i=1,...,n$$\n",
    "将$w$带回L并化简，得到和原来一样的目标函数：\n",
    "$$\\max\\limits_{\\alpha}\\sum_{i=1}^{n}\\alpha_i-\\frac{1}{2}\\sum_{i,j=1}^{n}\\alpha_i\\alpha_jy_iy_j<x_i,x_j>$$\n",
    "$$s.t.\\  0<=\\alpha_i<=C,i=1,...,n$$\n",
    "$$\\sum_{i=1}^{n}\\alpha_iy_i=0$$\n",
    "可以看到唯一区别就是现在dual variable $\\alpha$多了一个上限C。  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "3WNvki-1pDwq"
   },
   "source": [
    "**写到这里，可以做个小结，不准确的说，SVM它本质上即是一个分类方法，用$w^Tx+b$定义分类函数，于是求w、b为寻找最大间隔。引出$\\frac{1}{2}{\\parallel w \\parallel}^2$,继而引出拉格朗日因子，转化为对拉格朗日乘子$\\alpha$的求解（求解过程会涉及一系列最优化或凸二次规划等问题），如此，求w、b与求$\\alpha$等价，而$\\alpha$的求解可以用一种快速学习算法SMO。**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Yrh_E5n_pDwq"
   },
   "source": [
    "**六 核函数** \n",
    "\n",
    "**在以上的问题中，我们都假设数据本身都是线性可分的，事实上，大部分时候数据并不是线性可分的，这个时候满足这样的条件的超平面就根本不存在。在前面，我们已经了解到SVM处理线性可分的情况，那对于非线性的数据SVM如何处理？这时候SVM的处理方法是选择一个核函数K。通过将数据映射到高纬空间，来解决在原始空间中线性不可分的问题。**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "BowqeBx7pDwr"
   },
   "source": [
    "\n",
    "具体来说，在线性不可分的情况下，支持向量机首先在低维空间中完成计算，然后通过核函数将输入空间映射到高维特征空间，最终在高维特征空间中构造出最优分离超平面，从而把平面上本身不好分的非线性数据分开。如图所示，一维数据在二维空间无法划分，从而映射到三维空间里划分：\n",
    "![7.png](image/7.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Ob7MysdepDws"
   },
   "source": [
    "那么kernel是如何达到这个效果的呢？对于一个2维空间数据点v = (x, y)，要把它映射到3维空间，其中一种映射关系是：$p(x, y) = (x^2, \\sqrt 2xy, y^2)$。假如有任意两个数据点：$v_1=(x_1,y_1)$, $v_2=(x_2,y_2)$，我们可以直接计算它们对应向量的内积为：$$< p(v_1), p(v_2) > = < (x_1^2, \\sqrt 2x_1y_1, y_1^2), (x_2^2, \\sqrt 2x_2y_2, y_2^2) >$$<br>很明显，这是一个3维运算。假如3维还是无法线性区分，要映射到N维去，那这里就是N维运算，N越大计算量越大。有没有办法能够降低这个计算量呢？我们来展开推导一下：\n",
    "<br><br>$$< p(v_1), p(v_2) > = < (x_1^2, \\sqrt 2x_1y_1, y_1^2), (x_2^2, \\sqrt 2x_2y_2, y_2^2) > = (x_1x_2 + y_1y_2)^2 = (<v_1, v_2>)^2$$\n",
    "<br><br>\n",
    "经过推导可以看到，两个数据点在映射后的向量内积等于映射前向量内积的平方。如果我们引入核函数：$K(v_1, v_2) = (<v_1, v_2>)^2$，那么就可以通过核函数的计算来等价于映射后的向量内积，实现了高维向量运算转换为低维向量计算（本例中是2维向量运算代替了3维向量运算）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "N7fc9GEupDws"
   },
   "source": [
    "核函数相当于把原来的分类函数：\n",
    "$$f(x)=\\sum_{i=1}^{n}\\alpha_iy_i<x_i,x>+b$$\n",
    "映射成：\n",
    "$$f(x)=\\sum_{i=1}^{n}\\alpha_iy_i<\\phi(x_i),\\phi(x)>+b$$\n",
    "而其中的$\\alpha$可以通过求解如下的dual问题而得到的：\n",
    "$$\\max\\limits_{\\alpha}\\sum_{i=1}^{n}{\\alpha_i}-\\frac{1}{2}\\sum_{i,j=1}^{n}{\\alpha_i}{\\alpha_j}y_iy_j<\\phi(x_i),\\phi(x_j)>$$\n",
    "$$s.t.,\\alpha_i>=0,i=1,...,n$$\n",
    "$$\\sum_{i=1}^{n}\\alpha_iy_i=0$$\n",
    "举个简单的例子，设两个向量$x_1={(\\eta_1,\\eta_2)}^T和x_2={(\\zeta_1.\\zeta_2)}^T，\\phi（）为映射关系。$映射后的内积为：\n",
    "$$<\\phi(x_1),\\phi(x_2)>=\\eta_1\\zeta_1+\\eta_1^2\\zeta_1^2+\\eta_2\\zeta_2+\\eta_2^2\\zeta_2^2+\\eta_1\\eta_2\\zeta_1\\zeta_2$$\n",
    "另外，我们注意到：\n",
    "$${(<x_1,x_2>+1)}^2=2\\eta_1\\zeta_1+\\eta_1^2\\zeta_1^2+2\\eta_2\\zeta_2+\\eta_2^2\\zeta_2^2+2\\eta_1\\eta_2\\zeta_1\\zeta_2+1$$\n",
    "二者有很多相似的地方，实际上，我们只需要把某几个维度线性缩放一下，然后再加上一个常数维度，具体来说，上面这个式子的计算结果实际上和映射$\\varphi(x_1,x_2)={(\\sqrt2x_1,x_1^2+\\sqrt2x_2,x_2^2,\\sqrt2x_1x_2,1)}^T$之后的内存$<\\varphi(x_1),\\varphi(x_2)>$的结果是相等的。区别在于一个是是映射到高维空间中，然后根据内积的公式进行计算；而另一个则是直接在原来的低维空间中进行计算，而不需要显示地写出映射后的结果。  \n",
    "\n",
    "我们把这里的计算两个向量在隐式映射过后的空间中的内积的函数叫做核函数，核函数能简化映射空间的内积运算。现在我们的分类函数为：\n",
    "$$f(x)=\\sum_{i=1}^{n}\\alpha_iy_iK<x_i,x>+b$$\n",
    "而其中的$\\alpha$可以通过求解如下的dual问题而得到的：\n",
    "$$\\max\\limits_{\\alpha}\\sum_{i=1}^{n}{\\alpha_i}-\\frac{1}{2}\\sum_{i,j=1}^{n}{\\alpha_i}{\\alpha_j}y_iy_jK(x_i,x_j)$$\n",
    "$$s.t.,\\alpha_i>=0,i=1,...,n$$\n",
    "$$\\sum_{i=1}^{n}\\alpha_iy_i=0$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "S1nogf__pDwt"
   },
   "source": [
    "**七 SMO算法**  \n",
    "\n",
    "在上面我们得到了最后的目标函数：\n",
    "$$\\max\\limits_{\\alpha}\\sum_{i=1}^{n}\\alpha_i-\\frac{1}{2}\\sum_{i,j=1}^{n}\\alpha_i\\alpha_jy_iy_j<x_i,x_j>$$\n",
    "$$s.t.,0<=\\alpha_i<=C,i=1,...,n$$\n",
    "$$\\sum_{i=1}^{n}\\alpha_iy_i=0$$\n",
    "\n",
    "等价于求：\n",
    "$$\\min\\limits_\\alpha\\Psi\\left(\\vec{\\alpha}\\right)=\\min\\limits_{\\alpha}\\frac{1}{2}\\sum_{i=1}^{n}\\sum_{j=1}^{n}y_iy_jK\\left<x_i,x_j\\right>\\alpha_i\\alpha_j-\\sum_{i=1}^{n}\\alpha_i$$\n",
    "$$0<=\\alpha_i<=C,i=1,...,n$$\n",
    "$$\\sum_{i=1}^{n}y_i\\alpha_i=0$$\n",
    "**这里得到的min函数与我们之前的max函数实质是一样的。**    \n",
    "\n",
    "下面要解决的问题是：在$\\vec{\\alpha}={\\alpha_1,\\alpha_2,...\\alpha_n}$上求解目标函数的最小值。为了求解这些乘子，每次从中任意抽取两个乘子$\\alpha_1$和$\\alpha_2$，然后固定$\\alpha_1$和$\\alpha_2$以外的其它乘子${\\alpha_3,...,\\alpha_n}$，使得目标函数只是关于$\\alpha_1$和$\\alpha_2$的函数。这样，不断的从一堆乘子中任意抽取两个求解，不断迭代求解子问题，最终达到求解原问题的目的。\n",
    "而原对偶问题的子问题的目标函数可以表达为：\n",
    "$$\\Psi=\\frac{1}{2}K_{11}{\\alpha_1}^2+\\frac{1}{2}K_{22}{\\alpha_2}^2+sK_{12}\\alpha_1\\alpha_2+y_1{\\alpha}_1\\nu_1+y_2\\alpha_2\\nu_2-\\alpha_1-\\alpha_2+\\Psi_{constant}$$\n",
    "其中:\n",
    "$$K_{ij}=K(x_i,x_j)$$\n",
    "$$\\nu_i=\\sum_{j=3}^{n}y_j{\\alpha_j}^*K_{ij}=u_i+b^*-y_1{\\alpha_1}^*K_{1i}-y_2{\\alpha_2}^*K_{2i}$$\n",
    "$$u_i=w^Tx_i+b$$\n",
    "\n",
    "为了解决这个子问题，首要问题便是每次如何选取$\\alpha_1$和$\\alpha_2$。实际上，其中一个乘子是违反KKT条件最严重的，另外一个乘子则由另一个约束条件选取。  \n",
    "根据KKT条件可以得出目标函数中$\\alpha_i$取值的意义：\n",
    "$$\\alpha_i=0{\\Leftrightarrow}y_iu_i>=1$$\n",
    "$$0<\\alpha_i<C{\\Leftrightarrow}y_iu_i=1$$\n",
    "$$\\alpha_i=C{\\Leftrightarrow}y_iu_i<=1$$\n",
    "这里的$\\alpha_i$还是拉格朗日乘子：  \n",
    "1.对于第一种情况，表明$\\alpha_i$是正常分类，在间隔边界内部（我们知道正确分类的点$y_i*f(x_i)>=0$）  \n",
    "2.对于第二种情况，表明了$\\alpha_i$是支持向量，在间隔边界上；  \n",
    "3.对于第三种情况，表明了$\\alpha_i$是在两条间隔边界之间；  \n",
    "\n",
    "而最优解需要满足KKT条件，既满足3个条件都得满足，以下几种情况出现将会出现不满足：  \n",
    "$y_iu_i$<=1但是$\\alpha_i$<C则是不满足的,而原本$\\alpha_i$<C则是不满足的，而原本$\\alpha_i$=C  \n",
    "$y_iu_i$>=1但是$\\alpha_i$>0则是不满的，而原本$\\alpha_i$=0  \n",
    "$y_iu_i$=1但是$\\alpha_i$=0或者$\\alpha_i$=C则表明不满足，而原本应该是0<$\\alpha_i$<C\n",
    "\n",
    "也就是说，如果存在不满足KKT条件的$\\alpha_i$，那么需要更新这些$\\alpha_i$，这是第一个约束条件。此外，更新的同时还要受到第二个约束条件的限制，即：\n",
    "$$\\sum_{i=1}^{n}y_i\\alpha_i=0$$\n",
    "因此，如果假设选择的两个乘子$\\alpha_1$和$\\alpha_2$，它们在更新之前分别是${\\alpha_1}^{old}$、${\\alpha_2}^{old}$,更新之后分别是${\\alpha_1}^{new}$、${\\alpha_2}^{new}$,那么更新前后的值需要满足以下等式才能保证和为0的约束：\n",
    "$${\\alpha_1}^{new}y_1+{\\alpha_2}^{new}y_2={\\alpha_1}^{old}y_1+{\\alpha_2}^{old}y_2=\\zeta$$\n",
    "其中$\\zeta$是常数。\n",
    "两个因子不好同时求解，所以可先求第二个乘子$\\alpha_2$的解（${\\alpha_2}^{new}$）,得到$\\alpha_2$的解之后，再利用$\\alpha_2$的解表示$\\alpha_1$的解（${\\alpha_1}^{new}$）  \n",
    "为了求解${\\alpha_2}^{new}$,得先确定${\\alpha_2}^{new}$取值范围。假设它的上下边界分别为H和L，那么有：\n",
    "$$L<={\\alpha_2}^{new}<=H$$\n",
    "接下来，综合$0<=\\alpha_i<=C,i=1,...,n和{\\alpha_1}^{new}y_1+{\\alpha_2}^{new}y_2={\\alpha_1}^{old}y_1+{\\alpha_2}^{old}y_=\\zeta$这两个约束条件，求取${\\alpha_2}^{new}$值范围。  \n",
    "当$y_1!=y_2$，根据${\\alpha_1}^{new}y_1+{\\alpha_2}^{new}y_2={\\alpha_1}^{old}y_1+{\\alpha_2}^{old}y_=\\zeta$可得${\\alpha_1}^{old}-{\\alpha_2}^{old}=\\zeta$,所以$L=\\max(0,-\\zeta),H=\\min(C,C-\\zeta)$如下图所示：\n",
    "![5.png](image/5.png)\n",
    "当$y_1=y_2$时，同样根据${\\alpha_1}^{new}y_1+{\\alpha_2}^{new}y_2={\\alpha_1}^{old}y_1+{\\alpha_2}^{old}y_=\\zeta$可得：${\\alpha_1}^{old}+{\\alpha_2}^{old}=\\zeta$,所以有$L=\\max(0,\\zeta-C),H=\\min(C,\\zeta)$,如下图所示：\n",
    "![6.png](image/6.png)\n",
    "如此，根据$y_1$和$y_2$异号或同号，可得出${\\alpha_2}^{new}$的上下界分别为：\n",
    "$$L=\\max(0,-\\zeta),H=\\min(C,C-\\zeta)  ify_1 != y_2$$\n",
    "$$L=\\max(0,\\zeta-C),H=\\min(C,\\zeta)   if y_1 = y_2$$\n",
    "\n",
    "回顾下第二个约束条件${\\alpha_1}^{new}y_1+{\\alpha_2}^{new}y_2={\\alpha_1}^{old}y_1+{\\alpha_2}^{old}y_=\\zeta$,令上式两边分别乘以$y_1$，可得$\\alpha_1+s\\alpha_2={\\alpha_1}^*+s{\\alpha_2}^*=w$,其中:\n",
    "$$w=-y_1\\sum_{i=3}^{n}y_i{\\alpha_i}^*$$\n",
    "因此$\\alpha_1$可以用$\\alpha_2$表示，$\\alpha_1=w-s\\alpha_2$,从而把子问题的目标函数转换为只含$\\alpha_2$的问题：\n",
    "$$\\Psi=\\frac{1}{2}K_{11}{(w-s\\alpha_2)}^2+\\frac{1}{2}K_{22}{\\alpha_2}^2+sK_{12}(w-s\\alpha2)\\alpha_2+y_1(w-s\\alpha_2)\\nu_1-w+s\\alpha_2+y_2\\alpha_2\\nu_2-\\alpha_2+\\Psi_{constant}$$\n",
    "对$\\alpha_2$求导可得：\n",
    "$$\\frac{\\mathrm{d}\\Psi}{\\mathrm{d}\\alpha_2}=-sK_{11}(w-s\\alpha_2)+K_{22}\\alpha_2-K_{12}\\alpha_2+sK_{12}(w-s\\alpha_2)-y_2\\nu_1+s+y_2\\nu_2-1=0$$\n",
    "\n",
    "化简如下:\n",
    "$$\\alpha2(K_{11}+K_{22}-2K_{11})=s(K_{11}-K_{12})w+y_2(\\nu_1-\\nu_2)+1-s$$\n",
    "$$K_{ij}=K(x_i,x_j)$$\n",
    "然后将$s=y_1*y_2$、$\\alpha_1+s\\alpha_2={\\alpha_1}^*+s{\\alpha_2}^*=w$和$\\nu_i=\\sum_{j=3}^{n}y_j{\\alpha_j}^*K_{ij}=u_i+b^*-y_1{\\alpha_1}^*K_{1i}-y_2{\\alpha_2}^*K_{2i}$代入上式可得：\n",
    "$${\\alpha_2}^{new,wnc}(K_{11}+K_{22}-2K_{12})={\\alpha_2}^{old}(K_{11}+K_{22}-2K_{12})+y_2(u_1-u_2+y_2-y_1)$$\n",
    "\n",
    "令$E_i=u_i-y_i$(表示预测值与真实值之差),$\\eta=K<x_1,x_1)+K(x_2,x_2)-2K(x_1,x_2)$上式两边同时除以$\\eta$，得到一个关于单变量$\\alpha_2$的解：\n",
    "$${\\alpha_2}^{new,wnc}={\\alpha_2}^{old}+\\frac{y_2(E_1-E_2)}{\\eta}$$\n",
    "\n",
    "这个解没有考虑约束条件$0<=\\alpha_2<=C$。考虑约束条件经过剪辑$\\alpha_2^{new}$的解为：  \n",
    "1  ${\\alpha_2}^{new,wnc}>H$\n",
    "$${\\alpha_2}^{new}=H$$\n",
    "2  $L<={\\alpha_2}^{new,wnc}<=H$\n",
    "$${\\alpha_2}^{new}={\\alpha_2}^{new,wnc}$$\n",
    "3  ${\\alpha_2}^{new,wnc}<L$\n",
    "$${\\alpha_2}^{new}=L$$\n",
    "求出了${\\alpha_2}^{new}后，便可求出\\alpha_1^{new}, 得\\alpha_1^{new}=\\alpha_1^{old}+y_1y_2(\\alpha_2^{old}-\\alpha_2^{new})$  \n",
    "如何选择乘子$\\alpha_1和\\alpha_2$呢？  \n",
    "对于$\\alpha_1,即第一个乘子,可以通过刚刚说的那三种不满足KKT的条件来找$；\n",
    "而对于第二个乘子$\\alpha_2可以寻找满足条件:\\max|E_i-Ej|的乘子。$  \n",
    "而b在满足下述条件下更新b：\n",
    "\n",
    "1  $0<\\alpha_1^{new}<C$\n",
    "$$b=b_1$$\n",
    "2  $0<\\alpha_2{new}<C$\n",
    "$$b=b_2$$\n",
    "3  $otherwise$\n",
    "$$b=\\frac{b_1+b_2}{2}$$\n",
    "\n",
    "$$b_1^{new}=b^{old}-E_1-y_1(\\alpha_1^{new}-\\alpha_1^{old}k(x_1,x_1)-y_2(\\alpha_2^{new}-\\alpha_2^{old})k(x_1,x_2)$$\n",
    "\n",
    "$$b_2^{new}=b^{old}-y_1(\\alpha_1^{new}-\\alpha_1^{old})k(x_1,x_2)-y_2(\\alpha_2^{new}-\\alpha_2^{old})k(x_2,x_2)-E_2$$\n",
    "且每次更新完两个乘子的优化后,都需要再重新计算b,以及对应的$E_i$值。  \n",
    "最后更新所有的$\\alpha_i,y和b,这样模型就训练出来了,从而即可求出我们开头提出的分类函数:$  \n",
    "$$f(x)=\\sum_{i=1}^{n}\\alpha_iy_i<x_i,x>+b$$\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "lG2bWxpBpDwu"
   },
   "source": [
    "**现在我们来总结下SMO算法的步骤**  \n",
    "1 第一步选取一对$\\alpha_i和\\alpha_j，选取方法使用启发式方法$。  \n",
    "2 第二步，固定$除\\alpha_i和\\alpha_j之外的其它参数,确定W极值条件下的\\alpha_i,\\alpha_j由\\alpha_i表示。$  \n",
    "3 第三步，更新乘子，选取乘子的方式如下：\n",
    "$$先扫描所有乘子，把第一个违反KKT条件的作为更新对象，令为\\alpha_1$$\n",
    "$在所有不违反KKT条件的乘子中，选择使|E_1-E_2|最大的\\alpha_2进行更新，使得能最大限度增大目标函数的值。$  \n",
    "\n",
    "4 最后，每次更新完两个乘子的优化后，都需要再重新计算b,以及对应的$E_i$值。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "CK-D0y0WpDwu"
   },
   "source": [
    "**经过前面几节的铺垫，我们了解SVM对偶形式的求解，现在我们就来用代码实现SVM。**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "yLfY5dGGpDwv"
   },
   "source": [
    "**任务一 从DataSet.txt中导入数据，获得训练集以及标签。**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "0aPiRpNPpDwv"
   },
   "source": [
    "定义函数LoadData(filename),参数为文件名，返回训练数据集以及标签。数据集由两个特征$X_1和X_2$构成"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "15Vs1R_npDww"
   },
   "outputs": [],
   "source": [
    "#导入相应的库包\n",
    "from numpy import *\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\",category=DeprecationWarning)  #消除警告"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 137
    },
    "colab_type": "code",
    "id": "-Kzw5gSVpDw1",
    "outputId": "491c405b-be51-4910-f359-cf3d3d946f32",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def LoadData(filename):\n",
    "    data = []\n",
    "    label = []\n",
    "    with open(filename) as f:                               \n",
    "        for line in f.readlines():     #按行读取\n",
    "            ### START THE CODE ###\n",
    "            line = line.split()                             #消除分隔符\n",
    "            data.append([float(line[0]), float(line[1])])   #将特征存放到Data中\n",
    "            label.append(float(line[2]))                    #将标签存放到Label中       \n",
    "            ### END THE CODE ###\n",
    "    return data,label"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "BtUABdNjpDw9"
   },
   "source": [
    "获取训练集，数据和标签"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "o_x1F7IGpDw-"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TrainData =  [[3.542485, 1.977398], [3.018896, 2.556416], [7.55151, -1.58003]]\n",
      "TrainLabel =  [-1.0, -1.0, 1.0]\n"
     ]
    }
   ],
   "source": [
    "TrainData, TrainLabel = LoadData('DataSet.txt')\n",
    "print (\"TrainData = \",TrainData[:3])\n",
    "print (\"TrainLabel = \",TrainLabel[:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "6ZyvZj2XpDxC"
   },
   "source": [
    "输出：\n",
    "\n",
    "TrainData = [[3.542485, 1.977398], [3.018896, 2.556416], [7.55151, -1.58003]]\n",
    "\n",
    "TrainLabel = [-1.0, -1.0, 1.0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "NrEF5RNepDxD"
   },
   "source": [
    "**定义所需操作的数据结构DataOp如下**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "AiHiHOKnpDxD"
   },
   "outputs": [],
   "source": [
    "class DataOp(object):\n",
    "    def __init__(self,data,label,C,toler):      #定义构造函数\n",
    "        self.X = data                           #数据\n",
    "        self.label = label                      #标签\n",
    "        self.C = C                              #松弛变量\n",
    "        self.tol = toler                        #容忍度\n",
    "        self.m = shape(data)[0]                 #特征向量的第一个维度\n",
    "        self.alpha = mat(zeros((self.m,1)))     #Alpha个数初始化\n",
    "        self.b = 0                              #步长\n",
    "        self.Cache = mat(zeros((self.m,2)))     #第一列给出是否有效 第二列给出的是实际的E值       "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "QaZgRDvKpDxI"
   },
   "source": [
    "**我们利用上述定义的数据结构来表达我们整个训练模型的过程需要的参数以及数据，初始化一个DataOp对象**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "3ZEEaVB4pDxJ"
   },
   "outputs": [],
   "source": [
    "oS = DataOp(mat(TrainData), mat(TrainLabel).transpose(), 0.6, 0.001)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "O2LKy9dGpDxN"
   },
   "source": [
    "**在选择乘子过程中，我们需要选中两个不同的乘子，所以当我们固定了其中一个乘子，就需要选出不同于第一个乘子的第二个乘子。我们定义一个函数SelectAlpha来实现这个过程。**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "u7G4AZ5wpDxO"
   },
   "source": [
    "函数：SelectAlpha(i,m)  \n",
    "作用：随机选择一个整数j,(0<=j<=m-1 && j!=i)  \n",
    "参数：i第一个乘子的下标，m所有alpha的个数  \n",
    "返回：一个随机选择不同于i的下标j"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ZlZFcerwpDxO"
   },
   "outputs": [],
   "source": [
    "def  SelectAlpha(i,m):\n",
    "    j = i\n",
    "    while (j == i):\n",
    "        j = int(random.uniform(0,m))  \n",
    "    return j"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "XRCChWvOpDxS"
   },
   "source": [
    "**任务二 调整alpha的值**    \n",
    "\n",
    "根据如下规则来对我们计算出的alpha进行调整。  \n",
    "1  ${\\alpha_2}^{new,wnc}>H$\n",
    "$${\\alpha_2}^{new}=H$$\n",
    "2  $L<={\\alpha_2}^{new,wnc}<=H$\n",
    "$${\\alpha_2}^{new}={\\alpha_2}^{new,wnc}$$\n",
    "3  ${\\alpha_2}^{new,wnc}<L$\n",
    "$${\\alpha_2}^{new}=L$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "lM-zO8kUpDxV"
   },
   "source": [
    "函数：ResetAlpha(Alphaj,low,high)\n",
    "\n",
    "作用：调整Alphaj(即$\\alpha_j$)的值，使得low<=Alphaj<=high，调整幅度尽可能小\n",
    "\n",
    "参数：Alphaj 目标值， low 最小值， high最大值\n",
    "\n",
    "返回：调整后的Alphaj"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "OZJsY3hnpDxW"
   },
   "outputs": [],
   "source": [
    "def ResetAlpha(Alphaj,low,high):\n",
    "    ### STARD CODE HERE ###\n",
    "    if high < Alphaj:\n",
    "        Alphaj = high\n",
    "    elif Alphaj < low:\n",
    "        Alphaj = low\n",
    "    else:\n",
    "        Alphaj = Alphaj\n",
    "    ### END CODE HERE ###\n",
    "    return Alphaj"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "aV4xTp6hpDxc"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b =  11\n",
      "c =  8\n"
     ]
    }
   ],
   "source": [
    "a = 10\n",
    "b = ResetAlpha(a,11,20)\n",
    "c = ResetAlpha(a,1,8)\n",
    "print(\"b = \", b)\n",
    "print(\"c = \", c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "VOYFSGB_pDxf"
   },
   "source": [
    "输出：  \n",
    "b =  11  \n",
    "c =  8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "cSzXVhp0pDxf"
   },
   "source": [
    "**任务三 上述原理过程中，需要计算真实值与预测值之间的误差,定义一个函数ComputeEk。**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "PGz3rdNhpDxg"
   },
   "source": [
    "函数 ComputeEk(os,k)\n",
    "\n",
    "作用：求Ek误差 = 预测值 - 真实值。\n",
    "真实值即样本标签，以下公式计算预测值$f(x)=\\sum_{i=1}^{n}\\alpha_iy_i<x_i,x>+b$\n",
    "\n",
    "参数：os DataOp对象，k 具体的某一行\n",
    "\n",
    "返回：预测值与真实结果对比，计算误差Ek  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "y9lyiqmHpDxh"
   },
   "outputs": [],
   "source": [
    "def ComputeEk(os,k):\n",
    "    PredictK = float(multiply(os.alpha,os.label).T * (os.X*os.X[k,:].T)) + os.b\n",
    "    ### START CODE HERE ###\n",
    "    Ek = PredictK - os.label[k, 0]\n",
    "    ### END CODE HERE ###\n",
    "    return Ek"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "VJQLMOWjpDxk"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ek1 =  -1.0\n",
      "Ek2 =  1.0\n"
     ]
    }
   ],
   "source": [
    "Ek1 = ComputeEk(oS,25)\n",
    "Ek2 = ComputeEk(oS,30)\n",
    "print (\"Ek1 = \", Ek1)\n",
    "print (\"Ek2 = \", Ek2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "T_Ya1E9qpDxn"
   },
   "source": [
    "输出：\n",
    "\n",
    "Ek1 = -1.0\n",
    "\n",
    "Ek2 = 1.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "7CDrjx_epDxo"
   },
   "source": [
    "**任务四 选取最大$|E_i-E_j|$最大的j，并返回j以及$E_j$**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "cFfpDHdopDxq"
   },
   "source": [
    "函数：SelectMaxJ(i,oS,Ei)    \n",
    "\n",
    "作用：返回差值最大的j和对应的Ej，选择第二个（内循环）值以保证每次优化中采用最大步长。\n",
    "\n",
    "这里的目标是选择合适的第二个alpha值以保证每次优化中采用最大步长\n",
    "\n",
    "该函数的误差与第一个alpha值Ei和下标i有关。\n",
    "\n",
    "参数：\n",
    "\n",
    "i    具体的第i行\n",
    "\n",
    "oS   DataOp对象\n",
    "\n",
    "Ei   预测值与真实值对比，计算Ei\n",
    "\n",
    "返回：\n",
    "\n",
    "j    随机选出的第j行\n",
    "\n",
    "Ej   预测结果与真实值对比，计算误差Ej"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "W-bHozLNpDxr"
   },
   "outputs": [],
   "source": [
    "def SelectMaxj(i,oS,Ei):\n",
    "    MaxK = -1              #保存最大下标值\n",
    "    MaxDeltaE = 0          #保存最大步长\n",
    "    Ej = 0\n",
    "    oS.Cache[i] = [1,Ei]   #首先将输入值Ei在缓存中设置为有效的。这里意味着它已经计算好了\n",
    "    List = nonzero(oS.Cache[:,0].A)[0]\n",
    "    if (len(List)) > 1:               # 在所有的值上进行循环，并选择使得改变最大的那个值\n",
    "        for k in List:\n",
    "            if k == i:                \n",
    "                continue             #不计算\n",
    "            ### START CODE HERE ###\n",
    "            else:\n",
    "                DeltaE = abs(ComputeEk(oS, k) - Ei)  # 计算DeltaE\n",
    "                if DeltaE > MaxDeltaE:  # DeltaE > MaxDeltaE , 则进行更新\n",
    "                    MaxK = k  # 更新下标\n",
    "                    MaxDeltaE = DeltaE  # 最大值更新\n",
    "                    Ej = ComputeEk(oS, k)  # 替换Ej\n",
    "            ### END CODE HERE ###\n",
    "        return MaxK, Ej\n",
    "    else:                                #如果是第一次循环，则随机选择一个alpha\n",
    "        j = SelectAlpha(i,oS.m)    \n",
    "        Ej = ComputeEk(oS,j)\n",
    "    return j,Ej"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Ao9--XZQpDxu"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testj =  2\n",
      "TestEj =  -1.0\n"
     ]
    }
   ],
   "source": [
    "Data =  [[3.542485, 1.977398], [3.018896, 2.556416], [7.55151, -1.58003], [2.114999, -0.004466], [8.127113, 1.274372]]\n",
    "Label =  [-1.0, -1.0, 1.0, -1.0, 1.0]\n",
    "TestOs = DataOp(mat(Data),mat(Label).transpose(),0.6,0.001)\n",
    "TestEi = ComputeEk(TestOs,0)\n",
    "TestOs.Cache[1] = [1,ComputeEk(TestOs,1)]\n",
    "TestOs.Cache[2] = [1,ComputeEk(TestOs,2)]\n",
    "TestOs.Cache[3] = [1,ComputeEk(TestOs,3)]\n",
    "TestOs.Cache[4] = [1,ComputeEk(TestOs,4)]\n",
    "Testj,TestEj = SelectMaxj(0,TestOs,TestEi)\n",
    "\n",
    "print (\"Testj = \",Testj)\n",
    "print (\"TestEj = \", TestEj)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "-hRyu9NtpDxy"
   },
   "source": [
    "输出：\n",
    "\n",
    "j = 2\n",
    "\n",
    "Ej = -1.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "3_DzjQLdpDxy"
   },
   "source": [
    "**任务五 计算误差值并存入缓存，在对alpha值进行优化之后会用到这个函数**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Z8FHqi7spDxz"
   },
   "source": [
    "函数：updateEk(oS,k)\n",
    "\n",
    "作用：计算误差值并存入缓存os.Cache，在对alpha值进行优化之后会用到这个函数\n",
    "\n",
    "参数：\n",
    "\n",
    "Os DataOpt对象\n",
    "\n",
    "k 某一列的行号\n",
    "\n",
    "返回：无\n",
    "\n",
    "例如某行为oS.Cache[k] = [1,Ek] 其中1表示有效。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Mra8qnZrpDx0"
   },
   "outputs": [],
   "source": [
    "def updataEk(oS,k):\n",
    "    ###START THE CODE ###\n",
    "    Ek = ComputeEk(oS, k)  \t# 计算Ek\n",
    "    oS.Cache[k] = [1, Ek]\t# 更新第k行的oS.Cache[k]\n",
    "    ###END THE CODE ###"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Nz17-TWjpDx2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TestOs.Cache[0] =  [[1. 1.]]\n",
      "TestOs.Cache[1] =  [[1. 1.]]\n",
      "TestOs.Cache[2] =  [[ 1. -1.]]\n"
     ]
    }
   ],
   "source": [
    "TestOs = DataOp(mat(Data),mat(Label).transpose(),0.6,0.001)\n",
    "updataEk(TestOs,0)\n",
    "updataEk(TestOs,1)\n",
    "updataEk(TestOs,2)\n",
    "print (\"TestOs.Cache[0] = \",TestOs.Cache[0])\n",
    "print (\"TestOs.Cache[1] = \",TestOs.Cache[1])\n",
    "print (\"TestOs.Cache[2] = \",TestOs.Cache[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "5SZyuzQMpDx6"
   },
   "source": [
    "输出： \n",
    "\n",
    "TestOs.Cache[0] =  [[1. 1.]]  \n",
    "\n",
    "TestOs.Cache[1] =  [[1. 1.]]  \n",
    "\n",
    "TestOs.Cache[2] =  [[1. -1.]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "og4COhRSpDx7"
   },
   "source": [
    "**SMO算法是通过一个外循环来选择第一个alpha值得，并且其选择过程会在两种方式之间交替：一种方式是在所有数据集上进行单遍扫描，另一种方式则是在非边界alpha中实现单遍扫描。而所谓非边界alpha指的就是那些不等于边界0或C的alpha的值。对整个数据集的扫描相当容易，而实现非边界alpha值得扫描时，首先需要建立这些alpha值的列表，然后再对这个表进行遍历。同时，该步骤会跳过那么已知的不会改变的alpha的值。\n",
    "在选择第一个alpha值后，算法会通过一个内循环来选择第二个alpha值。在优化过程中，会通过最大步长的方式来获得第二个alpha值。我们建立一个全局的缓存用于保存误差值，并从中选择使得步长最大的alpha值（Ei-Ej）**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "DsD7w0p4pDx7"
   },
   "source": [
    "首先我们来看实现内循环的代码，如何选择另外第二个alpha乘子。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "CDw4XlZRpDx8"
   },
   "source": [
    "函数：InsideCycle(i,oS)  \n",
    "\n",
    "作用：SMO算法内循环选择第二个alpha值\n",
    "\n",
    "参数：\n",
    "\n",
    "i    具体某一行\n",
    "\n",
    "oS   DataOp对象\n",
    "\n",
    "返回：\n",
    "\n",
    "0    找不到最优值\n",
    "\n",
    "1    找到了最优值，并且存储到oS.Cache中\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "RI7OmGBGpDx9"
   },
   "outputs": [],
   "source": [
    "def InsideCycle(i,oS):\n",
    "    Ei = ComputeEk(oS,i)   #求Ek误差\n",
    "    #约束条件（KKT条件是解决最优化问题时用到的一种方法。我们这里提到的最优化问题通常\n",
    "    #是指对于给定的某一函数，求其在指定作用域上的全局最小值\n",
    "    #0<=alpha[i]<=C,但由于0和C是边界值，我们无法进行优化，因为需要升高一个alpha和降低一个alpha。\n",
    "    #表示发生错误的概率：label[i]*Ei ,如果超出toler，才需要优化。至于正负号，考虑绝对值就行\n",
    "    \n",
    "    #检验训练样本(xi,yi)是否满足KKT条件\n",
    "    #yi*f(xi) >= 1 and alpha = 0 (outside the boundary)\n",
    "    #yi*f(xi) == 1 0<alpha<C     (on the boundary)\n",
    "    #yi*f(xi) <= 1 and alpha = C  (between the boundary)\n",
    "    \n",
    "    if ((oS.label[i] * Ei < -oS.tol) and (oS.alpha[i] < oS.C)) or ((oS.label[i] * Ei > oS.tol) and (oS.alpha[i] > 0)):\n",
    "        #选择最大的误差对应的j进行优化。\n",
    "        j,Ej = SelectMaxj(i,oS,Ei)\n",
    "        IOldAlpha = oS.alpha[i].copy()\n",
    "        JOldAlpha = oS.alpha[j].copy()\n",
    "        \n",
    "        #L 和 H将用于将alpha[j]调整到0-C之间。如果L == H，就不做任何改变，直接Return 0\n",
    "        if (oS.label[i] != oS.label[j]):\n",
    "            L = max(0,oS.alpha[j] - oS.alpha[i])\n",
    "            H = min(oS.C, oS.C + oS.alpha[j] - oS.alpha[i])\n",
    "        else:\n",
    "            L = max(0,oS.alpha[j] + oS.alpha[i] - oS.C)\n",
    "            H = min(oS.C, oS.alpha[j] + oS.alpha[i])\n",
    "        \n",
    "        if L == H:\n",
    "            #print (\"L == H\")\n",
    "            return 0\n",
    "        \n",
    "        #eva 是alpha[j]的最优修改量，如果eva==0，需要退出for循环当前迭代过程\n",
    "        eva = 2.0 * oS.X[i, :] * oS.X[j, :].T - oS.X[i, :] * oS.X[i, :].T - oS.X[j, :] * oS.X[j, :].T\n",
    "        if eva >= 0:\n",
    "            #print(\"eva >= 0\")\n",
    "            return 0\n",
    "        \n",
    "        #计算一个新的alpha[j]值\n",
    "        oS.alpha[j] -= oS.label[j] * (Ei-Ej) / eva\n",
    "        #并使用辅助函数，以及L和H对其进行调整\n",
    "        oS.alpha[j] = ResetAlpha(oS.alpha[j],L,H)\n",
    "        #更新缓存误差\n",
    "        updataEk(oS,j)\n",
    "        \n",
    "        #检查alpha[j]是否只是轻微的改变，如果是的话，就退出for循环\n",
    "        if (abs(oS.alpha[j] - JOldAlpha) < 0.00001):\n",
    "            return 0\n",
    "        \n",
    "        #然后alpha[i]和alpha[j]做同样的修改，虽然改变的大小一样，但是改变的方向相反\n",
    "        oS.alpha[i] += oS.label[j] * oS.label[i] * (JOldAlpha - oS.alpha[j])\n",
    "        #更新误差缓存\n",
    "        updataEk(oS,i)\n",
    "        \n",
    "        #在对alpha[i],alpha[j]进行优化之后，给这个两个alpha值设置一个常数b。\n",
    "        '''\n",
    "         w= Σ[1~n] ai*yi*xi => b = yj Σ[1~n] ai*yi(xi*xj)\n",
    "         所以：  b1 - b = (y1-y) - Σ[1~n] yi*(a1-a)*(xi*x1)\n",
    "         为什么减2遍？ 因为是 减去Σ[1~n]，正好2个变量i和j，所以减2遍\n",
    "        '''\n",
    "        b1 = oS.b - Ei - oS.label[i] * (oS.alpha[i] - IOldAlpha) * oS.X[i, :] * oS.X[i, :].T - oS.label[j] * (oS.alpha[j] - JOldAlpha) * oS.X[i, :] * oS.X[j, :].T\n",
    "        b2 = oS.b - Ej - oS.label[i] * (oS.alpha[i] - IOldAlpha) * oS.X[i, :] * oS.X[j, :].T - oS.label[j] * (oS.alpha[j] - JOldAlpha) * oS.X[j, :] * oS.X[j, :].T\n",
    "        if (0 < oS.alpha[i]) and (oS.C > oS.alpha[i]):\n",
    "            oS.b = b1\n",
    "        elif (0 < oS.alpha[j]) and (oS.C > oS.alpha[j]):\n",
    "            oS.b = b2\n",
    "        else:\n",
    "            oS.b = (b1+b2) / 2.0\n",
    "        return 1\n",
    "    else:\n",
    "        return 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "P1kK06YCpDyA"
   },
   "source": [
    "**接下来我们实现SMO算法的外循环，外循环的结束迭代条件是：迭代次数达到最大迭代次数 或者 循环遍历所有alpha后，没有alpha改变。**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "XJr-JCaNpDyB"
   },
   "source": [
    "函数：Smo(oS,IterStep）\n",
    "\n",
    "作用：SMO算法外循环，计算出拉格朗日乘子以及模型的常量b\n",
    "\n",
    "参数：\n",
    "\n",
    "oS DataOp对象  \n",
    "\n",
    "IterStep 退出前的最大循环次数\n",
    "\n",
    "返回：\n",
    "\n",
    "b       模型的常量值\n",
    "\n",
    "alpha   拉格朗日乘子"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "megAwOczpDyC"
   },
   "outputs": [],
   "source": [
    "def Smo(oS,IterStep):\n",
    "    iter = 0                #迭代次数\n",
    "    EntireSet = True         #是否遍历了没有遍历整个alpha值\n",
    "    AlphaChanged = 0          #alpha改变的次数\n",
    "    \n",
    "    #循环迭代结束 或者 循环遍历所有alpha后，AlphaChanged还是没变化\n",
    "    \n",
    "    while (iter < IterStep) and ((AlphaChanged > 0) or (EntireSet)):\n",
    "        AlphaChanged = 0\n",
    "        #当EntireSet = True or 非边界alpha对没有了；就开始寻找alpha对，然后决定是否else。\n",
    "        if EntireSet:\n",
    "            #在数据集上遍历所有可能的alpha\n",
    "            for i in range(oS.m):\n",
    "                #是否存在alpha对，存在就+1\n",
    "                AlphaChanged += InsideCycle(i,oS)\n",
    "            iter += 1\n",
    "        #对已存在alpha对，选出非边界的alpha值，进行优化。\n",
    "        else:\n",
    "            #遍历所有非边界alpha值，进行优化。\n",
    "            nonBoundIs = nonzero((oS.alpha.A > 0) * (oS.alpha.A < oS.C))[0]\n",
    "            for i in nonBoundIs:\n",
    "                AlphaChanged += InsideCycle(i,oS)\n",
    "               \n",
    "            iter += 1\n",
    "        \n",
    "        #如果找到alpha对，就优化非边界alpha值，否则，就重新进行寻找，如果寻找一遍 遍历所有的行还是没找到，就退出循环。\n",
    "        if EntireSet:\n",
    "            EntireSet = False\n",
    "        elif (AlphaChanged == 0):\n",
    "            EntireSet = True\n",
    "    return oS.b, oS.alpha"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "RSe4CmadpDyG"
   },
   "source": [
    "**下面调用SMO算法，计算常量b以及a拉格朗日乘子alpha[50:55]。**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "JndPv9-cpDyH"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b =  [[-2.89901748]]\n",
      "alphas =  [[0.]\n",
      " [0.]\n",
      " [0.]\n",
      " [0.]\n",
      " [0.]]\n"
     ]
    }
   ],
   "source": [
    "b, alphas = Smo(oS, 40)\n",
    "print (\"b = \", b)\n",
    "print (\"alphas = \",alphas[50:55])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UGUJTWFepDyL"
   },
   "source": [
    "**任务六 根据计算出的拉格朗日乘子计算出权重向量W，计算公式如下：**\n",
    "$$W=\\sum_{i=1}^{n}\\alpha_iy_ix_i$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "LroXTRNgpDyM"
   },
   "source": [
    "函数：ComputeW(alphas,data,label)\n",
    "\n",
    "作用：基于alphas计算W\n",
    "\n",
    "参数：\n",
    "\n",
    "alphas：拉格朗日乘子\n",
    "\n",
    "data：特征数据集\n",
    "\n",
    "label：对应的标签数据\n",
    "\n",
    "返回：\n",
    "\n",
    "W：权重向量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "k35sIzVwpDyM"
   },
   "outputs": [],
   "source": [
    "def ComputeW(alphas,data,label):\n",
    "    Data = mat(data)                 #转换为矩阵形式\n",
    "    Label = mat(label).transpose()\n",
    "    \n",
    "    m,n = shape(Data)                #数据的维度\n",
    "    w = zeros((n,1))\n",
    "    ### START THE CODE ###\n",
    "    w = Data.T * multiply(alphas, Label)#根据计算公式求取w\n",
    "    ### END THE CODE ###\n",
    "    return w\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "WXDChas5pDyP"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w =  [[-0.02568303]\n",
      " [ 0.04319313]]\n"
     ]
    }
   ],
   "source": [
    "Testalphas =[[0.        ],[0.        ],[0.08999025],[0.        ],[0.04439791]]\n",
    "w = ComputeW(Testalphas,TrainData[50:55],TrainLabel[50:55])\n",
    "print (\"w = \", w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "DTy5XOTOpDyS"
   },
   "source": [
    "输出：  \n",
    "\n",
    "w =  [[-0.02568303]<br>\n",
    " [ 0.04319313]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "H9CS12lBpDyS"
   },
   "source": [
    "**任务七 画出SVM的决策边界**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "PC_TGJ3SpDyT"
   },
   "source": [
    "定义PlotSVM函数，根据训练数据，标签，W，b,alphas画出决策边界。  \n",
    "正负样本用不同颜色标注。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "sO8PFhwXpDyT"
   },
   "outputs": [],
   "source": [
    "W = ComputeW(alphas,TrainData,TrainLabel)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "FtkQ86ftpDyW"
   },
   "outputs": [],
   "source": [
    "def PlotSVM(data,label,W,b,alphas):\n",
    "    Data = mat(data)\n",
    "    Label = np.squeeze(label)\n",
    "    #b 原来是矩阵 先转化为数组类型后其数组大小为（1，1），然后后面加[0],变为（1，）\n",
    "    b = array(b)[0]\n",
    "    fig = plt.figure()\n",
    "    figure = fig.add_subplot(111)\n",
    "    \n",
    "    figure.scatter(Data[:,0].flatten().A[0],Data[:,1].flatten().A[0])\n",
    "    x = arange(-1.0,10.0,0.1)\n",
    "    \n",
    "    y = (-b-W[0,0]*x)/ W[1,0]  #画出分隔线\n",
    "    figure.plot(x,y)\n",
    "    \n",
    "    ### START THE CODE ### \n",
    "    pos = array([Data[i][0][0] for i in range(len(Data)) if Label[i] == 1]).reshape(-1, 2)  # 正性样本\n",
    "    neg = array([Data[i].flatten() for i in range(len(Data)) if Label[i] == -1]).reshape(-1, 2)  # 负性样本\n",
    "    figure.scatter(pos[:, 0], pos[:, 1], color=\"r\", label=\"Positive sample\")\n",
    "    figure.scatter(neg[:, 0], neg[:, 1], color=\"b\", label=\"Negative sample\")\n",
    "    figure.legend() #将正负样本点画在画布上\n",
    "    ###END THE CODE ###\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "gT2UL0wjpDya"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "PlotSVM(TrainData,TrainLabel,W,b,alphas)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "TgiEf6UNpDyf"
   },
   "source": [
    "**径向基函数是SVM中常用的一个核函数。径向基函数是一个采用向量作为自变量的函数，能够基于向量距离输出一个标量。这个距离可以是从<0,0>向量或者其他向量开始计算的距离。接下来，我们将会使用到径向基函数的高斯版本，其具体公式如下：**\n",
    "$$k(x_1,x_2)=exp(\\frac{-{{\\Vert}x_1-x_2\\Vert}^2}{2\\delta^2})$$\n",
    "其中,$\\delta$是用户定义的用于确定达到率或则说函数值跌落到0的速度参数。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "MYYlSJYxpDyg"
   },
   "source": [
    "**任务八 实现径向基核函数**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "IcizRL1OpDyh"
   },
   "source": [
    "函数名：KernelTransform(Data,DataI,Para)  \n",
    "作用：将数据映射到高纬空间  \n",
    "参数：  \n",
    "Data 数据集  \n",
    "DataI 数据集中的第i行数据  \n",
    "papa：径向基函数中的$\\delta$参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "DuAI8e9lpDyi"
   },
   "outputs": [],
   "source": [
    "def KernelTransform(Data,DataI,Para):\n",
    "    #计算Data的维度 【m,n】\n",
    "    m,n = shape(Data)\n",
    "    K = mat(zeros((m,1)))\n",
    "    \n",
    "    ### START THE CODE ###\n",
    "    K = exp(sum(square(array(Data) - array(DataI)), axis=1) / (-2 * square(Para))).reshape(m, 1) #按照径向基函数公式求取K\n",
    "    ### END THE CODE ###\n",
    "    return K"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ylI1QBBspDym"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Result =  [[6.21201706e-01]\n",
      " [1.00000000e+00]\n",
      " [1.67499988e-13]\n",
      " [3.14534050e-03]\n",
      " [3.88031058e-10]]\n"
     ]
    }
   ],
   "source": [
    "TestData =  [[3.542485, 1.977398], [3.018896, 2.556416], [7.55151, -1.58003], [2.114999, -0.004466], [8.127113, 1.274372]]\n",
    "TestDataI = [3.018896, 2.556416]\n",
    "TestPara = 0.8\n",
    "Result = KernelTransform(TestData,TestDataI,TestPara)\n",
    "print (\"Result = \", Result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "nz7igXXdpDyp"
   },
   "source": [
    "输出：  \n",
    "Result =  [[6.21201706e-01]<br>\n",
    " [1.00000000e+00]<br>\n",
    " [1.67499988e-13]<br>\n",
    " [3.14534050e-03]<br>\n",
    " [3.88031058e-10]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "OkZUvprdpDyp"
   },
   "source": [
    "**接下来我们导入KernnelTrainData数据进进行训练，每一行包括两个特征以及一个标签。然后利用SMO算法计算出拉格朗日乘子以及b，利用核函数转换计算K。最后进行预测并计算出预测错误率。**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ZxEFhUgvpDyq"
   },
   "outputs": [],
   "source": [
    "def TrainAccuracy(TrainFileName,TestFileName,P,C,Toler,MaxIter):\n",
    "    #导入数据\n",
    "    Data,Label = LoadData(TrainFileName)\n",
    "\n",
    "    #高斯核参数\n",
    "    Para = P\n",
    "    #转换为mat格式\n",
    "    Data = mat(Data)\n",
    "    Label = mat(Label).transpose()\n",
    "\n",
    "    #计算拉格朗日乘子以及b\n",
    "    oS = DataOp(Data,Label,C,Toler)\n",
    "    b,alphas = Smo(oS,MaxIter)\n",
    "\n",
    "    #获取alpha>0的行数\n",
    "    UnZero = nonzero(alphas.A > 0)[0]\n",
    "    SelectData = Data[UnZero]\n",
    "    SelectLabel = Label[UnZero]\n",
    "    SelectAlphas = alphas[UnZero]\n",
    "\n",
    "    #获取Data的维度\n",
    "    m, n = shape(Data)\n",
    "    \n",
    "    #获取测试数据集\n",
    "    TestData,TestLabel = LoadData(TestFileName)\n",
    "    TestCount = 0\n",
    "    \n",
    "    #转换格式\n",
    "    TestData = mat(TestData)\n",
    "    TestLabel = mat(TestLabel).transpose()\n",
    "    m,n = shape(TestData)\n",
    "    #遍历测试集每一行数据\n",
    "    for i in range(m):\n",
    "        #核函数转换\n",
    "        K = KernelTransform(SelectData,TestData[i],Para)\n",
    "        TestPredictValue = K.T*multiply(SelectLabel,SelectAlphas) + b\n",
    "        #测试准确度\n",
    "        if sign(TestPredictValue) != sign(TestLabel[i]):\n",
    "            TestCount += 1\n",
    "    print(\"The Test Error Rate is: %.1f%%\" % (float(TestCount)*100 / m))\n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "yUc58QMIpDyv"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Test Error Rate is: 15.0%\n"
     ]
    }
   ],
   "source": [
    "#训练数据\n",
    "TrainFileName = 'KernelTrainData.txt'\n",
    "#测试数据\n",
    "TestFileName = 'KernelTestData.txt'\n",
    "#SMO算法参数\n",
    "C = 210\n",
    "Toler = 0.0001\n",
    "MaxIter = 10000\n",
    "#径向基参数\n",
    "Para = 0.12\n",
    "TrainAccuracy(TrainFileName,TestFileName,Para,C,Toler,MaxIter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "2E54kKbWpDy1"
   },
   "source": [
    "输出：<br>\n",
    "    The Test Error Rate is: 20.0%"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "SuDVk1OopDy3"
   },
   "source": [
    "**由以上结果可以看到，应用高斯函数进行SVM分类，我们达到了80左右%的准确率，事实上你可以修改参数，来获得更加优化的模型。**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "zzYFuvK4pDy3"
   },
   "source": [
    "通过以上的学习，我想你已经对SVM的原理以及和核函数有了一定的了解。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**SVR算法**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "传统的回归模型通常直接基于模型输出f(x)与真实输出y之间的差来计算损失，只有当两者完全相同时，损失才为0。而SVR加入了一个ε参数，意为我们可以容忍f(x)与y最多有ε偏差，如下图\n",
    "![9.png](image/9.PNG)\n",
    "也就是说，在虚线之间的部分不进行损失计算，他们的损失为0，而只计算虚线以外的点的损失，因此他的对应损失函数为：\n",
    "![10.png](image/10.png)\n",
    "对于SVM，可以看作优化问题为：\n",
    "![11.png](image/11.png)\n",
    "引入松弛因子$ξ_i$、$ξ_i^*$，SVR的优化问题变为：\n",
    "![12.png](image/12.png)\n",
    "其中$h_{w,b}(x)=w^Tx+b$\n",
    "然后引入拉格朗日乘子,得到对应拉格朗日函数：\n",
    "$$L(w,b,α,α^*,ξ,ξ^*,r_i,r_i^*)=\\frac{1}{2}{\\parallel w\\parallel}^2+C\\sum_{i=0}^{m}(ξ_i+ξ_i^*)-\\sum_{i=1}^{m}r_iξ_i-\\sum_{i=1}^{m}r_i^*ξ_i^*+\\sum_{i=1}^{m}α_i(h_{w,b}(x^i)-y^i-ε-ξ_i)+$$\n",
    "$$\\sum_{i=1}^{m}α_i^*(y^i-h_{w,b}(x^i)-ε-ξ_i^*)$$\n",
    "令函数中对应偏导为0，得到：\n",
    "![13.png](image/13.png)\n",
    "代入到拉格朗日函数中得到之关于$α_i$,$α_i^*$的函数，最大化该函数即得到SVR的对偶问题：\n",
    "![14.png](image/14.png)\n",
    "可以看出其仍为QP问题，KKT条件为：\n",
    "![15.png](image/15.png)\n",
    "因此可以进行求解，同时对于非线性回归也可引入核函数实现。下面实现SVR。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SVR的实现使用scikit-learn库调用实现，scikit-learn库里集成了大量机器学习的常用方法，其中提供了基于libsvm的SVR解决方案。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**任务九 SVR：线性回归实现**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "#初始化一系列随机样本\n",
    "np.random.seed(42)\n",
    "m = 50\n",
    "X = 2 * np.random.rand(m, 1)\n",
    "y = (4 + 3 * X + np.random.randn(m, 1)).ravel()  # 将多维数组降为一维\n",
    "\n",
    "#调用sklearn库，实现LinearSVR\n",
    "from sklearn.svm import LinearSVR\n",
    "### START THE CODE ###\n",
    "linearsvr = LinearSVR(epsilon=0.3)   #设定epsilon = 0.3,方便观察效果，支持向量均位于容忍区域外侧\n",
    "linearsvr.fit(X, y)      #根据相关文档得到拟合模型\n",
    "### END THE CODE  ###\n",
    "\n",
    "\n",
    "#找到支持向量\n",
    "def find_support(svr,X,y):\n",
    "    y_pred=svr.predict(X)#计算预测值\n",
    "    margin=(np.abs(y-y_pred) >= svr.epsilon)#判断是否为支持向量\n",
    "    return np.argwhere(margin)\n",
    "\n",
    "linearsvr.support_=find_support(linearsvr,X,y)#获取对应的支持向量对应下标，注意将变量名改为你自己的命名\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "绘制SVR结果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "def plot_svr(svr,X,y,axes):\n",
    "    xls=np.linspace(axes[0],axes[1],100).reshape(100,1)\n",
    "    y_pred=svr.predict(xls)\n",
    "    plt.plot(xls, y_pred, \"-\")\n",
    "    plt.plot(xls, y_pred + svr.epsilon, \"--\")  \n",
    "    plt.plot(xls, y_pred - svr.epsilon, \"--\")\n",
    "    plt.plot(X, y, \"bo\")\n",
    "    plt.scatter(X[svr.support_], y[svr.support_], s=180, facecolors='#FFAAAA')\n",
    "    plt.axis(axes)\n",
    "plt.figure(figsize=(9, 4))  # width, height in inches\n",
    "plot_svr(linearsvr, X, y, [0, 2, 3, 11]) #注意第一个参数改为自己的命名"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通过观察图像可以看出，SVR中的支持向量均位于容忍区域外侧"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**任务十 SVR：非线性回归**<br>\n",
    "非线性回归中，参数C越大，对错样本的惩罚程度越大，正则化项的作用会越小，模型越趋向于过拟合。\n",
    "反之，C越小，正则化效果越强，模型会更简单。\n",
    "在实验中同学们可以通过调整C参数观察回归结果的不同。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'C': 200,\n",
       " 'cache_size': 200,\n",
       " 'coef0': 0.0,\n",
       " 'degree': 3,\n",
       " 'epsilon': 0.05,\n",
       " 'gamma': 'scale',\n",
       " 'kernel': 'rbf',\n",
       " 'max_iter': -1,\n",
       " 'shrinking': True,\n",
       " 'tol': 0.001,\n",
       " 'verbose': False}"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#初始化随机样本\n",
    "np.random.seed(42)\n",
    "m = 100\n",
    "X = 2 * np.random.rand(m, 1) - 1\n",
    "y = (0.2 + 0.1 * X + 0.5 * X**2 + np.random.randn(m, 1)/10).ravel()\n",
    "\n",
    "#实现SVR\n",
    "from sklearn.svm import SVR\n",
    "\n",
    "### START THE CODE ###\n",
    "svr_poly = SVR(C=200, epsilon=0.05)   #对初始化参数C进行调节观察结果\n",
    "svr_poly.fit(X, y)  #拟合模型\n",
    "### END THE CODE  ###\n",
    "\n",
    "plt.figure(figsize=(9, 4))\n",
    "plot_svr(svr_poly, X, y, [-1, 1, 0, 1])\n",
    "svr_poly.get_params()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "对应此数据集，通过改变C参数可以看出C越小，图像弯曲程度越小，而C越大图像越弯曲，对此数据拟合效果越好。"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "name": "SVM.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3.9.4 64-bit",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.4"
  },
  "vscode": {
   "interpreter": {
    "hash": "54d668a7a2b723eaa45db485aeb9405c48b3714a12ae318aa481966bf3ee5079"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}