gradient descent.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Gradient Descent\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "Gradient descent is machine learning 101. Gradient refers to the derivative of a matrix in linear algebra. The basics of GD is similar to Ordinary Least Square. They are using the same approach to minimize the mean square error. The only difference is that OLS gets the global optima via inverse while GD gets the local optima via iteration. Theoretically, the computation of inverse matrix would be more costly than the convergence of iteration in a really large matrix. \n",
    "\n",
    "Assuming we have an equation $y=x\\theta+\\epsilon$, where $y,\\epsilon \\in \\mathbb{R}^m$, $x \\in \\mathbb{R}^{m \\times n}$ and $\\theta \\in \\mathbb{R}^{n}$.\n",
    "\n",
    "* OLS solves the problem by minimizing $J(\\theta)=(y-x\\theta)^T(y-x\\theta)$ with respect to $\\theta$. By setting the partial derivative $\\frac{\\partial J(\\theta)}{\\partial \\theta}=0$, we shall obtain $\\theta=(x^Tx)^{-1}x^Ty$. \n",
    "\n",
    "* GD solves the problem by iterations of $\\theta:=\\theta-\\alpha\\frac{\\partial J(\\theta)}{\\partial \\theta}$, where $\\alpha$ denotes the learning rate and $\\frac{\\partial J(\\theta)}{\\partial \\theta}=x^T(x\\theta-y)$.\n",
    "\n",
    "So when do we stop the iteration of GD? This is where data science becomes state of art. This is no definite way. We have to preset the threshold $\\tau$, and when the threshold $\\tau$ is beached, we declare the algorithm has converged. The threshold $\\tau$ could be the percentage/absolute change of the coefficients or objective functions or sum of squared errors from the last iteration. The optimal $\\tau$ should be small enough so we get a more accurate result but not too small to drag down the performance. And hyperparameter $\\alpha$ is also crucial to the success of the algorithm. If $\\alpha$ is too large, we would oscillate around the optima without convergence. On the contrary, a really small $\\alpha$ takes forever to reach the optima.\n",
    "\n",
    "The application of GD ranges from Independent Component Analysis to Neural Networks. As long as we can solve the objective function in closed form (otherwise we need Expectation Maximization), we can always apply GD instead of OLS or Maximum Logarithm Likelihood to outperform the computation of the inverse matrix. \n",
    "\n",
    "Another material for your reference\n",
    "\n",
    "http://ozzieliu.com/2016/02/09/gradient-descent-tutorial/\n",
    "\n",
    "Reference to the application of GD in ICA\n",
    "\n",
    "https://github.com/je-suis-tm/machine-learning/blob/master/independent%20component%20analysis.ipynb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import sklearn.linear_model\n",
    "import sklearn.decomposition\n",
    "import sklearn.datasets\n",
    "from mpl_toolkits.mplot3d import Axes3D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Batch Gradient Descent\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "Batch Gradient Descent is the simplest form of GD. BGD takes consideration of the error from the entire dataset at each iteration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#simple ols in linear regression\n",
    "def ols(X,Y):\n",
    "    return np.linalg.inv(X.T@X)@X.T@Y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#batch gradient descent\n",
    "#alpha denotes learning rate \n",
    "#alpha usually takes 0.05,0.03,0.01,0.005,0.003,0.001 etc\n",
    "#tau denotes the threshold of convergence\n",
    "#tau usually take 0.01,0.001,0.0001,0.00001\n",
    "#we should try different hyper parameters\n",
    "#we need to balance the tradeoff between precision and performance\n",
    "def bgd(X,Y,tau=0.001,alpha=0.001,max_itr=1000,\n",
    "        theta_init=[],diagnosis=True):\n",
    "\n",
    "    #initialize\n",
    "    counter=0\n",
    "\n",
    "    #theta denotes coefficients\n",
    "    #initialize theta\n",
    "    if len(theta_init)>0:\n",
    "        theta=theta_init\n",
    "    else:\n",
    "        theta=np.ones((X.shape[1],1))\n",
    "\n",
    "    #residuals or you can call it objective function\n",
    "    epsilons=[]\n",
    "    \n",
    "    #collect thetas for viz\n",
    "    thetas=[theta.copy()]\n",
    "\n",
    "    #iterate through the entire dataset\n",
    "    while counter<max_itr:\n",
    "        x=X.copy()\n",
    "        y=Y.copy()\n",
    "\n",
    "        #gradient descent\n",
    "        y_estimated=x@theta\n",
    "        epsilon=y_estimated-y\n",
    "        gradient=x.T@epsilon\n",
    "        theta-=alpha*gradient\n",
    "\n",
    "        #tracking\n",
    "        counter+=1\n",
    "        epsilons.append(epsilon.ravel()[0])\n",
    "        thetas.append(theta.copy())\n",
    "\n",
    "        #convergence\n",
    "        if len(epsilons)>1 and abs(epsilons[-1]-epsilons[-2])<tau:\n",
    "            if diagnosis:\n",
    "                print(f'Converged after {counter} iterations.')\n",
    "            return thetas,epsilons\n",
    "                \n",
    "    if diagnosis:\n",
    "        print(f'Not converged.')\n",
    "    return thetas,epsilons"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#iris dataset is the default choice in this repository\n",
    "#plz refer to the website in the following link for original data\n",
    "# https://archive.ics.uci.edu/ml/datasets/iris\n",
    "iris=sklearn.datasets.load_iris()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#to make life easier\n",
    "#we start with a binary classification problem\n",
    "dataset=iris.data[iris.target!=2]\n",
    "Y=iris.target[iris.target!=2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#use principal component analysis to reduce dimensions for viz\n",
    "#check link below for details on pca\n",
    "# https://github.com/je-suis-tm/machine-learning/blob/master/principal%20component%20analysis.ipynb\n",
    "X=sklearn.decomposition.PCA(n_components=2).fit_transform(dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#make sure its in the vector form\n",
    "Y=Y.reshape(-1,1)\n",
    "\n",
    "#adding intercept\n",
    "#you can also do \n",
    "#import statsmodels.api as sm\n",
    "#X=sm.add_constant(X\n",
    "constant=np.ones((X.shape[0],1))\n",
    "X=np.concatenate([constant,X],axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converged after 76 iterations.\n"
     ]
    }
   ],
   "source": [
    "#run\n",
    "thetas_bgd,_=bgd(X,Y)\n",
    "theta_ols=ols(X,Y)\n",
    "theta_bgd=thetas_bgd[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.69 ms ± 14.9 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    }
   ],
   "source": [
    "#apparently ols is much faster\n",
    "%timeit bgd(X,Y,diagnosis=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "32.7 µs ± 517 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit ols(X,Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Coefficients from BGD\n",
      " [[0.50016649]\n",
      " [0.29194508]\n",
      " [0.03695356]]\n",
      "Coefficients from OLS\n",
      " [[ 0.5       ]\n",
      " [ 0.29194508]\n",
      " [-0.1693774 ]]\n"
     ]
    }
   ],
   "source": [
    "print('Coefficients from BGD\\n',theta_bgd)\n",
    "print('Coefficients from OLS\\n',theta_ols)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of squared errors from BGD\n",
      " 1.9240423019186674\n",
      "Sum of squared errors from OLS\n",
      " 0.9633040783278697\n"
     ]
    }
   ],
   "source": [
    "#compute sum of squared errors\n",
    "sse_bgd=((X@theta_bgd-Y).T@(X@theta_bgd-Y)).ravel()[0]\n",
    "sse_ols=((X@theta_ols-Y).T@(X@theta_ols-Y)).ravel()[0]\n",
    "\n",
    "#ols also has smaller variance\n",
    "print('Sum of squared errors from BGD\\n',sse_bgd)\n",
    "print('Sum of squared errors from OLS\\n',sse_ols)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of BGD\n",
      " 0.64\n",
      "Accuracy of OLS\n",
      " 1.0\n"
     ]
    }
   ],
   "source": [
    "#get forecast\n",
    "forecast_bgd=np.sign(X@theta_bgd)\n",
    "forecast_bgd[forecast_bgd<0]=0\n",
    "forecast_ols=np.array([abs(round(i[0],0)) for i in X@theta_ols])\n",
    "\n",
    "#bgd is less accurate as well\n",
    "print('Accuracy of BGD\\n',len(forecast_bgd[forecast_bgd==Y])/len(Y))\n",
    "print('Accuracy of OLS\\n',len(forecast_ols[forecast_ols==Y.ravel()])/len(Y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.title('Iris by BGD')\n",
    "plt.xlabel('Dimension 1')\n",
    "plt.ylabel('Dimension 2')\n",
    "for i in np.unique(forecast_bgd.ravel()):\n",
    "    plt.scatter(X[forecast_bgd.ravel()==i][:,1],\n",
    "                X[forecast_bgd.ravel()==i][:,2],\n",
    "                label=f'Group {int(i)}')\n",
    "plt.legend()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.title('Iris by OLS')\n",
    "plt.xlabel('Dimension 1')\n",
    "plt.ylabel('Dimension 2')\n",
    "for i in np.unique(forecast_ols):\n",
    "    plt.scatter(X[forecast_ols==i][:,1],\n",
    "                X[forecast_ols==i][:,2],\n",
    "                label=f'Group {int(i)}')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Stochastic Gradient Descent\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "Stochastic Gradient Descent is designed to boost the performance of GD. SGD takes consideration of the error from a random sample at each iteration which greatly reduces the computation burden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "#sklearn official sgd\n",
    "def skl_sgd(X,Y,**kwargs):\n",
    "\n",
    "    #keep the hyper parameters consistent with self implementation\n",
    "    clf=sklearn.linear_model.SGDClassifier(loss='squared_loss',\n",
    "                                           fit_intercept=False,\n",
    "                                           alpha=0.001,l1_ratio=0,\n",
    "                                           max_iter=1000,tol=0.001,\n",
    "                                           **kwargs)\n",
    "    clf.fit(X,Y)\n",
    "    \n",
    "    print(f'Sklearn converged after {clf.n_iter_} iterations')\n",
    "    print('Accuracy of Sklearn\\n',clf.score(X,Y))\n",
    "\n",
    "    return clf.coef_.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "#stochastic gradient descent\n",
    "#the only difference from bgd is the bootstrapping\n",
    "#bgd iterates through the entire dataset at each step\n",
    "#sgd randomly picks a set of data and runs gradient descent\n",
    "#until it reaches convergence or maximum number of iterations\n",
    "def sgd(X,Y,tau=0.001,alpha=0.001,max_itr=1000,\n",
    "        theta_init=[],diagnosis=True):\n",
    "\n",
    "    #initialize\n",
    "    counter=0\n",
    "\n",
    "    #theta denotes coefficients\n",
    "    #initialize theta\n",
    "    if len(theta_init)>0:\n",
    "        theta=theta_init\n",
    "    else:\n",
    "        theta=np.ones((X.shape[1],1))\n",
    "\n",
    "    #residuals or you can call it objective function\n",
    "    epsilons=[]\n",
    "    \n",
    "    #collect thetas for viz\n",
    "    thetas=[theta.copy()]\n",
    "\n",
    "    #iterate through the dataset\n",
    "    while counter<max_itr:\n",
    "        \n",
    "        #bootstrapping\n",
    "        i=np.random.randint(X.shape[0])        \n",
    "        x=X[i].reshape(1,-1)\n",
    "        y=Y[i].reshape(-1,1)\n",
    "\n",
    "        #gradient descent\n",
    "        y_estimated=x@theta\n",
    "        epsilon=y_estimated-y\n",
    "        gradient=x.T@epsilon\n",
    "        theta-=alpha*gradient\n",
    "\n",
    "        #tracking\n",
    "        counter+=1\n",
    "        epsilons.append(epsilon.ravel()[0])\n",
    "        thetas.append(theta.copy())\n",
    "\n",
    "        #convergence\n",
    "        if len(epsilons)>1 and abs(epsilons[-1]-epsilons[-2])<tau:\n",
    "            if diagnosis:\n",
    "                print(f'SGD has converged after {counter} iterations.')\n",
    "            return thetas,epsilons\n",
    "                \n",
    "    if diagnosis:\n",
    "        print(f'SGD has not converged.')\n",
    "    return thetas,epsilons"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SGD has converged after 39 iterations.\n",
      "Accuracy of SGD\n",
      " 0.89\n"
     ]
    }
   ],
   "source": [
    "#well sgd result is quite volatile due to its randomness\n",
    "thetas_sgd,_=sgd(X,Y)\n",
    "theta_sgd=thetas_sgd[-1]\n",
    "\n",
    "forecast_sgd=np.sign(X@theta_sgd)\n",
    "forecast_sgd[forecast_sgd<0]=0\n",
    "print('Accuracy of SGD\\n',len(forecast_sgd[forecast_sgd==Y])/len(Y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sklearn converged after 52 iterations\n",
      "Accuracy of Sklearn\n",
      " 1.0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\ProgramData\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\validation.py:72: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  return f(**kwargs)\n"
     ]
    }
   ],
   "source": [
    "#i have no idea why sklearn is so damn accurate\n",
    "theta_skl=skl_sgd(X,Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Coefficients from SGD\n",
      " [[0.97243862]\n",
      " [0.92915242]\n",
      " [0.9915781 ]]\n",
      "Coefficients from Sklearn\n",
      " [[ 0.14486601]\n",
      " [ 0.58746859]\n",
      " [-0.39961859]]\n"
     ]
    }
   ],
   "source": [
    "print('Coefficients from SGD\\n',theta_sgd)\n",
    "print('Coefficients from Sklearn\\n',theta_skl)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of squared errors from SGD\n",
      " 165.12271031840393\n",
      "Sum of squared errors from Sklearn\n",
      " 38.73778731948959\n"
     ]
    }
   ],
   "source": [
    "#compute sum of squared errors\n",
    "sse_sgd=((X@theta_sgd-Y).T@(X@theta_sgd-Y)).ravel()[0]\n",
    "sse_skl=((X@theta_skl-Y).T@(X@theta_skl-Y)).ravel()[0]\n",
    "\n",
    "#sklearn also has smaller variance\n",
    "print('Sum of squared errors from SGD\\n',sse_sgd)\n",
    "print('Sum of squared errors from Sklearn\\n',sse_skl)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8.52 ms ± 561 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    }
   ],
   "source": [
    "#in our case, sgd doesnt seem to be efficient\n",
    "%timeit sgd(X,Y,diagnosis=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.title('Iris by SGD')\n",
    "plt.xlabel('Dimension 1')\n",
    "plt.ylabel('Dimension 2')\n",
    "for i in np.unique(forecast_sgd.ravel()):\n",
    "    plt.scatter(X[forecast_sgd.ravel()==i][:,1],\n",
    "                X[forecast_sgd.ravel()==i][:,2],\n",
    "                label=f'Group {int(i)}')\n",
    "plt.legend()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mini-batch Gradient Descent\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "Mini-batch Gradient Descent is a mixture of BGD and SGD. MBGD takes consideration of the error from a subset at each iteration. It attempts to balance the tradeoff between efficiency from SGD and effectiveness from BGD. However, it creates a new hyperparameter for us to tune, batch size. Our learning rate $\\alpha$ is required to adapt with the change of batch size. \n",
    "\n",
    "More details of batch size can be found in the discussion below.\n",
    "\n",
    "https://stats.stackexchange.com/questions/164876/what-is-the-trade-off-between-batch-size-and-number-of-iterations-to-train-a-neu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "#mini batch gradient descent\n",
    "#a mixture of sgd and bgd\n",
    "def mbgd(X,Y,tau=0.001,alpha=0.001,max_itr=1000,\n",
    "        theta_init=[],batch_size=32,shuffle=False,\n",
    "         diagnosis=True):\n",
    "\n",
    "    #initialize\n",
    "    counter=0\n",
    "\n",
    "    #theta denotes coefficients\n",
    "    #initialize theta\n",
    "    if len(theta_init)>0:\n",
    "        theta=theta_init\n",
    "    else:\n",
    "        theta=np.ones((X.shape[1],1))\n",
    "\n",
    "    #residuals or you can call it objective function\n",
    "    epsilons=[]\n",
    "    \n",
    "    #collect thetas for viz\n",
    "    thetas=[theta.copy()]\n",
    "    \n",
    "    #shuffled subset\n",
    "    aleatoire=np.random.choice(X.shape[0],batch_size)\n",
    "\n",
    "    #iterate through the entire dataset\n",
    "    while counter<max_itr:\n",
    "        \n",
    "        #shuffled subset\n",
    "        if shuffle:\n",
    "            aleatoire=np.random.choice(X.shape[0],batch_size)\n",
    "        x=X[aleatoire]\n",
    "        y=Y[aleatoire]            \n",
    "\n",
    "        #gradient descent\n",
    "        y_estimated=x@theta\n",
    "        epsilon=y_estimated-y\n",
    "        gradient=x.T@epsilon/x.shape[0]\n",
    "        theta-=alpha*gradient\n",
    "\n",
    "        #tracking\n",
    "        counter+=1\n",
    "        epsilons.append(epsilon.ravel()[0])\n",
    "        thetas.append(theta.copy())\n",
    "\n",
    "        #convergence\n",
    "        if len(epsilons)>1 and abs(epsilons[-1]-epsilons[-2])<tau:\n",
    "            if diagnosis:\n",
    "                print(f'Converged after {counter} iterations.')\n",
    "            return thetas,epsilons\n",
    "                \n",
    "    if diagnosis:\n",
    "        print(f'Not converged.')\n",
    "    return thetas,epsilons"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converged after 331 iterations.\n"
     ]
    }
   ],
   "source": [
    "#well mbgd is supposed to be between bgd and sgd\n",
    "thetas_mbgd,_=mbgd(X,Y,shuffle=False)\n",
    "theta_mbgd=thetas_mbgd[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of MBGD\n",
      " 0.77\n"
     ]
    }
   ],
   "source": [
    "#mbgd is not that accurate\n",
    "forecast_mbgd=np.sign(X@theta_mbgd)\n",
    "forecast_mbgd[forecast_mbgd<0]=0\n",
    "print('Accuracy of MBGD\\n',len(forecast_mbgd[forecast_mbgd==Y])/len(Y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Coefficients from MBGD\n",
      " [[0.90860075]\n",
      " [0.65742179]\n",
      " [0.94107646]]\n"
     ]
    }
   ],
   "source": [
    "print('Coefficients from MBGD\\n',theta_mbgd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of squared errors from MBGD\n",
      " 82.1414376313023\n"
     ]
    }
   ],
   "source": [
    "#as expected, its sse is somewhere between bgd and sgd\n",
    "sse_mbgd=((X@theta_mbgd-Y).T@(X@theta_mbgd-Y)).ravel()[0]\n",
    "print('Sum of squared errors from MBGD\\n',sse_mbgd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12.4 ms ± 500 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    }
   ],
   "source": [
    "#apparently mbgd is not that better than bgd in performance\n",
    "%timeit mbgd(X,Y,shuffle=False,diagnosis=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "28.3 ms ± 4.74 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "#with shuffled subset at each iteration\n",
    "#the performance is even slower\n",
    "%timeit mbgd(X,Y,shuffle=True,diagnosis=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.title('Iris by MBGD')\n",
    "plt.xlabel('Dimension 1')\n",
    "plt.ylabel('Dimension 2')\n",
    "for i in np.unique(forecast_mbgd.ravel()):\n",
    "    plt.scatter(X[forecast_mbgd.ravel()==i][:,1],\n",
    "                X[forecast_mbgd.ravel()==i][:,2],\n",
    "                label=f'Group {int(i)}')\n",
    "plt.legend()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Convergence Comparison"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "#get sum of squared errors\n",
    "epsilons_bgd=[((X@i-Y).T@(X@i-Y).ravel())[0] for i in thetas_bgd]\n",
    "epsilons_sgd=[((X@i-Y).T@(X@i-Y).ravel())[0] for i in thetas_sgd]\n",
    "epsilons_mbgd=[((X@i-Y).T@(X@i-Y).ravel())[0] for i in thetas_mbgd]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "#create x and y coordinates\n",
    "shape_x=np.linspace(theta_ols.ravel()[1]-1,theta_ols.ravel()[1]+1,11)\n",
    "shape_y=np.linspace(theta_ols.ravel()[2]-1,theta_ols.ravel()[1]+1,11)\n",
    "hyperplane_x,hyperplane_y=np.meshgrid(shape_x,shape_y)\n",
    "\n",
    "#create z coordinates based upon sum of squared errors\n",
    "shape_z=[]\n",
    "for i in zip(np.ravel(hyperplane_x), np.ravel(hyperplane_y)):\n",
    "    theta=np.hstack((theta_ols[0],np.array(i))).reshape(-1,1)\n",
    "    shape_z.append(((X@theta-Y).T@(X@theta-Y)).ravel()[0])\n",
    "hyperplane_z=np.array(shape_z).reshape(hyperplane_x.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib notebook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support.' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            if (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
       "            }\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        fig.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option)\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\n",
       "\n",
       "    return {\"x\": x, \"y\": y};\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys (original) {\n",
       "  return Object.keys(original).reduce(function (obj, key) {\n",
       "    if (typeof original[key] !== 'object')\n",
       "        obj[key] = original[key]\n",
       "    return obj;\n",
       "  }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
       "    var canvas_pos = mpl.findpos(event)\n",
       "\n",
       "    if (name === 'button_press')\n",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.key_event = function(event, name) {\n",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
       "    if (name == 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message(\"toolbar_button\", {name: name});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to  previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function() {\n",
       "        comm.close()\n",
       "    };\n",
       "    ws.send = function(m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function(msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        event.shiftKey = false;\n",
       "        // Send a \"J\" for go to next cell\n",
       "        event.which = 74;\n",
       "        event.keyCode = 74;\n",
       "        manager.command_mode();\n",
       "        manager.handle_keydown(event);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.find_output_cell = function(html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i=0; i<ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code'){\n",
       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] == html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel != null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\" width=\"448\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#viz\n",
    "ax=plt.figure(dpi=70).add_subplot(111, projection='3d')\n",
    "\n",
    "ax.plot([i[1] for i in thetas_sgd],\n",
    "        [i[2] for i in thetas_sgd],\n",
    "        epsilons_sgd,label='SGD',\n",
    "        alpha=0.7,color='cyan',lw=7)\n",
    "ax.plot([i[1] for i in thetas_mbgd],\n",
    "        [i[2] for i in thetas_mbgd],\n",
    "        epsilons_mbgd,label='MBGD',\n",
    "        alpha=0.7,color='indigo',lw=4)\n",
    "ax.plot([i[1] for i in thetas_bgd],\n",
    "        [i[2] for i in thetas_bgd],\n",
    "        epsilons_bgd,label='BGD',\n",
    "        alpha=0.7,color='pink',lw=1)\n",
    "ax.plot(theta_ols[1],theta_ols[2],\n",
    "        ((X@theta_ols-Y).T@(X@theta_ols-Y)).ravel()[0],\n",
    "        marker='o',lw=0,label='OLS',alpha=0.7,c='red')\n",
    "ax.plot_surface(hyperplane_x,hyperplane_y,hyperplane_z,\n",
    "                cmap='gist_heat',alpha=0.9)\n",
    "\n",
    "ax.set_title('Gradient Descent')\n",
    "ax.set_xlabel('Theta 1')\n",
    "ax.set_ylabel('Theta 2')\n",
    "ax.set_zlabel('Squared Loss')\n",
    "ax.legend(loc=2)\n",
    "ax.view_init(elev=25, azim=105)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "#obviously bgd has the most proximity to ols\n",
    "#sgd is so far off and mbgd is somewhere in the middle"
   ]
  }
 ],
 "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": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "156px"
   },
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}