{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Neural Learning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Last revision: Wed  30 Dec 2021 16:45:03 AEST"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Author: Omar Ghattas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this lab we will expand on some of the concepts of neural learning, starting with an extension of the perceptron to the linear unit, which can be trained using gradient descent. \n",
    "\n",
    "The remainder of the lab goes into some \"hands-on\" aspects of supervised learning for neural networks, based on the multi-layer perceptron trained by error back-propagation. \n",
    "\n",
    "This code is for explanatory purposes only – for real neural networks you would use one of the many code libraries that exist. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Acknowledgements:\n",
    "Autograd Theory:\n",
    "\n",
    "    1. https://people.cs.umass.edu/~domke/courses/sml2011/08autodiff_nnets.pdf\n",
    "    2. Mathematics for Machine Learning by Marc Peter Deisenroth, A. Aldo Faisal, and Cheng Soon Ong.\n",
    "\n",
    "Pytorch Neural Network Examples:\n",
    "\n",
    "    1. https://pytorch.org/tutorials/beginner/blitz/neural_networks_tutorial.html\n",
    "    \n",
    "MLP Code from Scratch\n",
    "\n",
    "    1. https://github.com/rcassani/mlp-example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Useful Functions\n",
    "We will rely on the following helper functions from Lab3:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def generate_data(n=20, means=[[3,3],[-1,1]], seed=1):\n",
    "    '''\n",
    "    generate data from two gaussians\n",
    "    '''\n",
    "    np.random.seed(seed)\n",
    "    m1 = np.array(means[0])\n",
    "    m2 = np.array(means[1])\n",
    "    S1 = np.random.rand(2,2)\n",
    "    S2 = np.random.rand(2,2)\n",
    "    dist_01 = np.random.multivariate_normal(m1, S1.T @ S1, n)\n",
    "    dist_02 = np.random.multivariate_normal(m2, S2.T @ S2, n)\n",
    "    X = np.concatenate((np.ones(2*n).reshape(-1,1), \n",
    "                        np.concatenate((dist_01, dist_02))), axis=1)\n",
    "    y = np.concatenate((np.ones(n), np.zeros(n))).reshape(-1,1)\n",
    "    shuffle_idx = np.random.choice(2*n, size=2*n, replace=False)\n",
    "    X = X[shuffle_idx]\n",
    "    y = y[shuffle_idx]\n",
    "    return X, y\n",
    "\n",
    "def plot_perceptron(ax, X, y, w):\n",
    "    pos_points = X[np.where(y==1)[0]]\n",
    "    neg_points = X[np.where(y==0)[0]]\n",
    "    ax.scatter(pos_points[:, 1], pos_points[:, 2], color='blue')\n",
    "    ax.scatter(neg_points[:, 1], neg_points[:, 2], color='red')\n",
    "    xx = np.linspace(-6,6)\n",
    "    yy = -w[0]/w[2] - w[1]/w[2] * xx\n",
    "    ax.plot(xx, yy, color='orange')\n",
    "    \n",
    "    ratio = (w[2]/w[1] + w[1]/w[2])\n",
    "    xpt = (-1*w[0] / w[2]) * 1/ratio\n",
    "    ypt = (-1*w[0] / w[1]) * 1/ratio\n",
    "    \n",
    "    ax.arrow(xpt, ypt, w[1], w[2], head_width=0.2, color='orange')\n",
    "    ax.axis('equal')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Augmenting the Perceptron with Gradient Descent\n",
    "\n",
    "Recall from that the Perceptron is a mistake-driven algorithm - it continues to update so long as it makes mistakes on the data. In the linearly separable setting, where can separate the data exactly with a linear separator, the algorithm is always guaranteed to terminate. If however the data is not linearly separable, the algorithm will never terminate. In this case, we might still want to learn a linear classifier that achieves low error (classifies most of the points correctly), and instead of looking at a mistake-driven algorithm, we look instead to a loss-based algorithm. In this section, we introduce learning linear classifiers via gradient descent. You should view this section of the lab as a precursor to learning in multilayer perceptrons (Neural Networks) via Backpropagation. This extension is known as the linear unit, it is basically a one-node neural network."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The original perceptron uses the sgn activation function, which we saw earlier has a 'S' shape. We can use a smoother version of the sgn activation known as a sigmoid. The reason we prefer smoother activations is that we can take derivatives (any function with sharp angles (discontinuities) is not differentiable). We use here a type of sigmoid known as the logistic sigmoid: \n",
    "\n",
    "$$\n",
    "\\sigma(x) = \\frac{1}{1+e^{-x}}\n",
    "$$\n",
    "\n",
    "Now, note that\n",
    "\n",
    "$$\n",
    "\\frac{d \\sigma(x)}{d x} = \\sigma(x) (1-\\sigma(x))\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now implement the sigmoid and its derivative and observe its shape for different values of the steepness parameter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sigmoid(x):\n",
    "    return 1/(1+np.exp(-1*x))\n",
    "\n",
    "def grad_sigmoid(x):\n",
    "    return sigmoid(x) * (1-sigmoid(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot sigmoid functions \n",
    "xx = np.linspace(-6, 6, 1000)\n",
    "plt.plot(xx, sigmoid(xx), label='$\\sigma(x)$')\n",
    "plt.plot(xx, grad_sigmoid(xx), label='$\\sigma\\'(x)$')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instead of updating $w$ whenever we make a mistake, i.e. whenever $w^T x y < 0$, we will consider updating the weight vector by moving in a direction that minimizes the loss as much as possible, this is known as gradient descent/\n",
    "\n",
    "Recall that the prediction (output) of the standard perceptron was $\\hat{y}=\\text{sgn}(h_w(x))$. Since we are no longer using the sign activation, but the sigmoid activation, our output now is $\\hat{y} =  \\sigma(h_w(x)) = \\sigma(w^T x)$. Next, consider the cross-entropy loss\n",
    "\n",
    "$$\n",
    "L(w) = - \\sum_{i=1}^N y_i \\ln p_i + (1-y_i) \\ln (1-p_i), \\qquad p_i = \\sigma(w^T x_i) = \\frac{1}{1+e^{-w^T x_i}}.\n",
    "$$\n",
    "\n",
    "We would like to find $\\hat{w}$ that minimizes this loss, i.e. we want to solve \n",
    "\n",
    "$$\n",
    "\\hat{w} = \\arg \\min_w L(w).\n",
    "$$\n",
    "\n",
    "Unfortunately in this case, we cannot solve for $\\hat{w}$ in closed form, and so we must resort to numerical techniques such as gradient descent."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " <font color='purple'>\n",
    "\n",
    "#### Exercise:\n",
    "    \n",
    "1. Show that $\\frac{d p_i}{dw} = p_i (1-p_i) x_i$, where $p_i = \\sigma(w^T x_i)$.\n",
    "2. Show that $\\frac{d \\ln p_i}{dw} = (1-p_i) x_i$.\n",
    "3. Using the results of the previous parts, show that $\\frac{d L(w)}{dw} = - \\sum_{i=1}^n (y_i - p_i) x_i$. Write down the gradient descent update for $w$ with step size $\\eta$.\n",
    "4. Fill out the code below to implement gradient descent for the model on a randomly generated dataset."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " <font color='green'>\n",
    "\n",
    "#### Solutions:\n",
    "1. This follows immediately by the chain rule:\n",
    "    \\begin{align*}\n",
    "        \\frac{d p_i}{d w} \n",
    "        = \\frac{d \\sigma(w^T x_i) }{d w} \n",
    "        = \\frac{d \\sigma(w^T x_i) }{d (w^T x_i)}  \\frac{d (w^T x_i) }{d w} \n",
    "        = \\sigma(w^T x_i) (1-\\sigma(w^T x_i) )x_i \n",
    "        = p_i (1-p_i)x_i.\n",
    "    \\end{align*}\n",
    "    \n",
    "    \n",
    "2.  Using the chain rule again gives us:\n",
    "    \\begin{align*}\n",
    "        \\frac{d\\ln p_i}{dw}  = \\frac{d \\ln p_i}{d p_i} \\frac{d p_i}{dw}=\\frac{1}{p_i} p_i (1-p_i)x_i = (1-p_i)x_i \n",
    "    \\end{align*}\n",
    "    \n",
    "    \n",
    "3. The working is as follows:\n",
    "    \n",
    "    \\begin{align*}\n",
    "            \\frac{d L(w)}{dw} \n",
    "            &= \\frac{d}{dw} \\left [-\\sum_{i=1}^n y_i \\ln p_i + (1-y_i) \\ln (1-p_i)\\right ]\\\\\n",
    "            &= -\\sum_{i=1}^n \\left [y_i \\frac{d}{dw} \\ln p_i + (1-y_i) \\frac{d}{dw} \\ln (1-p_i)\\right ]\\\\\n",
    "            &= -\\sum_{i=1}^n \\left [y_i (1-p_i)x_i + (1-y_i) \\left ( -\\frac{1}{1-p_i} p_i (1-p_i) x_i\\right)\\right ]\\\\\n",
    "            &= -\\sum_{i=1}^n \\left [y_i (1-p_i)x_i - (1-y_i) p_i  x_i\\right ]\\\\\n",
    "            &= -\\sum_{i=1}^n (y_i - p_i)x_i.\n",
    "        \\end{align*}\n",
    "\n",
    "Therefore, the gradient descent update at iteration $k+1$ is \n",
    "\\begin{align*}\n",
    "    w^{(k+1)} = w^{(k)} + \\eta\\sum_{i=1}^n (y_i - p_i)x_i.\n",
    "\\end{align*}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loss_i(w, x_i, y_i):\n",
    "    '''cross entropy loss for i-th data point'''\n",
    "    p = sigmoid(w@x_i)\n",
    "    return -1 * (y_i * np.log(p) + (1-y_i) * np.log(1-p))\n",
    "    \n",
    "def grad_loss_i(w, x_i, y_i):\n",
    "    '''grad loss for i-th data point'''\n",
    "    p = sigmoid(w@x_i)\n",
    "    return -1 * (y_i - p) * x_i\n",
    "\n",
    "def gradient_descent(X, y, eta, T):\n",
    "    N = X.shape[0]\n",
    "    w = np.array([0,0,0]) # init w\n",
    "    for t in range(T):\n",
    "        loss = 0\n",
    "        grad_loss = 0\n",
    "        for i in range(N):\n",
    "            loss += loss_i(w, X[i], y[i])\n",
    "            grad_loss += grad_loss_i(w, X[i], y[i])\n",
    "        print(f\"loss = {loss}\")\n",
    "        w = w - eta * grad_loss\n",
    "        fig, ax = plt.subplots()\n",
    "        plot_perceptron(ax, X, y, w)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss = [55.45177444]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXIAAAD4CAYAAADxeG0DAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAg+klEQVR4nO3dd5yU1b3H8c9vC52lLiJSFkRRNBZYUFS6FYmo0USD/RqixgTTjIZcr0kuN4kmRhNbsMRoiCQW7A2kiQVdFRAFFRUVQlkEaUvZcu4fZwjLOrM7u/PMPFO+79drXzvM0348M/vdZ8+c5xxzziEiIpkrL+wCREQkMQpyEZEMpyAXEclwCnIRkQynIBcRyXAFYRy0c+fOrqSkJIxDi4hkrDfffHO9c6647vOhBHlJSQllZWVhHFpEJGOZ2afRnlfTiohIhlOQi4hkOAW5iEiGU5CLiGQ4BbmISIZTkIuIZDgFuYhIhlOQp6u1c+H9P4ddhYhkgFBuCJI4fHwvfHI/5LeAvt8JuxoRSWMK8nQ1+C7YUQ6vfxcK2kLJOWFXJCJpSk0r6Sq/GQx9GLoMhVfPh1VPhV2RiKSpQILczNqb2cNmtszMlprZkCD2m/MKWsHwJ6HDEfDSWbB2dtgViUgaCuqK/BbgOefcQcDhwNKA9iuFRTDyOWjbF+Z+HdYvCLsiEUkzCQe5mbUDhgH3ADjndjnnvkx0v1JL804waga02AfmnAIbF4ddkYikkSCuyHsD5cBfzextM7vbzFrXXcnMJphZmZmVlZeXB3DYHNNyXxg1E/JbwewTYfOHYVckImkiiCAvAAYAdzjnjgS2AdfUXck5N8U5V+qcKy0u/sq46BKPNr19mLtqmHU8bPss7IpEJA0EEeQrgZXOud2Ntw/jg12Sod1BMPIFqNzkw3z72rArEpGQJRzkzrk1wOdm1i/y1GjgvUT3K/XoeCSMeBoqVvlmll0bw65IREIUVK+V7wNTzWwxcATwfwHtV2IpPhaGPQabl8HsMVC5NeyKRCQkgQS5c25hpP37MOfc6c45XSKmwr4nwLHTYMMbMG8cVO8IuyIRCYHu7Mx0Pc6Ao++DtbNg/jehpjLsikQkxRTk2aD3eVB6G6x6El69CGqqw65IRFJIg2ZliwOvgMrNsOhaKGwDg+4Es7CrEpEUUJBnk0Ou8WH+3m/8rf1H3KAwF8kBCvJsc/hkH+ZLfw+F7eDQX4RdkYgkmYI825hB6Z98mC/+b39l3u8HYVclIkmkIM9GlgdH3wtVW+HNiX5iiv0vDrsqEUkS9VrJVnkFcOyD0PUEeP1S+OzhsCsSkSRRkGez/OYwbDp0HgKvfBv+/WzYFYlIEijIs11Baxj+FLQ7FF46E9bNC7siEQmYgjwXNGsPI5+H1iUwZyx8URZ2RSISIAV5rmhR7GcZat4JZp8EX74bdkUiEhAFeS5p1T0yy1BzmH0CbPko7IpEJAAK8lzTdn8YOQOqd/qJKSpWhl2RiCRIQZ6L2h/i28x3fgGzToAdmkNVJJMpyHNVp1IY8RRsW+HbzHdtCrsiEWkiBXku6zIMhk6HTUtg7lioqgi7IhFpAgV5rut2MhwzFda/AvPO8G3nIpJRFOQCPc+GwXfDmhf8HaA1VWFXJCKNoCAXb/+LYcDN8PmjsOBScDVhVyQicdLoh7LHQRP98LfvXAeFbWHgnzQxhUgGUJDL3g79BVRugmV/8BNTHP6/YVckIg0ILMjNLB8oA1Y558YGtV9JMTM48kZ/Zf7uZH9l3v9nYVclIvUI8op8IrAUKApwnxIGMxh0B1RtgYXX+IkpDrwi7KpEJIZAPuw0s+7AqcDdQexP0kBePgy5H7qNhbLvwSd/D7siEYkhqF4rNwNXAzG7OpjZBDMrM7Oy8nLdEp4R8gph6EOwz0h47SL4/LGwKxKRKBIOcjMbC6xzzr1Z33rOuSnOuVLnXGlxcXGih5VUyW8Bwx6HjqXw8rdg9YywKxKROoK4Ij8WOM3MVgDTgFFmpr/Ds0lhWxjxDBT1g3mnQ/krYVckIrUkHOTOuWudc92dcyXAOcAs59x5CVcm6aV5Rxj5ArTsBnPGwIa3w65IRCJ0Z6fEr2VXGP0iFBb5ERM3LQu7IhEh4CB3zs1RH/Is17qnn2XIzM8ytHVF2BWJ5DxdkUvjFR3oZxmq3OpnGdq+OuyKRHKaglyapsNhMPJZ2LHGzzK084uwKxLJWQpyabrOR8OwJ2DLcph9ClRuCbsikZykIJfEdB0Fxz0EG9+GuV+Hqu1hVySScxTkkrjuX/e386+bB/PPgupdYVckklMU5BKMknNh8J3w72fg1fOgpjrsikRyhsYjl+D0neCHv337p76v+eC7NDGFSAooyCVYB//Eh/mSX/vhbwfcpDAXSTIFuQTva7+EXZvg/Zv9LEOHXR92RSJZTUEuwTODgX+Eqs2w5JfQrB0c9MOwqxLJWgpySQ7L823klVvhrR/5Zpa+l4ZdlUhWUpBL8uQVwDFTYd5WeH2CHw6317fCrkok66j7oSRXfjMY+ggUHwevnAerng67IpGsoyCX5CtoBSOegg5H+BuG1s4JuyKRrKIgl9QoLIKRz0GbPv5W/vWvh12RSNZQkEvqNO/kh79t0QXmnAxfvhN2RSJZQUEuqdWqm5+YIr+VH/5284dhVySS8RTkknptesOoGeCq/cQU2z4LuyKRjKYgl3C0OxhGPg+VX/or8+1rw65IJGMpyCU8HQfA8Keh4nM/mfOujWFXJJKRFOQSri7HwbDHYPNSmD3G3wkqIo2iIJfw7XsiHPsgbHgd5p0O1TvCrigtTZ0KJSWQl+e/T50adkWSLhIOcjPrYWazzew9M3vXzCYGUZjkmB5nwlF/hbUvwvxvQU1l2BWllalTYcIE+PRTcM5/nzBBYS5eEFfkVcCPnXP9gaOB75lZ/wD2K7mmzwVQeiusegJevQhcTdgVhabu1ffEiVBRsfc6FRUwaVIY1Um6SXjQLOfcamB15PEWM1sK7Ae8l+i+JQcd+D0/McWin/u7QQfdnjsTU1TvhE8eYOWCx/n+FQ+xcXMLwF99x/KZem4KAY9+aGYlwJHAgijLJgATAHr27BnkYSXbHHItVG6C937nR0w84nfZHeaVm+GD2/3/t2oLO9f35cstzeLaVD9KAgEGuZm1AR4BrnLOba673Dk3BZgCUFpa6oI6rmSpw3/jA27pjdCsPRzy87ArSo7qHfBoN6AGqrdDfmsuu/tWnGu41bNVK5g8OfklSvoLJMjNrBAf4lOdc48GsU/JcWa+vbxyKyya5Cem6Pf9sKsKnhX6MWgqPqPGGWXLD2PmkuPj2nTKFBg/Psn1SUZIOMjNzIB7gKXOuZsSL0kkwvLg6Huhagu8+QPfZt7nwrCrCtaHt0HFnobuy+6+Na7NevVSiMseQfRaORY4HxhlZgsjX2MC2K+In2Xo2GnQ9QRYcAl89kjYFQVn0S/gzYlwwOX0u247g37xBm+vGNDgZs2aqUlF9hZEr5X5QBZ/EiWhy28Ow6bDrBPhlXOh4EnodlLYVSVmwQT46C449H/gsOv58GNwbmCDm3XqBLfcoqtx2Zvu7JTMUNAaRjwN7Q6Bl86AdfPDrqjp5o7zIV56Kxx2PRB/7xOFuESjIJfM0ay9HzGxdU+YeypseCvsihrvuUH+hqdjHvR95iMmT4bCwoY31w1AEo2CXDJLiy5+YopmHWD2ibApg+47m94NNpTBiGeh5JyvLC4qangXugFIolGQS+Zp1d2HuRX6scy3fhJ2RfVzDv5hsH01nPAKdDt5r8VTp8KFF8IXXzS8K90AJNEoyCUzte3rZxmq3gEvjoaKVWFXFF1NNTwY+TEb8w4UD/nKKt/9LlRXN7yrwkL1VpHoFOSSudofCiOfg53l/sp8x/qwK9pb9S6YFukYdtonvt4otm1reFedOsFf/6oPOiU6Bblktk6DYPhTsO2TyCxDm8KuyKvcCv9s7h+fuRbalERdLd5haNevV4hLbApyyXz7DIfjHoEvF8PcsVBV0fA2ybTzC3iorX981pf+A9qI2sPTtmkD550XSoWSZRTkkh32GwPHTIX1r8BLZ/ohYcNQsRIe6ewff7MCmrX7z6K6k0PE06QiEg8FuWSPXt+EwVNg9fPwynioqUrt8Td/AI/18I/PqYSClnstnjTpq5NDiARBQS7ZZf//ggE3weePwIJLUzfL0Ia34Kl+/vG5NX6MmDqa2ge8desE6pKcoCCX7HPQD+Fr18Mnf4M3r/LtGMm0djY8N9APtXtuzZ5JMOrM13Zlx8ZPsJmfD3/5S7DlSvYJdIYgkbRx6HV+YoplN/nhbw//3+Qc5/Ppvk2+6CAYu3TP87sbxHe3pXz6KTc1m8CWQrivMv7uJxMmqLeKNExX5JKdzODI38P+l8K7k+G9G4I/xkf3+BDfZ/TeIQ5RG8QLdlXw56LGDZbyt7/F30VRcpeCXLKXGQy6E3p+Cxb+DD68M7h9v3eDb4MvOQ9Gz/zq8hgzJrfZ8BmXXx7/YSoqNFCWNExBLtktLx+OeQC6nQpvXAEr/pH4Pt/6qf/F0O+Hft91XXFF7G179uT22xs3l7QGypKGKMgl++UVwnEPQZfh8OoFsPLxpu/rlQth2e/95NADo8xsOHUq3HFH1E1rgPGfTqakpHGfv2qgLGmIglxyQ0FLGP4EdBwI878Ja15s/D5mnQgr7ofBd8Eh10Rfp552EAP+wfhYrS5RtWqlgbKkYQpyyR2Fbf1Y4EX9YN44KH81/m2fPhTWzIChj0DfS6OvM3VqzLbxeI0e7SdWNvPfp0xRrxVpmIJcckvzjjDyBWixL8wZAxsX1b++c/BQO9j0Lox6EXqcGX29K64IZOCU5cv9FXhNDaxYoRCX+CjIJfe07Op7mhS29bMMbX4/+nrO+bHEKzfDSW9A11HR15s6Fe5suEfMejo1uM6nn/q+4+pyKI2hIJfc1LqXn2UIYNbxsK1Ok0hN1Z4JIcYug06lsfc1aVKDn17uIo+J3BJXaepyKI0VSJCb2clm9r6ZLTezGJ8CiaSZogN9M0vlVnjxeNi+xj9fvQOmRWZCHveZb1OPJc528R205EHibydRl0NpjISD3MzygduAU4D+wLlm1j/R/YqkRIfDYcQzsGO1n2Vo2wr4Z2TUwjPLoXWP2NvunmwzDm3ZxrnE316iLofSGEFckQ8GljvnPnbO7QKmAeMC2K9IahQPgWGPw5YP4PHe/rmzt0CLzvVvN3FifJNt4rse/tbiay9Rl0NprCCCfD/g81r/Xhl5bi9mNsHMysysrLy8PIDDigSo62g4dhqQB12GgeU3vE08097X0sN9Rq9e0Zfl56vLoTRdyj7sdM5Ncc6VOudKi4uLU3VYkfj1OAOG3A/rXoL5Z0NN5VfX2T00bWPusY+wXj2ZPBkKC/d+vrDQD46lLofSVEEE+SqgdkNi98hzIpmn93gYdDv8+2l/O39NraaT2nO1NdI2WjF/jG8vqfs7oAm/E0T2Yi7BQffNrAD4ABiND/A3gG87596NtU1paakrKytL6LgiSfXejbDwaj8M7uApPm07d250c4rD9x+fyC38K3887dtH30WvXv5qXKQ+Zvamc+4rfWETnljCOVdlZlcCzwP5wL31hbhIRuj/U6jc5McyLyyCpUc2OsSrMc7ngT3dDqtj70LdDSURgcwQ5Jx7BngmiH2JpI3Dfr1nlqEX2zVq05q6Id4AdTeURGiqN5FYzGDgzVC1BY6/D1YDzzW8mQPuyruMB2viC3F1N5RE6RZ9kfpYnh+2dkkrOB8YHscm/fvT5v7byY/Rg7FTJ41wKMHSFblIQ/IK4JDbYPHFcCmwA1gQY93Ro2HmzP80qNSefxn81fcttyi4JVi6IheJx/iL4I/4/llXAIfXWf73v/uBs2buPX9ny5Z7HnfqpKtvSQ4FuUi89u0Fv8ffx3wVcFDk+U6dvpLOu7uc1+6lsn17asqU3KMgF4nX5MlgreC3wDrgJ0D/5r6tpI5Jk/ZuUgENTyvJoyAXidf48b5tpFMvH+bbC+DnBXBq3XaW2P3C1V9ckkFBLtIY48f7WzA3OLjofWjVzg9/u2X5XqvF6heu/uKSDApykaZq0wdGzQBXGZllaM8goJMn+x4qtam/uCSLglwkEe36w8jnYddGmH0C7FgH7GmFUX9xSYWEB81qCg2aJVln3Xw/kXNRPxg9G5q1D7siyUKxBs3SFblIELocB0Onw6Z3Yc4YqNoWdkWSQxTkIkHpdhIc8yB8sQDmne4ncRZJAQW5SJB6fgOOuhfWzISXz4WaqrArkhygIBcJWp8LYeCfYeVj8NrF4GrCrkiynAbNEkmGfldC1WZYNAkK20LpbZrTTZJGQS6SLP2vhV2bYOkNUNgOjvhN2BVJllKQiySLGRzxWz/L0Hu/9VPGHXJt2FVJFlKQiySTGQy6zc8ytOjnPswP/F7YVUmWUZCLJJvlwdF/haqtUHYlFLSFPheEXZVkEfVaEUmFvEI4dhrsMxoWXAyfTw+7IskiCnKRVMlvAcMeg05HwcvnwOoXwq5IskRCQW5mN5rZMjNbbGbTzax9QHWJZKfCNjDiaSg62N/9uW5+2BVJFkj0inwGcKhz7jD8bIb6SF6kIc06wKgXoFUPmHsqbHgz7IokwyUU5M65F5xzu+9Bfg3onnhJIjmgRRcYNRMK28Psk2HT0rArkgwWZBv5JcCzsRaa2QQzKzOzsvLy8gAPK5KhWvfwYW75fmKKrZ+EXZFkqAaD3MxmmtmSKF/jaq0zCagCpsbaj3NuinOu1DlXWlxcHEz1Ipmu6AA/y1D1dh/mFf8OuyLJQA32I3fOHV/fcjO7CBgLjHZhzFIhkunafw1GPAuzRvtZhkbPhRadw65KMkiivVZOBq4GTnPOVQRTkkgO6nwUDH8StnwEc072t/WLxCnRNvJbgbbADDNbaGZ3BlCTSG7aZyQMfRg2LoI5Y6FK10YSn4Ru0XfO9Q2qEBEB9hsLx/zdT0rx0jdg2OOQ3yzsqiTN6c5OkXTT61sweAqsfg5eGa9ZhqRBGjRLJB31vdSPmPjWj+D1NnDUPX7wLZEoFOQi6eqgH/oPPd+5HgqKYODNmmVIolKQi6SzQ6/zswy9/0do1g4O+1XYFUkaUpCLpDMzGPAHP//nkl/7scz7/zTsqiTNKMhF0p0ZDPoLVG6BhVf7K/O+E8KuStKIglwkE+Tlw5AH/CxDr1/mr8xLzg27KkkT+hhcJFPkN4PjHoYuw+DV82Hlk2FXJGlCQS6SSQpa+lv5OwyA+WfDmllhVyRpQEEukmkK28LIZ6HtATDvNFj/WtgVScgU5CKZqHknP8tQi64w+xTYuDjsiiRECnKRTNVy38gsQ2388LebPwi7IgmJglwkk7Up8WHunJ+YYttnYVckIVCQi2S6on6+maVysw/z7WvDrkhSTEEukg06HOFnGapY5ZtZdm4IuyJJIQW5SLYoHgLDH4fN78OcMf5OUMkJCnKRbNL1eDjuX7ChDOaNg+odYVckKaAgF8k23cfB0ffB2tnw0tlQUxl2RZJkCnKRbNT7PBh0B/z7KXj1AqipDrsiSSINmiWSrQ64DCo3wcJr/CBbg/+iiSmylIJcJJv1/5mfmOK930BhERx5o8I8CynIRbLd4ZN9H/Nlf/Bh/rXrwq5IAhZIG7mZ/djMnJl1DmJ/IhIgMyj9E/S+AN75H1h2S9gVScASviI3sx7AiYDuDRZJV5YHR93j+5a/dZUfQXH/S8KuSgISxBX5H4GrARfAvkQkWfIK4NgHoeuJ8Pp34LOHwq5IApJQkJvZOGCVc25RHOtOMLMyMysrLy9P5LAi0lT5zWHYo9B5CLz8bVj1TNgVSQAaDHIzm2lmS6J8jQN+DsT1yYlzbopzrtQ5V1pcXJxo3SLSVAWtYfjT0P4wmP8NWDs37IokQQ0GuXPueOfcoXW/gI+B3sAiM1sBdAfeMrOuyS1ZRBLWrB2MfA5a94a5X4cvysKuSBLQ5KYV59w7zrkuzrkS51wJsBIY4JxbE1h1IpI8LYph1Axo3hlmnwRfvht2RdJEukVfJJe12g9Gz/Rt57NPgC0fhV2RNEFgQR65Ml8f1P5EJEXa9PGzDNXs8hNTVKwMuyJpJF2Riwi06w8jn4edX8CsE2CHepZlEgW5iHgdB8KIp2Hbp77NfNeXYVckcVKQi8geXYbC0Edh0xKYOxaqtoVdkcRBQS4ie+t2MhzzD1j/Ksw7E6p3hl2RNEBBLiJf1fMsPzbLmhfg5XOhpirsiqQeCnIRia7PRTDwFlg5HV67BFxN2BVJDBqPXERi6/cDP5b54v/2IyaW3qqJKdKQglxE6nfIJD9l3NLfQ2E7OOL/wq5I6lCQi0j9zOCIG/yV+e4p4w65JuyqpBYFuYg0zAxKb4fKrbDoWh/mB14RdlUSoSAXkfjk5cOQ+6BqC5R9z7eZ9z4/7KoE9VoRkcbIK4Tj/gX7jILXLobPp4ddkaAgF5HGym8Bwx6HjqXw8jmwekbYFeU8BbmINF5hGxjxDBQdBPNOh/KXw64opynIRaRpmneEkS/4Mc3nnAob3g67opylIBeRpmu5jx/LvLAIZp8Im5aFXVFOUpCLSGJa94RRL4Ll+4kptq4Iu6KcoyAXkcQVHeCbWaorfJhvXx12RTlFQS4iwehwGIx4Fnas8bMM7fwi7IpyhoJcRILT+SgY/iRsWQ6zT/G39UvSKchFJFj7jIShD8PGt2Hu16GqIuyKsp6CXESCt99YGPIArHsJXjoLqneFXVFWSzjIzez7ZrbMzN41sxuCKEpEskDJOTD4L7D6WXj1PKipDruirJXQoFlmNhIYBxzunNtpZl2CKUtEskLf7/h28rd/AgVt4ai7wNQQELRERz+8HPitc24ngHNuXeIliUhWOfjHPsyX/MrfODTgJs0yFLBEfzUeCAw1swVmNtfMBsVa0cwmmFmZmZWVl5cneFgRyShfux76TYT3b4Z3fhl2NVmnwStyM5sJdI2yaFJk+47A0cAg4F9m1sc55+qu7JybAkwBKC0t/cpyEcliZv5KvHIzLPmlvzI/+EdhV5U1Ggxy59zxsZaZ2eXAo5Hgft3MaoDOgC65RWRvlgeD74KqrfD2j/3EFH2/E3ZVWSHRppXHgJEAZnYg0AxYn+A+RSRb5eXDkL/DvqfA69+FFdPCrigrJBrk9wJ9zGwJMA24MFqziojIf+Q38zcMdRkKr54Pq54Ou6KMl1CQO+d2OefOc84d6pwb4JybFVRhIpLFClr5W/k7HAEvfQPWzgm7ooymDp0iEo7CIhj5HHQZDi10C0oiEu1HLiLSdM07wajnw64i4+mKXEQkwynIRUQynIJcRCTDKchFRDKcglxEJMMpyEVEMpyCXEQkwynIRUQynIUxNIqZlQOfNmKTzqTvYFyqrWnStbZ0rQtUW1NlU229nHPFdZ8MJcgby8zKnHOlYdcRjWprmnStLV3rAtXWVLlQm5pWREQynIJcRCTDZUqQTwm7gHqotqZJ19rStS5QbU2V9bVlRBu5iIjElilX5CIiEoOCXEQkw6VNkJvZ2Wb2rpnVmFlpnWXXmtlyM3vfzE6KsX1vM1sQWe+fZtYsSXX+08wWRr5WmNnCGOutMLN3IuuVJaOWKMe83sxW1apvTIz1To6cy+Vmdk0K6rrRzJaZ2WIzm25m7WOsl7Jz1tA5MLPmkdd6eeR9VZLMemodt4eZzTaz9yI/DxOjrDPCzDbVep2vS0VtkWPX+xqZ96fIeVtsZgNSVFe/WudjoZltNrOr6qyTsvNmZvea2brIfMa7n+toZjPM7MPI9w4xtr0wss6HZnZhXAd0zqXFF3Aw0A+YA5TWer4/sAhoDvQGPgLyo2z/L+CcyOM7gctTUPMfgOtiLFsBdE7xObwe+EkD6+RHzmEfoFnk3PZPcl0nAgWRx78DfhfmOYvnHABXAHdGHp8D/DNFr+G+wIDI47bAB1FqGwE8lcr3VryvETAGeBYw4GhgQQg15gNr8DfPhHLegGHAAGBJreduAK6JPL4m2s8B0BH4OPK9Q+Rxh4aOlzZX5M65pc6596MsGgdMc87tdM59AiwHBtdewcwMGAU8HHnqb8DpSSx39zG/CTyYzOMkwWBguXPuY+fcLmAa/hwnjXPuBedcVeSfrwHdk3m8OMRzDsbh30fg31ejI695UjnnVjvn3oo83gIsBfZL9nEDNA6433mvAe3NbN8U1zAa+Mg515i7xwPlnJsHbKjzdO33VKyMOgmY4Zzb4JzbCMwATm7oeGkT5PXYD/i81r9X8tU3difgy1phEW2doA0F1jrnPoyx3AEvmNmbZjYhybXUdmXkT9p7Y/zpFs/5TKZL8Fds0aTqnMVzDv6zTuR9tQn/PkuZSHPOkcCCKIuHmNkiM3vWzA5JYVkNvUZhv7/A/wUV6wIrrPMGsI9zbnXk8RpgnyjrNOn8pXTyZTObCXSNsmiSc+7xVNZSnzjrPJf6r8aPc86tMrMuwAwzWxb5LZ202oA7gF/jf9h+jW/6uSTRYyZa1+5zZmaTgCpgaozdJOWcZSIzawM8AlzlnNtcZ/Fb+GaDrZHPQR4DDkhRaWn9GkU+GzsNuDbK4jDP216cc87MAuv7ndIgd84d34TNVgE9av27e+S52r7A/wlXELl6irZO3Bqq08wKgDOBgfXsY1Xk+zozm47/cz7hN3y859DM7gKeirIonvMZeF1mdhEwFhjtIo2BUfaRlHMWRTznYPc6KyOvdzv8+yzpzKwQH+JTnXOP1l1eO9idc8+Y2e1m1tk5l/SBoeJ4jZLy/mqEU4C3nHNr6y4I87xFrDWzfZ1zqyPNTeuirLMK35a/W3f854b1yoSmlSeAcyK9CHrjf4O+XnuFSDDMBs6KPHUhkMwr/OOBZc65ldEWmllrM2u7+zH+w74l0dYNUp22yDNiHPMN4ADzvXya4f8MfSLJdZ0MXA2c5pyriLFOKs9ZPOfgCfz7CPz7alasX0BBirTD3wMsdc7dFGOdrrvb681sMP7nOOm/ZOJ8jZ4ALoj0Xjka2FSrOSEVYv6lHNZ5q6X2eypWRj0PnGhmHSJNoydGnqtfKj7BjfNT3jPw7UE7gbXA87WWTcL3MngfOKXW888A3SKP++ADfjnwENA8ibXeB1xW57luwDO1alkU+XoX37yQinP4APAOsDjyptm3bm2Rf4/B94b4KBW1RV6Tz4GFka8769aV6nMW7RwAv8L/sgFoEXkfLY+8r/qk6DU8Dt80trjW+RoDXLb7PQdcGTlHi/AfHh+TotqivkZ1ajPgtsh5fYdaPdBSUF9rfDC3q/VcKOcN/8tkNVAZybX/wn/G8iLwITAT6BhZtxS4u9a2l0Ted8uBi+M5nm7RFxHJcJnQtCIiIvVQkIuIZDgFuYhIhlOQi4hkOAW5iEiGU5CLiGQ4BbmISIb7fzHTFnQ4gdYTAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss = [82.23337408]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss = [170.1009187]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss = [266.15160025]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss = [33.87424748]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss = [29.89696311]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss = [27.9431673]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss = [26.50966444]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss = [25.36239334]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss = [24.34035736]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss = [23.41360613]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss = [22.55720271]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss = [21.76595221]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss = [21.03226629]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss = [20.35381279]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss = [19.72553712]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss = [19.14550196]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss = [18.60882787]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss = [18.11458383]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss = [17.65744861]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "np.random.seed(12)\n",
    "X, y = generate_data(n=40, means=[[2,1],[1,0]])\n",
    "gradient_descent(X, y, 0.1, 20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far so good, we now have an algorithm that can give us something useful even when the data is not linearly separable. This is important since in practice we cannot hope to achieve zero error. One problem however is that in order to compute the gradient at each step, we need to run over the entire data set, which can be computationally infeasible. This brings us to the idea of Stochastic Gradient Descent (SGD). The idea behind SGD is very simple, instead of computing the true gradient by summing over the entire dataset, we instead estimate the gradient by looking at the gradient on a single observation. In other words, we update the weight vector after each observation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " <font color='purple'>\n",
    "\n",
    "#### Exercise:\n",
    "    \n",
    "5. Instead of SGD, which might have high variance, try to implement a batch gradient descent, in which we consider a subset of size $m \\ll n$ to estimate the gradient with. Plot your results after each update. How does this compare with the results from gradient descent?\n",
    "6. Consider the case of Linear Regression from the first tutorial. In this case, the optimisation can be done in closed form (least squares solution). Use gradient descent instead to solve linear regression on a simulated dataset, does the gradient descent solution achieve the least squares solution?\n",
    "7. Investigate other sigmoid functions and implement them: https://en.wikipedia.org/wiki/Sigmoid_function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Neural Networks\n",
    "\n",
    "At this point, you should be comfortable with the two concepts covered so far: 1. Perceptrons and 2. Gradient Descent. These are the two basic building blocks for neural networks, also referred to as Multi-layer percetrpons. The idea is to chain together perceptrons to be able to learn very complex decision surfaces (as opposed to just linear decision surfaces in the case of the standard perceptron). Once we chain perceptrons together however, how do we learn the weights? We do so via Backpropagation, which at its core is an algorithm that implements the chain rule from calculus. Recall that the chain rule comes up any time we have a composition of functions. For example, consider two functions $g_1(x) = e^x$ and $g_2(x)=x^2-3$, then we can compose these functions:\n",
    "\n",
    "$$\n",
    "(g_1 \\circ g_2) (x) = g_1(g_2(x)) = e^{x^2 - 3}.\n",
    "$$\n",
    "\n",
    "We could also compose them in the reverse direction:\n",
    "\n",
    "$$\n",
    "(f_2 \\circ g_1) (x) = g_2(g_1(x)) = e^{2x} - 3.\n",
    "$$\n",
    "\n",
    "If we have a third function, say $g_3(x) = \\log (x)$, then we can create the following 3-fold composition:\n",
    "\n",
    "$$\n",
    "(g_1 \\circ g_2 \\circ g_3)(x) = g_1(g_2(g_3(x))) = g_1( (\\log x)^2 - 3 ) = e^{(\\log x)^2 - 3 }.\n",
    "$$\n",
    "\n",
    "A neural network is essentially one big composition of functions, let's see why. Assume we have a $D$ layer neural network, and assume that the $i$-th layer has $n_i$ many units (or perceptrons), which can be different from layer to layer. The $j$-th perceptron in layer $i$ can therefore be represented by its weight vector $w^{ij}$ and its bias term $b^{ij}$. Instead of keeping track of all these vectors, we combine all the weights in a single layer into a single weight matrix, $W_i$, where each row of the matrix corresponds to the weights of a perceptron. Similarly, we combine all bias terms into a single vector $b_i$ (See the diagram below). To see why this is a composition, we can write the forward step of a NN as follows:\n",
    "\n",
    "\\begin{align*}\n",
    "f_0 &:= x\\\\\n",
    "f_i &:= \\sigma(W_{i-1} f_{i-1} + b_{i-1}) \\quad i=1,\\dots,K.\n",
    "\\end{align*}\n",
    "\n",
    "In other words, we set the input $x$ to be output of the zero-th layer, and the output of the $i$-th layer is the element-wise sigmoid of the matrix product $W_{i-1} f_i + b_{i-1}$. What is this product? Recall from above that the product $W f$ returns a vector where each element is the dot product $\\langle w_i, f\\rangle$, where $w_i$ is the $i$-th row of $W$, i.e. the weights of the $i$-th perceptron/unit in the corresponding layer. Adding $b$ adds the bias, and the sigmoid is applied element-wise. This output then becomes the input of the next layer, and so on.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"misc/nn.jpg\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's unroll this process and show explicitly why it is a composition of functions. Let $f_K$ denote the output of a $K$ layer NN, then\n",
    "\n",
    "\\begin{align*}\n",
    "y \n",
    "&= f_K(x)\\\\\n",
    "&= \\sigma(W_{K-1} f_{K-1}(x) + b_{K-1})\\\\\n",
    "&= \\sigma(W_{K-1} \\sigma(W_{K-2} f_{K-2}(x) + b_{K-2}) + b_{K-1})\\\\\n",
    "& ~~~~ \\vdots\\\\\n",
    "&= \\sigma(W_{K-1} \\sigma(W_{K-2} (\\cdots \\sigma( W_{0} x + b_0) )+ \\cdots + b_{K-2}) + b_{K-1}),\n",
    "\\end{align*}\n",
    "\n",
    "which is equivalent to writing:\n",
    "\n",
    "$$\n",
    "y = (f_K \\circ f_{K-1} \\circ \\dots \\circ f_1)(x) = f_K(f_{K-1}(f_{K-2}(\\dots(f_1(x)) \\cdots)).\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have understood the forward pass of a neural network, we can turn our attention to learning the parameters of the network. In this case, we need to learn the weights and biases in every layer, and we can combine our parameters into a single set $\\theta := \\{W_0, b_0, W_1, b_1,\\dots, W_{K-1}, b_{K-1}\\}$. Let $\\theta_i = \\{W_i, b_i\\}$. Assume that we have some loss function $\\mathcal{L}$, say MSE. Then, to perform gradient descent, we need to compute gradients of the loss with respect to each of the parameters, and update as in the gradient descent discussion above. The gradeints can be computed using the chain rule:\n",
    "\n",
    "\\begin{align*}\n",
    "\\frac{\\partial \\mathcal{L}}{\\partial \\theta_{K-1}} &= \\frac{\\partial \\mathcal{L}}{\\partial f_{K}} \\color{red}{\\frac{\\partial f_K}{\\partial \\theta_{K-1}}}\\\\\n",
    "\\frac{\\partial \\mathcal{L}}{\\partial \\theta_{K-2}} &= \n",
    "\\frac{\\partial \\mathcal{L}}{\\partial f_{K}} \n",
    "\\color{blue}{\\frac{\\partial f_K}{\\partial f_{K-1}}}\n",
    "\\color{red}{\\frac{\\partial f_{K-1}}{\\partial \\theta_{K-2}}}\\\\\n",
    "\\frac{\\partial \\mathcal{L}}{\\partial \\theta_{K-3}} &= \n",
    "\\frac{\\partial \\mathcal{L}}{\\partial f_{K}} \n",
    "\\color{blue}{\\frac{\\partial f_K}{\\partial f_{K-1}} \\frac{\\partial f_{K-1}}{\\partial f_{K-2}} }\n",
    "\\color{red}{\\frac{\\partial f_{K-2}}{\\partial \\theta_{K-3}}}\\\\\n",
    "&\\vdots\\\\\n",
    "\\frac{\\partial \\mathcal{L}}{\\partial \\theta_{i}} &= \n",
    "\\frac{\\partial \\mathcal{L}}{\\partial f_{K}} \n",
    "\\color{blue}{\\frac{\\partial f_K}{\\partial f_{K-1}}  \\cdots \\frac{\\partial f_{i+1}}{\\partial f_{i+1}} }\n",
    "\\color{red}{\\frac{\\partial f_{i+1}}{\\partial \\theta_{i}}}\\\\\n",
    "\\end{align*}\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The terms in blue are the partial derivatives of the output of a layer with respect to its inputs, and the terms in red are the partial derivatives of the output of a layer with respect to its parameters. We make the important observation that if we simply compute each of the gradients naively, then we are redoing the same computations over and over, since the same (blue) terms crop up in many of the calculations. The idea behind backpropagation is to do the chain rule but in a smarter way, so as to re-use the computations already done at a layer to solve for gradients in later layers. For a detiled look at backpropagation, please refer to the more detailed derivation here: https://www.youtube.com/watch?v=dVexyOg3HnQ&t=1s&ab_channel=OmarGhattas "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Automatic Differentiation and a short intro to PyTorch\n",
    "\n",
    "Before we move on to computation, let us explore the computational aspects of Automatic Differentiation. Backpropagation is one special case of automatic differentiation, and many deep learning libraries, such as PyTorch, are general use automatic differentiation libraries. We saw earlier that standard chain rule can be computationally naive, and in fact is infeasible for compositions of a large number of functions, which is important if we want to do anything with deep networks! Let us consider a simplified example to demonstrate the power of autodiff.\n",
    "\n",
    "Consider the following function:\n",
    "\n",
    "$$\n",
    "f(x) = \\exp (\\exp(x) + \\exp(2x)) + \\sin(\\exp(x) + \\exp(2x)).\n",
    "$$\n",
    "\n",
    "This looks quite complicated, but with a bit of work we can show that the derivative of $f$ is\n",
    "\n",
    "$$\n",
    "f'(x) = \\exp (\\exp(x) + \\exp(2x))(\\exp(x) + 2\\exp(2x)) + \\cos(\\exp(x) + \\exp(2x))(\\exp(x) + 2\\exp(2x))\n",
    "$$\n",
    "\n",
    "For those of you that attempted this by hand, you should see that the standard differentiation approach is somewhat wasteful, since we have the same factor $(\\exp(x) + \\exp(2x))$ in both expressions. Let's consider a more algorithmic approach. Define the following intermediate variables:\n",
    "\n",
    "\\begin{align*}\n",
    "a &= \\exp(x)\\\\\n",
    "b &= a^2\\\\\n",
    "c &= a+b\\\\\n",
    "d &= \\sin(c)\\\\\n",
    "e &= \\exp(c)\\\\\n",
    "f &= d+e\n",
    "\\end{align*}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This may look strange at first, but we are basically rewriting $f(x)$ as an iterative procedure. We can represent this in graph form, using a structure known as a computational graph:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"misc/f1.jpg\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The square nodes are computation nodes, they implement the functions they are named after, and the circular nodes are variable nodes, which store the intermediate variables. Viewing $f$ in this way allows us to compute the gradient in an iterative manner. We compute the derivatives of the intermediate variables with respect to their inputs:\n",
    "\\begin{align*}\n",
    "\\frac{\\partial a}{\\partial x} &= \\exp(x)\\\\\n",
    "\\frac{\\partial b}{\\partial a} &= 2 a\\\\\n",
    "\\frac{\\partial c}{\\partial a} &= 1 = \\frac{\\partial c}{\\partial b}\\\\\n",
    "\\frac{\\partial d}{\\partial c} &= \\cos(c)\\\\\n",
    "\\frac{\\partial e}{\\partial c} &= \\exp(c)\\\\\n",
    "\\frac{\\partial f}{\\partial d} &= 1 = \\frac{\\partial f}{\\partial e}\n",
    "\\end{align*}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The goal is to compute $\\frac{\\partial f}{\\partial x}$, we can do so by working our way backwards through the computation graph from the output node (node $f$) to the input node (node $x$). We first introduce the following notation $\\text{child}(y)$ to denote the children of a node $y$. For example $\\text{child}(c) = \\{d, e\\}$. Then, for any node $y$ in the graph, the chain rule tells us that\n",
    "\n",
    "$$\n",
    "\\frac{\\partial f}{\\partial y} = \\sum_{z \\in \\text{child}(y)} \\frac{\\partial f}{\\partial z} \\frac{\\partial z}{\\partial y}\n",
    "$$\n",
    "\n",
    "Let's apply this formula, we already have the partial derivatives of $f$ with respect to $d,e$ from above, so we start with $c$:\n",
    "\n",
    "\\begin{align*}\n",
    "\\frac{\\partial f}{\\partial c} &= \\frac{\\partial f}{\\partial d}\\frac{\\partial d}{\\partial c} + \\frac{\\partial f}{\\partial e}\\frac{\\partial e}{\\partial c} = 1 \\times \\exp(c) + 1 \\times \\cos (c)\\\\\n",
    "\\frac{\\partial f}{\\partial b} &= \\frac{\\partial f}{\\partial c}\\frac{\\partial c}{\\partial b} =\\frac{\\partial f}{\\partial c} \\times 1\\\\\n",
    "\\frac{\\partial f}{\\partial a} &= \\frac{\\partial f}{\\partial b}\\frac{\\partial b}{\\partial a} + \\frac{\\partial f}{\\partial c}\\frac{\\partial c}{\\partial a} = \n",
    "\\frac{\\partial f}{\\partial b} \\times 2 a + \\frac{\\partial f}{\\partial c} \\times 1\\\\\n",
    "\\frac{\\partial f}{\\partial x} &= \\frac{\\partial f}{\\partial a} \\frac{\\partial a}{\\partial x} = \\frac{\\partial f}{\\partial a} \\times \\exp(x)\n",
    "\\end{align*}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe that the computation required for calculating the derivative is proportional to the computation required to calculate the function. You can visualise this process as if each node in the computational graph stores the derivatives of itself with respect to any child nodes, then to compute the gradient of the graph, we start from the output and work our way backwards, at each step re-using gradients computed earlier in the process. As you become more familiar with backpropagation, you should see that the two concepts are identical. Let's finalise our understanding by looking at a toy example using Pytorch. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since we have an excplicit form for the gradient, the goal will be to compare our explicit form to the solution computed numerically with PyTorch. Note that this is numerical differentiation, not symbolic, so the value of the gradient will change as we vary the input. We will compare the two results at the end."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch            # run \"! pip3 install torch\" in jupyter if you do not have torch\n",
    "\n",
    "def func(x):\n",
    "    t = np.exp(x) + np.exp(2*x)\n",
    "    return np.exp(t) + np.sin(t)\n",
    "\n",
    "def grad_func(x):\n",
    "    t1 = np.exp(x) + np.exp(2*x)\n",
    "    t2 = np.exp(x) + 2*np.exp(2*x)\n",
    "    return t2 * (np.exp(t1) + np.cos(t1))\n",
    "\n",
    "def sequential_func(x):\n",
    "    inp = torch.tensor([[x]], dtype=torch.float64, requires_grad=True)\n",
    "    a = torch.exp(inp)\n",
    "    b = torch.pow(a, 2)\n",
    "    c = a + b\n",
    "    d = torch.exp(c)\n",
    "    e = torch.sin(c)\n",
    "    f = d + e\n",
    "    f.backward()\n",
    "    return inp.grad.item()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "explicit gradient:  59.578079470554506\n",
      "autograd gradient:  59.57807947055451\n"
     ]
    }
   ],
   "source": [
    "x_input = 0.2\n",
    "print(\"explicit gradient: \", grad_func(x_input))\n",
    "print(\"autograd gradient: \", sequential_func(x_input))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " <font color='purple'>\n",
    "\n",
    "#### Exercise:\n",
    "    \n",
    "8. Consider the function $f(x) = \\sqrt{x^2 + \\exp(x^2)} + \\cos(x^2 + \\exp(x^2))$. Compute its derivative explicitly, and then write down its computational graph, repeat the analysis and use PyTorch to check your solutions.\n",
    "9. We have just scratched the surface of numerical optimisation with PyTorch, try to re-implement the gradient descent perceptron, note that we no longer need to explicitly compute the gradient, we can just rely on automatic differentiation.\n",
    "10. Repeat 2. but for Linear Regression, or any other loss-based model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To finish of the lab, we will see how to use pytorch to train a neural network on the MNIST dataset, and then we will look at some code that implements a neural network from scratch. In practice, we will obviously make use of existing libraries like pytorch, but it is also important to be able to build things from scratch."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### MNIST Dataset\n",
    "First we load in the MNIST dataset using the pytorch utilities. We transform the data and create a loader object that makes training networks more straight forward. We can set the batch size directly in the loader object, and this is analogous to the discussion on batch gradient descent earlier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torchvision           #! pip3 install torchvision\n",
    "import torchvision.transforms as transforms\n",
    "from torchvision.datasets import MNIST\n",
    "\n",
    "transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (1.0,))])\n",
    "trainset = MNIST(root = './', train=True, download=True, transform=transform)\n",
    "testset = MNIST(root = './', train=False, download=True, transform=transform)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 5\n",
    "trainloader = torch.utils.data.DataLoader(trainset, \n",
    "                                          batch_size=batch_size, \n",
    "                                          shuffle=True)\n",
    "testloader = torch.utils.data.DataLoader(testset, \n",
    "                                         batch_size=batch_size, \n",
    "                                         shuffle=False)\n",
    "classes = (0,1,2,3,4,5,6,7,8,9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pytorch makes it very simple to define networks, you need to create a Net() class that inherits from the nn module. You then need to define your architecture in the __init__ method, and a forward pass of your network. In this case, we are constructing a very simple neural network with a single hidden layer. We are dealing with MNIST, which are $28 \\times 28$ arrays (images), and so we have $28 \\times 28 = 784$ features. Therefore, the first layer (fully connected layer fc1) needs to have input dimension equal to 784. The output dimension can be anything, and I chose 100 arbitrarily. The second fully connected layer needs to have the same input dimension as the previous output dimension. Finally, since we have 10 classes, the output dimension of the last fully connected layer, in this case fc2, must be 10.\n",
    "\n",
    "The forward function describes what we want the network to do, and we are simply implementing the function \n",
    "\n",
    "$$\n",
    "y = f_2(f_1(x)),\n",
    "$$\n",
    "\n",
    "where $f_i(x) = \\sigma(W_{i-1}x+b_{i-1})$, and where we have chosen the ReLU activation, $\\sigma(x) = \\max\\{0,x\\}$, one of the most popular choices in the current literature. \n",
    "\n",
    "Next, we define a loss function (criterion), in this case we use the CrossEntropy Loss, which is appropriate for multi-class classification, and finally we define an optimizer, in this case we just use stochastic gradient descent. The rest of the code explains how to call the loader object to get some data, compute the network output, compute the gradients, and then update the weights."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'trainloader' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-4-72b123975f5c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     21\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mepoch\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     22\u001b[0m     \u001b[0mrunning_loss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0.0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 23\u001b[0;31m     \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrainloader\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     24\u001b[0m         \u001b[0;31m# get the inputs; data is a list of [inputs, labels]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     25\u001b[0m         \u001b[0minputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabels\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'trainloader' is not defined"
     ]
    }
   ],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "\n",
    "class Net(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Net, self).__init__()\n",
    "        self.fc1 = nn.Linear(784, 100)\n",
    "        self.fc2 = nn.Linear(100, 10) \n",
    "\n",
    "    def forward(self, x):\n",
    "        x = x.view(-1, 784)\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = self.fc2(x)\n",
    "        return x\n",
    "\n",
    "net = Net()\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)\n",
    "\n",
    "for epoch in range(5):  \n",
    "    running_loss = 0.0\n",
    "    for i, data in enumerate(trainloader, 0):\n",
    "        # get the inputs; data is a list of [inputs, labels]\n",
    "        inputs, labels = data\n",
    "\n",
    "        # zero the parameter gradients\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        # forward + backward + optimize\n",
    "        outputs = net(inputs)\n",
    "        loss = criterion(outputs, labels)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        # print statistics\n",
    "        running_loss += loss.item()\n",
    "        if i % 2000 == 1999:    # print every 2000 mini-batches\n",
    "            print('[%d, %5d] loss: %.3f' %\n",
    "                  (epoch + 1, i + 1, running_loss / 2000))\n",
    "            running_loss = 0.0\n",
    "\n",
    "print('Finished Training')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have trained our network, let's check out its test accuracy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of the network on the 10000 test images: 96 %\n"
     ]
    }
   ],
   "source": [
    "correct = 0\n",
    "total = 0\n",
    "with torch.no_grad():\n",
    "    for data in testloader:\n",
    "        images, labels = data\n",
    "        outputs = net(images)\n",
    "        _, predicted = torch.max(outputs.data, 1)\n",
    "        total += labels.size(0)\n",
    "        correct += (predicted == labels).sum().item()\n",
    "\n",
    "print('Accuracy of the network on the 10000 test images: %d %%' % (\n",
    "    100 * correct / total))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As many of you know, it is more appropriate to use convolutional neural networks for image data, and the following shows it is fairly straightforward to extend the above to the CNN setting. For those interested, you can read more here: https://pytorch.org/tutorials/beginner/blitz/neural_networks_tutorial.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1,  2000] loss: 1.539\n",
      "[1,  4000] loss: 0.551\n",
      "[1,  6000] loss: 0.407\n",
      "[1,  8000] loss: 0.348\n",
      "[1, 10000] loss: 0.307\n",
      "[1, 12000] loss: 0.280\n",
      "[2,  2000] loss: 0.271\n",
      "[2,  4000] loss: 0.239\n",
      "[2,  6000] loss: 0.229\n",
      "[2,  8000] loss: 0.243\n",
      "[2, 10000] loss: 0.209\n",
      "[2, 12000] loss: 0.216\n",
      "[3,  2000] loss: 0.201\n",
      "[3,  4000] loss: 0.193\n",
      "[3,  6000] loss: 0.192\n",
      "[3,  8000] loss: 0.194\n",
      "[3, 10000] loss: 0.172\n",
      "[3, 12000] loss: 0.189\n",
      "[4,  2000] loss: 0.187\n",
      "[4,  4000] loss: 0.178\n",
      "[4,  6000] loss: 0.174\n",
      "[4,  8000] loss: 0.166\n",
      "[4, 10000] loss: 0.166\n",
      "[4, 12000] loss: 0.162\n",
      "[5,  2000] loss: 0.162\n",
      "[5,  4000] loss: 0.155\n",
      "[5,  6000] loss: 0.153\n",
      "[5,  8000] loss: 0.149\n",
      "[5, 10000] loss: 0.150\n",
      "[5, 12000] loss: 0.153\n",
      "Finished Training\n"
     ]
    }
   ],
   "source": [
    "class ConvNet(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(ConvNet, self).__init__()\n",
    "        # 1 input image channel, 6 output channels, 3x3 square convolution\n",
    "        self.conv1 = nn.Conv2d(1, 10, kernel_size=5)\n",
    "        self.conv2 = nn.Conv2d(10, 20, kernel_size=5)\n",
    "        self.conv2_drop = nn.Dropout2d()\n",
    "        self.fc1 = nn.Linear(320, 60)\n",
    "        self.fc2 = nn.Linear(60, 10)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = F.relu(F.max_pool2d(self.conv1(x), 2))\n",
    "        x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))\n",
    "        x = x.view(-1, 320)\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.dropout(x, training=self.training)\n",
    "        x = self.fc2(x)\n",
    "        return F.log_softmax(x, dim=1)\n",
    "\n",
    "net = ConvNet()\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)\n",
    "\n",
    "for epoch in range(5):\n",
    "\n",
    "    running_loss = 0.0\n",
    "    for i, data in enumerate(trainloader, 0):\n",
    "        inputs, labels = data\n",
    "\n",
    "        # zero the parameter gradients\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        # forward + backward + optimize\n",
    "        outputs = net(inputs)\n",
    "        loss = criterion(outputs, labels)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        # print statistics\n",
    "        running_loss += loss.item()\n",
    "        if i % 2000 == 1999:    # print every 2000 mini-batches\n",
    "            print('[%d, %5d] loss: %.3f' %\n",
    "                  (epoch + 1, i + 1, running_loss / 2000))\n",
    "            running_loss = 0.0\n",
    "\n",
    "print('Finished Training')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of the network on the 10000 test images: 95 %\n"
     ]
    }
   ],
   "source": [
    "correct = 0\n",
    "total = 0\n",
    "with torch.no_grad():\n",
    "    for data in testloader:\n",
    "        images, labels = data\n",
    "        outputs = net(images)\n",
    "        _, predicted = torch.max(outputs.data, 1)\n",
    "        total += labels.size(0)\n",
    "        correct += (predicted == labels).sum().item()\n",
    "\n",
    "print('Accuracy of the network on the 10000 test images: %d %%' % (\n",
    "    100 * correct / total))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that the CNN achieves performance similar to the standard NN, and this is almost definitely due to requiring more training. The code in this section has been instructional, and you should try to tweak the parameters/network architectures to get better results."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Advanced Exercise\n",
    "Find a recent paper (NeuRIPS, ICML, ICLR, etc..) that introduces a novel deep learning architecture and implement it in pytorch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### MLP from scratch\n",
    "Finally, we will now take a look at a MLP code example built from scratch. We will no longer rely on pytorch to build models (although we will use the same mnist data installed from torch)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import OneHotEncoder\n",
    "\n",
    "# we will work with a small random subset of 10000 images\n",
    "np.random.seed(123)\n",
    "idxs = np.random.choice(range(60000), size=10000)\n",
    "\n",
    "Xtrain = trainset.data.numpy()[idxs]\n",
    "Xtrain = Xtrain.reshape(Xtrain.shape[0], -1)\n",
    "ytrain = trainset.targets.numpy()[idxs]\n",
    "labels = np.unique(ytrain)\n",
    "\n",
    "# one hot encoded version of y, called Y\n",
    "Ytrain = OneHotEncoder(sparse=False).fit_transform(ytrain.reshape(-1,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# for example, we can look at an image of one of the MNIST figures by doing:\n",
    "ii = 23\n",
    "plt.imshow(Xtrain[ii].reshape(28,28), cmap=\"gray\")\n",
    "plt.title(f\"label: {ytrain[ii]}\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Implementing a Multi-layer Perceptron from Scratch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Mlp():\n",
    "    # reference: Based on the Mlp example code by Raymundo Cassani\n",
    "    # https://github.com/rcassani/mlp-example\n",
    "    def __init__(self, size_layers):\n",
    "        '''\n",
    "        Arguments:\n",
    "            size_layers : List with the number of Units for:\n",
    "                [Input, Hidden1, Hidden2, ... HiddenN, Output] Layers.\n",
    "        '''\n",
    "        self.size_layers = size_layers\n",
    "        self.n_layers    = len(size_layers)\n",
    " \n",
    "        # initialize weights (in a smart way)\n",
    "        self.initialize_weights()\n",
    "\n",
    "    def train(self, X, Y, iterations=100):\n",
    "        '''\n",
    "        Given X (feature matrix) and y (class vector)\n",
    "        Updates the Weights by running Backpropagation N tines\n",
    "        Arguments:\n",
    "            X          : Feature matrix [n_examples, n_features]\n",
    "            Y          : Sparse class matrix [n_examples, classes]\n",
    "            iterations : Number of times Backpropagation is performed\n",
    "                default = 100\n",
    "        '''\n",
    "        n_examples = Y.shape[0]\n",
    "\n",
    "        for iteration in range(iterations):\n",
    "            self.gradients = self.backpropagation(X, Y)\n",
    "            self.gradients_vector = self.unroll_weights(self.gradients)\n",
    "            self.weight_vector = self.unroll_weights(self.weights)\n",
    "            self.weight_vector = self.weight_vector - self.gradients_vector\n",
    "            self.weights = self.roll_weights(self.weight_vector)\n",
    "\n",
    "    def predict(self, X):\n",
    "        '''\n",
    "        Given X (feature matrix), y_hat is computed\n",
    "        Arguments:\n",
    "            X      : Feature matrix [n_examples, n_features]\n",
    "        Output:\n",
    "            y_hat  : Computed Vector Class for X\n",
    "        '''\n",
    "        A , Z = self.feedforward(X)\n",
    "        Y_hat = A[-1]\n",
    "        return Y_hat\n",
    "    \n",
    "    def initialize_weights(self):\n",
    "        '''\n",
    "        Initialize weights - initialization method depends\n",
    "        on the Number of Units in the current layer\n",
    "        and the next layer. The weights for each layer as of the \n",
    "        size [next_layer, current_layer + 1]\n",
    "        '''\n",
    "        self.weights = []\n",
    "        size_next_layers = self.size_layers.copy()\n",
    "        size_next_layers.pop(0)\n",
    "        for size_layer, size_next_layer in zip(self.size_layers, size_next_layers):\n",
    "            # Method presented \"Understanding the difficulty of training deep feedforward neural networks\"\n",
    "            # Xavier Glorot and Youshua Bengio, 2010\n",
    "            epsilon = 4.0 * np.sqrt(6) / np.sqrt(size_layer + size_next_layer)\n",
    "            # Weigts from a uniform distribution [-epsilon, epsion] \n",
    "            tmp = epsilon * ( (np.random.rand(size_next_layer, size_layer + 1) * 2.0 ) - 1)\n",
    "            self.weights.append(tmp)\n",
    "        return self.weights\n",
    "\n",
    "    def backpropagation(self, X, Y):\n",
    "\n",
    "        g_dz = lambda x: self.sigmoid_derivative(x)\n",
    "        n_examples = X.shape[0]\n",
    "        \n",
    "        # Feedforward\n",
    "        A, Z = self.feedforward(X)\n",
    "\n",
    "        # Backpropagation\n",
    "        deltas = [None] * self.n_layers\n",
    "        deltas[-1] = A[-1] - Y\n",
    "        # For the second last layer to the second one\n",
    "        for ix_layer in np.arange(self.n_layers - 1 - 1 , 0 , -1):\n",
    "            tmp = self.weights[ix_layer]\n",
    "            tmp = np.delete(tmp, np.s_[0], 1)\n",
    "            deltas[ix_layer] = (tmp.T @ deltas[ix_layer + 1].T ).T * g_dz(Z[ix_layer])\n",
    "\n",
    "        # Compute gradients\n",
    "        gradients = [None] * (self.n_layers - 1)\n",
    "        for ix_layer in range(self.n_layers - 1):\n",
    "            grads_tmp = deltas[ix_layer + 1].T @ A[ix_layer]\n",
    "            gradients[ix_layer] = grads_tmp / n_examples \n",
    "        return gradients\n",
    "\n",
    "    def feedforward(self, X):\n",
    "\n",
    "        g = lambda x: self.sigmoid(x)\n",
    "        A = [None] * self.n_layers\n",
    "        Z = [None] * self.n_layers\n",
    "        input_layer = X\n",
    "\n",
    "        for ix_layer in range(self.n_layers - 1):\n",
    "            n_examples = input_layer.shape[0]\n",
    "            # augment input layer with vector of ones to account for bias\n",
    "            input_layer = np.concatenate((np.ones([n_examples, 1]), input_layer), axis=1)\n",
    "            A[ix_layer] = input_layer\n",
    "            # Multiplying input_layer by weights for this layer\n",
    "            Z[ix_layer + 1] = input_layer @ self.weights[ix_layer].T \n",
    "            output_layer = g(Z[ix_layer + 1])\n",
    "            # Current output_layer will be next input_layer\n",
    "            input_layer = output_layer\n",
    "\n",
    "        A[self.n_layers - 1] = output_layer\n",
    "        return A, Z\n",
    "\n",
    "    def unroll_weights(self, rolled_data):\n",
    "        '''\n",
    "        Unroll a list of matrices to a single vector\n",
    "        Each matrix represents the Weights (or Gradients) from one layer to the next\n",
    "        '''\n",
    "        unrolled_array = np.array([])\n",
    "        for one_layer in rolled_data:\n",
    "            unrolled_array = np.concatenate((unrolled_array, one_layer.flatten(\"F\")) )\n",
    "        return unrolled_array\n",
    "\n",
    "    def roll_weights(self, unrolled_data):\n",
    "        '''\n",
    "        rolls a single vector to a list of matrices\n",
    "        Each matrix represents the Weights (or Gradients) from one layer to the next\n",
    "        '''\n",
    "        size_next_layers = self.size_layers.copy()\n",
    "        size_next_layers.pop(0)\n",
    "        rolled_list = []\n",
    "        extra_item = 1\n",
    "        for size_layer, size_next_layer in zip(self.size_layers, size_next_layers):\n",
    "            n_weights = (size_next_layer * (size_layer + extra_item))\n",
    "            data_tmp = unrolled_data[0 : n_weights]\n",
    "            data_tmp = data_tmp.reshape(size_next_layer, (size_layer + extra_item), order = 'F')\n",
    "            rolled_list.append(data_tmp)\n",
    "            unrolled_data = np.delete(unrolled_data, np.s_[0:n_weights])\n",
    "        return rolled_list\n",
    "\n",
    "    def sigmoid(self, z):\n",
    "        return 1.0 / (1.0 + np.exp(-z))\n",
    "\n",
    "    def sigmoid_derivative(self, z):\n",
    "        return self.sigmoid(z) * (1 - self.sigmoid(z))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we can train the MLP on the MNIST dataset, using the same architecture as in the PyTorch case"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-30-fa493704a30e>:139: RuntimeWarning: overflow encountered in exp\n",
      "  return 1.0 / (1.0 + np.exp(-z))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "MLP accuracy:  0.9378\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-30-fa493704a30e>:139: RuntimeWarning: overflow encountered in exp\n",
      "  return 1.0 / (1.0 + np.exp(-z))\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD4CAYAAADiry33AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAiK0lEQVR4nO3deXxc5X3v8c9vRjPaF2v1Ihlb3sDGGIxjDCQOhLCGQtM4CSRt6A0tSRtebW/atKTckpTem3uT1y3c5BW60GyENDUJCYkDDpRiEkhYbBm84k3eJcvWvi+j0Tz3jzkS0ki2ZZA046Pv+/XyS2fOOdb8dCR99czzPPMcc84hIiL+FUh2ASIiMrkU9CIiPqegFxHxOQW9iIjPKehFRHwuLdkFJCouLnbz5s1LdhkiIueVrVu3NjrnSsY6lnJBP2/ePKqqqpJdhojIecXMjp7umLpuRER8TkEvIuJzCnoREZ9T0IuI+JyCXkTE5xT0IiI+p6AXEfE53wT9ybZeHvrPfRxs6Ex2KSIiKcU3QV/f0cs3NlVzpLEr2aWIiKQU3wR9wAyAmO6jIiIygm+C3st5YrpjlojICL4J+sEWvW6NKCIyku+CXl03IiIj+Sjo4x/VdSMiMpJvgt7UohcRGZNvgn6wRa8+ehGRkXwU9IMtegW9iMhw/gv6WJILERFJMb4Jes2jFxEZm2+CPhAYnEef5EJERFKMf4JeLXoRkTH5KOg1vVJEZCy+CXr10YuIjM03Qa+1bkRExua7oFfXjYjISD4K+vhHdd2IiIzkm6DXWjciImPzTdBrrRsRkbH5KOi11o2IyFh8GPRJLkREJMX4Jug1j15EZGy+Cfq359EnuRARkRTjo6CPf4yp70ZEZAQfBb366EVExuKboFcfvYjI2HwU9IaZ5tGLiCTyTdBDvPtGXTciIiONK+jN7CYz22dm1WZ23xjH083sCe/462Y2z9sfMrPHzGynme0xsy9OcP0jBExdNyIiic4a9GYWBB4BbgaWAnea2dKE0+4GWpxzC4GHga96+z8KpDvnlgOXA58Z/CMwGUwtehGRUcbTol8NVDvnDjnnIsB64PaEc24HHvO2nwSus/gqYw7INrM0IBOIAO0TUvkYAuqjFxEZZTxBPwc4PuxxjbdvzHOcc1GgDSgiHvpdQB1wDPi/zrnmxCcws3vMrMrMqhoaGs75ixgU76NX0IuIDDfZg7GrgQFgNjAf+Eszq0w8yTn3qHNulXNuVUlJyTt+Mg3GioiMNp6grwUqhj0u9/aNeY7XTZMPNAGfAJ51zvU75+qB3wKr3m3Rp2MajBURGWU8Qb8FWGRm880sDNwBbEg4ZwNwl7e9Dtjk4p3lx4APAJhZNrAG2DsRhY8lYKa1bkREEpw16L0+93uB54A9wI+cc7vN7EEzu8077dtAkZlVA58HBqdgPgLkmNlu4n8wvuuc2zHRX8QgTa8UERktbTwnOec2AhsT9j0wbLuX+FTKxP/XOdb+yaLBWBGR0Xz1zljNoxcRGc1XQa959CIio/ks6I1YLNlViIikFp8FvQZjRUQS+Sro1UcvIjKar4I+EFAfvYhIIn8FvaZXioiM4sOgT3YVIiKpxVdBr7VuRERG81XQa60bEZHRfBb0atGLiCTyWdBrMFZEJJGvgl7z6EVERvNV0GutGxGR0XwW9GrRi4gk8lnQazBWRCSRr4JeffQiIqP5KujVRy8iMprPgt4YUJNeRGQE3wW9+uhFREbyVdDH17pJdhUiIqnFV0EfX+tGSS8iMpy/gj6gFr2ISCJ/Bb366EVERvFV0GsevYjIaL4Kes2jFxEZzVdBH1TXjYjIKL4KejMjFkt2FSIiqcVXQa9FzURERvNZ0OuesSIiifwV9AG16EVEEvkq6E2DsSIio/gq6NV1IyIyms+CXl03IiKJfBb0emesiEiicQW9md1kZvvMrNrM7hvjeLqZPeEdf93M5g07domZvWpmu81sp5llTGD9CXWoRS8ikuisQW9mQeAR4GZgKXCnmS1NOO1uoMU5txB4GPiq93/TgB8An3XOLQOuAfonrPoE6qMXERltPC361UC1c+6Qcy4CrAduTzjnduAxb/tJ4DozM+AGYIdzbjuAc67JOTcwMaWPpj56EZHRxhP0c4Djwx7XePvGPMc5FwXagCJgMeDM7Dkze8PM/nqsJzCze8ysysyqGhoazvVrGKJlikVERpvswdg04L3AJ72PHzaz6xJPcs496pxb5ZxbVVJS8o6fTMsUi4iMNp6grwUqhj0u9/aNeY7XL58PNBFv/b/knGt0znUDG4GV77bo09EyxSIio40n6LcAi8xsvpmFgTuADQnnbADu8rbXAZtcPHGfA5abWZb3B+D9wFsTU/poml4pIjJa2tlOcM5Fzexe4qEdBL7jnNttZg8CVc65DcC3gcfNrBpoJv7HAOdci5k9RPyPhQM2OueemaSvRYOxIiJjOGvQAzjnNhLvdhm+74Fh273AR0/zf39AfIrlpIuvR6+gFxEZznfvjFWDXkRkJJ8FvbpuREQS+SvoAxqMFRFJ5Kug11o3IiKj+Sro1UcvIjKaz4JeLXoRkUQ+C3qtdSMikshXQa+1bkRERvNV0Acs/lHr3YiIvM1nQR9PerXqRUTe5rOgj3/815cOsvlwc3KLERFJEeNa6+Z8YV6L/mvP7gPgyP/5UDLLERFJCT5r0VuySxARSTk+C/pkVyAiknp8FfRBJb2IyCi+CvrKkuwRjzXNUkTEZ0F/+dzCEY+7IgNJqkREJHX4Kujzs0IjHjd19iWpEhGR1OGroAf42rpLuGJ+vGXf2BlJcjUiIsnnu6D/2KoK/u7WpQA0qkUvIuK/oAeYkR0GoLVbLXoREV8GfUFmvK++tbs/yZWIiCSfL4M+KxwkFDRaexT0IiK+DHozIz8zrBa9iAg+DXqAgqwQbT3qoxcR8W/QZ4bUohcRwc9Bn6WgFxEBHwd9vI9eXTciIr4N+oKskGbdiIjg56DPDNEdGaAvqoXNRGR682/QewuctamfXkSmOd8GfXFOOgANWu9GRKY53wZ9aZ4X9B0KehGZ3nwb9CU5GQDUK+hFZJrzb9DnjmzRf2XjHpY98GwySxIRSQrfBn1mOEhuetpQ0D/60iG6IgOaWy8i0864gt7MbjKzfWZWbWb3jXE83cye8I6/bmbzEo7PNbNOM/urCap7XEry0kf10e8/1TmVJYiIJN1Zg97MgsAjwM3AUuBOM1uacNrdQItzbiHwMPDVhOMPAb989+Wem5Kc0UG/71THVJchIpJU42nRrwaqnXOHnHMRYD1we8I5twOPedtPAteZmQGY2e8Ch4HdE1LxOZiZn8Ghxq4R3TX7TrZPdRkiIkk1nqCfAxwf9rjG2zfmOc65KNAGFJlZDvA3wN+f6QnM7B4zqzKzqoaGhvHWflYfWVlOY2cfdz9WNbTvaFP3hH1+EZHzwWQPxn4ZeNg5d8aOcefco865Vc65VSUlJRP25GsXl/DH75vP1qMtABRmhzWvXkSmnbRxnFMLVAx7XO7tG+ucGjNLA/KBJuAKYJ2ZfQ0oAGJm1uuc++a7LXy87v/QUtZUFvHTN2oJpwV4af/EvWIQETkfjCfotwCLzGw+8UC/A/hEwjkbgLuAV4F1wCbnnAPeN3iCmX0Z6JzKkB903UVlXHdRGQ8/v5+mrgj9AzFCQd/OLBURGeGsaef1ud8LPAfsAX7knNttZg+a2W3ead8m3idfDXweGDUFMxUMLovQqPVvRGQaGU+LHufcRmBjwr4Hhm33Ah89y+f48juob0KV5saXRWjo6GNWfmaSqxERmRrTqv9icFmE+na16EVk+phWQV/qBf2pjt4kVyIiMnWmXdAXZod59WBTsksREZky0yro04IBbr1kFs+/dYqOXt15SkSmh2kV9ADXXlhKXzTGnjqteSMi08O0C/oS7xaDLVquWESmiWkX9IM3Dde69CIyXUy7oJ+RFQagpVt99CIyPUy7oM8KBwmnBdR1IyLTxrQLejNjRlaIli4FvYhMD9Mu6CHefaOuGxGZLqZl0BdkhTQYKyLTxrQM+sJstehFZPqYlkFfkBUe0UcfXzo/7hfbT/Avvz6YjLJERCbFtAz6WXkZNHdHaOrs4ydba7jsH57nZFt8obP1W47xyKbqEeEvInI+m5ZBf91FZTgHz+0+xRNVx2nt7ufBp3cDcLy5h46+KLWtPUmuUkRkYkzLoL9oVi7zi7P55a46TrXHW/Iv7Kmnqy/KCS/g92otHBHxiWkZ9GbG+xeX8PKBRo42dXPF/EL6ojGe3nGCaCzeZbP3ZHuSqxQRmRjTMugB1lQWDm3/yTULCKcFeOyVo0P7tLqliPjFtA361fOLACjOCfP+xSVcu6SEt+rirfhFpTnsUYteRHxi2gZ9YXaYH/7RFfznf38/ZsbvXjoHiN+F6oZlZRxp7KKrL8rWoy00deoesyJy/kpLdgHJdNXC4qHtG5bN5KGPreDaJaW8friJmINPfut1th1v5YMXlfGtu1YlsVIRkXduWgf9cMGA8XsrywFYNjsfgG3HWwF4+UADPZEBMsPBZJUnIvKOTduumzOpKMzithWzAfjCjUvoi8Z45WBjkqsSEXlnFPSn8Y8fW8HPP3c1f3DlBQAcauhKckUiIu+Mum5OIxQMsKKigFjMETBo69EiaCJyflKL/iwCASMvM0R7r4JeRM5PCvpxyMsIjWjRv7S/gb9Y/6YWPhOR84K6bsYhPzNE+7Cg/9R3NgOw92QHJbnprJw7g7/44CLMLFklioicllr045CXmTZmH/3ekx28fKCRr79wgFbdyEREUpSCfhzyM9/uunlhz6kRx+7yZuU069aEIpKiFPTjkJ8Zor03SmNnH3c/VjXi2JUL4mvmNHcp6EUkNSnoxyEvI0RDRx+PvFg96lj5jCxAQS8iqUuDseOQlxkC4Lu/PQLA565dwIysMAEzinLCgIJeRFKXgn4cMkIj17j5wo0XDm339g8ACnoRSV3j6roxs5vMbJ+ZVZvZfWMcTzezJ7zjr5vZPG//9Wa21cx2eh8/MMH1T4nh8+XnF2ePOJYRCpIVDtLcFSESjQ0thCYikirO2qI3syDwCHA9UANsMbMNzrm3hp12N9DinFtoZncAXwU+DjQCv+OcO2FmFwPPAXMm+ouYbL+/5gIKssJcs6SEUHD038bC7DAtXRH+9N+38l976tl8/3WU5mYkoVIRkdHG03WzGqh2zh0CMLP1wO3A8KC/Hfiyt/0k8E0zM+fcm8PO2Q1kmlm6c+68upNHRijIusvLT3s8GDB++mbt0OPjzT0KehFJGePpupkDHB/2uIbRrfKhc5xzUaANKEo45yPAG2OFvJndY2ZVZlbV0NAw3tpTRm5G/O9lOC1+OU+09ow6ZyCm5RJEJDmmZHqlmS0j3p3zmbGOO+cedc6tcs6tKikpmYqSJtTX77iMn3/uaqr+xwcB2FPXPjRIC7D5cDPLvvQs1fWdySpRRKax8QR9LVAx7HG5t2/Mc8wsDcgHmrzH5cBTwKeccwffbcGpaEFJDisqCsjLCJEdDvJPvzrIp7+3Zej4L7afoLc/xsaddQBs2nuKu76zmehALFkli8g0Mp6g3wIsMrP5ZhYG7gA2JJyzAbjL214HbHLOOTMrAJ4B7nPO/XaCak5pXZF4S/6Vg0382X+8yaMvHeTx144C8Pxb8eUT7n9qF7/e38Crh5qSVqeITB9nDXqvz/1e4jNm9gA/cs7tNrMHzew277RvA0VmVg18HhicgnkvsBB4wMy2ef9KJ/yrSFEbtp/gKxv3AnD5BTPYWdtGXVsPM7Lib7L6xfYTOOdo7DyvxqZF5Dxjqbam+qpVq1xVVdXZT0xRG7af4MW99Tw1bBbOP350BSsqCvjgQ7/m46sq2LD9BD39A4TTAtywtIynd9Sx9X98kKKc9CRWLiLnMzPb6pxbNdYxrXUzwW5bMZuHP34pr37xAywqzQHgsrkFLCzNYUFJNk9UHaenf4B71lYSHYjx9I54v/2v9p1/s41E5PygoJ8ks/IzWVNZRFle+tC7ab9113u49ZJZANyyfBbfumsVS2flAbBpX33SahURf1PXzSTq6ovS0RtlZv7IN0/Vt/dSmvf2vr99aidPvVHL6/dfR15GfAG1lw808K+/PsQ37ryMwuzwlNYtIucfdd0kSXZ62qiQB0aEPMDHV1XQ0z/At18+jHOOXbVtfPbxrfymupFvbqrmcGPXVJUsIj6kFn0KcM7xR49V8cLeei6tKGBPXTtF2WHMjFrvXbbf/MRl3HrJ7CRXKiKpSi36FGdmPPqpVdx/y0XsP9VBelqA7316Nf/zwxez7vJywmkBfvpGfBZPT2SAWMzRFx0Y8e5bEZHT0Xr0KSIYMP54bSUfX11BX3+Mktx0Fpflcu2SUnLS01i/5Rhf+vkuHn/tKDOywjggYMavv3AN2en6NorI6alFn2LyMkKU5I6cT3/DsjJ6+2M89upR1lQW0dQVobkrQmNnH/f+8A217EXkjBT054ErK4t4/+L4Ym9fv+MyvvLh5cwtzOK+my/kxX0NXPh3z/KRf36F1m7d5UpERtNg7HliIOZo6Y5QnPDu2ZX/8PyI2xh+487LuG2FBm1FphsNxvpAMGCjQh7g89cvBmC2N43zq7/cy6a9p6a0NhFJbQr689wnr5jLWw/eyAt/eQ13rp5LbWsPn/5eFd96+RCn2nupaekecf7gDVCcc/ztUzuHlk4WEf9S142PVNd38KUNu3ntUPNQoIeDAT537UJuXj6TQw1dPPDzXbxnfiEdvVFe2h9fX+fw/74FMzvj527tjvD64WauXlhMjmb5iKScM3XdKOh9qDsSZcuRFp7ZcYKfvXmCyFlucFJZks3PPnf10PILEG/xH2nqHlqn576f7GD9luNcWVnE9+9eTU1Lz9AxEUk+Bf001ts/wJ66dl452MTMvAxyM9L44eZjrJw7g5n5Gfy46jhbjrTwB2suYNW8Gfy4qoayvAx21LRyoL6Tmy+eSW//AC8OW13zoll57KlrZ+OfvY+ls/OS+NWJyCAFvZzRn69/k59vOwFAelqAzHCQ1u7+oeOz8jMw4IHfWcpnf/DG0P7rLizl3z61CjOIDMRITwue8Xk6evsZiDkKsrRIm8hEU9DLGUUHYuw+0U59Rx9XLSgiMxTkhb315GeG2Ha8hU9fPZ+0YHzc/mvP7qUsL4O+6ABf2biX7HCQrsgAxTnpfGxVOdcvLSMac5TkpDOrIIO2nn6ywmn85kAj//D0WzR3RXjrwRvpi8boH4iRO6y7SETeOQW9TDjnHD/eWsPP3qzllYPndu/b37tsDq8daqIrMsAd76ngsrkzqCjMZH5xNllhDfSKvBMKepk0zjm6IgNkhoK09fSzaW89+0918P1Xj7B2UQlXLSji5QONvLB35I1VFpRk0z/gqG3tGZohBLB2cQk9kSihYIDV8wsJmHGksYuinDCluRl8cs1cssJpRKIx3jzWwpwZmZTPyBqq5Wyzh0T8SkEvUy4SjRFOe/ttGgMxR0NHH519UcCxoCQHM6M7EmVnTRvba1rZVdvOc7tP0hcdOUtoRlaIFm/MIDc9jTkzMmnqitDQ0YcZzC3MojgnnZ21baxdVMz84mwyw2nUNHezal4ht106m82Hm6ht6WHJzDyWzMwlP3Nkl1F9ey/BgA3dt7exs48ZWWGCAf3hkPODgl7OG739AzgH7b39ZIaDZIWCBANGXzTGrto2fratlpNtfaQFjOuXlnGwoZNf7WvgRFsPK8oL+PX+BsLBAJGB2NDHRIXZYZaU5XK0qYslM3Mpyknnya01BAy+cOOFLCrN4Y++X8WHls/ir25cwryirKFXCv0DMdZvPsa1F5ZSPiML59yogeieyADpaQEC+iMhU0hBL742PGw7+6JkhoL8prqRi2fncaSpi19sr2PZ7DwumpXHWyfaeX7PKVq74yuAHmyI373rD6+ax9GmrhHTSAelBYyLZuUxKz+DU+29bK9pIxQ0ZhdkUtfWCy5+A/jMcJDq+k5qWnqoLM7m0++dT25GGhu2naCxs49FZbnMys/g01fPxwF/85MdzMrP4O9vW8YzO+vYtKeel6sb+cOr5vGZtZVDA+Ai46GgFzmN3SfaSE8LsLA0l+5IlF9sP0E4LcCy2fk8s6OOgqwQNS09bD3aQldflJhzfPCiMjr7orT19DOnIJPXDjez/Xgrs/IzqGvr5cZlZRw41ckh7xaQcwoyKc4Js72mDYCAgQMGf/XK8tI51d4HxMcuDjZ0kZuRRm56GrMKMrn7vfOHXiG0dkfoj8bHNmpaesjNSGPJzFzmFWWzvDyfrFCQwWGKwVchx5u7ycsIkZ8V767aWdPGorIc+qIx9ta1s2xOPnWtPRRmhynKScc5xz/96iC/rW7kSGMXT3zmSioKs2jv7aepM8LMvAx+uauOG5bNPO27pJM1XtLZF+8KXFNZOO3GaxT0IpOot3+AU+29zC3M4mhTNxcUxQeHd9W2s62mlY+tKic9LchAzHGwoZNndtQRMOPGi8t4dtdJ/unFg3z8PRX83a1LCQWNX+46yasHm+jtH+ClAw1DfwQShYJG/8DI39/8zBA9/QPkZ4YImtHe2093ZIDinDDvmVdIc1d8KYsVFQUcauikozc69H/DwQAfuXwOGaEg3/3tEbLCQboj8XsdLJ+TT11bDy3d/ZTkpHOyvZfscJAFpTksKs2lICvEX9+0hFNtfXzhye3UtvbwySsu4AMXltLW08+lFQUjxmxOtfdSXd9JJBrjygVFZIRGvgcjOhDj0ZcPcWlFAVdWFo0rtA82dPKZx7dSXd/JQx9bwe+tLB/fN9AnFPQiKSw6EDttN01Hbz8H6jtJ88YpAga5GSHKZ2SSnhaktTtCbzTGr/bVc+BUJwfqO1hQksP+Ux3kZ4YoyAyTHgpwtKmbE609pAUD1Lf30tQVYe3iEt63sJin3qzlw5fN4XBTF09urSESjXHL8pl8886VPLOzjmd3n6SutQdHfIyipauf9y4sJiMUYPORFvbUtQPxN9Y1dUYIBKA0N4NjzW8vqJebnsZVC4s4cKqTlu7I0OD6oCVluaypLGTPyQ62HW8lMmxAvnxGJretmM09aytp74mycVcdtS09XFFZyDVLSskOBznU2MW6f34FM6M0N529JzuYV5TFJ66Yy9rFJVw4M48fvHaUx145wu+vuYCL5+QzryiLwuwwJ9p6mZmXQcDgYEMXZXnpQ9N8zzYYf7Ktl/zMEJv21tPW089HLp9z1jcOThYFvYiMUNvaw+z8jFEt5Z7IAM3dEeYUZI7r80SiMTbtraempZvXDjWxoCSHu66ax+yCTHbVtvGLHSe4ZE4BLx9o4LcHGwkFAiwuy2V5eT6XVRRQdbSFh57fT/mM+HhHcU6YaxaX8tS2Wq6sLOL6pWVs3Fk36r0a6WkB+qLxAfeYc0RjjuKcME9+9ipmZIVZv+UYG3fWDXWXmb3dVTYoIxTgkvICNh9uZk5BJmZQ09JDOC1ATnoaRnwdqIrCLNatLKepK0JeZohjTV3sqGnjJ2/UEEv4nJUl2dy6fBYz8zO5tKKAmpZu6jv6+NW+BtZUFtLQ2cfRxm4unpPHNUtKeXbXSXIz0lhenk9ZXgYLSnLO6fs4nIJeRFLWsaZuymdk0trTT1Y4SEYo/kolIxQc6tJ5cW89VUebiQ44KkuyWXd5BVVHmtm0r57GjgjHW7r5yoeXs7D07aCMDsTYdryV7TVtnGrvJRKN8WfXLWL9lmMUZIZ5/LWjnGjt4Y7VFRxq6CLdG5s51tzNk1uPD3WLjdVFluietZVcWVnEAxt2cby554zn5meGaOvpH/PYf7t6Hl/6nWXncvmGKOhFRBJEojFizo0aH4D4YPJP36jl6oXF9PQPcKy5m5KcdNp7+5lfnE1BVojuvgH6ojEyQ8Ghge7OviivHmxi/6kOwsEAy2bn0R0ZYO3iEl4+0EBpbgbLy/M53NjFbw40cNXCYtICxvHmHl4+0EBFYRa/v+aCd/T1KOhFRHxOtxIUEZnGFPQiIj6noBcR8TkFvYiIzynoRUR8TkEvIuJzCnoREZ9T0IuI+FzKvWHKzBqAo+/iUxQDjRNUzkRSXedGdZ0b1XXuUrW2d1rXBc65krEOpFzQv1tmVnW6d4clk+o6N6rr3Kiuc5eqtU1GXeq6ERHxOQW9iIjP+THoH012Aaehus6N6jo3quvcpWptE16X7/roRURkJD+26EVEZBgFvYiIz/km6M3sJjPbZ2bVZnZfkms5YmY7zWybmVV5+wrN7HkzO+B9nDFFtXzHzOrNbNewfWPWYnHf8K7hDjNbOcV1fdnMar3rts3Mbhl27IteXfvM7MZJqqnCzF40s7fMbLeZ/bm3P6nX6wx1JfV6ec+TYWabzWy7V9vfe/vnm9nrXg1PmFnY25/uPa72js+b4rq+Z2aHh12zS739U/az7z1f0MzeNLOnvceTe72cc+f9PyAIHAQqgTCwHViaxHqOAMUJ+74G3Odt3wd8dYpqWQusBHadrRbgFuCXgAFrgNenuK4vA381xrlLve9pOjDf+14HJ6GmWcBKbzsX2O89d1Kv1xnqSur18p7LgBxvOwS87l2LHwF3ePv/BfgTb/tPgX/xtu8Anpjiur4HrBvj/Cn72fee7/PAD4GnvceTer380qJfDVQ75w455yLAeuD2JNeU6HbgMW/7MeB3p+JJnXMvAc3jrOV24Psu7jWgwMxmTWFdp3M7sN451+ecOwxUE/+eT3RNdc65N7ztDmAPMIckX68z1HU6U3K9vHqcc67Texjy/jngA8CT3v7EazZ4LZ8ErjMzm8K6TmfKfvbNrBz4EPAt77ExydfLL0E/Bzg+7HENZ/5FmGwO+E8z22pm93j7ypxzdd72SaAsOaWdsZZUuI73ei+dvzOse2vK6/JeIl9GvCWYMtcroS5IgevldUNsA+qB54m/gmh1zkXHeP6h2rzjbUDRVNTlnBu8Zv/Lu2YPm1l6Yl1j1DzR/h/w10DMe1zEJF8vvwR9qnmvc24lcDPwOTNbO/ygi78OS4l5ralUC/DPwALgUqAO+MdkFGFmOcBPgL9wzrUPP5bM6zVGXSlxvZxzA865S4Fy4q8cLkxGHYkS6zKzi4EvEq/vPUAh8DdTWZOZ3QrUO+e2TuXz+iXoa4GKYY/LvX1J4Zyr9T7WA08R/+E/NfhS0PtYn6z6zlBLUq+jc+6U98sZA/6Nt7sbpqwuMwsRD9N/d8791Nud9Os1Vl2pcL2Gc861Ai8CVxLv+kgb4/mHavOO5wNNU1TXTV43mHPO9QHfZeqv2dXAbWZ2hHgX8weArzPJ18svQb8FWOSNXIeJD1psSEYhZpZtZrmD28ANwC6vnru80+4Cfp6M+jynq2UD8ClvBsIaoG1Yl8WkS+gT/TDx6zZY1x3eDIT5wCJg8yQ8vwHfBvY45x4adiip1+t0dSX7enk1lJhZgbedCVxPfAzhRWCdd1riNRu8luuATd6rpKmoa++wP9hGvB98+DWb9O+lc+6Lzrly59w84jm1yTn3SSb7ek3kSHIy/xEfNd9PvH/w/iTWUUl8xsN2YPdgLcT71V4ADgD/BRROUT3/QfxlfT/xvr+7T1cL8RkHj3jXcCewaorretx73h3eD/isYeff79W1D7h5kmp6L/FumR3ANu/fLcm+XmeoK6nXy3ueS4A3vRp2AQ8M+z3YTHwg+MdAurc/w3tc7R2vnOK6NnnXbBfwA96emTNlP/vDaryGt2fdTOr10hIIIiI+55euGxEROQ0FvYiIzynoRUR8TkEvIuJzCnoREZ9T0IuI+JyCXkTE5/4/7kbOPkMt3+oAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "mlp_classifier = Mlp(size_layers = [784, 100, 10])\n",
    "\n",
    "# Training with epochs\n",
    "epochs = 400\n",
    "loss = np.zeros([epochs,1])\n",
    "\n",
    "# train the MLP\n",
    "for i in range(epochs):\n",
    "    mlp_classifier.train(Xtrain, Ytrain, 1)       # 1 iteration of backprop\n",
    "    Y_hat = mlp_classifier.predict(Xtrain)\n",
    "    loss[i] = (0.5) * np.mean((Y_hat - Ytrain)**2)\n",
    "      \n",
    "# Plot loss vs epochs\n",
    "plt.figure()\n",
    "plt.plot(np.arange(epochs), loss)\n",
    "\n",
    "# Training Accuracy\n",
    "MLP_preds = mlp_classifier.predict(Xtrain)             # predicted values\n",
    "class_idxs = np.argmax(MLP_preds, axis=1)              # take argmax to find idx of predicted class\n",
    "y_hat = labels[class_idxs]                             # find predicted class\n",
    "\n",
    "print(\"\\nMLP accuracy: \", accuracy_score(ytrain, y_hat))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " <font color='purple'>\n",
    "\n",
    "#### Extra Exercise:\n",
    "    \n",
    "Update the MLP class so that it has the following functionality:\n",
    "    - user specified option to include/exclude a bias term\n",
    "    - ability to handle different activation functions beyond the logistic sigmoid\n",
    "    - advanced: explore different approaches to initialising the neural net weights, this can make a big difference to training\n",
    "    - advanced: implement different optimisation schemes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}