PS2_TenzinChoedon.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Homework 2 - Logistic Regression\n",
    "## CSCI 5622 - Spring 2019\n",
    "***\n",
    "**Name**: $<$Tenzin Choedon$>$ \n",
    "***\n",
    "\n",
    "This assignment is due on Canvas by **11.59 PM on Wednesday, February 26th**. Submit only this Jupyter notebook to Canvas.  Do not compress it using tar, rar, zip, etc. Your solutions to analysis questions should be done in Markdown directly below the associated question.  Remember that you are encouraged to discuss the problems with your classmates and instructors, but **you must write all code and solutions on your own**, and list any people or sources consulted. The only exception to this rule is that you may copy code directly from your own solution to homework 1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I discuss homework with Ryan and Jason on some confusion and performance comparison. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Overview \n",
    "***\n",
    "\n",
    "\n",
    "Your task for this homework is to build a logistic regression model that implements stochastic gradient ascent. You'll apply it to the task of determining whether a number is 8 or 9\n",
    "\n",
    "We start by importing and plotting the given data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pylab as plt\n",
    "%matplotlib inline \n",
    "import random"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [ 70 points] Problem 1: Implementing the Logistic Regression Classifier for Binary Classification\n",
    "***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pylab as plt\n",
    "%matplotlib inline\n",
    "import pickle, gzip       \n",
    "import numpy as np\n",
    "np.set_printoptions(suppress=True)\n",
    "class Numbers:\n",
    "    \"\"\"\n",
    "    Class to store MNIST data for images of 9 and 8 only\n",
    "    \"\"\" \n",
    "    def __init__(self, location):\n",
    "        # You shouldn't have to modify this class, but you can if you'd like\n",
    "        # Load the dataset\n",
    "        with gzip.open(location, 'rb') as f:\n",
    "            train_set, valid_set, test_set = pickle.load(f)\n",
    " \n",
    "        self.train_x, self.train_y = train_set\n",
    "        train_indices = np.where(self.train_y > 7)\n",
    "        self.train_x, self.train_y = self.train_x[train_indices], self.train_y[train_indices]\n",
    "        self.train_y = self.train_y - 8\n",
    " \n",
    "        self.valid_x, self.valid_y = valid_set\n",
    "        valid_indices = np.where(self.valid_y > 7)\n",
    "        self.valid_x, self.valid_y = self.valid_x[valid_indices], self.valid_y[valid_indices]\n",
    "        self.valid_y = self.valid_y - 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = Numbers('./mnist-1.pklz')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this homework you'll implement a Logistic Regression classifier to take drawings of either an eight or a nine and output the corresponding label.\n",
    "* [10 pts] Finish the `calculate_score` function to return the output of applying the dot product of the weights with the input parameter\n",
    "\n",
    "* [10 pts] Finish the `sigmoid` function to return the output of applying the sigmoid function to the calculated score\n",
    "\n",
    "* [10 pts] Finish the `compute_gradient` function to return the derivate of the cost w.r.t. the weights\n",
    "\n",
    "* [10 pts] Finish the `sgd_update` function so that it performs stochastic gradient descent on the single training example and updates the weight vector correspondingly\n",
    "\n",
    "* [10 pts] Finish the `mini_batch_update` function so that it performs mini-batch gradient descent on the batches of the training data set example and updates the weight vector correspondingly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import defaultdict\n",
    "class LogReg:\n",
    "    \n",
    "    def __init__(self, X, y, eta = 0.1):\n",
    "        \"\"\"\n",
    "        Create a logistic regression classifier\n",
    "        :param num_features: The number of features (including bias)\n",
    "        :param eta: Learning rate (the default is a constant value)\n",
    "        :method: This should be the name of the method (sgd_update or mini_batch_descent)\n",
    "        :batch_size: optional argument that is needed only in the case of mini_batch_descent\n",
    "        \"\"\"\n",
    "        self.X = X\n",
    "        self.y = y\n",
    "        self.w = np.zeros(X.shape[1]) # can remove from here and ask to be defined in the function\n",
    "        self.eta = eta\n",
    "        \n",
    "    def calculate_score(self, x):\n",
    "        \"\"\"\n",
    "        :param x: This can be a single training example or it could be n training examples\n",
    "        :return score: Calculate the score that you will plug into the logistic function\n",
    "        \"\"\"\n",
    "        # TODO: Compute the score to be fed to the sigmoid function\n",
    "        return np.dot(self.w,x)\n",
    "    \n",
    "    def sigmoid(self, score):\n",
    "        \"\"\"\n",
    "        :param score: Either a real valued number or a vector to convert into a number between 0 and 1\n",
    "        :return sigmoid: Calcuate the output of applying the sigmoid function to the score. This could be a single\n",
    "        value or a vector depending on the input\n",
    "        \"\"\"\n",
    "        # TODO: Complete this function to return the output of applying the sigmoid function to the score\n",
    "        return 1/(1+np.exp(-score))\n",
    "    \n",
    "    def compute_gradient(self, x, h, y):\n",
    "        \"\"\"\n",
    "        :param x: Feature vector\n",
    "        :param h: predicted class label\n",
    "        :param y: real class label\n",
    "        :return gradient: Return the derivate of the cost w.r.t to the weights\n",
    "        \"\"\"\n",
    "        # TODO: Finish this function to compute the gradient\n",
    "        return x * (h-y)\n",
    "     \n",
    "    def sgd_update(self):\n",
    "        \"\"\"\n",
    "        Compute a stochastic gradient update over the entire dataset to improve the log likelihood.\n",
    "        :param x_i: The features of the example to take the gradient with respect to\n",
    "        :param y: The target output of the example to take the gradient with respect to\n",
    "        :return: Return the new value of the regression coefficients\n",
    "        \"\"\" \n",
    "        # TODO: Finish this function to do a stochastic gradient descent update over the entire dataset\n",
    "        # and return the updated weight vector\n",
    "        # w = w - lambda * [1/(1 + e ^ - (w* x_i)) - y_i] * x_ik for k = 0 -> D\n",
    "        for i in range(len(self.X)):\n",
    "            self.w = self.w - self.eta * self.compute_gradient(self.X[i],self.sigmoid(self.calculate_score(self.X[i])),self.y[i])\n",
    "        return self.w\n",
    "    \n",
    "    def mini_batch_update(self, batch_size):\n",
    "        \"\"\"\n",
    "        One iteration of the mini-batch update over the entire dataset (one sweep of the dataset).\n",
    "        :param X: NumPy array of features (size : no of examples X features)\n",
    "        :param y: Numpy array of class labels (size : no of examples X 1)\n",
    "        :param batch_size: size of the batch for gradient update\n",
    "        :returns w: Coefficients of the classifier (after updating)\n",
    "        \"\"\"\n",
    "        # TODO: Performing mini-batch training follows the same steps as in stochastic gradient descent,\n",
    "        # the only major difference is that we’ll use batches of training examples instead of one. \n",
    "        # Here we decide a batch size, which is the number of examples that will be fed into the \n",
    "        # computational graph at once.\n",
    "        # print(\"batch size\",batch_size)\n",
    "        for i in range(0,len(self.X),batch_size):\n",
    "            \n",
    "            if((i+batch_size) < len(self.X)):\n",
    "                \n",
    "                score  = self.calculate_score(self.X[i:i+batch_size].T)\n",
    "                h      = self.sigmoid(score)\n",
    "                self.w = self.w - self.eta * np.sum(self.compute_gradient(self.X[i:i+batch_size],h.reshape((-1, 1)),self.y[i:i+batch_size].reshape((-1, 1))),axis=0)\n",
    "            \n",
    "            else:                \n",
    "                h      = self.sigmoid(self.calculate_score(self.X[i]))\n",
    "                self.w = self.w - self.eta * self.compute_gradient(self.X[i],h,self.y[i])\n",
    "        return self.w\n",
    "    \n",
    "    def progress(self, test_x, test_y, update_method, *batch_size):\n",
    "        \"\"\"\n",
    "        Given a set of examples, computes the probability and accuracy\n",
    "        :param test_x: The features of the test dataset to score\n",
    "        :param test_y: The features of the test \n",
    "        :param update_method: The update method to be used, either 'sgd_update' or 'mini_batch_update'\n",
    "        :param batch_size: Optional arguement to be given only in case of mini_batch_update\n",
    "        :return: A tuple of (log probability, accuracy)\n",
    "        \"\"\"\n",
    "        # TODO: Complete this function to compute the predicted value for an example based on the logistic value\n",
    "        # and return the log probability and the accuracy of those predictions\n",
    "        pred = []\n",
    "        if(update_method == 'sgd_update'):\n",
    "            self.sgd_update()\n",
    "        elif(update_method == 'mini_batch_update'):\n",
    "            self.mini_batch_update(batch_size[0])\n",
    "            \n",
    "        log_prob_list = [] # array to store all the log prob.\n",
    "        \n",
    "        for i in range(len(test_x)):\n",
    "            sig = self.sigmoid(self.calculate_score(test_x[i]))\n",
    "            \n",
    "            if(test_y[i] == 1):\n",
    "                log_prob_list.append(np.log(sig))\n",
    "            elif(test_y[i] == 0):\n",
    "                log_prob_list.append(np.log(1-sig))\n",
    "                \n",
    "                \n",
    "            if(abs(sig)> 0.5):\n",
    "                pred.append(1)\n",
    "            else:\n",
    "                pred.append(0)\n",
    "                \n",
    "        acc = [1 if(pred[i]==test_y[i]) else 0 for i in range(len(test_y))]\n",
    "        \n",
    "        return (sum(log_prob_list)/len(test_y),acc.count(1)/len(acc))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "...\n",
      "----------------------------------------------------------------------\n",
      "Ran 3 tests in 0.009s\n",
      "\n",
      "OK\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<unittest.runner.TextTestResult run=3 errors=0 failures=0>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import unittest\n",
    "\n",
    "class LogRegTester(unittest.TestCase):\n",
    "    def setUp(self):\n",
    "        self.X = np.array([[0.1, 0.3 ], [0.4, 0.6], [0.8, 0.1], [0.8, 0.1], [0.5, 0.8]])\n",
    "        self.y = np.array([0,  0, 1, 1,  0])\n",
    "        self.log_reg_classifier_1 = LogReg(self.X, self.y, 0.5)\n",
    "        self.log_reg_classifier_2 = LogReg(self.X, self.y, 0.5)\n",
    "        \n",
    "    def test_sgd_update(self):\n",
    "        \"\"\"\n",
    "        Test sgd_update function from LogReg\n",
    "        \"\"\"\n",
    "        weights = self.log_reg_classifier_1.sgd_update()\n",
    "        self.assertEqual(round(weights[0], 2), 0.16)\n",
    "        self.assertEqual(round(weights[1], 2), -0.37)\n",
    "        \n",
    "    def tests_mini_batch_update(self):\n",
    "        \"\"\"\n",
    "        Test mini_batch_update function from LogReg\n",
    "        \"\"\"\n",
    "        weights = self.log_reg_classifier_2.mini_batch_update(2)\n",
    "        self.assertEqual(round(weights[0], 2), 0.17)\n",
    "        self.assertEqual(round(weights[1], 2), -0.37)\n",
    "        \n",
    "    def tests_progress_sgd_update(self):\n",
    "        \"\"\"\n",
    "        Test progress function from LogReg with method = 'sgd_update'\n",
    "        \"\"\"\n",
    "        self.log_reg_classifier_1 = LogReg(self.X[:4], self.y[:4], 0.5)\n",
    "        log_prob, accuracy = self.log_reg_classifier_1.progress(self.X[4:], self.y[4:], 'sgd_update')\n",
    "        self.assertEqual(round(log_prob, 1), -0.7)  # Changed to round 1.\n",
    "        self.assertEqual(accuracy, 0)\n",
    "    \n",
    "        \n",
    "      \n",
    "    #BEGIN Workspace\n",
    "    #Add more test functions as required\n",
    "    #HINT - You'll want to make sure your\n",
    "    #END Workspace\n",
    "    \n",
    "tests = LogRegTester()\n",
    "myTests = unittest.TestLoader().loadTestsFromModule(tests)\n",
    "unittest.TextTestRunner().run(myTests)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "66271acf9fa2ad5ba37138c6c65d0e4b",
     "grade": true,
     "grade_id": "cell-6dae20a6650e207a",
     "locked": true,
     "points": 10,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# DO NOT DELETE THIS CELL !!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "fc5fb2bf05afb8b55193714209151048",
     "grade": true,
     "grade_id": "cell-758427c4f39cdc27",
     "locked": true,
     "points": 10,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# DO NOT DELETE THIS CELL !!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "d8de3625beec198e3f16aeae05b6343d",
     "grade": true,
     "grade_id": "cell-4faa4c852f8052c5",
     "locked": true,
     "points": 10,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# DO NOT DELETE THIS CELL !!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "e5a0d847dc62f3be14b1741bd706757f",
     "grade": true,
     "grade_id": "cell-83bae9107e0d2269",
     "locked": true,
     "points": 10,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# DO NOT DELETE THIS CELL !!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "25cfd3959691f614fae03fbe78d14a4b",
     "grade": true,
     "grade_id": "cell-3ef057a9059ef5d4",
     "locked": true,
     "points": 10,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# DO NOT DELETE THIS CELL !!!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q:** After completing the class above, loop over the training data and perform ___stochastic gradient descent___ for 10 epochs, and five different values of eta range [.0001, .01, .1, .5, 1]. Train your model and do the following:\n",
    "\n",
    "* [2.5 pts] PART A : Create a new classifier object and Using the `progress` method, calculate the accuracy on the __training sets__ at the end of each epoch and store it. Plot the accuracy trends for the different values of eta on same graph.\n",
    "\n",
    "* [2.5 pts] PART B : Create a new classifier object and Using the `progress` method, calculate the accuracy on the __validation set__ at the end of each epoch and store it. Plot the accuracy trends for the different values of eta on same graph.\n",
    "\n",
    "Don't forget to shuffle your training data after each epoch."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Implement part A below. DO NOT DELETE THE CELL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "dab6194829c3f760a0700843b8ac0d14",
     "grade": true,
     "grade_id": "cell-ef8affc8f47de848",
     "locked": false,
     "points": 2.5,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:130: RuntimeWarning: divide by zero encountered in log\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 17.5 s, sys: 241 ms, total: 17.8 s\n",
      "Wall time: 18.1 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# YOUR CODE HERE\n",
    "eta       = [0.0001,0.01,0.1,0.5,1]\n",
    "train_acc = []\n",
    "X         = data.train_x\n",
    "y         = data.train_y\n",
    "\n",
    "for e in range(len(eta)): # with different value of step size\n",
    "    acc = []\n",
    "    LogReg_classifier = LogReg(X,y,eta[e]) # create new classifier for each eta value\n",
    "    for j in range(10): # run 10 epochs\n",
    "        idx   = np.arange(len(y)) # index\n",
    "        np.random.shuffle(idx) # shuffle index\n",
    "        X_mix = X[idx,:]\n",
    "        y_mix = y[idx]\n",
    "        LogReg_classifier.sgd_update()\n",
    "        acc.append(LogReg_classifier.progress(X_mix[:],y_mix[:],'sgd_update')[1]) # pass in the log\n",
    "    train_acc.append(acc)\n",
    "    \n",
    "fig,ax = plt.subplots()\n",
    "for i in train_acc:\n",
    "    ax.plot(np.arange(10),i)\n",
    "    \n",
    "ax.legend(eta,loc='lower right')\n",
    "plt.xlabel(\"Epoch Iterations\")\n",
    "plt.ylabel(\"accuracy\")\n",
    "plt.title(\"sgd with traning data\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Implement part B below. DO NOT DELETE THE CELL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "1fb60d22338d71c2da37a063263b109c",
     "grade": true,
     "grade_id": "cell-ec6999395608d8f1",
     "locked": false,
     "points": 2.5,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:130: RuntimeWarning: divide by zero encountered in log\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 3.8 s, sys: 43.7 ms, total: 3.84 s\n",
      "Wall time: 3.97 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# YOUR CODE HERE\n",
    "eta       = [0.0001,0.01,0.1,0.5,1]\n",
    "train_acc = []\n",
    "X         = data.valid_x\n",
    "y         = data.valid_y\n",
    "\n",
    "for e in range(len(eta)): # with different value of step size\n",
    "    acc = []\n",
    "    LogReg_classifier = LogReg(X,y,eta[e]) # create new classifier for each eta value\n",
    "    for j in range(10): # run 10 epochs\n",
    "        idx   = np.arange(len(y)) # index\n",
    "        np.random.shuffle(idx) # shuffle index\n",
    "        X_mix = X[idx,:]\n",
    "        y_mix = y[idx]\n",
    "        LogReg_classifier.sgd_update()\n",
    "        acc.append(LogReg_classifier.progress(X_mix[:],y_mix[:],'sgd_update')[1]) # pass in the log\n",
    "    train_acc.append(acc)\n",
    "    \n",
    "fig,ax = plt.subplots()\n",
    "for i in train_acc:\n",
    "    ax.plot(np.arange(10),i)\n",
    "    \n",
    "ax.legend(eta,loc='lower right')\n",
    "plt.xlabel(\"Epoch Iterations\")\n",
    "plt.ylabel(\"accuracy\")\n",
    "plt.title(\"sgd with validation data\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q:** After completing the class above, loop over the training data and perform ___mini batch gradient descent___ for 10 epochs, and five different values of eta range [.0001, .01, .1, .5, 1]. Train your model and do the following:\n",
    "\n",
    "* [2.5 pts] PART C : Create a new classifier object and Using the `progress` method, calculate the accuracy on the __training sets__ at the end of each epoch and store it. Plot the accuracy trends for the different values of eta on same graph.\n",
    "\n",
    "* [2.5 pts] PART D : Create a new classifier object and Using the `progress` method, calculate the accuracy on the __validation set__ at the end of each epoch and store it. Plot the accuracy trends for the different values of eta on same graph.\n",
    "\n",
    "Don't forget to shuffle your training data after each epoch."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Implement part C below. DO NOT DELETE THE CELL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "7aed5aa63ce920693892ad8525ba0174",
     "grade": true,
     "grade_id": "cell-52542793c69f29c3",
     "locked": false,
     "points": 2.5,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:130: RuntimeWarning: divide by zero encountered in log\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 19.1 s, sys: 304 ms, total: 19.4 s\n",
      "Wall time: 19.8 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# YOUR CODE HERE\n",
    "eta       = [0.0001,0.01,0.1,0.5,1]\n",
    "train_acc = []\n",
    "X         = data.train_x\n",
    "y         = data.train_y\n",
    "\n",
    "for e in range(len(eta)): # with different value of step size\n",
    "    acc = []\n",
    "    LogReg_classifier = LogReg(X,y,eta[e]) # create new classifier for each eta value\n",
    "    for j in range(10): # run 10 epochs\n",
    "        idx = np.arange(len(y)) # index\n",
    "        np.random.shuffle(idx) # shuffle index\n",
    "        X_mix = X[idx,:]\n",
    "        y_mix = y[idx]\n",
    "        LogReg_classifier.mini_batch_update(2)\n",
    "        acc.append(LogReg_classifier.progress(X_mix[:],y_mix[:],'mini_batch_update',2)[1]) # pass in the log\n",
    "    train_acc.append(acc)\n",
    "    \n",
    "fig,ax = plt.subplots()\n",
    "for i in train_acc:\n",
    "    ax.plot(np.arange(10),i)\n",
    "    \n",
    "ax.legend(eta,loc='lower right')\n",
    "plt.xlabel(\"Epoch Iterations\")\n",
    "plt.ylabel(\"accuracy\")\n",
    "plt.title(\"mini-batch with training data\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Implement part D below. DO NOT DELETE THE CELL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "6476b7a70a099d872b9939d68f8da698",
     "grade": true,
     "grade_id": "cell-d02f5de2e6a3f212",
     "locked": false,
     "points": 2.5,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:130: RuntimeWarning: divide by zero encountered in log\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 4.04 s, sys: 72.8 ms, total: 4.12 s\n",
      "Wall time: 4.34 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# YOUR CODE HERE\n",
    "eta       = [0.0001,0.01,0.1,0.5,1]\n",
    "train_acc = []\n",
    "X         = data.valid_x\n",
    "y         = data.valid_y\n",
    "\n",
    "for e in range(len(eta)): # with different value of step size\n",
    "    acc = []\n",
    "    LogReg_classifier = LogReg(X,y,eta[e]) # create new classifier for each eta value\n",
    "    for j in range(10): # run 10 epochs\n",
    "        idx = np.arange(len(y)) # index\n",
    "        np.random.shuffle(idx) # shuffle index\n",
    "        X_mix = X[idx,:]\n",
    "        y_mix = y[idx]\n",
    "        LogReg_classifier.mini_batch_update(2)\n",
    "        acc.append(LogReg_classifier.progress(X_mix[:],y_mix[:],'mini_batch_update',2)[1]) # pass in the log\n",
    "    train_acc.append(acc)\n",
    "    \n",
    "fig,ax = plt.subplots()\n",
    "for i in train_acc:\n",
    "    ax.plot(np.arange(10),i)\n",
    "    \n",
    "ax.legend(eta,loc='lower right')\n",
    "plt.xlabel(\"Epoch Iterations\")\n",
    "plt.ylabel(\"accuracy\")\n",
    "plt.title(\"mini-batch with validation data\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q:** [5 pts] Describe the role of learning rate (eta) on the efficiency of convergence during training?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "4803267a54ce015791ce3a8f6ac01e7a",
     "grade": true,
     "grade_id": "cell-672c3d3d77a18ef1",
     "locked": false,
     "points": 5,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "source": [
    "The smaller the learning rate is, the smoother the convergence is but sometime it can be less accurate like shown is the above plot of eta value 0.0001. But the larger the eta value is, there is steep drop in the accuracy due to more zig zag when it is descending close to minimum or goal. We can see that in the plot. Eta value of 0.5 fluctuated alot while eta value 0.0001, 0.01,0.1 was descending pretty smooth. When we take the right amount of steps, then we descends smooth and also get really good accuracy. Smaller steps can also cost more to get to the goal.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q:** [5 pts] Describe the role of the number of epochs on validation accuracy?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "673287df57a6b4ddc1a7073723c5686a",
     "grade": true,
     "grade_id": "cell-2aebead81356b6ec",
     "locked": false,
     "points": 5,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "source": [
    "The more epochs we run on certain range of smaller step size, the more accurate result we get like it is shown in all the plots above. But that can't be said for all cases. The bigger steps like 1 didn't benifit much from more number of epochs. As we can see in the plots, the accuracy doesn't increase consistant like eta value of 0.1. So it depends on steps size value. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [ 30 points] Problem 2: Implementing the Logistic Regression Classifier for Multinomial Classification\n",
    "\n",
    "You will not create a classifier that is commonly referred to as Multinomial Logistic Regression. The particular method you will be implementing is **One Vs All** or **One Vs Rest**. The dataset will be the MNIST dataset which includes all digits 0-9. You are free to use the functions you created above as needed.\n",
    "\n",
    "* [5 pts] 2.1 Normalize your data.\n",
    "* [5 pts] 2.2 Transform your outputs into a set of binary features via one-hot encoding.\n",
    "* [5 pts] 2.3 Write get_optimal_parameters - train all ten models at once.\n",
    "* [5 pts] 2.4 Calculate the accuracy of your model on Train and Test data.\n",
    "* [5 pts] 2.5 Generate a confusion matrix on test and train Data.\n",
    "* [5 pts] 2.6 Predict the labels of the first ten datapoints from your test set alongside the images of those same datapoints."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Numbers2:\n",
    "    \"\"\"\n",
    "    Class to store MNIST data for images of 0-9\n",
    "    \"\"\" \n",
    "    def __init__(self, location):\n",
    "        # You shouldn't have to modify this class, but you can if you'd like\n",
    "        # Load the dataset\n",
    "        with gzip.open(location, 'rb') as f:\n",
    "            train_set, valid_set, test_set = pickle.load(f)\n",
    " \n",
    "        self.train_x, self.train_y = train_set\n",
    "        self.test_x, self.test_y = valid_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5 0 4 1 9 2 1 3 1 4]\n",
      "true label: 6\n"
     ]
    },
    {
     "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": [
    "data2 = Numbers2('./mnist-1.pklz')\n",
    "print(data2.train_y[:10])\n",
    "def view_digit(example, label=None):\n",
    "    if label is not None: print(\"true label: {:d}\".format(label))\n",
    "    plt.imshow(example.reshape(28,28), cmap='gray');\n",
    "view_digit(data2.train_x[18],data2.train_y[18])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import preprocessing\n",
    "\n",
    "class MultiLogReg:\n",
    "    \n",
    "    def __init__(self, X, y, eta = 0.1):\n",
    "        self.X = self.normalize_data(X)\n",
    "        self.y = self.one_hot_encoding(y)\n",
    "        self.eta = eta\n",
    "        self.classifier = [LogReg(self.X,self.y[:,i]) for i in range(10)]\n",
    "        \n",
    "    def one_hot_encoding(self, y):\n",
    "        # TO DO: Represent the output vector y as a one hot encoding. Create a matrix of dimensions (m X 10) \n",
    "        # where m = number of examples, and 10 for number of classes\n",
    "        # if the class for the ith example is 7, then y[i][7] = 1 and the for k != 7, y[i][k] = 0.\n",
    "        m = np.zeros([len(y),10])\n",
    "        for i in range(len(y)): #update matrix with value 1 for each with corresponding value\n",
    "            m[i] = [1 if(ii == y[i]) else 0 for ii in range(10)]\n",
    "        return m\n",
    "    def normalize_data(self, X):\n",
    "        # TO DO: Normalize the feature values of dataset X using the mean and standard deviation of the respective features \n",
    "        \n",
    "        return preprocessing.scale(X)\n",
    "\n",
    "    def get_optimal_parameters(self):\n",
    "        # TO DO: This is the main training loop. You will have to find the optimal weights for all 10 models\n",
    "        # Each model is fit to it's class which is (0-9), and the cost function will be against all of the other \n",
    "        # numbers \"the rest\".\n",
    "        X   = self.X\n",
    "        y   = self.y\n",
    "        \n",
    "        for j in range(10): # run and update each models\n",
    "            for e in range(6): # run X epochs\n",
    "                idx = np.arange(len(y)) # index\n",
    "                np.random.shuffle(idx) # shuffle index\n",
    "                X_mix = X[idx,:]\n",
    "                y_mix = y[idx,j]\n",
    "                self.classifier[j].progress(X_mix[:],y_mix[:],'sgd_update') # update classifier\n",
    "            \n",
    "    def predict(self, test_image, test_label):\n",
    "        # TO DO: This function should return the probabilities predicted by each of the models for some given \n",
    "        # input image. The probabilities are sorted with the most likely being listed first.\n",
    "        # Return a vector of shape (10, 2) with the first column holding the number and the second column with\n",
    "        # the probability that the test_image is that number\n",
    "        p = np.zeros([10,2])\n",
    "        for i in range(10): p[i,0] = i # initialize first column with digit\n",
    "        for i in range(10):\n",
    "            p[i,1] = self.classifier[i].sigmoid(self.classifier[i].calculate_score(test_image)) # store probabilty\n",
    "            \n",
    "        return p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "7a9848ee01129a955b176d30e8b5ad7b",
     "grade": true,
     "grade_id": "cell-6b2210e74f243cc5",
     "locked": true,
     "points": 5,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# DO NOT DELETE THIS CELL !!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "0864f8ccc23364600d23825d74b4b805",
     "grade": true,
     "grade_id": "cell-c999e8642ad56c95",
     "locked": true,
     "points": 5,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# DO NOT DELETE THIS CELL !!!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### QUESTION ###\n",
    "It is important to know how well your model did on the whole. You need to report the ___accuracy as a percentage___ on the training set and the test set from Numbers2. You should also plot a ___confusion matrix___ for both, just like you did on the last homework and mention the numbers that were misclassified the most. Finally use the predict method to predict the labels for the FIRST 10 instances from the test set, while also plotting the respective images for validation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Train a MultiLogReg Model in the cell below. DO NOT DELETE THE CELL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "6adc8b9ff983ac7fb1d90033bb0841fa",
     "grade": true,
     "grade_id": "cell-5a678a51a11b6ce8",
     "locked": false,
     "points": 5,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:172: UserWarning: Numerical issues were encountered when centering the data and might not be solved. Dataset may contain too large values. You may need to prescale your features.\n",
      "  warnings.warn(\"Numerical issues were encountered \"\n",
      "/opt/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:189: UserWarning: Numerical issues were encountered when scaling the data and might not be solved. The standard deviation of the data is probably very close to 0. \n",
      "  warnings.warn(\"Numerical issues were encountered \"\n",
      "/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:40: RuntimeWarning: overflow encountered in exp\n",
      "/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:130: RuntimeWarning: divide by zero encountered in log\n",
      "/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:128: RuntimeWarning: divide by zero encountered in log\n"
     ]
    }
   ],
   "source": [
    "# YOUR CODE HERE\n",
    "mul_LogReg_classifier = MultiLogReg(data2.train_x,data2.train_y)\n",
    "mul_LogReg_classifier.get_optimal_parameters()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute the accuracy on the train and test data from Numbers2 using the model you trained above. DO NOT DELETE THE CELL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "training data score:  0.55034\n",
      "test date score:  0.5746\n"
     ]
    }
   ],
   "source": [
    "# YOUR CODE HERE\n",
    "# 6 epochs seems to give the highest accuracy of 0.55 for train data\n",
    "# train_pred_arr = []\n",
    "# test_pred_arr = []\n",
    "N = 10\n",
    "train_C = np.array(np.zeros([N,N]))\n",
    "test_C = np.array(np.zeros([N,N]))\n",
    "\n",
    "for i in range(len(data2.train_y)):\n",
    "    pred = mul_LogReg_classifier.predict(data2.train_x[i],data2.train_y[i])\n",
    "    row = data2.train_y[i]\n",
    "    col = int(pred[np.argmax(pred[:,1]),0])\n",
    "#     train_pred_arr.append(pred[np.argmax(pred[:,1]),0]) # update prediction array\n",
    "    train_C[row][col] += 1 # update confusion matrix\n",
    "score = np.sum(train_C.diagonal()) / train_C.sum()\n",
    "print(\"training data score: \",score)\n",
    "\n",
    "for i in range(len(data2.test_y)):\n",
    "    pred = mul_LogReg_classifier.predict(data2.test_x[i],data2.test_y[i])\n",
    "    row = data2.test_y[i]\n",
    "    col = int(pred[np.argmax(pred[:,1]),0])\n",
    "#     train_pred_arr.append(pred[np.argmax(pred[:,1]),0]) # update prediction array\n",
    "    test_C[row][col] += 1 # update confusion matrix\n",
    "score = np.sum(test_C.diagonal()) / test_C.sum()\n",
    "print(\"test date score: \",score)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "7216ab7a873dd1839e1ba8b783aec16e",
     "grade": true,
     "grade_id": "cell-f82d99c679208a96",
     "locked": false,
     "points": 5,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:172: UserWarning: Numerical issues were encountered when centering the data and might not be solved. Dataset may contain too large values. You may need to prescale your features.\n",
      "  warnings.warn(\"Numerical issues were encountered \"\n",
      "/opt/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:189: UserWarning: Numerical issues were encountered when scaling the data and might not be solved. The standard deviation of the data is probably very close to 0. \n",
      "  warnings.warn(\"Numerical issues were encountered \"\n",
      "/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:40: RuntimeWarning: overflow encountered in exp\n",
      "/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:130: RuntimeWarning: divide by zero encountered in log\n",
      "/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:128: RuntimeWarning: divide by zero encountered in log\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0001 0.55034\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:172: UserWarning: Numerical issues were encountered when centering the data and might not be solved. Dataset may contain too large values. You may need to prescale your features.\n",
      "  warnings.warn(\"Numerical issues were encountered \"\n",
      "/opt/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:189: UserWarning: Numerical issues were encountered when scaling the data and might not be solved. The standard deviation of the data is probably very close to 0. \n",
      "  warnings.warn(\"Numerical issues were encountered \"\n",
      "/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:40: RuntimeWarning: overflow encountered in exp\n",
      "/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:130: RuntimeWarning: divide by zero encountered in log\n",
      "/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:128: RuntimeWarning: divide by zero encountered in log\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.01 0.55034\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:172: UserWarning: Numerical issues were encountered when centering the data and might not be solved. Dataset may contain too large values. You may need to prescale your features.\n",
      "  warnings.warn(\"Numerical issues were encountered \"\n",
      "/opt/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:189: UserWarning: Numerical issues were encountered when scaling the data and might not be solved. The standard deviation of the data is probably very close to 0. \n",
      "  warnings.warn(\"Numerical issues were encountered \"\n",
      "/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:40: RuntimeWarning: overflow encountered in exp\n",
      "/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:130: RuntimeWarning: divide by zero encountered in log\n",
      "/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:128: RuntimeWarning: divide by zero encountered in log\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.1 0.55034\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:172: UserWarning: Numerical issues were encountered when centering the data and might not be solved. Dataset may contain too large values. You may need to prescale your features.\n",
      "  warnings.warn(\"Numerical issues were encountered \"\n",
      "/opt/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:189: UserWarning: Numerical issues were encountered when scaling the data and might not be solved. The standard deviation of the data is probably very close to 0. \n",
      "  warnings.warn(\"Numerical issues were encountered \"\n",
      "/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:40: RuntimeWarning: overflow encountered in exp\n",
      "/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:130: RuntimeWarning: divide by zero encountered in log\n",
      "/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:128: RuntimeWarning: divide by zero encountered in log\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5 0.55034\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:172: UserWarning: Numerical issues were encountered when centering the data and might not be solved. Dataset may contain too large values. You may need to prescale your features.\n",
      "  warnings.warn(\"Numerical issues were encountered \"\n",
      "/opt/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:189: UserWarning: Numerical issues were encountered when scaling the data and might not be solved. The standard deviation of the data is probably very close to 0. \n",
      "  warnings.warn(\"Numerical issues were encountered \"\n",
      "/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:40: RuntimeWarning: overflow encountered in exp\n",
      "/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:130: RuntimeWarning: divide by zero encountered in log\n",
      "/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:128: RuntimeWarning: divide by zero encountered in log\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 0.55034\n"
     ]
    }
   ],
   "source": [
    "# Here I am trying and see if the eta value effect accuracy, but it doesn't seem to in this case. Below is the accuracy \n",
    "# rate for running 6 epochs\n",
    "\n",
    "eta = [0.0001,0.01,0.1,0.5,1]\n",
    "for e in eta:\n",
    "    mul_LogReg_classifier = MultiLogReg(data2.train_x,data2.train_y,e)\n",
    "    mul_LogReg_classifier.get_optimal_parameters()\n",
    "    train_pred_arr = []\n",
    "    test_pred_arr = []\n",
    "    N = 10\n",
    "    C = np.array(np.zeros([N,N]))\n",
    "    for i in range(len(data2.train_y)):\n",
    "        pred = mul_LogReg_classifier.predict(data2.train_x[i],data2.train_y[i])\n",
    "        row = data2.train_y[i]\n",
    "        col = int(pred[np.argmax(pred[:,1]),0])\n",
    "        train_pred_arr.append(pred[np.argmax(pred[:,1]),0]) # update prediction array\n",
    "        C[row][col] += 1 # update confusion matrix\n",
    "    score = np.sum(C.diagonal()) / C.sum()\n",
    "    print(e,score)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot the confusion matrix on Test and Train Data using the model you trained before. DO NOT DELETE THE CELL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "12ad7b3162aa14d26a16359ea6b937e7",
     "grade": true,
     "grade_id": "cell-99273a4c41cde194",
     "locked": false,
     "points": 5,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training data confusion matrix:\n",
      "[[4256.    2.   23.   92.   41.   41.    1.    1.  391.   84.]\n",
      " [   1. 4409.   88.   51.   78.    5.    0.    0.  971.   75.]\n",
      " [  78.  130. 3151.  175.   93.   12.    3.    5. 1129.  192.]\n",
      " [ 184.   73.  249. 2799.   97.   93.    0.    8. 1118.  480.]\n",
      " [   7.   30.   66.   42. 3559.   22.    3.    1.  656.  473.]\n",
      " [ 733.   54.   50.  489.  492. 1576.    7.    1.  964.  140.]\n",
      " [ 238.   76.  190.   32.  203.  329. 1061.    0. 1884.  938.]\n",
      " [ 116.   94.   52.  867.  800.   27.    0. 1160. 1546.  513.]\n",
      " [ 378.  192.   78.  333.  343.  273.    1.    1. 3125.  118.]\n",
      " [  70.   17.   36.  325.  764.   85.    0.   30. 1240. 2421.]]\n",
      "\n",
      "\n",
      "Testing data confusion matrix:\n",
      "[[850.   0.   4.  14.  12.  10.   0.   0.  82.  19.]\n",
      " [  0. 854.   8.   8.   9.   0.   0.   0. 168.  17.]\n",
      " [  9.  25. 663.  21.  11.   0.   0.   0. 229.  32.]\n",
      " [ 32.  10.  33. 573.  22.  14.   0.   1. 254.  91.]\n",
      " [  2.   9.   5.   6. 741.   2.   0.   0. 136.  82.]\n",
      " [146.   7.  20. 105.  94. 359.   1.   1. 149.  33.]\n",
      " [ 34.  16.  34.   4.  37.  55. 240.   0. 376. 171.]\n",
      " [ 19.  15.   7. 156. 161.   5.   0. 282. 343. 102.]\n",
      " [ 51.  39.  13.  60.  64.  67.   0.   0. 700.  15.]\n",
      " [ 10.   2.   1.  38. 146.  15.   0.   9. 256. 484.]]\n"
     ]
    }
   ],
   "source": [
    "# YOUR CODE HERE\n",
    "# create confusion matrix for both test and training data\n",
    "print(\"Training data confusion matrix:\")\n",
    "print(train_C)\n",
    "print(\"\\n\\nTesting data confusion matrix:\")\n",
    "print(test_C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Predict Labels of First 10 datapoints from your test set and also the plot their images in the cell below. DO NOT DELETE THE CELL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "357ff8dee98adb78a768e9f690b3245d",
     "grade": true,
     "grade_id": "cell-2ae148d5cb9b50b2",
     "locked": false,
     "points": 5,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true label: 3\n",
      "true label: 8\n",
      "true label: 6\n",
      "true label: 9\n",
      "true label: 6\n",
      "true label: 4\n",
      "true label: 5\n",
      "true label: 3\n",
      "true label: 8\n",
      "true label: 4\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "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": [
    "# YOUR CODE HERE\n",
    "for i in range(10):\n",
    "    plt.figure()\n",
    "    pred = mul_LogReg_classifier.predict(data2.test_x[i],data2.test_y[i])\n",
    "    \n",
    "    idx = int(pred[np.argmax(pred[:,1]),0])\n",
    "#     print(\"predicted label: \" ,idx)\n",
    "    plt.title(\"predicted label: {}\".format(idx))\n",
    "    view_digit(data2.test_x[i],data2.test_y[i])\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}