perceptronCensored.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import sklearn\n",
    "from sklearn import datasets\n",
    "from sklearn.metrics import confusion_matrix\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.ticker as ticker"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Packages, Data, and Setup"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Get the sklearn digit recognition toy dataset, it contains 1797 images.\n",
    "We then take the first 1700 to be our training set and the last 97 for testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load the data set\n",
    "img,label=sklearn.datasets.load_digits(return_X_y=True)\n",
    "TRAIN_SIZE = 1700\n",
    "# split the data set\n",
    "train_img,test_img = img[:TRAIN_SIZE], img[TRAIN_SIZE:]\n",
    "train_label,test_label = label[:TRAIN_SIZE], label[TRAIN_SIZE:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As can be observed, each of these train img is an 8x8 pixel grayscale image of a handwritten digit, \n",
    "for instance training image number 47 is of the handwritten digit '1'. \n",
    "We can also verify that the label in the dataset is indeed 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "IMG_DIM = (8,8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "label in the dataset is 1\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Try it yourself with any index!\n",
    "img_idx = 47\n",
    "plt.matshow(np.reshape(train_img[img_idx],IMG_DIM),cmap='gray')\n",
    "print('label in the dataset is '+str(train_label[img_idx]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. The Perceptron"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sigmoid Activation Function\n",
    "def sigmoid(x):\n",
    "    return 1 / (1 + np.exp(-x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# tanh Activation Function\n",
    "def tanh(x):\n",
    "    return (np.exp(x) - np.exp(-x)) / ( np.exp(x) + np.exp(-x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Linear Activation Function\n",
    "def linear(x):\n",
    "    return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Perceptron Class\n",
    "class Perceptron(object):\n",
    "    # Initialize the perceptron\n",
    "    def __init__(self, function=linear, dim_input=8*8, dim_out=10):\n",
    "        self.w = [np.zeros(dim_input) for ii in range(dim_out)]\n",
    "        self.f = function\n",
    "        self.dim_input = dim_input # dimension of the input (8*8 for our images)\n",
    "        self.dim_out = dim_out # dimension of the output, 10 for the digits 0,1,..,9\n",
    "    \n",
    "    def predict(self,input_array):\n",
    "        # See the \"learning: Multiclass Perceptron\" slides: w_y * f(x)\n",
    "        z = # Censored! Censored! Censored! Censored! Censored! Censored!\n",
    "        # The arg max\n",
    "        y = # Censored! Censored! Censored! Censored! Censored! Censored!\n",
    "        return y,z\n",
    "        \n",
    "    def one_update(self,input_array,label):\n",
    "        y,z = self.predict(input_array)\n",
    "        if y == label:\n",
    "            # Do absolutely nothing\n",
    "            noiceeee = 1\n",
    "        else:\n",
    "            # Updates, see the \"learning: Multiclass Perceptron\" slides\n",
    "            # Censored! Censored! Censored!\n",
    "            # Censored! Censored! Censored!\n",
    "            # Censored! Censored! Censored!\n",
    "                    \n",
    "    def train(self, training_inputs, labels):\n",
    "        # for every img label pair in the training set\n",
    "        # perform an update to perceptron\n",
    "        for input_array,label in zip(training_inputs,labels):\n",
    "            self.one_update(input_array,label)\n",
    "    \n",
    "    def test(self, testing_inputs, labels):\n",
    "        # number of correct predictions\n",
    "        count_correct = 0\n",
    "        # a list of the predicted labels the same order as the input \n",
    "        pred_list = []\n",
    "        for test_array, label in zip(testing_inputs,labels):\n",
    "            # Does the predicted label match the actual label?\n",
    "            # Update \"count_correct\" and \"pred_list\"!\n",
    "            # Censored! Censored! Censored!\n",
    "            # Censored! Censored! Censored!\n",
    "            # Censored! Censored! Censored!\n",
    "        accuracy = float(count_correct)/len(test_label)\n",
    "        print('Accuracy is '+str(accuracy))\n",
    "        return np.asarray(pred_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.1 Testing the Perceptron"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Number of epochs (iterations over the training set)\n",
    "NUM_EPOCH = 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For sigmoid activation and 6 epochs\n",
      "Accuracy is \n"
     ]
    }
   ],
   "source": [
    "# Try the perceptron with sigmoid activation\n",
    "perceptron = Perceptron(function=sigmoid)\n",
    "for ii in range(NUM_EPOCH):\n",
    "    perceptron.train( , ) # Censored! \n",
    "print('For sigmoid activation and '+str(NUM_EPOCH)+' epochs')\n",
    "pred_array = perceptron.test( , ) # Censored! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For tanh activation and 6 epochs\n",
      "Accuracy is \n"
     ]
    }
   ],
   "source": [
    "# Try the perceptron with tanh activation\n",
    "perceptron = Perceptron(function=tanh)\n",
    "for ii in range(NUM_EPOCH):\n",
    "    perceptron.train( , ) # Censored! \n",
    "print('For tanh activation and '+str(NUM_EPOCH)+' epochs')\n",
    "pred_array = perceptron.test( , ) # Censored! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For linear activation and 6 epochs\n",
      "Accuracy is \n"
     ]
    }
   ],
   "source": [
    "# Try the perceptron with linear activation\n",
    "perceptron = Perceptron(function=linear)\n",
    "for ii in range(NUM_EPOCH):\n",
    "    perceptron.train( , ) # Censored! \n",
    "print('For linear activation and '+str(NUM_EPOCH)+' epochs')\n",
    "pred_array = perceptron.test( , ) # Censored! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2 Analysis of the results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAATIAAAEfCAYAAADC9EotAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi40LCBodHRwOi8vbWF0cGxvdGxpYi5vcmcv7US4rQAAHFdJREFUeJzt3XuUXlWd5vHvQxIIgUi4CEIAob3QzWIa0EwaRRkFQVAa7F52Nyg0OPYwbasNXsaBblej3T2jtg5LnbGdieKNm5cgM4wXCKJo04NIEgIEgiD3hGi4yP2WVD3zxzmllaJS9V7OOfWequez1lmp931P/fauIvyyzz777J9sExHRZltNdQciIvqVRBYRrZdEFhGtl0QWEa2XRBYRrZdEFhGtl0Q2zUjaVtL/lfSopG/1EeftkpZV2bepIOn7kk6Z6n5EvZLIpoikt0laLukJSevL/+FeU0HotwK7ATvb/pNeg9i+wPZRFfRnM5JeJ8mSLhnz/oHl+1d1GOcjks6f7Dzbx9j+ao/djZZIIpsCkt4PfBr4rxRJZ2/gn4HjKwj/YuA225sqiFWXB4BXSdp51HunALdV1YAK+fs9U9jO0eAB7AA8AfzJBOdsQ5Ho7i+PTwPblJ+9DlgLfADYAKwH3lF+9lHgOWBj2cY7gY8A54+KvQ9gYHb5+lTgTuBx4C7g7aPev3rU970auA54tPzz1aM+uwr4B+BfyzjLgF228LON9P9/Au8u35sFrAP+Drhq1LmfAe4DHgNWAK8t3z96zM95w6h+/JeyH08DLy3f+4vy888DF4+K/wngSkBT/fciR39H/sVq3quAucAlE5zzt8AhwEHAgcBi4MOjPn8RRUJcSJGsPidpR9tnU4zyvmF7e9vnTtQRSdsBnwWOsT2fIlmtGue8nYDvlufuDJwDfHfMiOptwDuAXYGtgQ9O1DbwNeDPy6/fCKymSNqjXUfxO9gJuBD4lqS5ti8b83MeOOp7TgZOA+YD94yJ9wHg30g6VdJrKX53p7jMatFeSWTN2xl40BNf+r0d+HvbG2w/QDHSOnnU5xvLzzfa/h7FqGS/HvszDBwgaVvb623fPM45bwZut32e7U22LwJuBf5w1Dlftn2b7aeBb1IkoC2y/f+AnSTtR5HQvjbOOefbfqhs879RjFQn+zm/Yvvm8ns2jon3FMXv8RzgfOC9ttdOEi9aIImseQ8Bu0iaPcE5e7D5aOKe8r3fxBiTCJ8Ctu+2I7afBP4M+EtgvaTvSvrdDvoz0qeFo17/sof+nAe8B3g944xQJX1Q0pryDuwjFKPQXSaJed9EH9q+luJSWhQJN6aBJLLmXQM8C7xlgnPup5i0H7E3z7/s6tSTwLxRr180+kPbl9s+EtidYpT1hQ76M9KndT32acR5wF8B3ytHS79RXvp9CPhTYEfbCyjm5zTS9S3EnPAyUdK7KUZ295fxYxpIImuY7UcpJrU/J+ktkuZJmiPpGEn/VJ52EfBhSS+UtEt5/qRLDbZgFXCYpL0l7QCcNfKBpN0kHV/OlT1LcYk6PE6M7wEvL5eMzJb0Z8D+wHd67BMAtu8C/h3FnOBY84FNFHc4Z0v6O+AFoz7/FbBPN3cmJb0c+EfgJIpLzA9JmvASONohiWwKlPM976eYwH+A4nLoPcD/Lk/5R2A5cCNwE7CyfK+Xtq4AvlHGWsHmyWersh/3Aw9TJJV3jRPjIeBYisnyhyhGMsfafrCXPo2JfbXt8UablwOXUSzJuAd4hs0vG0cW+z4kaeVk7ZSX8ucDn7B9g+3bgb8BzpO0TT8/Q0w95YZNRLRdRmQR0XpJZBHReklkEdF6SWQR0XpJZBHReklkEdF6SWQR0XpJZBHReklkEdF6SWQR0XpJZBHReklkEdF6SWQR0XpJZBHReq1LZJKOlvRzSb+QdGZFMb8kaYOk1VXEK2PuJelHkm6RdLOk0yuKO1fSzyTdUMb9aBVxR8WfJel6SX1tmjgm5t2SbpK0StLyimIukLRU0q3ldtivqiDmfmUfR47HJJ1RUX/fV/73Wi3pIklzK4p7ehnz5qr62kpTXcapm4OibNgdwO9QVOq5Adi/griHAa8AVlfY192BV5Rfz6fYILCKvgrYvvx6DnAtcEiF/X4/RcWi71QY8262UB6uj5hf5bdl3rYGFtTwd+2XwIsriLWQotTetuXrbwKnVhD3AIrqU/OA2cAPgJdW+Xtoy9G2Edli4Be277T9HPB1Kihqa/snFDukVsZFRaKV5dePA2vYvFhHr3Ft+4ny5ZzyqGR3TEl7UlRM+mIV8epSbtl9GHAugO3nbD9ScTNHAHfYHlt0pVezgW3LnWrn0XsNhtF+D7jW9lMuitH8GPjjCuK2TtsS2UI23+54LRUkh7pJ2gc4mGL0VEW8WZJWURTovcJFZaAqfJpiG+vx9u3vh4FlklZIOq2CePtSbBH+5fIy+Itl3YEqnUBRO6FvttcBnwLupSio/KjtZRWEXg28VtLOkuYBbwL2qiBu67QtkbWOpO2Bi4EzbD9WRUzbQ7YPAvYEFks6oN+Yko4FNthe0XcHn+81tl8BHAO8W9JhfcabTTEV8HnbB1NUiqpkvhRA0tbAcfy2LkC/8XakuHLYl6K03naSTuo3ru01FNXSl1HUN1gFDPUbt43alsjWsfm/OHvSf0my2kiaQ5HELrD97arjl5dTPwKOriDcocBxku6muGQ/XFKvlZs2U45IsL2Bon7l4j5DrgXWjhqJLqVIbFU5Blhp+1cVxXsDcJftB1wUDf42RVX3vtk+1/YrbR8G/JpiLnbGaVsiuw54maR9y381TwAuneI+jUuSKOZw1tg+p8K4L5S0oPx6W+BIinqUfbF9lu09be9D8Xv9oe2+Rw2StpM0f+Rr4CiKS6J++vpL4L6ySjkU81m39NXRzZ1IRZeVpXuBQ8rSf6Lo75oqAkvatfxzb4r5sQuriNs2E1W7Hji2N0l6D0WpsFnAl2zf3G9cSRcBr6OoAL4WONv2uX2GPZSiduJN5XwWwN/Y/l6fcXcHvippFsU/RN+0XdlSiRrsBlxS/P/LbOBC25dVEPe9wAXlP2h3Au+oIOZIsj0S+I9VxIOiurmkpRRl/TYB1wNLKgp/saSdgY3Au2u46dEKKQcXEa3XtkvLiIjnSSKLiNZLIouI1ksii4jWa2Uiq2h1eOI2FDNx64tZZ9wmjLdhg6SdJF0h6fbyzx0ni9PKRAbU9R8ucdvV17bFbVNfm/IVnr+g+0zgStsvA66kg6c22prIImIa2MKGDcdT7G5C+edbJoszUOvIdthpll+0cM6k5z3y8BALdprVcdz1q+d1dN5GnmUO23Qct1NtitumvrYt7iD09Rme5Dk/q37ae+Prt/NDD3f2SOeKG5+9GXhm1FtLbG+2GLjcVOE7tg8oXz9ie+TpFQG/Hnm9JQO1sv9FC+fw+UtfXHncj73k9yuPGdFG1/rKvmM89PAQP7t8747OnbX77c/YXtRrW7YtadLR1kAlsogYfAaGK9/paTO/krS77fWSdqfYrmpCmSOLiK4Ys9FDHR09uhQ4pfz6FOD/TPYNGZFFRNeqGpGNt2ED8HHgm5LeCdwD/OlkcZLIIqIrxgxVdJPQ9olb+OiIbuIkkUVE14arKRNRmSSyiOiKgaEBS2S1TvbXUYMyIqbeMO7oaEptI7JyB9PPUey2uRa4TtKltqvckjgiGmZg4wAtpId6R2S11KCMiKllzFCHR1PqnCMbrwblH4w9qXxy/zSAXffIlF3EwDMMDdaAbOoXxNpeYnuR7UXdPD8ZEVOjWNnf2dGUOodArapBGRGdEkP09dx55epMZL+pQUmRwE4A3lZjexHRgGKyf4YksrpqUEbE1CrWkc2QRAZQFqPttyBtRAyY4ZkyIouI6WnGjcgiYvoxYmjqFzxsJoksIrqWS8uIaDUjnvNgrflMIouIrhQLYnNpuUXrV8+rpVDI5fevqjwmwBv3OKiWuBGDLpP9EdFqthhyRmQR0XLDGZFFRJsVk/2DlToGqzcRMfAy2R8R08JQ1pFFRJtlZX9ETAvDA3bXsrbeSPqSpA2SVtfVRkQ0r3hofKuOjqbU2dJXgKNrjB8RU8CIjZ7V0dGUOjdW/ImkfeqKHxFTwyYLYscaXUVpLvOmuDcRMTllQexYtpcASwBeoJ0GrMhURIxlMiKLiGkgyy8iotWMBm5jxTqXX1wEXAPsJ2mtpHfW1VZENKcoBze7o6Mpdd61PLGu2BExlWZWgd6ImIbM4K3sTyKLiK4N2ohssNJqRAw8Wwx7q46OyUh6n6SbJa2WdJGkub30KYksIrpSTPb3/4iSpIXAXwOLbB8AzAJO6KVPubSMiC5Vumf/bGBbSRuBecD9vQaZ9uqqdnTWHTdWHvOTRx5XeUyATXfeXUvcmHmKyf6O58h2kbR81Osl5dM82F4n6VPAvcDTwDLby3rp04xIZBFRrS5W9j9oe9F4H0jaETge2Bd4BPiWpJNsn99tfzJHFhFdGVnZ38kxiTcAd9l+wPZG4NvAq3vpU0ZkEdG1ioqP3AscImkexaXlEcDyib9lfElkEdEVGzYO95/IbF8raSmwEtgEXE+5E063ksgioivFpWU1s1K2zwbO7jdOEllEdG3GrOyXtJekH0m6pVy5e3pdbUVEc0aWX1Qw2V+ZOkdkm4AP2F4paT6wQtIVtm+psc2IqF11l5ZVqXMbn/XA+vLrxyWtARYCSWQRLTcj9+wvqykdDFzbRHsRUZ/irmVzpd46UXsik7Q9cDFwhu3Hxvk8VZQiWmQQt7quNZFJmkORxC6w/e3xzkkVpYj2mTGXlpIEnAussX1OXe1ERLO6fGi8EXXeejgUOBk4XNKq8nhTje1FREOq2lixKnXetbwaBmz8GRF9s8WmmbL8IiKmr0G7tEwii4iuDOIcWRJZRHQtiSwiWm3GrSOLiOlpxqwjmwk+9pLfrz7olZuqjwnF3ptRi02Hv7KWuHPvfqjymFq7dd8xbNhUwcaKVUoii4iu5dIyIlotc2QRMS04iSwi2i6T/RHRanbmyCKi9cRQ7lpGRNvNmDkySXOBnwDblO0sLWvYRUSLzbRnLZ8FDrf9RLlT7NWSvm/7pzW2GRF1czFPNkjq3I/MwBPlyznlMWA/fkT0YkbdtZQ0C1gBvBT4nO3nVVFK8ZGIdvEATvbX2hvbQ7YPAvYEFks6YJxzltheZHvRHLapszsRURG7s6MpjaRV248APwKObqK9iKiXrY6OptSWyCS9UNKC8uttgSOBW+tqLyKaUYy2BiuR1TlHtjvw1XKebCvgm7a/U2N7EdGQGbP8wvaNwMF1xY+IqTNjll9ExPRkxPCA3bVMIouIrg3YgKyZu5YRMY1UONkvaYGkpZJulbRG0qt66VJGZBHRveqGZJ8BLrP9VklbQ2+r4pPIIqJrVSytkLQDcBhwahHTzwHP9RIriWzQHLG2lrCX37+qlrhv3OOgWuK2yewfrqglbh31tIpc0WcMYHi440S2i6Tlo14vsb2k/Hpf4AHgy5IOpHic8XTbT3bbp8yRRUR3DFidHfDgyCOI5bFkVKTZwCuAz9s+GHgSOLOXLiWRRUTXKnrWci2wdtRmEkspElvXksgionvu8JgohP1L4D5J+5VvHQHc0kt3MkcWEV2q9DnK9wIXlHcs7wTe0UuQJLKI6F5Fyy9srwIW9RsniSwiumNw53ctG5FEFhE9GKxEVvtkv6RZkq6XlC18IqaLCib7q9TEXcvTgTUNtBMRTZlJiUzSnsCbgS/W2U5ENKi7BbGNqHuO7NPAh4D5WzohVZQi2mfQNlbseEQmqasSR5KOBTbYnvBBtFRRimihYXV2NGTSRCZpsaSbgNvL1wdK+u8dxD4UOE7S3cDXgcMlnd9PZyNiMMidHU3pZET2WeBY4CEA2zcAr5/sm2yfZXtP2/sAJwA/tH1SH32NiEHQ6UR/g4mskzmyrWzfI202TByqqT8RMfCancjvRCeJ7D5JiwGXpd3eC9zWTSO2rwKu6rp3ETGYBmyyv5NE9i6Ky8u9gV8BPyjfi4iZaniqO7C5SROZ7Q0Uc1wREb9dRzZAJk1kkr7AOANJ26fV0qOIGHhN3pHsRCeXlj8Y9fVc4I+A++rpTkS0QtsSme1vjH4t6Tzg6tp6FBHRpV4eUdoX2K3qjkS96qp2dOeF9cT9nbfVU/WpTR45uadatRMa+u5PK4nTuktLSb/mtwPJrYCH6bHSSURMA6bRx486MWEiU7EK9kBgXfnWsD1oj4tGROMGLAtM+IhSmbS+Z3uoPAas+xExFdr4rOUqSQfX3pOIaI+2PGspabbtTcDBwHWS7qCoBCyKwVpPhTQjYhoYsGuziebIfkZR9fe4hvoSES3Q9GVjJyZKZAKwfUdDfYmItmjRXcsXSnr/lj60fc5kwctNFR+n2PZnk+2+C3FGxNRr04hsFrA9/Rewe73tB/uMERGDpEWJbL3tv2+sJxHRDgM4RzbR8osqLoINLJO0oqyW9PxGpNMkLZe0fCPPVtBkRNSuLcsvgCMqiP8a2+sk7QpcIelW2z8ZfYLtJcASgBdopwHL8xExHg3YxopbHJHZfrjf4LbXlX9uAC4BFvcbMyJirNoqjUvaTtL8ka+Bo4DVdbUXEQ1q0aVlv3YDLimrL80GLrR9WY3tRUQTBnCyv7ZEZvtOip0zImK6mSmJLCKmsSSyiGgz0aK7lhER4+pwL7JO59EkzZJ0vaTv9NqlJLKI6F61dy1PB9b0050ksojoXkWJTNKewJuBL/bTncyRRV/qqnZ0+f31xK2rmlQdFpx3TeUxZ/nJSuJ0sfxiF0nLR71eUj7NM+LTwIeA+f30J4ksIrrXeSJ7cEvbd0k6Fthge4Wk1/XTnSSyiOiOK7treShwnKQ3AXOBF0g63/ZJ3QbKHFlEdK+COTLbZ9ne0/Y+wAnAD3tJYpARWUT0YMY8ohQR01jFicz2VcBVvX5/EllEdKfhnS06UescmaQFkpZKulXSGkmvqrO9iKifGLxK43WPyD4DXGb7rZK2BubV3F5ENGDGzJFJ2gE4DDgVwPZzwHN1tRcRDRqwRFbnpeW+wAPAl8sHQr9Y7hQbEW03YDvE1pnIZgOvAD5v+2DgSeDMsSelilJEy1S8+0UV6kxka4G1tq8tXy+lSGybsb3E9iLbi+awTY3diYjKzJQRme1fAvdJ2q986wjglrrai4jmaLizoyl137V8L3BBecfyTuAdNbcXEQ2YMXctAWyvAsZ98j0iWmoAF8RmZX9EdC+JLCLabGRl/yBJIouIrml4sDJZEllEdCdzZBExHeTSMiLaL4kspsKmw19ZS9zZP1xRS9y6qh3921VDlce87qBZlcccdBmRRUT7JZFFRKtVV0WpMklkEdGVrCOLiOnBg5XJksgiomsZkUVEuw3ggtja9iOTtJ+kVaOOxySdUVd7EdGcGbMfme2fAwcBSJoFrAMuqau9iGjOTL1reQRwh+17GmovIupiZuxk/wnAReN9IOk04DSAuSl7GdEKgzbZX2ulcYBym+vjgG+N93mKj0S00IAVH2liRHYMsNL2rxpoKyJqNlMXxJ7IFi4rI6KF7IHbWLHWS8uysviRwLfrbCciGjaTLi1tPwnsXGcbEdG8mXhpGRHTiYEBu7RMIouI7g1WHqt/+UVETD9yZ8eEMaS9JP1I0i2SbpZ0eq/9yYgsIrpW0V3LTcAHbK+UNB9YIekK27d0GygjsojoTqd3LCfJdbbX215Zfv04sAZY2EuXMiKbIeoqEtI2dRQKufz+VZXHhPoKsPSrWBDb8YhsF0nLR71eYnvJ82JK+wAHA9f20qcksojoXue7Xzxoe9FEJ0jaHrgYOMP2Y710J4ksIrrWxYhs4jjSHIokdoHtnhfOJ5FFRHcqWrUvScC5wBrb5/QTK5P9EdGl4lnLTo5JHAqcDBw+aifpN/XSo4zIIqJ7FVxa2r6a4t5B35LIIqI7KdAbEdPCgG11Xfc2Pu8rHz1YLekiSXPrbC8iGjJg2/jUWQ5uIfDXwCLbBwCzKPbuj4iW0/BwR0dT6r60nA1sK2kjMA+4v+b2IqJuppsFsY2obURmex3wKeBeYD3wqO1lY8+TdJqk5ZKWb+TZuroTERURRu7saEqdl5Y7AscD+wJ7ANtJOmnseamiFNFCdmdHQ+qc7H8DcJftB2xvpNi3/9U1thcRTRmwRFbnHNm9wCGS5gFPU1QbXz7xt0TEwBvAObLaEpntayUtBVZSbKB2PfC87Tsion2avCPZibqrKJ0NnF1nGxHRtGYvGzuRlf0R0R2TRBYR08BgXVkmkUVE95pcI9aJJLKI6F4SWUS0mg1Dg3VtmUQW0ae6qh2ddceNlcd813FPVRMoI7KIaL0ksohoNQPVVBqvTBJZRHTJ4MyRRUSbmUz2R8Q0kDmyiGi9JLKIaLfBe2i87ipKp5cVlG6WdEadbUVEQwwMD3d2NKTOra4PAP4DsBg4EDhW0kvrai8iGjRgO8TWOSL7PeBa20/Z3gT8GPjjGtuLiEaUjyh1cjSkzkS2GnitpJ3L7a7fBOw19qRUUYpoGYM93NHRlDq3ul4j6RPAMuBJYBUwNM55Syi3wH6BdhqsGcSIGN+AreyvdbLf9rm2X2n7MODXwG11thcRDRmwObJal19I2tX2Bkl7U8yPHVJnexHRALvRO5KdqHsd2cWSdgY2Au+2/UjN7UVEEwZsHVndVZReW2f8iJgKxkPPm+6eUlnZHxHdyTY+ETEtDNg2PrXetYyI6ceAh93RMRlJR0v6uaRfSDqz1z4lkUVEd1xurNjJMQFJs4DPAccA+wMnStq/ly7l0jIiulbRZP9i4Be27wSQ9HXgeOCWbgPJA3QbVdIDwD0dnLoL8GANXUjcdvW1bXEHoa8vtv3CfhqTdFnZZifmAs+Mer2kfJoHSW8Fjrb9F+Xrk4E/sP2ebvs0UCOyTn/BkpbbXlR1+4nbrr62LW6b+joR20c31VanMkcWEVNlHZtvJLFn+V7XksgiYqpcB7xM0r6StgZOAC7tJdBAXVp2YUni1ha3TX1tW9w29bV2tjdJeg9wOTAL+JLtm3uJNVCT/VEPSUPATRT/cK0BTrH9VI+xXgd80Paxko4D9rf98S2cuwB4m+1/7rKNjwBP2P5UL32MmSeXljPD07YPsn0A8Bzwl6M/VKHrvwu2L91SEistAP6q27gR3Uoim3n+BXippH3KFdVfo9jNdy9JR0m6RtJKSd+StD38ZvX1rZJWMmq7ckmnSvof5de7SbpE0g3l8Wrg48BLJK2S9MnyvP8k6TpJN0r66KhYfyvpNklXA/s19tuIaaGtc2TRA0mzKVZRX1a+9TKKy8yfStoF+DDwBttPSvrPwPsl/RPwBeBw4BfAN7YQ/rPAj23/Ublie3vgTOAA2weV7R9VtrkYEHCppMModhA+ATiI4u/kSmBFtT99TGdJZDPDtpJWlV//C3AusAdwj+2flu8fQvGYyL9KAtgauAb4XeAu27cDSDofOG2cNg4H/hzA9hDwqKQdx5xzVHlcX77eniKxzQcuGZm3k9TTnauYuZLIZoanR0ZFI8pk9eTot4ArbJ845rzNvq9PAj5m+3+NaSM1T6MvmSOLET8FDh2pPSppO0kvB24F9pH0kvK8E7fw/VcC7yq/d5akHYDHKUZbIy4H/v2oubeFknYFfgK8RdK2kuYDf1jxzxbTXBJZAGD7AeBU4CJJN1JeVtp+huJS8rvlZP+GLYQ4HXi9pJso5rf2t/0QxaXqakmftL0MuBC4pjxvKTDf9kqKubcbgO9TLJSM6FjWkUVE62VEFhGtl0QWEa2XRBYRrZdEFhGtl0QWEa2XRBYRrZdEFhGt9/8B9t05y2HiRboAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#########################################################################################\n",
    "# Confusion matrix shows what we predicted vs what was the real (True) label.\n",
    "# A perfect classifier will have has non zero elements only in the diagonal (why??)\n",
    "# Look at the results outside the diagonal, does it make sense that these mistakes happened?\n",
    "confusion_mat = confusion_matrix(test_label, pred_array, labels=range(0,10))\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(1,1,1)\n",
    "cax = ax.matshow(confusion_mat)\n",
    "plt.title('Confusion Matrix\\n')\n",
    "fig.colorbar(cax)\n",
    "labels = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']\n",
    "ax.set_xticklabels(['']+labels)\n",
    "ax.set_yticklabels(['']+labels)\n",
    "ax.xaxis.set_major_locator(ticker.MultipleLocator(1))\n",
    "ax.yaxis.set_major_locator(ticker.MultipleLocator(1))\n",
    "plt.xlabel('Predicted')\n",
    "plt.ylabel('True')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Note the perceptron seems to have misclassified some 3s as 8s, these digits do look similar  \n",
    "# so this is to be expected.. what else did we misclassify?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Off the shelf classifiers \n",
    "While it is important that you are able to implement classifiers yourself, \n",
    "it is also importent that you learn how to utilize existing packadges and\n",
    "off the shelf methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "#########################################################################################\n",
    "# Import the sklearn packadge, it contains many relevent useful algorithm implementations\n",
    "# and datasets (like the one we are using)\n",
    "from sklearn import tree\n",
    "from sklearn import naive_bayes\n",
    "from sklearn import linear_model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For sklearn decision tree classifier accuracy is:\n"
     ]
    }
   ],
   "source": [
    "# Decision tree classifiers, what is the best accuracy you can get?\n",
    "decision_tree_classifier = sklearn.tree.DecisionTreeClassifier()\n",
    "decision_tree_classifier.fit( , ) # Censored!\n",
    "print('For sklearn decision tree classifier accuracy is:')\n",
    "print(decision_tree_classifier.score( , )) # Censored! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For sklearn naive bayes classifier accuracy is:\n"
     ]
    }
   ],
   "source": [
    "# Naive Bayes classifiers, what is the best accuracy you can get?\n",
    "naive_bayes_classifier = sklearn.naive_bayes.BernoulliNB()\n",
    "naive_bayes_classifier.fit( , ) # Censored! \n",
    "print('For sklearn naive bayes classifier accuracy is:')\n",
    "print(naive_bayes_classifier.score( , )) # Censored! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For sklearn perceptron classifier accuracy is:\n"
     ]
    }
   ],
   "source": [
    "# Finally there is even a perceptron classifier, how does it do compare to your implementation?\n",
    "perceptron_classifier = sklearn.linear_model.Perceptron(max_iter=NUM_EPOCH)\n",
    "perceptron_classifier.fit( , ) # Censored! \n",
    "print('For sklearn perceptron classifier accuracy is:')\n",
    "print(perceptron_classifier.score( , )) # Censored! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "###############################################\n",
    "#  How does the decision tree Confusion matrix look like?\n",
    "pred_array = naive_bayes_classifier.predict(test_img)\n",
    "#pred_array = decision_tree_classifier.predict(test_img)\n",
    "#pred_array = perceptron_classifier.predict(test_img)\n",
    "confusion_mat = confusion_matrix(test_label, pred_array, labels=range(0,10))\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(1,1,1)\n",
    "cax = ax.matshow(confusion_mat)\n",
    "plt.title('Confusion Matrix\\n')\n",
    "fig.colorbar(cax)\n",
    "labels = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']\n",
    "ax.set_xticklabels(['']+labels)\n",
    "ax.set_yticklabels(['']+labels)\n",
    "ax.xaxis.set_major_locator(ticker.MultipleLocator(1))\n",
    "ax.yaxis.set_major_locator(ticker.MultipleLocator(1))\n",
    "plt.xlabel('Predicted')\n",
    "plt.ylabel('True')\n",
    "plt.show()"
   ]
  },
  {
   "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": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.15rc1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}