sequential minimal optimization.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#smo is a very complex algorithm\n",
    "#plz make sure you have a solid understanding of svm to continue\n",
    "#for basics of svm, plz refer to the following link\n",
    "# https://github.com/je-suis-tm/machine-learning/blob/master/binary%20support%20vector%20machine.ipynb\n",
    "\n",
    "#a reference for python codes of smo\n",
    "# https://jonchar.net/notebooks/SVM/\n",
    "#a reference for original paper of smo\n",
    "# https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/tr-98-14.pdf\n",
    "#a reference for math derivation of smo\n",
    "# http://jupiter.math.nctu.edu.tw/~yuhjye/assets/file/teaching/2017_machine_learning/SMO%20algorithm.pdf\n",
    "\n",
    "#as most details can be found in pseudo code of john platts paper\n",
    "#i will not give too many comments\n",
    "import random as rd\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import sklearn.svm\n",
    "import sklearn.decomposition\n",
    "import sklearn.model_selection\n",
    "import sklearn.datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#this part is purely math derivation\n",
    "\n",
    "def get_alpha2(alpha2_old,y2,e2,e1,eta):\n",
    "    \n",
    "    alpha2_new=alpha2_old+y2*(e2-e1)/eta\n",
    "    \n",
    "    return alpha2_new\n",
    "\n",
    "\n",
    "#in john platts paper\n",
    "#the assumption is y=wx-b\n",
    "#but my code is based on y=wx+b\n",
    "#thats why we need to change the sign of eta\n",
    "def get_eta(k11,k22,k12):\n",
    "    \n",
    "    eta=k11+k22-2*k12\n",
    "    \n",
    "    return -eta\n",
    "\n",
    "\n",
    "def get_alpha1(alpha1_old,y1,y2,alpha2_old,alpha2_new):\n",
    "    \n",
    "    alpha1_new=alpha1_old+y1*y2*(alpha2_old-alpha2_new)\n",
    "    \n",
    "    return alpha1_new\n",
    "\n",
    "\n",
    "\n",
    "def get_b(e1,e2,y1,alpha1_new,alpha1, \\\n",
    "          k11,k12,k22,y2,alpha2_new_clipped,alpha2,b):\n",
    "    \n",
    "    b1=e1+y1*(alpha1_new-alpha1)*k11+ \\\n",
    "    y2*(alpha2_new_clipped-alpha2)*k12+b\n",
    "    \n",
    "    b2=e2+y1*(alpha1_new-alpha1)*k12+ \\\n",
    "    y2*(alpha2_new_clipped-alpha2)*k22+b\n",
    "    \n",
    "    return b1,b2\n",
    "\n",
    "\n",
    "def clip_alpha2(alpha2_new,l,h):\n",
    "    \n",
    "        \n",
    "    if alpha2_new>h:\n",
    "        alpha2_new_clipped=h\n",
    "    elif alpha2_new<l:\n",
    "        alpha2_new_clipped=l\n",
    "    else:\n",
    "        alpha2_new_clipped=alpha2_new\n",
    "        \n",
    "    return alpha2_new_clipped\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#still 3 types of kernels, linear,polynomial,gaussian\n",
    "def kernel(x1,x2,ktype='linear', \\\n",
    "           poly_constant=0,poly_power=1,gamma=0.5):\n",
    "    \n",
    "    if ktype=='linear':\n",
    "        x_product=(np.mat(x1)*np.mat(x2).T).tolist()[0][0]\n",
    "    elif ktype=='polynomial':\n",
    "        projection=np.mat(x1)*np.mat(x2).T\n",
    "        x_product=((x1.T*x2+poly_constant)**poly_power).tolist()[0][0]\n",
    "    else:\n",
    "        projection=np.mat([i-j for j in x1 for i in x2]).reshape(len(x1), \\\n",
    "                                                           len(x2))\n",
    "        x_product=np.exp(-1*gamma*(np.linalg.norm(projection))**2)\n",
    "        \n",
    "    return x_product"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#the main routine in the original paper\n",
    "def train(x_train,y_train,c=10,**kwargs):\n",
    "    numchanged=0\n",
    "    examineall=True\n",
    "    alphas=list(np.zeros(len(x_train)))\n",
    "    b=0\n",
    "    \n",
    "    #this is crucial\n",
    "    #without initial value\n",
    "    #everything will stay at 0\n",
    "    errors=list(np.multiply(y_train,-1))\n",
    "    \n",
    "    \n",
    "    while numchanged>0 or examineall:\n",
    "        numchanged=0\n",
    "        if examineall:\n",
    "            for i in range(len(x_train)):\n",
    "                output,alphas,b=examine_example(i, \\\n",
    "                                            x_train, \\\n",
    "                                            y_train, \\\n",
    "                                            b, \\\n",
    "                                            alphas,errors, \\\n",
    "                                            constant=c, \\\n",
    "                                            **kwargs)\n",
    "                numchanged+=output\n",
    "                \n",
    "        else:\n",
    "            for i in range(len(x_train)):\n",
    "                if alphas[i]!=0 and alphas[i]!=c:\n",
    "                    output,alphas,b=examine_example(i, \\\n",
    "                                            x_train, \\\n",
    "                                            y_train, \\\n",
    "                                            b, \\\n",
    "                                            alphas,errors, \\\n",
    "                                            constant=c, \\\n",
    "                                            **kwargs)\n",
    "                    numchanged+=output\n",
    "        \n",
    "        if examineall==True:\n",
    "            examineall=False\n",
    "        else:\n",
    "            if numchanged==0:\n",
    "                examineall==True\n",
    "    \n",
    "    return alphas,b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#selection criteria on alpha1 and alpha2\n",
    "def examine_example(i,x_train,y_train,b, \\\n",
    "                    alphas,errors,constant, \\\n",
    "                    tol=0.005, \\\n",
    "                    **kwargs):\n",
    "\n",
    "    y2=y_train[i]\n",
    "    alpha2=alphas[i]\n",
    "    e2=errors[i]\n",
    "    support_vector=[]\n",
    "    output=0\n",
    "    \n",
    "    r2=e2*y2\n",
    "    \n",
    "    for idn in range(len(alphas)):\n",
    "        if alphas[idn]!=0 and alphas[idn]!=constant:\n",
    "            support_vector.append(idn)\n",
    "    \n",
    "\n",
    "    if (r2<-tol and alpha2<constant) or \\\n",
    "    (r2>tol and alpha2>0):\n",
    "        if len(support_vector) > 1:\n",
    "            \n",
    "            if e2>0:\n",
    "                crap,j=second_heuristic(i,alphas,y_train, \\\n",
    "                                         x_train,b,errors)\n",
    "            if e2<0:\n",
    "                j,crap=second_heuristic(i,alphas,y_train, \\\n",
    "                                         x_train,b,errors)\n",
    "            \n",
    "            result,b,alphas,errors=takestep(j,i, \\\n",
    "                                              alphas,y_train, \\\n",
    "                                              x_train,b, \\\n",
    "                                              constant,errors, \\\n",
    "                                             **kwargs)\n",
    "            if result:\n",
    "                output=1\n",
    "                return output,alphas,b\n",
    "            \n",
    "            \n",
    "            sampler=rd.sample(support_vector,len(support_vector))\n",
    "            for l in sampler:               \n",
    "                result,b,alphas,errors=takestep(l,i, \\\n",
    "                                              alphas,y_train, \\\n",
    "                                              x_train,b, \\\n",
    "                                              constant,errors, \\\n",
    "                                             **kwargs)\n",
    "                if result:\n",
    "                    output=1\n",
    "                    return output,alphas,b\n",
    "        \n",
    "        sampling=rd.sample(list(np.arange(len(alphas))),len(alphas))\n",
    "        for m in sampling:\n",
    "            result,b,alphas,errors=takestep(m,i, \\\n",
    "                                              alphas,y_train, \\\n",
    "                                              x_train,b, \\\n",
    "                                              constant,errors, \\\n",
    "                                             **kwargs)\n",
    "            if result:\n",
    "                output=1\n",
    "                return output,alphas,b\n",
    "\n",
    "    return output,alphas,b\n",
    "\n",
    "\n",
    "\n",
    "def second_heuristic(i,alphas,y_train, \\\n",
    "                     x_train,b,errors):\n",
    "    \n",
    "    e_list=[errors[k] for k in range(len(x_train)) if k!=i]\n",
    "    \n",
    "    maxval=e_list.index(max(e_list))\n",
    "    minval=e_list.index(min(e_list))\n",
    "    \n",
    "    return maxval,minval"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#the core part of updating alpha1,alpha2\n",
    "def takestep(idn1,idn2,alphas,y_train, \\\n",
    "             x_train,b,constant,errors, \\\n",
    "             eps=0.001,**kwargs):\n",
    "    \n",
    "    result=False\n",
    "    \n",
    "\n",
    "    if idn1==idn2:\n",
    "        return result,b,alphas,errors\n",
    "    \n",
    "    alpha1=alphas[idn1]\n",
    "    x1=x_train[idn1]\n",
    "    y1=y_train[idn1]\n",
    "    e1=errors[idn1]\n",
    "    alpha2=alphas[idn2]\n",
    "    x2=x_train[idn2]\n",
    "    y2=y_train[idn2]\n",
    "    e2=errors[idn2]\n",
    "    \n",
    "    s=y1*y2\n",
    "    \n",
    "    if y1!=y2:\n",
    "        l=max(0,alpha2-alpha1)\n",
    "        h=min(constant,constant-alpha1+alpha2)\n",
    "    else:\n",
    "        l=max(0,alpha1+alpha2-constant)\n",
    "        h=min(constant,alpha2+alpha1)\n",
    "    \n",
    "    if l==h:\n",
    "        return result,b,alphas,errors\n",
    "    \n",
    "    k11=kernel(x1,x1,**kwargs)\n",
    "    k12=kernel(x1,x2,**kwargs)\n",
    "    k22=kernel(x2,x2,**kwargs)\n",
    "    \n",
    "    eta=get_eta(k11,k22,k12)\n",
    "    \n",
    "    if eta<0:\n",
    "        alpha2_new=get_alpha2(alpha2,y2,e2,e1,eta)\n",
    "        alpha2_new_clipped=clip_alpha2(alpha2_new,l,h)\n",
    "    else:\n",
    "        f1=y1*(e1+b)-alpha1*kernel(x1,x1,**kwargs)+ \\\n",
    "        s*alpha2*kernel(x1,x2,**kwargs)\n",
    "        \n",
    "        f2=y2*(e2+b)-s*alpha1*kernel(x1,x2,**kwargs)- \\\n",
    "        alpha2*kernel(x2,x2,**kwargs)\n",
    "        \n",
    "        l1=alpha1+s*(alpha2-l)\n",
    "        h1=alpha1+s*(alpha2-h)\n",
    "        \n",
    "        lobj=l1*f1+l*f2+0.5*l1*l1*kernel(x1,x1,**kwargs)+ \\\n",
    "        0.5*l*l*kernel(x2,x2,**kwargs)+ \\\n",
    "        s*l*l1*kernel(x1,x2,**kwargs)\n",
    "        \n",
    "        hobj=h1*f1+h*f2+0.5*h1*h1*kernel(x1,x1,**kwargs)+ \\\n",
    "        0.5*h*h*kernel(x2,x2,**kwargs)+ \\\n",
    "        s*h*h1*kernel(x1,x2,**kwargs)\n",
    "        \n",
    "        if lobj<hobj-eps:\n",
    "            alpha2_new_clipped=hobj\n",
    "        elif lobj>hobj+eps:\n",
    "            alpha2_new_clipped=lobj\n",
    "        else:\n",
    "            alpha2_new_clipped=alpha2\n",
    "\n",
    "\n",
    "    if np.abs(alpha2_new_clipped-alpha2)<eps*(alpha2_new_clipped+ \\\n",
    "                                              alpha2+eps):\n",
    "\n",
    "        return result,b,alphas,errors\n",
    "\n",
    "    alpha1_new=get_alpha1(alpha1,y1,y2,alpha2,alpha2_new_clipped)\n",
    "    b1,b2=get_b(e1,e2,y1,alpha1_new,alpha1, \\\n",
    "              k11,k12,k22,y2,alpha2_new_clipped, \\\n",
    "                alpha2,b)\n",
    "    \n",
    "    if alpha1_new>0 and alpha1_new<constant:\n",
    "        b_new=b1\n",
    "    elif alpha2_new_clipped>0 and alpha2_new_clipped<constant:\n",
    "        b_new=b2\n",
    "    else:\n",
    "        b_new=(b1+b2)/2\n",
    "    \n",
    "    alphas[idn1]=alpha1_new\n",
    "    alphas[idn2]=alpha2_new_clipped\n",
    "    \n",
    "    \n",
    "    \n",
    "    for i in range(len(alphas)):\n",
    "        if i!=idn1 and i!=idn2:\n",
    "            \n",
    "            errors[i]+=y1*(alpha1_new-alpha1)* \\\n",
    "            kernel(x1,x_train[i],**kwargs)+ \\\n",
    "            y2*(alpha2_new_clipped-alpha2)* \\\n",
    "            kernel(x2,x_train[i],**kwargs)+ \\\n",
    "            (b-b_new)\n",
    "   \n",
    "    b=b_new\n",
    "    \n",
    "    result=True\n",
    "\n",
    "    return result,b,alphas,errors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#using smo to forecast\n",
    "def smo(x_train,x_test,y_train,y_test,constant=10,**kwargs):\n",
    "    \n",
    "    alphas,b=train(x_train,y_train,c=constant,**kwargs)\n",
    "\n",
    "    forecast=[]\n",
    "    \n",
    "    for j in x_test:\n",
    "        summation=0\n",
    "        for i in range(len(x_train)):\n",
    "            summation+=alphas[i]*y_train[i]*kernel(x_train[i],j)\n",
    "        forecast.append(summation)\n",
    "    \n",
    "    forecast=list(np.sign(forecast))\n",
    "\n",
    "\n",
    "    return forecast"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#calculate train and test accuracy\n",
    "def self_smo(x_train,x_test,y_train,y_test,constant=10,**kwargs):\n",
    "    \n",
    "    forecast=smo(x_train,x_train,y_train,y_train,constant=constant)\n",
    "    percentage=len(pd.Series(y_train)[pd.Series(forecast)==pd.Series(y_train)])/len(y_train)\n",
    "    \n",
    "    print('\\ntrain accuracy: %.2f'%(percentage*100)+'%')\n",
    "    \n",
    "    forecast=smo(x_train,x_test,y_train,y_test,constant=10)\n",
    "    percentage=len(pd.Series(y_test)[pd.Series(forecast)==pd.Series(y_test)])/len(y_test)\n",
    "    \n",
    "    print('\\ntest accuracy: %.2f'%(percentage*100)+'%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#official package of machine learning\n",
    "def sklearn_svm(x_train,x_test,y_train,y_test,constant=10,**kwargs):\n",
    "    \n",
    "    m=sklearn.svm.SVC(kernel='linear', C=constant).fit(x_train,y_train)\n",
    "    \n",
    "    percentage=m.score(x_train,y_train)\n",
    "    print('\\ntrain accuracy: %.2f'%(percentage*100)+'%')\n",
    "    \n",
    "    percentage=m.score(x_test,y_test)\n",
    "    print('\\ntest accuracy: %.2f'%(percentage*100)+'%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#get iris\n",
    "df=pd.DataFrame(sklearn.datasets.load_iris()['data'],\n",
    "               columns=['x1','x2','x3','x4'])\n",
    "df['y']=sklearn.datasets.load_iris()['target']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#as usual, we use binary classification to simplify things\n",
    "#multiclass svm can be found in the following link\n",
    "# https://github.com/je-suis-tm/machine-learning/blob/master/multiclass%20support%20vector%20machine.ipynb\n",
    "df=df[df['y']!=0.0].copy()\n",
    "df['y']=df['y'].replace({2:-1})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#two dimensional data for the sake of easy visualization\n",
    "#check the link below for more details of pca\n",
    "# https://github.com/je-suis-tm/machine-learning/blob/master/principal%20component%20analysis.ipynb\n",
    "x1=sklearn.decomposition.PCA(\n",
    "    n_components=1).fit_transform(\n",
    "    df[['x1','x2']])\n",
    "x2=sklearn.decomposition.PCA(\n",
    "    n_components=1).fit_transform(\n",
    "    df[['x3','x4']])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "y=df['y'].tolist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "#crucial!\n",
    "#always reset index after loc or shuffle\n",
    "df.reset_index(drop=True,inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "#wrap x into matrix form\n",
    "x=[[x1[i].item(),x2[i].item()] for i in range(len(df))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train,x_test,y_train,y_test=sklearn.model_selection.train_test_split(\n",
    "    x,y,test_size=0.3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "train accuracy: 95.71%\n",
      "\n",
      "test accuracy: 100.00%\n"
     ]
    }
   ],
   "source": [
    "sklearn_svm(x_train,x_test,y_train,y_test,constant=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "train accuracy: 91.43%\n",
      "\n",
      "test accuracy: 95.71%\n"
     ]
    }
   ],
   "source": [
    "self_smo(x_train,x_train,y_train,y_train,constant=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "577 µs ± 13.4 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit m=sklearn.svm.SVC(kernel='linear', C=100).fit(x_train,y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "227 ms ± 46.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "%timeit w,b=train(x_train,y_train,c=100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h4>Apparently self implementation of SMO is not as fast as sklearn. After all, sklearn runs on cython</h4>\n",
    "<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#visualization of linear kernel\n",
    "m=sklearn.svm.SVC(kernel='linear', C=10).fit(x_train,y_train)\n",
    "xx=np.arange(min(np.mat(x)[:,0])-1, \\\n",
    "             max(np.mat(x)[:,0])+1, \\\n",
    "             (max(np.mat(x)[:,0])-min(np.mat(x)[:,0]))/200)\n",
    "\n",
    "yy=np.arange(min(np.mat(x)[:,1])-1, \\\n",
    "             max(np.mat(x)[:,1])+1, \\\n",
    "             (max(np.mat(x)[:,1])-min(np.mat(x)[:,1]))/200)\n",
    "\n",
    "\n",
    "X,Y=np.meshgrid(xx,yy)\n",
    "forecast=m.predict(np.c_[X.ravel(),Y.ravel()])\n",
    "\n",
    "\n",
    "fig=plt.figure(figsize=(10,6))\n",
    "ax=fig.add_subplot(111)\n",
    "ax.spines['top'].set_visible(False)\n",
    "ax.spines['right'].set_visible(False)\n",
    "plt.pcolormesh(X,Y,forecast.reshape(X.shape),cmap='pink')\n",
    "\n",
    "for i in range(len(x)):\n",
    "    plt.scatter(x[i][0],x[i][1],c='r' if y[i]==1 else 'y')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#visualization of gaussian kernel\n",
    "m=sklearn.svm.SVC(kernel='rbf', C=10).fit(x_train,y_train)\n",
    "xx=np.arange(min(np.mat(x)[:,0])-1, \\\n",
    "             max(np.mat(x)[:,0])+1, \\\n",
    "             (max(np.mat(x)[:,0])-min(np.mat(x)[:,0]))/200)\n",
    "\n",
    "yy=np.arange(min(np.mat(x)[:,1])-1, \\\n",
    "             max(np.mat(x)[:,1])+1, \\\n",
    "             (max(np.mat(x)[:,1])-min(np.mat(x)[:,1]))/200)\n",
    "\n",
    "\n",
    "X,Y=np.meshgrid(xx,yy)\n",
    "forecast=m.predict(np.c_[X.ravel(),Y.ravel()])\n",
    "\n",
    "\n",
    "fig=plt.figure(figsize=(10,6))\n",
    "ax=fig.add_subplot(111)\n",
    "ax.spines['top'].set_visible(False)\n",
    "ax.spines['right'].set_visible(False)\n",
    "plt.pcolormesh(X,Y,forecast.reshape(X.shape),cmap='pink')\n",
    "\n",
    "for i in range(len(x)):\n",
    "    plt.scatter(x[i][0],x[i][1],c='r' if y[i]==1 else 'y')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#visualization of polynomial kernel\n",
    "m=sklearn.svm.SVC(kernel='poly', C=10).fit(x_train,y_train)\n",
    "xx=np.arange(min(np.mat(x)[:,0])-1, \\\n",
    "             max(np.mat(x)[:,0])+1, \\\n",
    "             (max(np.mat(x)[:,0])-min(np.mat(x)[:,0]))/200)\n",
    "\n",
    "yy=np.arange(min(np.mat(x)[:,1])-1, \\\n",
    "             max(np.mat(x)[:,1])+1, \\\n",
    "             (max(np.mat(x)[:,1])-min(np.mat(x)[:,1]))/200)\n",
    "\n",
    "\n",
    "X,Y=np.meshgrid(xx,yy)\n",
    "forecast=m.predict(np.c_[X.ravel(),Y.ravel()])\n",
    "\n",
    "\n",
    "fig=plt.figure(figsize=(10,6))\n",
    "ax=fig.add_subplot(111)\n",
    "ax.spines['top'].set_visible(False)\n",
    "ax.spines['right'].set_visible(False)\n",
    "plt.pcolormesh(X,Y,forecast.reshape(X.shape),cmap='pink')\n",
    "\n",
    "for i in range(len(x)):\n",
    "    plt.scatter(x[i][0],x[i][1],c='r' if y[i]==1 else 'y')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}