Gopinath-A4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#A4-Neural-Network-Classifier\" data-toc-modified-id=\"A4-Neural-Network-Classifier-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>A4 Neural Network Classifier</a></span><ul class=\"toc-item\"><li><span><a href=\"#NeuralNetworkClassifier\" data-toc-modified-id=\"NeuralNetworkClassifier-1.1\"><span class=\"toc-item-num\">1.1&nbsp;&nbsp;</span><code>NeuralNetworkClassifier</code></a></span></li><li><span><a href=\"#percent_correct\" data-toc-modified-id=\"percent_correct-1.2\"><span class=\"toc-item-num\">1.2&nbsp;&nbsp;</span><code>percent_correct</code></a></span></li><li><span><a href=\"#Apply-NeuralNetworkClassifier-to-Images-of-Handwritten-Digits\" data-toc-modified-id=\"Apply-NeuralNetworkClassifier-to-Images-of-Handwritten-Digits-1.3\"><span class=\"toc-item-num\">1.3&nbsp;&nbsp;</span>Apply <code>NeuralNetworkClassifier</code> to Images of Handwritten Digits</a></span></li><li><span><a href=\"#Define-train_for_best_validation-and-apply-to-MNIST-data\" data-toc-modified-id=\"Define-train_for_best_validation-and-apply-to-MNIST-data-1.4\"><span class=\"toc-item-num\">1.4&nbsp;&nbsp;</span>Define <code>train_for_best_validation</code> and apply to MNIST data</a></span></li></ul></li><li><span><a href=\"#Grading\" data-toc-modified-id=\"Grading-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Grading</a></span></li><li><span><a href=\"#Extra-Credit\" data-toc-modified-id=\"Extra-Credit-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Extra Credit</a></span></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ANJU GOPINATH"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A4 Neural Network Classifier\n",
    "\n",
    "## `NeuralNetworkClassifier`\n",
    "\n",
    "Starting with the `NeuralNetwork` class defined in Lecture Notes 12, complete the subclass `NeuralNetworkClassifier` as discussed.\n",
    "\n",
    "## `percent_correct`\n",
    "\n",
    "When trying to classify real data, we need a way to evaluate our performance.  One way is to just calculate the percent of samples correctly classified, and to show a confusion matrix.  Define the function\n",
    "`percent_correct(Y, T)`, that returns the percent of samples correctly classified, given `T` as a column matrix of class labels, and `Y` as the column matrix of classes predicted by `use`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import optimizers as opt\n",
    "import sys\n",
    "class NeuralNetwork():\n",
    "\n",
    "    def __init__(self, n_inputs, n_hiddens_list, n_outputs):\n",
    "\n",
    "        self.n_inputs = n_inputs\n",
    "        self.n_hiddens_list = n_hiddens_list\n",
    "        self.n_outputs = n_outputs\n",
    "        self.n_layers = len(n_hiddens_list) + 1\n",
    "\n",
    "        self.all_weights, self.Ws = self.make_weights()\n",
    "        self.initialize_weights()\n",
    "        self.all_gradients, self.Gs = self.make_weights()\n",
    "\n",
    "        self.stand_params = None\n",
    "        self.error_trace = []\n",
    "\n",
    "    def __repr__(self):\n",
    "        return f'NeuralNetwork({self.n_inputs}, {self.n_hiddens_list}, {self.n_outputs})'\n",
    "\n",
    "    def make_weights(self):\n",
    "        # Create list of matrix shapes, one per layer\n",
    "        n_in = self.n_inputs\n",
    "        units = self.n_hiddens_list + [self.n_outputs]\n",
    "        shapes = []\n",
    "        for n_units in units:\n",
    "            shapes.append((n_in + 1, n_units))\n",
    "            n_in = n_units\n",
    "\n",
    "        # Allocate contiguous memory to hold all weights\n",
    "        n_weights = sum([ni * nu for (ni, nu) in shapes])\n",
    "        all_weights = np.zeros(n_weights)\n",
    "\n",
    "        # Create numpy views into this memory with the appropriate\n",
    "        # shapes to be our weight matrices.\n",
    "        Ws = []\n",
    "        first = 0\n",
    "        for (ni, nu) in shapes:\n",
    "            n_w = ni * nu\n",
    "            W = all_weights[first:first + n_w].reshape(ni, nu)\n",
    "            Ws.append(W)\n",
    "            first += n_w\n",
    "\n",
    "        return all_weights, Ws\n",
    "\n",
    "    def initialize_weights(self):\n",
    "        for W in self.Ws:\n",
    "            ni, nu = W.shape\n",
    "            W[:] = np.random.uniform(-1, 1, size=(ni, nu)) / np.sqrt(ni)\n",
    "        self.error_trace = []\n",
    "\n",
    "    def forward(self,Xst):\n",
    "        Ys = [Xst]\n",
    "        for layer_i, W in enumerate(self.Ws):\n",
    "            X = Ys[-1]\n",
    "            Y = self.add_ones(X) @ W\n",
    "            if layer_i < self.n_layers - 1:\n",
    "                Y = np.tanh(Y)\n",
    "            Ys.append(Y)\n",
    "        return Ys[1:]  # remove X from Ys\n",
    "\n",
    "    def backward(self, Xst, Tst):\n",
    "        n_samples = Xst.shape[0]\n",
    "\n",
    "        Ys = self.forward(Xst)\n",
    "        Ys = [Xst] + Ys  # Ys now has n_layers + 1 elements.  Ws still has n_layers elements.\n",
    "        delta = - (Tst - Ys[-1]) / (n_samples * self.n_outputs)\n",
    "        for layeri in range(self.n_layers)[::-1]:\n",
    "            X = Ys[layeri]\n",
    "            self.Gs[layeri][:] = self.add_ones(X).T @ delta\n",
    "            if layeri > 0:\n",
    "                delta = delta @ self.Ws[layeri][1:, :].T\n",
    "                Y = X  # Ys[layeri]\n",
    "                delta *= 1 - Ys[layeri] ** 2\n",
    "            # if layeri < self.n_layers - 1:\n",
    "            #     delta *= 1 - Y ** 2\n",
    "        # print(self.all_gradients)\n",
    "        return self.all_gradients\n",
    "\n",
    "    def mse(self, Xst, Tst):\n",
    "        Yst = self.forward(Xst)\n",
    "        return 0.5 * np.mean((Tst - Yst[-1])**2)\n",
    "\n",
    "    def train(self, X, T, n_epochs, learning_rate=0.01, method='scg', verbose=True):\n",
    "\n",
    "        self.stand_params = self.calc_standardize_parameters(X, T)\n",
    "        Xst = self.standardize_X(X)\n",
    "        Tst = self.standardize_T(T)\n",
    "\n",
    "        if method == 'sgd':\n",
    "            optimizer = opt.Optimizers(self.all_weights).sgd\n",
    "        elif method == 'adam':\n",
    "            optimizer = opt.Optimizers(self.all_weights).adam\n",
    "        elif method == 'scg':\n",
    "            optimizer = opt.Optimizers(self.all_weights).scg\n",
    "        else:\n",
    "            print('train: method must be \\'sgd\\', \\'adam\\', or \\'scg\\'.')\n",
    "\n",
    "        def error_convert(err):\n",
    "            if T.shape[1] == 1:\n",
    "                return np.sqrt(err) * self.stand_params['Tstds']\n",
    "            else:\n",
    "                # Can't unstandardize err if more than one network output\n",
    "                return np.sqrt(err)\n",
    "            \n",
    "        error_trace = optimizer(self.mse, self.backward, [Xst, Tst],\n",
    "                                n_epochs, learning_rate,\n",
    "                                error_convert_f=error_convert,\n",
    "                                verbose=verbose)\n",
    "        self.error_trace += error_trace\n",
    "        return self\n",
    "\n",
    "    def use(self, X, return_hidden_layer_outputs=False):\n",
    "        Xst = self.standardize_X(X)\n",
    "        Ys = self.forward(Xst)\n",
    "        Y = Ys[-1]\n",
    "        Y = self.unstandardize_T(Y)\n",
    "        Zs = Ys[:-1]\n",
    "        return (Y, Zs) if return_hidden_layer_outputs else Y\n",
    "\n",
    "    def get_error_trace(self):\n",
    "        return self.error_trace\n",
    "\n",
    "    def add_ones(self, X):\n",
    "        return np.insert(X, 0, 1, axis=1)\n",
    "\n",
    "    def calc_standardize_parameters(self, X, T):\n",
    "        Xmeans = X.mean(axis=0)\n",
    "        Xstds = X.std(axis=0)\n",
    "        Xstds[Xstds == 0] = np.mean(Xstds[Xstds > 0])\n",
    "        Tmeans = T.mean(axis=0)\n",
    "        Tstds = T.std(axis=0)\n",
    "        return {'Xmeans': Xmeans, 'Xstds': Xstds, 'Tmeans': Tmeans, 'Tstds': Tstds}\n",
    "\n",
    "    def standardize_X(self, X):\n",
    "        return (X - self.stand_params['Xmeans']) / self.stand_params['Xstds']\n",
    "\n",
    "    def unstandardize_X(self, Xst):\n",
    "        return Xst * self.stand_params['Xstds'] + self.stand_params['Xmeans']\n",
    "\n",
    "    def standardize_T(self, T):\n",
    "        return (T - self.stand_params['Tmeans']) / self.stand_params['Tstds']\n",
    "\n",
    "    def unstandardize_T(self, Tst):\n",
    "        return Tst * self.stand_params['Tstds'] + self.stand_params['Tmeans']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NeuralNetworkClassifier(NeuralNetwork):\n",
    "    \n",
    "    \n",
    "    def train(self, X, T, n_epochs, learning_rate=0.01, method='scg', verbose=True):\n",
    "\n",
    "        self.stand_params = self.calc_standardize_parameters(X, T)\n",
    "        Xst = self.standardize_X(X)\n",
    "        # Tst = self.standardize_T(T)                                  ## CHANGED\n",
    "\n",
    "        # NEW PART FROM HERE ...\n",
    "        \n",
    "        self.classes, counts = np.unique(T, return_counts=True)\n",
    "        #print(\"inside NeuralNetworkClassifier : self.classes :\",self.classes,\"counts :\",counts)\n",
    "        self.most_common_class = self.classes[np.argmax(counts)]\n",
    "\n",
    "        if self.n_outputs != len(self.classes):\n",
    "            raise ValueError(f'''In NeuralNetworkClassifier, the number of outputs must equal\n",
    "the number of classes in the training data. The given number of outputs\n",
    "is {self.n_outputs} and number of classes is {len(self.classes)}. Try changing\n",
    "the number of outputs in the call to NeuralNetworkClassifier().''')\n",
    "\n",
    "        T_ind_vars = self.make_indicator_variables(T)\n",
    "        #print(\"inside train : T_ind_vars is :\",T_ind_vars)\n",
    "        #   ... TO HERE\n",
    "        \n",
    "        if method == 'sgd':\n",
    "            optimizer = opt.Optimizers(self.all_weights).sgd\n",
    "        elif method == 'adam':\n",
    "            optimizer = opt.Optimizers(self.all_weights).adam\n",
    "        elif method == 'scg':\n",
    "            optimizer = opt.Optimizers(self.all_weights).scg\n",
    "        else:\n",
    "            print('train: method must be \\'sgd\\', \\'adam\\', or \\'scg\\'.')\n",
    "\n",
    "        def error_convert(negLL):\n",
    "            return np.exp(-negLL)                                                    ## CHANGED\n",
    "            \n",
    "        error_trace = optimizer(self.neg_log_likelihood, self.backward, [Xst, T_ind_vars],   ## CHANGED\n",
    "                                n_epochs, learning_rate,\n",
    "                                error_convert_f=error_convert,\n",
    "                                verbose=verbose)\n",
    "        \n",
    "        self.error_trace += error_trace\n",
    "        return self\n",
    "    def make_indicator_variables(self, T):\n",
    "        '''Assumes argument is N x 1, N samples each being integer class label.'''\n",
    "        # Make sure T is two-dimensional. Should be n_samples x 1.\n",
    "        if T.ndim == 1:\n",
    "            T = T.reshape((-1, 1))    \n",
    "        return (T == np.unique(T)).astype(int)\n",
    "    def softmax(self, Y):\n",
    "        '''Apply to final layer weighted sum outputs'''\n",
    "        # Trick to avoid overflow\n",
    "        maxY = max(0, np.max(Y))\n",
    "        expY = np.exp(Y - maxY)\n",
    "        denom = np.sum(expY, axis=1).reshape((-1, 1)) \n",
    "        Y = expY / (denom + sys.float_info.epsilon)             # requires an    import sys\n",
    "        return Y\n",
    "    \n",
    "    def forward(self,Xst):\n",
    "        Ys = [Xst]\n",
    "        for layer_i, W in enumerate(self.Ws):\n",
    "            X = Ys[-1]\n",
    "            Y = self.add_ones(X) @ W\n",
    "            if layer_i < self.n_layers - 1: \n",
    "                #apply tanh only to the hidden layers\n",
    "                Y = np.tanh(Y)\n",
    "            if layer_i == self.n_layers-1: \n",
    "                #last layer\n",
    "                Ys.append(self.softmax(Y))\n",
    "            else: \n",
    "                #if not last layer\n",
    "                Ys.append(Y)\n",
    "        return Ys[1:]  # remove X from Ys\n",
    "   \n",
    "    def backward(self, Xst, Tst):\n",
    "        n_samples = Xst.shape[0]\n",
    "\n",
    "        Ys = self.forward(Xst)\n",
    "        Ys = [Xst] + Ys  # Ys now has n_layers + 1 elements.  Ws still has n_layers elements.\n",
    "        delta = - (Tst - Ys[-1]) / (n_samples * self.n_outputs)\n",
    "        for layeri in range(self.n_layers)[::-1]:\n",
    "            X = Ys[layeri]\n",
    "            self.Gs[layeri][:] = self.add_ones(X).T @ delta\n",
    "            if layeri > 0:\n",
    "                delta = delta @ self.Ws[layeri][1:, :].T\n",
    "                Y = X  # Ys[layeri]\n",
    "                delta *= 1 - Ys[layeri] ** 2\n",
    "            # if layeri < self.n_layers - 1:\n",
    "            #     delta *= 1 - Y ** 2\n",
    "        # print(self.all_gradients)\n",
    "        return self.all_gradients\n",
    "    def neg_log_likelihood(self, Xst, T):  # T must be indicator variables\n",
    "        (N,K) = T.shape\n",
    "        Y=self.forward(Xst)\n",
    "        \n",
    "        LL=0\n",
    "        \n",
    "        temp = (np.log(Y[-1]+sys.float_info.epsilon))\n",
    "        \n",
    "        result = np.multiply(T,temp)\n",
    "        result1=np.mean(result)\n",
    "        \n",
    "        return -result1\n",
    "    def use(self, X, return_hidden_layer_outputs=False):\n",
    "        Xst = self.standardize_X(X)\n",
    "        Ys = self.forward(Xst)\n",
    "        Y = Ys[-1]\n",
    "        max1=np.argmax(Y,axis=1)\n",
    "        classes=max1.reshape(-1,1)\n",
    "        Zs = Ys[:-1]\n",
    "        return (classes, Y, Zs) if return_hidden_layer_outputs else (classes, Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def percent_correct(Y, T):\n",
    "#given T as a column matrix of class labels, and Y as the column matrix of classes predicted by use\n",
    "    number_of_correct = 0\n",
    "    for i, j in zip(range(len(Y)), range(len(T))):\n",
    "        if Y[i]==T[j]:\n",
    "            number_of_correct=number_of_correct+1\n",
    "    percent=(number_of_correct/len(Y))*100\n",
    "    return percent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A second way to evaluate a classifier is to calculate a confusion matrix. This shows the percent accuracy for each class, and also shows which classes are predicted in error.\n",
    "\n",
    "Here is a function you can use to show a confusion matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-10-21T16:01:59.683535Z",
     "start_time": "2020-10-21T16:01:59.561551Z"
    }
   },
   "outputs": [],
   "source": [
    "import pandas\n",
    "\n",
    "def confusion_matrix(Y_classes, T):\n",
    "    class_names = np.unique(T)\n",
    "    table = []\n",
    "    for true_class in class_names:\n",
    "        row = []\n",
    "        for Y_class in class_names:\n",
    "            row.append(100 * np.mean(Y_classes[T == true_class] == Y_class))\n",
    "        table.append(row)\n",
    "    conf_matrix = pandas.DataFrame(table, index=class_names, columns=class_names)\n",
    "    # cf.style.background_gradient(cmap='Blues').format(\"{:.1f} %\")\n",
    "    print('Percent Correct')\n",
    "    return conf_matrix.style.background_gradient(cmap='Blues').format(\"{:.1f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Apply `NeuralNetworkClassifier` to Images of Handwritten Digits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Apply your `NeuralNetworkClassifier` to the [MNIST digits dataset](http://deeplearning.net/tutorial/gettingstarted.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-10-21T16:01:59.808976Z",
     "start_time": "2020-10-21T16:01:59.807302Z"
    }
   },
   "outputs": [],
   "source": [
    "import pickle\n",
    "import gzip\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-10-21T16:02:00.504930Z",
     "start_time": "2020-10-21T16:01:59.809809Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(50000, 784) (50000, 1) (10000, 784) (10000, 1) (10000, 784) (10000, 1)\n"
     ]
    }
   ],
   "source": [
    "with gzip.open('mnist.pkl.gz', 'rb') as f:\n",
    "    train_set, valid_set, test_set = pickle.load(f, encoding='latin1')\n",
    "\n",
    "Xtrain = train_set[0]\n",
    "Ttrain = train_set[1].reshape(-1, 1)\n",
    "\n",
    "Xval = valid_set[0]\n",
    "Tval = valid_set[1].reshape(-1, 1)\n",
    "\n",
    "Xtest = test_set[0]\n",
    "Ttest = test_set[1].reshape(-1, 1)\n",
    "\n",
    "print(Xtrain.shape, Ttrain.shape,  Xval.shape, Tval.shape,  Xtest.shape, Ttest.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-10-21T16:02:00.519909Z",
     "start_time": "2020-10-21T16:02:00.509608Z"
    }
   },
   "outputs": [],
   "source": [
    "def draw_image(image, label):\n",
    "    plt.imshow(-image.reshape(28, 28), cmap='gray')\n",
    "    # plt.axis('off')\n",
    "    plt.xticks([])\n",
    "    plt.yticks([])\n",
    "    plt.axis('off')\n",
    "    plt.title(label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-10-21T16:02:02.451747Z",
     "start_time": "2020-10-21T16:02:00.520864Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x864 with 100 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(12, 12))\n",
    "for i in range(100):\n",
    "    plt.subplot(10, 10, i+1)\n",
    "    draw_image(Xtrain[i], Ttrain[i,0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define `train_for_best_validation` and apply to MNIST data\n",
    "\n",
    "Using the function `run` from Lecture Notes 11 as a guide, define a new function `train_for_best_validation` that accepts arguments\n",
    "* `Xtrain, Ttrain`: matrices of shapes $N\\times D$ and $N\\times 1$ as input and target training data, where $N$ is number of training samples and $D$ is number of input components,\n",
    "* `Xval, Tval`: matrices of shapes  $N\\times D$ and $N\\times 1$ of validation data ($N$ not same value as above)\n",
    "* `n_epochs`: total number of epochs to train for,\n",
    "* `n_epochs_per_train`: divide `n_epochs` by this value to get number of times the neural network `train` function is called for this many epochs,\n",
    "* `n_hiddens_list`: structure of hidden layers,\n",
    "* `method`: optimizer method,\n",
    "* `learning_rate`: used for optimizer methods 'adam' and 'sgd'.\n",
    "\n",
    "It must return \n",
    "* `nnet`: resulting neural network with weights that produced the highest accuracy for the validation data set,\n",
    "* `epoch`: epoch corresponding to best validation accuracy,\n",
    "* `train_accuracy`: accuracy at that best epoch on training data,\n",
    "* `val_accuracy`: accuracy at that best epoch on validation data.\n",
    "\n",
    "This function should call your `percent_correct` function to calculate classification accuracies.\n",
    "\n",
    "Apply it to the MNIST data as shown below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_for_best_validation(Xtrain, Ttrain,  Xval, Tval, n_epochs, n_epochs_per_train, n_hiddens_list, method,learning_rate=None):\n",
    "    \n",
    "    n_reps = n_epochs // n_epochs_per_train\n",
    "    n_epochs_last_train = n_epochs - n_reps * n_epochs_per_train\n",
    "    if n_epochs_last_train > 0:\n",
    "        n_reps += 1\n",
    " \n",
    "    m,n=Xtrain.shape\n",
    "    #print(\"Xtrain shape is m:\",m,\" n is \",n)\n",
    "    #print(\"unique is :\",len(np.unique(Ttrain)))\n",
    "    num_outputs = len(np.unique(Ttrain))\n",
    "    nnet = NeuralNetworkClassifier(n, n_hiddens_list, num_outputs)\n",
    "\n",
    "    accuracies = []\n",
    "    for reps in range(n_reps):\n",
    "        n_epoch = n_epochs_per_train \n",
    "        if n_epochs_last_train > 0 and reps == n_reps-1:\n",
    "            n_epoch = n_epochs_last_train\n",
    "            \n",
    "        nnet.train(Xtrain, Ttrain, n_epoch, method, verbose=False)\n",
    "        \n",
    "        accuracies.append([(reps + 1) * n_epoch,\n",
    "                      percent_correct(nnet.use(Xtrain)[0], Ttrain),\n",
    "                      percent_correct(nnet.use(Xval)[0], Tval),nnet])\n",
    "        \n",
    "    accuracies = np.array(accuracies)\n",
    "    best_val_index = np.argmax(accuracies[:, -2])\n",
    "    best_val_epoch, best_val_train_accuracy, best_val_test_accuracy,nnet = accuracies[best_val_index, :]\n",
    "    print(f'Best val error is at epoch {best_val_epoch}', end='')\n",
    "    print(f' with Accuracy for Training data of {best_val_train_accuracy} and Validation data of {best_val_test_accuracy}')\n",
    "\n",
    "    return nnet,best_val_epoch,best_val_train_accuracy,best_val_test_accuracy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### EXPERIMENT function\n",
    "\n",
    "This function calls the 'train_for_best_validation' function. It iterates over the list of all parameter variations and calls the 'train_for_best_validation' function. Finally it returns a dataframe table which is displayed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def experiment(Xtrain, Ttrain,  Xval, Tval,method,n_epochs_list,n_epochs_per_train_list,n_hiddens_listof_list,learning_rate_list):\n",
    "    import pandas as pd\n",
    "    \n",
    "    results_mnist_num=[]\n",
    "    for learning_rate in range(len(learning_rate_list)):\n",
    "            for n_hiddens_list in range(len(n_hiddens_listof_list)):\n",
    "                for n_epochs in range(len(n_epochs_list)):\n",
    "                    for n_epochs_per_train in range(len(n_epochs_per_train_list)):\n",
    "                        print(\"learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\")\n",
    "                        print(learning_rate_list[learning_rate],n_hiddens_listof_list[n_hiddens_list],n_epochs_list[n_epochs],n_epochs_per_train_list[n_epochs_per_train])\n",
    "                        \n",
    "                        nnet, val_epoch, train_accuracy, val_accuracy = train_for_best_validation(Xtrain, Ttrain,  Xval, Tval, \n",
    "                                                                              n_epochs_list[n_epochs], n_epochs_per_train_list[n_epochs_per_train], n_hiddens_listof_list[n_hiddens_list], method,learning_rate_list[learning_rate])\n",
    "                        \n",
    "                        results_temp=[]\n",
    "                        results_temp.append(learning_rate_list[learning_rate])\n",
    "                        results_temp.append(n_hiddens_listof_list[n_hiddens_list])\n",
    "                        results_temp.append(n_epochs_list[n_epochs])\n",
    "                        results_temp.append(n_epochs_per_train_list[n_epochs_per_train])\n",
    "                        results_temp.append(nnet)\n",
    "                        results_temp.append(train_accuracy)\n",
    "                        results_temp.append(val_accuracy)\n",
    "                        results_mnist_num.append(results_temp)\n",
    "                        #mnist_num_df=[]\n",
    "                        #for i in [0,1,2,3,5,6]:\n",
    "                            #mnist_num_df.append(results_temp[i])\n",
    "                        df_mnist = pd.DataFrame(results_mnist_num, columns=('Learning Rate','Hidden Layers','Epochs','Epochs per Train','nnet','Train Accuracy', 'Val Accuracy'))\n",
    "    return results_mnist_num,df_mnist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SGD "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SGD\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.05 [] 200 10\n",
      "Best val error is at epoch 30 with Accuracy for Training data of 96.52965296529653 and Validation data of 91.11\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.05 [] 200 50\n",
      "Best val error is at epoch 50 with Accuracy for Training data of 96.95969596959696 and Validation data of 90.71000000000001\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.05 [] 250 10\n",
      "Best val error is at epoch 10 with Accuracy for Training data of 94.03940394039404 and Validation data of 91.06\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.05 [] 250 50\n",
      "Best val error is at epoch 100 with Accuracy for Training data of 97.21972197219722 and Validation data of 90.68\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.05 [50, 50] 200 10\n",
      "Best val error is at epoch 40 with Accuracy for Training data of 100.0 and Validation data of 93.82000000000001\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.05 [50, 50] 200 50\n",
      "Best val error is at epoch 50 with Accuracy for Training data of 100.0 and Validation data of 93.89999999999999\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.05 [50, 50] 250 10\n",
      "Best val error is at epoch 20 with Accuracy for Training data of 99.08990899089909 and Validation data of 93.45\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.05 [50, 50] 250 50\n",
      "Best val error is at epoch 50 with Accuracy for Training data of 100.0 and Validation data of 93.86\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.1 [] 200 10\n",
      "Best val error is at epoch 10 with Accuracy for Training data of 94.11941194119412 and Validation data of 91.21000000000001\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.1 [] 200 50\n",
      "Best val error is at epoch 50 with Accuracy for Training data of 95.23952395239525 and Validation data of 91.14999999999999\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.1 [] 250 10\n",
      "Best val error is at epoch 10 with Accuracy for Training data of 94.01940194019402 and Validation data of 91.17\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.1 [] 250 50\n",
      "Best val error is at epoch 100 with Accuracy for Training data of 96.65966596659666 and Validation data of 90.86\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.1 [50, 50] 200 10\n",
      "Best val error is at epoch 40 with Accuracy for Training data of 100.0 and Validation data of 93.63\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.1 [50, 50] 200 50\n",
      "Best val error is at epoch 100 with Accuracy for Training data of 100.0 and Validation data of 93.57\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.1 [50, 50] 250 10\n",
      "Best val error is at epoch 50 with Accuracy for Training data of 100.0 and Validation data of 93.72\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.1 [50, 50] 250 50\n",
      "Best val error is at epoch 100 with Accuracy for Training data of 100.0 and Validation data of 93.38\n",
      "SGD TABLE :\n",
      "    Learning Rate Hidden Layers  Epochs  Epochs per Train  \\\n",
      "0            0.05            []     200                10   \n",
      "1            0.05            []     200                50   \n",
      "2            0.05            []     250                10   \n",
      "3            0.05            []     250                50   \n",
      "4            0.05      [50, 50]     200                10   \n",
      "5            0.05      [50, 50]     200                50   \n",
      "6            0.05      [50, 50]     250                10   \n",
      "7            0.05      [50, 50]     250                50   \n",
      "8            0.10            []     200                10   \n",
      "9            0.10            []     200                50   \n",
      "10           0.10            []     250                10   \n",
      "11           0.10            []     250                50   \n",
      "12           0.10      [50, 50]     200                10   \n",
      "13           0.10      [50, 50]     200                50   \n",
      "14           0.10      [50, 50]     250                10   \n",
      "15           0.10      [50, 50]     250                50   \n",
      "\n",
      "                                nnet  Train Accuracy  Val Accuracy  \n",
      "0         NeuralNetwork(784, [], 10)       96.529653         91.11  \n",
      "1         NeuralNetwork(784, [], 10)       96.959696         90.71  \n",
      "2         NeuralNetwork(784, [], 10)       94.039404         91.06  \n",
      "3         NeuralNetwork(784, [], 10)       97.219722         90.68  \n",
      "4   NeuralNetwork(784, [50, 50], 10)      100.000000         93.82  \n",
      "5   NeuralNetwork(784, [50, 50], 10)      100.000000         93.90  \n",
      "6   NeuralNetwork(784, [50, 50], 10)       99.089909         93.45  \n",
      "7   NeuralNetwork(784, [50, 50], 10)      100.000000         93.86  \n",
      "8         NeuralNetwork(784, [], 10)       94.119412         91.21  \n",
      "9         NeuralNetwork(784, [], 10)       95.239524         91.15  \n",
      "10        NeuralNetwork(784, [], 10)       94.019402         91.17  \n",
      "11        NeuralNetwork(784, [], 10)       96.659666         90.86  \n",
      "12  NeuralNetwork(784, [50, 50], 10)      100.000000         93.63  \n",
      "13  NeuralNetwork(784, [50, 50], 10)      100.000000         93.57  \n",
      "14  NeuralNetwork(784, [50, 50], 10)      100.000000         93.72  \n",
      "15  NeuralNetwork(784, [50, 50], 10)      100.000000         93.38  \n"
     ]
    }
   ],
   "source": [
    "\n",
    "n_epochs_list=[200,250]\n",
    "n_epochs_per_train_list=[10,50]\n",
    "n_hiddens_listof_list=[[],[50,50]]\n",
    "learning_rate_list=[0.05,0.1]\n",
    "\n",
    "\n",
    "Xtrain1=Xtrain[0:9999,:]\n",
    "Ttrain1=Ttrain[0:9999,:]\n",
    "##SGD\n",
    "print(\"SGD\")\n",
    "results_mnist_num_sgd,df_mnist_sgd=experiment(Xtrain1, Ttrain1,  Xval, Tval,'sgd',n_epochs_list,n_epochs_per_train_list,n_hiddens_listof_list,learning_rate_list)\n",
    "print(\"SGD TABLE :\")\n",
    "print(df_mnist_sgd)\n",
    "results_array_sgd=np.array(results_mnist_num_sgd)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Select the entry with best validation accuracy from the table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.05, list([50, 50]), 200, 50, NeuralNetwork(784, [50, 50], 10),\n",
       "       100.0, 93.89999999999999], dtype=object)"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results_array_sgd[5,:]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.05 list([50, 50]) 200 50 NeuralNetwork(784, [50, 50], 10) 100.0\n",
      " 93.89999999999999]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "NeuralNetwork(784, [50, 50], 10)"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "best_result_sgd=results_array_sgd[5,:]\n",
    "print(best_result_sgd)\n",
    "nnet_1_sgd=results_array_sgd[5,4]\n",
    "nnet_1_sgd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[100.0, 93.71000000000001, 92.96]"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[percent_correct(nnet_1_sgd.use(X)[0], T) for X, T in zip([Xtrain1, Xval, Xtest], [Ttrain1, Tval, Ttest])]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Confusion matrix for best validation accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Percent Correct\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<style  type=\"text/css\" >\n",
       "    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row0_col0 {\n",
       "            background-color:  #08306b;\n",
       "            color:  #f1f1f1;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row0_col1 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row0_col2 {\n",
       "            background-color:  #f6faff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row0_col3 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row0_col4 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row0_col5 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row0_col6 {\n",
       "            background-color:  #f6faff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row0_col7 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row0_col8 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row0_col9 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row1_col0 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row1_col1 {\n",
       "            background-color:  #08306b;\n",
       "            color:  #f1f1f1;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row1_col2 {\n",
       "            background-color:  #f6faff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row1_col3 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row1_col4 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row1_col5 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row1_col6 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row1_col7 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row1_col8 {\n",
       "            background-color:  #f6faff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row1_col9 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row2_col0 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row2_col1 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row2_col2 {\n",
       "            background-color:  #08306b;\n",
       "            color:  #f1f1f1;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row2_col3 {\n",
       "            background-color:  #f4f9fe;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row2_col4 {\n",
       "            background-color:  #f5fafe;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row2_col5 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row2_col6 {\n",
       "            background-color:  #f5fafe;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row2_col7 {\n",
       "            background-color:  #f5f9fe;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row2_col8 {\n",
       "            background-color:  #f5fafe;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row2_col9 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row3_col0 {\n",
       "            background-color:  #f6faff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row3_col1 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row3_col2 {\n",
       "            background-color:  #f5f9fe;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row3_col3 {\n",
       "            background-color:  #08306b;\n",
       "            color:  #f1f1f1;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row3_col4 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row3_col5 {\n",
       "            background-color:  #f2f8fd;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row3_col6 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row3_col7 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row3_col8 {\n",
       "            background-color:  #f2f8fd;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row3_col9 {\n",
       "            background-color:  #f5fafe;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row4_col0 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row4_col1 {\n",
       "            background-color:  #f6faff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row4_col2 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row4_col3 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row4_col4 {\n",
       "            background-color:  #08306b;\n",
       "            color:  #f1f1f1;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row4_col5 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row4_col6 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row4_col7 {\n",
       "            background-color:  #f5fafe;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row4_col8 {\n",
       "            background-color:  #f6faff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row4_col9 {\n",
       "            background-color:  #f5f9fe;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row5_col0 {\n",
       "            background-color:  #f5fafe;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row5_col1 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row5_col2 {\n",
       "            background-color:  #f6faff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row5_col3 {\n",
       "            background-color:  #eff6fc;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row5_col4 {\n",
       "            background-color:  #f5fafe;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row5_col5 {\n",
       "            background-color:  #08306b;\n",
       "            color:  #f1f1f1;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row5_col6 {\n",
       "            background-color:  #f3f8fe;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row5_col7 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row5_col8 {\n",
       "            background-color:  #f4f9fe;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row5_col9 {\n",
       "            background-color:  #f6faff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row6_col0 {\n",
       "            background-color:  #f5fafe;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row6_col1 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row6_col2 {\n",
       "            background-color:  #f5fafe;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row6_col3 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row6_col4 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row6_col5 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row6_col6 {\n",
       "            background-color:  #08306b;\n",
       "            color:  #f1f1f1;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row6_col7 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row6_col8 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row6_col9 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row7_col0 {\n",
       "            background-color:  #f6faff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row7_col1 {\n",
       "            background-color:  #f6faff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row7_col2 {\n",
       "            background-color:  #f6faff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row7_col3 {\n",
       "            background-color:  #f5f9fe;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row7_col4 {\n",
       "            background-color:  #f6faff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row7_col5 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row7_col6 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row7_col7 {\n",
       "            background-color:  #08306b;\n",
       "            color:  #f1f1f1;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row7_col8 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row7_col9 {\n",
       "            background-color:  #f5f9fe;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row8_col0 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row8_col1 {\n",
       "            background-color:  #f5fafe;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row8_col2 {\n",
       "            background-color:  #f5fafe;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row8_col3 {\n",
       "            background-color:  #f2f8fd;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row8_col4 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row8_col5 {\n",
       "            background-color:  #f2f7fd;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row8_col6 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row8_col7 {\n",
       "            background-color:  #f5fafe;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row8_col8 {\n",
       "            background-color:  #08306b;\n",
       "            color:  #f1f1f1;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row8_col9 {\n",
       "            background-color:  #f4f9fe;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row9_col0 {\n",
       "            background-color:  #f6faff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row9_col1 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row9_col2 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row9_col3 {\n",
       "            background-color:  #f5fafe;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row9_col4 {\n",
       "            background-color:  #f2f7fd;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row9_col5 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row9_col6 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row9_col7 {\n",
       "            background-color:  #f2f8fd;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row9_col8 {\n",
       "            background-color:  #f5f9fe;\n",
       "            color:  #000000;\n",
       "        }    #T_9049c79c_18c6_11eb_ad51_5b315dbf3695row9_col9 {\n",
       "            background-color:  #08306b;\n",
       "            color:  #f1f1f1;\n",
       "        }</style><table id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695\" ><thead>    <tr>        <th class=\"blank level0\" ></th>        <th class=\"col_heading level0 col0\" >0</th>        <th class=\"col_heading level0 col1\" >1</th>        <th class=\"col_heading level0 col2\" >2</th>        <th class=\"col_heading level0 col3\" >3</th>        <th class=\"col_heading level0 col4\" >4</th>        <th class=\"col_heading level0 col5\" >5</th>        <th class=\"col_heading level0 col6\" >6</th>        <th class=\"col_heading level0 col7\" >7</th>        <th class=\"col_heading level0 col8\" >8</th>        <th class=\"col_heading level0 col9\" >9</th>    </tr></thead><tbody>\n",
       "                <tr>\n",
       "                        <th id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695level0_row0\" class=\"row_heading level0 row0\" >0</th>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row0_col0\" class=\"data row0 col0\" >97.7</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row0_col1\" class=\"data row0 col1\" >0.1</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row0_col2\" class=\"data row0 col2\" >0.7</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row0_col3\" class=\"data row0 col3\" >0.0</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row0_col4\" class=\"data row0 col4\" >0.3</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row0_col5\" class=\"data row0 col5\" >0.1</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row0_col6\" class=\"data row0 col6\" >0.5</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row0_col7\" class=\"data row0 col7\" >0.2</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row0_col8\" class=\"data row0 col8\" >0.2</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row0_col9\" class=\"data row0 col9\" >0.2</td>\n",
       "            </tr>\n",
       "            <tr>\n",
       "                        <th id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695level0_row1\" class=\"row_heading level0 row1\" >1</th>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row1_col0\" class=\"data row1 col0\" >0.0</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row1_col1\" class=\"data row1 col1\" >97.9</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row1_col2\" class=\"data row1 col2\" >0.5</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row1_col3\" class=\"data row1 col3\" >0.2</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row1_col4\" class=\"data row1 col4\" >0.1</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row1_col5\" class=\"data row1 col5\" >0.1</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row1_col6\" class=\"data row1 col6\" >0.3</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row1_col7\" class=\"data row1 col7\" >0.2</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row1_col8\" class=\"data row1 col8\" >0.6</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row1_col9\" class=\"data row1 col9\" >0.2</td>\n",
       "            </tr>\n",
       "            <tr>\n",
       "                        <th id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695level0_row2\" class=\"row_heading level0 row2\" >2</th>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row2_col0\" class=\"data row2 col0\" >0.2</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row2_col1\" class=\"data row2 col1\" >0.3</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row2_col2\" class=\"data row2 col2\" >93.1</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row2_col3\" class=\"data row2 col3\" >1.5</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row2_col4\" class=\"data row2 col4\" >0.9</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row2_col5\" class=\"data row2 col5\" >0.3</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row2_col6\" class=\"data row2 col6\" >0.9</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row2_col7\" class=\"data row2 col7\" >1.4</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row2_col8\" class=\"data row2 col8\" >1.0</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row2_col9\" class=\"data row2 col9\" >0.3</td>\n",
       "            </tr>\n",
       "            <tr>\n",
       "                        <th id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695level0_row3\" class=\"row_heading level0 row3\" >3</th>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row3_col0\" class=\"data row3 col0\" >0.6</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row3_col1\" class=\"data row3 col1\" >0.2</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row3_col2\" class=\"data row3 col2\" >1.4</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row3_col3\" class=\"data row3 col3\" >91.3</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row3_col4\" class=\"data row3 col4\" >0.1</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row3_col5\" class=\"data row3 col5\" >2.3</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row3_col6\" class=\"data row3 col6\" >0.3</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row3_col7\" class=\"data row3 col7\" >0.5</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row3_col8\" class=\"data row3 col8\" >2.4</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row3_col9\" class=\"data row3 col9\" >1.0</td>\n",
       "            </tr>\n",
       "            <tr>\n",
       "                        <th id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695level0_row4\" class=\"row_heading level0 row4\" >4</th>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row4_col0\" class=\"data row4 col0\" >0.3</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row4_col1\" class=\"data row4 col1\" >0.6</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row4_col2\" class=\"data row4 col2\" >0.1</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row4_col3\" class=\"data row4 col3\" >0.3</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row4_col4\" class=\"data row4 col4\" >95.4</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row4_col5\" class=\"data row4 col5\" >0.1</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row4_col6\" class=\"data row4 col6\" >0.2</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row4_col7\" class=\"data row4 col7\" >1.0</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row4_col8\" class=\"data row4 col8\" >0.6</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row4_col9\" class=\"data row4 col9\" >1.3</td>\n",
       "            </tr>\n",
       "            <tr>\n",
       "                        <th id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695level0_row5\" class=\"row_heading level0 row5\" >5</th>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row5_col0\" class=\"data row5 col0\" >0.9</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row5_col1\" class=\"data row5 col1\" >0.1</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row5_col2\" class=\"data row5 col2\" >0.7</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row5_col3\" class=\"data row5 col3\" >3.7</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row5_col4\" class=\"data row5 col4\" >0.9</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row5_col5\" class=\"data row5 col5\" >89.2</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row5_col6\" class=\"data row5 col6\" >2.2</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row5_col7\" class=\"data row5 col7\" >0.2</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row5_col8\" class=\"data row5 col8\" >1.6</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row5_col9\" class=\"data row5 col9\" >0.5</td>\n",
       "            </tr>\n",
       "            <tr>\n",
       "                        <th id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695level0_row6\" class=\"row_heading level0 row6\" >6</th>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row6_col0\" class=\"data row6 col0\" >0.9</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row6_col1\" class=\"data row6 col1\" >0.1</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row6_col2\" class=\"data row6 col2\" >0.9</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row6_col3\" class=\"data row6 col3\" >0.0</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row6_col4\" class=\"data row6 col4\" >0.2</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row6_col5\" class=\"data row6 col5\" >0.2</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row6_col6\" class=\"data row6 col6\" >97.2</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row6_col7\" class=\"data row6 col7\" >0.2</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row6_col8\" class=\"data row6 col8\" >0.2</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row6_col9\" class=\"data row6 col9\" >0.0</td>\n",
       "            </tr>\n",
       "            <tr>\n",
       "                        <th id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695level0_row7\" class=\"row_heading level0 row7\" >7</th>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row7_col0\" class=\"data row7 col0\" >0.6</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row7_col1\" class=\"data row7 col1\" >0.6</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row7_col2\" class=\"data row7 col2\" >0.6</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row7_col3\" class=\"data row7 col3\" >1.1</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row7_col4\" class=\"data row7 col4\" >0.6</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row7_col5\" class=\"data row7 col5\" >0.2</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row7_col6\" class=\"data row7 col6\" >0.0</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row7_col7\" class=\"data row7 col7\" >94.8</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row7_col8\" class=\"data row7 col8\" >0.2</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row7_col9\" class=\"data row7 col9\" >1.3</td>\n",
       "            </tr>\n",
       "            <tr>\n",
       "                        <th id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695level0_row8\" class=\"row_heading level0 row8\" >8</th>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row8_col0\" class=\"data row8 col0\" >0.1</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row8_col1\" class=\"data row8 col1\" >1.2</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row8_col2\" class=\"data row8 col2\" >1.0</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row8_col3\" class=\"data row8 col3\" >2.4</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row8_col4\" class=\"data row8 col4\" >0.3</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row8_col5\" class=\"data row8 col5\" >2.7</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row8_col6\" class=\"data row8 col6\" >0.2</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row8_col7\" class=\"data row8 col7\" >1.0</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row8_col8\" class=\"data row8 col8\" >89.5</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row8_col9\" class=\"data row8 col9\" >1.7</td>\n",
       "            </tr>\n",
       "            <tr>\n",
       "                        <th id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695level0_row9\" class=\"row_heading level0 row9\" >9</th>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row9_col0\" class=\"data row9 col0\" >0.6</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row9_col1\" class=\"data row9 col1\" >0.2</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row9_col2\" class=\"data row9 col2\" >0.1</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row9_col3\" class=\"data row9 col3\" >0.8</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row9_col4\" class=\"data row9 col4\" >3.0</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row9_col5\" class=\"data row9 col5\" >0.4</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row9_col6\" class=\"data row9 col6\" >0.1</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row9_col7\" class=\"data row9 col7\" >2.7</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row9_col8\" class=\"data row9 col8\" >1.6</td>\n",
       "                        <td id=\"T_9049c79c_18c6_11eb_ad51_5b315dbf3695row9_col9\" class=\"data row9 col9\" >90.4</td>\n",
       "            </tr>\n",
       "    </tbody></table>"
      ],
      "text/plain": [
       "<pandas.io.formats.style.Styler at 0x7f25189fd130>"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "confusion_matrix(nnet_1_sgd.use(Xval)[0], Tval)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ADAM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ADAM\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.05 [] 200 10\n",
      "Best val error is at epoch 10 with Accuracy for Training data of 93.96939693969398 and Validation data of 91.14999999999999\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.05 [] 200 50\n",
      "Best val error is at epoch 50 with Accuracy for Training data of 95.26952695269527 and Validation data of 91.06\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.05 [] 250 10\n",
      "Best val error is at epoch 10 with Accuracy for Training data of 93.92939293929393 and Validation data of 91.19\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.05 [] 250 50\n",
      "Best val error is at epoch 50 with Accuracy for Training data of 96.96969696969697 and Validation data of 90.38000000000001\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.05 [50, 50] 200 10\n",
      "Best val error is at epoch 70 with Accuracy for Training data of 100.0 and Validation data of 93.93\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.05 [50, 50] 200 50\n",
      "Best val error is at epoch 50 with Accuracy for Training data of 100.0 and Validation data of 93.57\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.05 [50, 50] 250 10\n",
      "Best val error is at epoch 60 with Accuracy for Training data of 100.0 and Validation data of 93.82000000000001\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.05 [50, 50] 250 50\n",
      "Best val error is at epoch 50 with Accuracy for Training data of 100.0 and Validation data of 93.56\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.1 [] 200 10\n",
      "Best val error is at epoch 10 with Accuracy for Training data of 93.96939693969398 and Validation data of 91.2\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.1 [] 200 50\n",
      "Best val error is at epoch 200 with Accuracy for Training data of 97.24972497249725 and Validation data of 90.79\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.1 [] 250 10\n",
      "Best val error is at epoch 10 with Accuracy for Training data of 94.01940194019402 and Validation data of 91.32000000000001\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.1 [] 250 50\n",
      "Best val error is at epoch 150 with Accuracy for Training data of 97.23972397239724 and Validation data of 90.68\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.1 [50, 50] 200 10\n",
      "Best val error is at epoch 30 with Accuracy for Training data of 99.94999499949995 and Validation data of 93.56\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.1 [50, 50] 200 50\n",
      "Best val error is at epoch 50 with Accuracy for Training data of 100.0 and Validation data of 93.49\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.1 [50, 50] 250 10\n",
      "Best val error is at epoch 70 with Accuracy for Training data of 100.0 and Validation data of 93.44\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.1 [50, 50] 250 50\n",
      "Best val error is at epoch 50 with Accuracy for Training data of 100.0 and Validation data of 93.82000000000001\n",
      "ADAM TABLE :\n",
      "    Learning Rate Hidden Layers  Epochs  Epochs per Train  \\\n",
      "0            0.05            []     200                10   \n",
      "1            0.05            []     200                50   \n",
      "2            0.05            []     250                10   \n",
      "3            0.05            []     250                50   \n",
      "4            0.05      [50, 50]     200                10   \n",
      "5            0.05      [50, 50]     200                50   \n",
      "6            0.05      [50, 50]     250                10   \n",
      "7            0.05      [50, 50]     250                50   \n",
      "8            0.10            []     200                10   \n",
      "9            0.10            []     200                50   \n",
      "10           0.10            []     250                10   \n",
      "11           0.10            []     250                50   \n",
      "12           0.10      [50, 50]     200                10   \n",
      "13           0.10      [50, 50]     200                50   \n",
      "14           0.10      [50, 50]     250                10   \n",
      "15           0.10      [50, 50]     250                50   \n",
      "\n",
      "                                nnet  Train Accuracy  Val Accuracy  \n",
      "0         NeuralNetwork(784, [], 10)       93.969397         91.15  \n",
      "1         NeuralNetwork(784, [], 10)       95.269527         91.06  \n",
      "2         NeuralNetwork(784, [], 10)       93.929393         91.19  \n",
      "3         NeuralNetwork(784, [], 10)       96.969697         90.38  \n",
      "4   NeuralNetwork(784, [50, 50], 10)      100.000000         93.93  \n",
      "5   NeuralNetwork(784, [50, 50], 10)      100.000000         93.57  \n",
      "6   NeuralNetwork(784, [50, 50], 10)      100.000000         93.82  \n",
      "7   NeuralNetwork(784, [50, 50], 10)      100.000000         93.56  \n",
      "8         NeuralNetwork(784, [], 10)       93.969397         91.20  \n",
      "9         NeuralNetwork(784, [], 10)       97.249725         90.79  \n",
      "10        NeuralNetwork(784, [], 10)       94.019402         91.32  \n",
      "11        NeuralNetwork(784, [], 10)       97.239724         90.68  \n",
      "12  NeuralNetwork(784, [50, 50], 10)       99.949995         93.56  \n",
      "13  NeuralNetwork(784, [50, 50], 10)      100.000000         93.49  \n",
      "14  NeuralNetwork(784, [50, 50], 10)      100.000000         93.44  \n",
      "15  NeuralNetwork(784, [50, 50], 10)      100.000000         93.82  \n"
     ]
    }
   ],
   "source": [
    "##ADAM\n",
    "print(\"ADAM\")\n",
    "results_mnist_num_adam,df_mnist_adam=experiment(Xtrain1, Ttrain1,  Xval, Tval,'adam',n_epochs_list,n_epochs_per_train_list,n_hiddens_listof_list,learning_rate_list)\n",
    "print(\"ADAM TABLE :\")\n",
    "print(df_mnist_adam)\n",
    "results_array_adam=np.array(results_mnist_num_adam)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Select the entry with best validation accuracy from the table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.05 list([50, 50]) 200 10 NeuralNetwork(784, [50, 50], 10) 100.0 93.93]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "NeuralNetwork(784, [50, 50], 10)"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "best_result_adam=results_array_adam[4,:]\n",
    "print(best_result_adam)\n",
    "nnet_1_adam=results_array_adam[4,4]\n",
    "nnet_1_adam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[100.0, 93.61, 92.89]"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[percent_correct(nnet_1_adam.use(X)[0], T) for X, T in zip([Xtrain1, Xval, Xtest], [Ttrain1, Tval, Ttest])]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Confusion matrix for best validation accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Percent Correct\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<style  type=\"text/css\" >\n",
       "    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row0_col0 {\n",
       "            background-color:  #08306b;\n",
       "            color:  #f1f1f1;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row0_col1 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row0_col2 {\n",
       "            background-color:  #f6faff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row0_col3 {\n",
       "            background-color:  #f6faff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row0_col4 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row0_col5 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row0_col6 {\n",
       "            background-color:  #f6faff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row0_col7 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row0_col8 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row0_col9 {\n",
       "            background-color:  #f6faff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row1_col0 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row1_col1 {\n",
       "            background-color:  #08306b;\n",
       "            color:  #f1f1f1;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row1_col2 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row1_col3 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row1_col4 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row1_col5 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row1_col6 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row1_col7 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row1_col8 {\n",
       "            background-color:  #f6faff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row1_col9 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row2_col0 {\n",
       "            background-color:  #f6faff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row2_col1 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row2_col2 {\n",
       "            background-color:  #08306b;\n",
       "            color:  #f1f1f1;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row2_col3 {\n",
       "            background-color:  #f4f9fe;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row2_col4 {\n",
       "            background-color:  #f5fafe;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row2_col5 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row2_col6 {\n",
       "            background-color:  #f5fafe;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row2_col7 {\n",
       "            background-color:  #f5fafe;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row2_col8 {\n",
       "            background-color:  #f5f9fe;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row2_col9 {\n",
       "            background-color:  #f6faff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row3_col0 {\n",
       "            background-color:  #f6faff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row3_col1 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row3_col2 {\n",
       "            background-color:  #f3f8fe;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row3_col3 {\n",
       "            background-color:  #08306b;\n",
       "            color:  #f1f1f1;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row3_col4 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row3_col5 {\n",
       "            background-color:  #f2f7fd;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row3_col6 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row3_col7 {\n",
       "            background-color:  #f6faff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row3_col8 {\n",
       "            background-color:  #f4f9fe;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row3_col9 {\n",
       "            background-color:  #f6faff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row4_col0 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row4_col1 {\n",
       "            background-color:  #f6faff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row4_col2 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row4_col3 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row4_col4 {\n",
       "            background-color:  #08306b;\n",
       "            color:  #f1f1f1;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row4_col5 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row4_col6 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row4_col7 {\n",
       "            background-color:  #f5fafe;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row4_col8 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row4_col9 {\n",
       "            background-color:  #f3f8fe;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row5_col0 {\n",
       "            background-color:  #f5fafe;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row5_col1 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row5_col2 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row5_col3 {\n",
       "            background-color:  #eff6fc;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row5_col4 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row5_col5 {\n",
       "            background-color:  #08306b;\n",
       "            color:  #f1f1f1;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row5_col6 {\n",
       "            background-color:  #f3f8fe;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row5_col7 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row5_col8 {\n",
       "            background-color:  #f2f8fd;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row5_col9 {\n",
       "            background-color:  #f5fafe;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row6_col0 {\n",
       "            background-color:  #f6faff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row6_col1 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row6_col2 {\n",
       "            background-color:  #f5fafe;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row6_col3 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row6_col4 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row6_col5 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row6_col6 {\n",
       "            background-color:  #08306b;\n",
       "            color:  #f1f1f1;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row6_col7 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row6_col8 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row6_col9 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row7_col0 {\n",
       "            background-color:  #f6faff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row7_col1 {\n",
       "            background-color:  #f6faff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row7_col2 {\n",
       "            background-color:  #f6faff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row7_col3 {\n",
       "            background-color:  #f5fafe;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row7_col4 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row7_col5 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row7_col6 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row7_col7 {\n",
       "            background-color:  #08306b;\n",
       "            color:  #f1f1f1;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row7_col8 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row7_col9 {\n",
       "            background-color:  #f5f9fe;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row8_col0 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row8_col1 {\n",
       "            background-color:  #f5fafe;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row8_col2 {\n",
       "            background-color:  #f6faff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row8_col3 {\n",
       "            background-color:  #f4f9fe;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row8_col4 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row8_col5 {\n",
       "            background-color:  #f0f6fd;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row8_col6 {\n",
       "            background-color:  #f6faff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row8_col7 {\n",
       "            background-color:  #f5fafe;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row8_col8 {\n",
       "            background-color:  #08306b;\n",
       "            color:  #f1f1f1;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row8_col9 {\n",
       "            background-color:  #f5f9fe;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row9_col0 {\n",
       "            background-color:  #f6faff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row9_col1 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row9_col2 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row9_col3 {\n",
       "            background-color:  #f5fafe;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row9_col4 {\n",
       "            background-color:  #f1f7fd;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row9_col5 {\n",
       "            background-color:  #f6faff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row9_col6 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row9_col7 {\n",
       "            background-color:  #f2f8fd;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row9_col8 {\n",
       "            background-color:  #f5fafe;\n",
       "            color:  #000000;\n",
       "        }    #T_a3523d74_18c6_11eb_ad51_5b315dbf3695row9_col9 {\n",
       "            background-color:  #08306b;\n",
       "            color:  #f1f1f1;\n",
       "        }</style><table id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695\" ><thead>    <tr>        <th class=\"blank level0\" ></th>        <th class=\"col_heading level0 col0\" >0</th>        <th class=\"col_heading level0 col1\" >1</th>        <th class=\"col_heading level0 col2\" >2</th>        <th class=\"col_heading level0 col3\" >3</th>        <th class=\"col_heading level0 col4\" >4</th>        <th class=\"col_heading level0 col5\" >5</th>        <th class=\"col_heading level0 col6\" >6</th>        <th class=\"col_heading level0 col7\" >7</th>        <th class=\"col_heading level0 col8\" >8</th>        <th class=\"col_heading level0 col9\" >9</th>    </tr></thead><tbody>\n",
       "                <tr>\n",
       "                        <th id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695level0_row0\" class=\"row_heading level0 row0\" >0</th>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row0_col0\" class=\"data row0 col0\" >97.1</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row0_col1\" class=\"data row0 col1\" >0.0</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row0_col2\" class=\"data row0 col2\" >0.5</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row0_col3\" class=\"data row0 col3\" >0.6</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row0_col4\" class=\"data row0 col4\" >0.2</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row0_col5\" class=\"data row0 col5\" >0.2</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row0_col6\" class=\"data row0 col6\" >0.5</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row0_col7\" class=\"data row0 col7\" >0.1</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row0_col8\" class=\"data row0 col8\" >0.4</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row0_col9\" class=\"data row0 col9\" >0.4</td>\n",
       "            </tr>\n",
       "            <tr>\n",
       "                        <th id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695level0_row1\" class=\"row_heading level0 row1\" >1</th>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row1_col0\" class=\"data row1 col0\" >0.0</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row1_col1\" class=\"data row1 col1\" >97.7</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row1_col2\" class=\"data row1 col2\" >0.4</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row1_col3\" class=\"data row1 col3\" >0.2</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row1_col4\" class=\"data row1 col4\" >0.2</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row1_col5\" class=\"data row1 col5\" >0.2</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row1_col6\" class=\"data row1 col6\" >0.3</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row1_col7\" class=\"data row1 col7\" >0.1</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row1_col8\" class=\"data row1 col8\" >0.9</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row1_col9\" class=\"data row1 col9\" >0.1</td>\n",
       "            </tr>\n",
       "            <tr>\n",
       "                        <th id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695level0_row2\" class=\"row_heading level0 row2\" >2</th>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row2_col0\" class=\"data row2 col0\" >0.4</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row2_col1\" class=\"data row2 col1\" >0.3</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row2_col2\" class=\"data row2 col2\" >92.3</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row2_col3\" class=\"data row2 col3\" >1.5</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row2_col4\" class=\"data row2 col4\" >1.0</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row2_col5\" class=\"data row2 col5\" >0.3</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row2_col6\" class=\"data row2 col6\" >1.1</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row2_col7\" class=\"data row2 col7\" >0.9</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row2_col8\" class=\"data row2 col8\" >1.6</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row2_col9\" class=\"data row2 col9\" >0.5</td>\n",
       "            </tr>\n",
       "            <tr>\n",
       "                        <th id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695level0_row3\" class=\"row_heading level0 row3\" >3</th>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row3_col0\" class=\"data row3 col0\" >0.4</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row3_col1\" class=\"data row3 col1\" >0.1</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row3_col2\" class=\"data row3 col2\" >2.0</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row3_col3\" class=\"data row3 col3\" >91.5</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row3_col4\" class=\"data row3 col4\" >0.2</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row3_col5\" class=\"data row3 col5\" >2.7</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row3_col6\" class=\"data row3 col6\" >0.2</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row3_col7\" class=\"data row3 col7\" >0.4</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row3_col8\" class=\"data row3 col8\" >1.8</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row3_col9\" class=\"data row3 col9\" >0.7</td>\n",
       "            </tr>\n",
       "            <tr>\n",
       "                        <th id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695level0_row4\" class=\"row_heading level0 row4\" >4</th>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row4_col0\" class=\"data row4 col0\" >0.1</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row4_col1\" class=\"data row4 col1\" >0.7</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row4_col2\" class=\"data row4 col2\" >0.2</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row4_col3\" class=\"data row4 col3\" >0.1</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row4_col4\" class=\"data row4 col4\" >95.3</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row4_col5\" class=\"data row4 col5\" >0.1</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row4_col6\" class=\"data row4 col6\" >0.3</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row4_col7\" class=\"data row4 col7\" >0.8</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row4_col8\" class=\"data row4 col8\" >0.4</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row4_col9\" class=\"data row4 col9\" >1.9</td>\n",
       "            </tr>\n",
       "            <tr>\n",
       "                        <th id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695level0_row5\" class=\"row_heading level0 row5\" >5</th>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row5_col0\" class=\"data row5 col0\" >1.0</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row5_col1\" class=\"data row5 col1\" >0.1</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row5_col2\" class=\"data row5 col2\" >0.4</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row5_col3\" class=\"data row5 col3\" >3.7</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row5_col4\" class=\"data row5 col4\" >0.3</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row5_col5\" class=\"data row5 col5\" >88.6</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row5_col6\" class=\"data row5 col6\" >2.1</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row5_col7\" class=\"data row5 col7\" >0.3</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row5_col8\" class=\"data row5 col8\" >2.6</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row5_col9\" class=\"data row5 col9\" >0.8</td>\n",
       "            </tr>\n",
       "            <tr>\n",
       "                        <th id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695level0_row6\" class=\"row_heading level0 row6\" >6</th>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row6_col0\" class=\"data row6 col0\" >0.5</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row6_col1\" class=\"data row6 col1\" >0.1</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row6_col2\" class=\"data row6 col2\" >0.9</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row6_col3\" class=\"data row6 col3\" >0.0</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row6_col4\" class=\"data row6 col4\" >0.4</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row6_col5\" class=\"data row6 col5\" >0.4</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row6_col6\" class=\"data row6 col6\" >97.0</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row6_col7\" class=\"data row6 col7\" >0.0</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row6_col8\" class=\"data row6 col8\" >0.6</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row6_col9\" class=\"data row6 col9\" >0.0</td>\n",
       "            </tr>\n",
       "            <tr>\n",
       "                        <th id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695level0_row7\" class=\"row_heading level0 row7\" >7</th>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row7_col0\" class=\"data row7 col0\" >0.6</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row7_col1\" class=\"data row7 col1\" >0.6</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row7_col2\" class=\"data row7 col2\" >0.7</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row7_col3\" class=\"data row7 col3\" >0.9</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row7_col4\" class=\"data row7 col4\" >0.3</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row7_col5\" class=\"data row7 col5\" >0.2</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row7_col6\" class=\"data row7 col6\" >0.0</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row7_col7\" class=\"data row7 col7\" >95.2</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row7_col8\" class=\"data row7 col8\" >0.5</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row7_col9\" class=\"data row7 col9\" >1.1</td>\n",
       "            </tr>\n",
       "            <tr>\n",
       "                        <th id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695level0_row8\" class=\"row_heading level0 row8\" >8</th>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row8_col0\" class=\"data row8 col0\" >0.1</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row8_col1\" class=\"data row8 col1\" >1.0</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row8_col2\" class=\"data row8 col2\" >0.8</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row8_col3\" class=\"data row8 col3\" >1.8</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row8_col4\" class=\"data row8 col4\" >0.5</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row8_col5\" class=\"data row8 col5\" >3.3</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row8_col6\" class=\"data row8 col6\" >0.4</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row8_col7\" class=\"data row8 col7\" >0.9</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row8_col8\" class=\"data row8 col8\" >90.2</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row8_col9\" class=\"data row8 col9\" >1.1</td>\n",
       "            </tr>\n",
       "            <tr>\n",
       "                        <th id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695level0_row9\" class=\"row_heading level0 row9\" >9</th>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row9_col0\" class=\"data row9 col0\" >0.4</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row9_col1\" class=\"data row9 col1\" >0.2</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row9_col2\" class=\"data row9 col2\" >0.1</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row9_col3\" class=\"data row9 col3\" >1.0</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row9_col4\" class=\"data row9 col4\" >3.4</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row9_col5\" class=\"data row9 col5\" >0.5</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row9_col6\" class=\"data row9 col6\" >0.1</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row9_col7\" class=\"data row9 col7\" >2.3</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row9_col8\" class=\"data row9 col8\" >1.4</td>\n",
       "                        <td id=\"T_a3523d74_18c6_11eb_ad51_5b315dbf3695row9_col9\" class=\"data row9 col9\" >90.5</td>\n",
       "            </tr>\n",
       "    </tbody></table>"
      ],
      "text/plain": [
       "<pandas.io.formats.style.Styler at 0x7f251686c160>"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "confusion_matrix(nnet_1_adam.use(Xval)[0], Tval)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Call `train_for_best_validation` a number of times to compare accuracies using the three different optimization methods, and a few different values of `n_epochs`, `n_epochs_per_train`, and `n_hiddens_list`, and `learning_rate` when using 'sgd' and 'adam'.  You do not have to find the very best values of these parameters.  For example, for `n_hiddens_list` at least use `[]` (a linear model) and a larger network, like `[100, 100]`.\n",
    "\n",
    "Show the confusion matrix for the network that gave you the best validation accuracy.\n",
    "\n",
    "Write at least 10 sentences about what you observe in the accuracy plots, the train, validation and test accuracies, and the confusion matrix."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Observations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "========================\n",
    "\n",
    "SGD best parameters\n",
    "\n",
    "========================\n",
    "\n",
    "\n",
    "Learning Rate: 0.0\n",
    "\n",
    "Hidden Layers: [50,50] \n",
    "\n",
    "Epochs:200 \n",
    "\n",
    "Epochs per train:50   \n",
    "\n",
    "Best Training accuracy: 100%\n",
    "\n",
    "Best Validation accuracy:93.99%  \n",
    "\n",
    "========================\n",
    "\n",
    "Adam best parameters\n",
    "\n",
    "========================\n",
    "\n",
    "\n",
    "Learning Rate:  0.05    \n",
    "\n",
    "Hidden Layers: [50,50]\n",
    "\n",
    "Epochs: 200\n",
    "\n",
    "Epochs per train: 10\n",
    "\n",
    "Best Training accuracy: 100%\n",
    "\n",
    "Best Validation accuracy:93.93%\n",
    "\n",
    "1. Both SGD and ADAM gave identical accuracies wrt the validation data.(~93%).\n",
    "The parameters used were also identical. \n",
    "Hidden Layers :[50,50], Epochs 200, learning rate 0.05. Only epochs per train varied. SGD required 50 epochs per train and Adam required 10 epochs per train.\n",
    "2. Both methods gave 100% training accuracy, showing significant overfitting. This is also obvious from the fact that validation accuracy is less.\n",
    "3. Since SGD took more epochs per train(50), it means that it took less repetitions. Next step would be to compare the time taken with 50 epochs per train and arrive at a conclusion. This should be compared with the time taken by Adam with 10 epochs per train. We could further vary epochs per train with values ranging from 10-50 for both methods and arrive at a conclusion.\n",
    "4. From the Adam table, it was very interesting to note that whenever the number of hidden layers was empty, validation accuracy fell to around 90%. This shows that with more hidden layers and hidden units, the network learns the features of the input images better. This was also the case on observing the SGD table.\n",
    "5. From the Adam table, it is interesting to note that within the group with least accuracies, the lowest was obtained by the network with most epochs and most epochs_per_train. So was the case with SGD.\n",
    "6. At the same time, the highest accuracy for SGD was obtained when epochs_per_train was 50 instead of 10(with the other parameters the same). While also considering the 5th point I made, it becomes obvious that we should do more experiments with epochs_per_train.\n",
    "7. When hidden layers were [50,50], the ADAM method performed better with 250 epochs and 50 epochs_per_train. \n",
    "Similarly, it did better with 250 epochs and 10 epochs_per_train with no hidden layers. Hence , without hidden layers, ADAM method seemed to prefer\n",
    "fewer epochs_per_train.\n",
    "No such correlation could be observed for SGD.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-10-16T20:44:33.927450Z",
     "start_time": "2020-10-16T20:44:33.925092Z"
    }
   },
   "source": [
    "# Grading\n",
    "\n",
    "Download [A4grader.tar](https://www.cs.colostate.edu/~anderson/cs545/notebooks/A4grader.tar), extract `A4grader.py` before running the following cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-10-16T21:31:34.762274Z",
     "start_time": "2020-10-16T21:31:33.286016Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "======================= Code Execution =======================\n",
      "\n",
      "Extracting python code from notebook named 'Gopinath-A4.ipynb' and storing in notebookcode.py\n",
      "Removing all statements that are not function or class defs or import statements.\n",
      "\n",
      "## Testing constructor ####################################################################\n",
      "\n",
      "    # Linear network\n",
      "    nnet = NeuralNetworkClassifier(2, [], 5)\n",
      "    # Is isinstance(nnet, NeuralNetwork) True?\n",
      "\n",
      "\n",
      "--- 5/5 points. NeuralNetworkClassifier is correctly of type NeuralNetwork\n",
      "\n",
      "## Testing constructor ####################################################################\n",
      "\n",
      "    # Linear network\n",
      "    nnet = NeuralNetworkClassifier(2, [], 5)\n",
      "    W_shapes = [W.shape for W in nnet.Ws]\n",
      "\n",
      "\n",
      "--- 5/5 points. W_shapes is correct value of [(3, 5)]\n",
      "\n",
      "## Testing constructor ####################################################################\n",
      "\n",
      "    G_shapes = [G.shape for G in nnet.Gs]\n",
      "\n",
      "\n",
      "--- 5/5 points. G_shapes is correct value of [(3, 5)]\n",
      "\n",
      "## Testing train ####################################################################\n",
      "\n",
      "    np.random.seed(42)\n",
      "    X = np.random.uniform(0, 1, size=(100, 2))\n",
      "    T = (np.abs(X[:, 0:1] - X[:, 1:2]) < 0.5).astype(int)\n",
      "\n",
      "    nnet = NeuralNetworkClassifier(2, [10, 5], 2)\n",
      "    nnet.train(X, T, 1000, method='scg')\n",
      "\n",
      "    Then check  nnet.get_error_trace()\n",
      "\n",
      "SCG: Epoch 100 Error=0.99996\n",
      "\n",
      "--- 10/10 points. Correct values in error_trace\n",
      "\n",
      "## Testing train ####################################################################\n",
      "\n",
      "    np.random.seed(42)\n",
      "    X = np.random.uniform(0, 1, size=(100, 2))\n",
      "    T = (np.abs(X[:, 0:1] - X[:, 1:2]) < 0.5).astype(int)\n",
      "\n",
      "    nnet = NeuralNetworkClassifier(2, [10, 5], 2)\n",
      "    nnet.train(X, T, 1000, method='scg')\n",
      "    classes, prob = nnet.use(X)\n",
      "\n",
      "SCG: Epoch 100 Error=0.99996\n",
      "\n",
      "--- 10/10 points. Correct values in classes\n",
      "\n",
      "---  0/10 points. Incorrect values in prob\n",
      "                 Your value is\n",
      " [[9.99999847e-01 1.53399217e-07]\n",
      " [5.19865196e-11 1.00000000e+00]\n",
      " [5.27661095e-11 1.00000000e+00]\n",
      " [1.00000000e+00 1.16062569e-10]\n",
      " [5.14473951e-11 1.00000000e+00]\n",
      " [1.00000000e+00 1.15117630e-10]\n",
      " [9.99999987e-01 1.29107425e-08]\n",
      " [5.27030140e-11 1.00000000e+00]\n",
      " [5.36536765e-11 1.00000000e+00]\n",
      " [5.26732249e-11 1.00000000e+00]\n",
      " [9.23760167e-08 9.99999908e-01]\n",
      " [5.24910274e-11 1.00000000e+00]\n",
      " [5.55586995e-11 1.00000000e+00]\n",
      " [6.03434840e-11 1.00000000e+00]\n",
      " [9.99999837e-01 1.62641242e-07]\n",
      " [3.62712768e-10 1.00000000e+00]\n",
      " [1.00000000e+00 1.15457988e-10]\n",
      " [5.15624955e-11 1.00000000e+00]\n",
      " [5.37660699e-11 1.00000000e+00]\n",
      " [5.34598072e-11 1.00000000e+00]\n",
      " [8.93334933e-11 1.00000000e+00]\n",
      " [1.00000000e+00 1.14930014e-10]\n",
      " [9.07831381e-11 1.00000000e+00]\n",
      " [5.33898893e-11 1.00000000e+00]\n",
      " [6.83942638e-11 1.00000000e+00]\n",
      " [5.18849975e-11 1.00000000e+00]\n",
      " [5.09015048e-11 1.00000000e+00]\n",
      " [5.33397670e-11 1.00000000e+00]\n",
      " [5.34333224e-11 1.00000000e+00]\n",
      " [6.06837349e-11 1.00000000e+00]\n",
      " [5.25939716e-11 1.00000000e+00]\n",
      " [8.33381860e-10 9.99999999e-01]\n",
      " [5.49815258e-11 1.00000000e+00]\n",
      " [1.00000000e+00 1.45736627e-10]\n",
      " [1.00000000e+00 1.15708116e-10]\n",
      " [9.99999924e-01 7.63530787e-08]\n",
      " [1.00000000e+00 1.14960058e-10]\n",
      " [5.12633760e-11 1.00000000e+00]\n",
      " [9.99999992e-01 7.50810733e-09]\n",
      " [5.45738451e-11 1.00000000e+00]\n",
      " [5.27850230e-11 1.00000000e+00]\n",
      " [5.59037841e-11 1.00000000e+00]\n",
      " [5.23780454e-11 1.00000000e+00]\n",
      " [5.17206095e-11 1.00000000e+00]\n",
      " [7.61894568e-11 1.00000000e+00]\n",
      " [1.00000000e+00 2.71575638e-10]\n",
      " [5.25269500e-11 1.00000000e+00]\n",
      " [5.39866641e-11 1.00000000e+00]\n",
      " [5.22131771e-11 1.00000000e+00]\n",
      " [5.34892129e-11 1.00000000e+00]\n",
      " [1.00000000e+00 1.77409640e-10]\n",
      " [5.31719196e-11 1.00000000e+00]\n",
      " [9.99999991e-01 9.21459004e-09]\n",
      " [5.77127229e-11 1.00000000e+00]\n",
      " [5.31356410e-11 1.00000000e+00]\n",
      " [5.28394324e-11 1.00000000e+00]\n",
      " [5.13913896e-11 1.00000000e+00]\n",
      " [5.16728539e-11 1.00000000e+00]\n",
      " [9.99999987e-01 1.28161813e-08]\n",
      " [5.75353283e-11 1.00000000e+00]\n",
      " [5.07669762e-11 1.00000000e+00]\n",
      " [5.37511760e-11 1.00000000e+00]\n",
      " [5.38273348e-11 1.00000000e+00]\n",
      " [5.08631497e-11 1.00000000e+00]\n",
      " [9.99999886e-01 1.13673767e-07]\n",
      " [5.32870753e-11 1.00000000e+00]\n",
      " [5.52130525e-11 1.00000000e+00]\n",
      " [9.99999982e-01 1.79636656e-08]\n",
      " [5.19532261e-11 1.00000000e+00]\n",
      " [9.99999999e-01 1.14040403e-09]\n",
      " [9.99999992e-01 7.66768217e-09]\n",
      " [5.31253285e-11 1.00000000e+00]\n",
      " [5.51320954e-11 1.00000000e+00]\n",
      " [5.20933542e-11 1.00000000e+00]\n",
      " [5.63830888e-11 1.00000000e+00]\n",
      " [9.99999991e-01 8.65152712e-09]\n",
      " [6.94984782e-11 1.00000000e+00]\n",
      " [9.99999993e-01 7.30822787e-09]\n",
      " [5.12130446e-11 1.00000000e+00]\n",
      " [1.97798767e-07 9.99999802e-01]\n",
      " [5.41096057e-11 1.00000000e+00]\n",
      " [5.19852899e-11 1.00000000e+00]\n",
      " [1.00000000e+00 1.20133799e-10]\n",
      " [5.28245640e-11 1.00000000e+00]\n",
      " [9.99999999e-01 6.68820045e-10]\n",
      " [9.99999992e-01 7.98723731e-09]\n",
      " [5.57921947e-11 1.00000000e+00]\n",
      " [2.16171053e-08 9.99999978e-01]\n",
      " [5.56407810e-11 1.00000000e+00]\n",
      " [9.99999993e-01 6.98588878e-09]\n",
      " [5.41597038e-11 1.00000000e+00]\n",
      " [5.09548481e-11 1.00000000e+00]\n",
      " [8.91994015e-11 1.00000000e+00]\n",
      " [5.33818466e-11 1.00000000e+00]\n",
      " [5.58051307e-11 1.00000000e+00]\n",
      " [1.00000000e+00 1.16974811e-10]\n",
      " [5.31706671e-11 1.00000000e+00]\n",
      " [5.23077631e-11 1.00000000e+00]\n",
      " [5.09882930e-11 1.00000000e+00]\n",
      " [5.14071958e-11 1.00000000e+00]].\n",
      "                 Correct value is\n",
      " [[9.99999992e-01 7.59567880e-09]\n",
      " [6.09379897e-12 1.00000000e+00]\n",
      " [6.16799347e-12 1.00000000e+00]\n",
      " [1.00000000e+00 1.84484302e-11]\n",
      " [6.05233606e-12 1.00000000e+00]\n",
      " [1.00000000e+00 1.83657451e-11]\n",
      " [9.99999999e-01 1.01771845e-09]\n",
      " [6.16206667e-12 1.00000000e+00]\n",
      " [6.21859867e-12 1.00000000e+00]\n",
      " [6.15074193e-12 1.00000000e+00]\n",
      " [3.99126690e-09 9.99999996e-01]\n",
      " [6.13973057e-12 1.00000000e+00]\n",
      " [6.34006118e-12 1.00000000e+00]\n",
      " [6.69623630e-12 1.00000000e+00]\n",
      " [9.99999990e-01 1.03292599e-08]\n",
      " [2.37869969e-11 1.00000000e+00]\n",
      " [1.00000000e+00 1.84001552e-11]\n",
      " [6.05993969e-12 1.00000000e+00]\n",
      " [6.22902897e-12 1.00000000e+00]\n",
      " [6.19597131e-12 1.00000000e+00]\n",
      " [8.79563572e-12 1.00000000e+00]\n",
      " [1.00000000e+00 1.83471767e-11]\n",
      " [8.86341411e-12 1.00000000e+00]\n",
      " [6.19982345e-12 1.00000000e+00]\n",
      " [7.17023823e-12 1.00000000e+00]\n",
      " [6.08337885e-12 1.00000000e+00]\n",
      " [6.00976100e-12 1.00000000e+00]\n",
      " [6.17925409e-12 1.00000000e+00]\n",
      " [6.21834938e-12 1.00000000e+00]\n",
      " [6.73834222e-12 1.00000000e+00]\n",
      " [6.14666106e-12 1.00000000e+00]\n",
      " [4.59246732e-11 1.00000000e+00]\n",
      " [6.31250303e-12 1.00000000e+00]\n",
      " [1.00000000e+00 2.10726806e-11]\n",
      " [1.00000000e+00 1.84254176e-11]\n",
      " [9.99999995e-01 5.03153122e-09]\n",
      " [1.00000000e+00 1.83400401e-11]\n",
      " [6.03858734e-12 1.00000000e+00]\n",
      " [9.99999999e-01 6.64406676e-10]\n",
      " [6.27954235e-12 1.00000000e+00]\n",
      " [6.14730852e-12 1.00000000e+00]\n",
      " [6.36760007e-12 1.00000000e+00]\n",
      " [6.13209436e-12 1.00000000e+00]\n",
      " [6.07400369e-12 1.00000000e+00]\n",
      " [7.64388724e-12 1.00000000e+00]\n",
      " [1.00000000e+00 3.14989200e-11]\n",
      " [6.13168117e-12 1.00000000e+00]\n",
      " [6.22828809e-12 1.00000000e+00]\n",
      " [6.11464037e-12 1.00000000e+00]\n",
      " [6.22674041e-12 1.00000000e+00]\n",
      " [1.00000000e+00 2.37389839e-11]\n",
      " [6.18456985e-12 1.00000000e+00]\n",
      " [9.99999999e-01 7.76463363e-10]\n",
      " [6.49258323e-12 1.00000000e+00]\n",
      " [6.19079786e-12 1.00000000e+00]\n",
      " [6.16790631e-12 1.00000000e+00]\n",
      " [6.04745488e-12 1.00000000e+00]\n",
      " [6.06436604e-12 1.00000000e+00]\n",
      " [9.99999999e-01 1.01121023e-09]\n",
      " [6.45444772e-12 1.00000000e+00]\n",
      " [5.99896244e-12 1.00000000e+00]\n",
      " [6.22748566e-12 1.00000000e+00]\n",
      " [6.23598713e-12 1.00000000e+00]\n",
      " [6.00686383e-12 1.00000000e+00]\n",
      " [9.99999995e-01 5.01621907e-09]\n",
      " [6.19295344e-12 1.00000000e+00]\n",
      " [6.34158561e-12 1.00000000e+00]\n",
      " [9.99999999e-01 1.34507129e-09]\n",
      " [6.08930170e-12 1.00000000e+00]\n",
      " [1.00000000e+00 9.14442270e-11]\n",
      " [9.99999999e-01 6.75326774e-10]\n",
      " [6.17933303e-12 1.00000000e+00]\n",
      " [6.31919147e-12 1.00000000e+00]\n",
      " [6.10380087e-12 1.00000000e+00]\n",
      " [6.43049434e-12 1.00000000e+00]\n",
      " [9.99999999e-01 7.39525262e-10]\n",
      " [7.35737532e-12 1.00000000e+00]\n",
      " [9.99999999e-01 6.52092127e-10]\n",
      " [6.03407272e-12 1.00000000e+00]\n",
      " [1.53816705e-08 9.99999985e-01]\n",
      " [6.24589187e-12 1.00000000e+00]\n",
      " [6.09528221e-12 1.00000000e+00]\n",
      " [1.00000000e+00 1.88113449e-11]\n",
      " [6.16556430e-12 1.00000000e+00]\n",
      " [1.00000000e+00 5.96743348e-11]\n",
      " [9.99999999e-01 6.95009925e-10]\n",
      " [6.35281677e-12 1.00000000e+00]\n",
      " [9.22742377e-10 9.99999999e-01]\n",
      " [6.33723478e-12 1.00000000e+00]\n",
      " [9.99999999e-01 6.31301186e-10]\n",
      " [6.25323820e-12 1.00000000e+00]\n",
      " [6.01397830e-12 1.00000000e+00]\n",
      " [8.75021161e-12 1.00000000e+00]\n",
      " [6.18780945e-12 1.00000000e+00]\n",
      " [6.35301412e-12 1.00000000e+00]\n",
      " [1.00000000e+00 1.85361500e-11]\n",
      " [6.17229233e-12 1.00000000e+00]\n",
      " [6.12588196e-12 1.00000000e+00]\n",
      " [6.01477036e-12 1.00000000e+00]\n",
      " [6.04895529e-12 1.00000000e+00]]\n",
      "\n",
      "## Testing percent_correct ####################################################################\n",
      "\n",
      "    Y = np.array([1, 2, 3, 1, 2, 3]).reshape(-1, 1)\n",
      "    T = np.array([1, 2, 3, 3, 2, 1]).reshape(-1, 1)\n",
      "    pc = percent_correct(Y, T)\n",
      "\n",
      "\n",
      "--- 5/5 points. Correct percent_correct.\n",
      "\n",
      "## Testing train_for_best_validation ####################################################################\n",
      "\n",
      "    np.random.seed(42)\n",
      "    X = np.random.uniform(0, 1, size=(100, 2))\n",
      "    np.random.shuffle(X)\n",
      "    T = (np.abs(X[:, 0:1] - X[:, 1:2]) < 0.5).astype(int)\n",
      "\n",
      "    Xtrain = X[:50, :]\n",
      "    Ttrain = T[:50, :]\n",
      "    Xval = X[50:75, :]\n",
      "    Ttest = T[50:75, :]\n",
      "    Xtest = X[75:, :]\n",
      "    Ttest = T[75:, :]\n",
      "\n",
      "    nnet, epoch, train_accuracy, val_accuracy = train_for_best_validation(Xtrain, Ttrain,  Xval, Tval, \n",
      "                                                                          400, 10, [10, 10], method='scg') \n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best val error is at epoch 15 with Accuracy for Training data of 98.0 and Validation data of 100.0\n",
      "\n",
      "--- 5/5 points. Correct best epoch.\n",
      "\n",
      "--- 5/5 points. Correct train_accuracy.\n",
      "\n",
      "--- 5/5 points. Correct val_accuracy.\n",
      "\n",
      "======================================================================\n",
      "A4 Execution Grade is 55 / 65\n",
      "======================================================================\n",
      "\n",
      "__ / 5 points. Correctly downloaded and read the MNIST data.\n",
      "\n",
      "__ / 10 points. Correctly applied train_for_best_validation function\n",
      "                to MNIST data.\n",
      "\n",
      "__ / 5 points. Experimented with different values of parameters as \n",
      "               arguments to train_for_best_validation.\n",
      "\n",
      "__ / 5 points. Show confusion matrix for best neural network.\n",
      "\n",
      "__ / 10 points. Described results with at least 10 sentences.\n",
      "\n",
      "======================================================================\n",
      "A4 Results and Discussion Grade is ___ / 35\n",
      "======================================================================\n",
      "\n",
      "======================================================================\n",
      "A4 FINAL GRADE is  _  / 100\n",
      "======================================================================\n",
      "\n",
      "Extra Credit: Earn one point of extra credit for repeating the above\n",
      "experiments for another classification data set.\n",
      "\n",
      "A4 EXTRA CREDIT is 0 / 1\n"
     ]
    }
   ],
   "source": [
    "%run -i A4grader.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Extra Credit\n",
    "\n",
    "Repeat the above experiments with a different data set.  Randonly partition your data into training, validaton and test parts if not already provided.  Write in markdown cells descriptions of the data and your results."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### About the dataset: "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I am generating a set of images for each of training, validation and testing datasets. There are 2 classes - squares and diamonds. I am using the code Professor Anderson used in the lecture \"\n",
    "Convolutional Neural Networks Training\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Image generation function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_images(n_each_class):\n",
    "    '''Make 20x20 black and white images with diamonds or squares for the two classes, as line drawings.'''\n",
    "    images = np.zeros((n_each_class * 2, 20, 20))  # nSamples, rows, columns\n",
    "    radii = 3 + np.random.randint(10 - 5, size=(n_each_class * 2, 1))\n",
    "    centers = np.zeros((n_each_class * 2, 2))\n",
    "    for i in range(n_each_class * 2):\n",
    "        r = radii[i, 0]\n",
    "        centers[i, :] = r + 1 + np.random.randint(18 - 2 * r, size=(1, 2))\n",
    "        x = int(centers[i, 0])\n",
    "        y = int(centers[i, 1])\n",
    "        if i < n_each_class:\n",
    "            # squares\n",
    "            images[i, x - r:x + r, y + r] = 1.0\n",
    "            images[i, x - r:x + r, y - r] = 1.0\n",
    "            images[i, x - r, y - r:y + r] = 1.0\n",
    "            images[i, x + r, y - r:y + r + 1] = 1.0\n",
    "        else:\n",
    "            # diamonds\n",
    "            images[i, range(x - r, x), range(y, y + r)] = 1.0\n",
    "            images[i, range(x - r, x), range(y, y - r, -1)] = 1.0\n",
    "            images[i, range(x, x + r + 1), range(y + r, y - 1, -1)] = 1.0\n",
    "            images[i, range(x, x + r), range(y - r, y)] = 1.0\n",
    "    T = np.array(['square'] * n_each_class + ['diamond'] * n_each_class).reshape(-1, 1)\n",
    "    return images, T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generate train, validation and test images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((200, 20, 20), (200, 1), (200, 20, 20), (200, 1), (200, 20, 20), (200, 1))"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n_each_class = 100\n",
    "Xtrain_ec, Ttrain_ec_0 = make_images(n_each_class)\n",
    "Xval_ec,Tval_ec_0 = make_images(n_each_class)\n",
    "Xtest_ec, Ttest_ec_0 = make_images(n_each_class)\n",
    "\n",
    "Xtrain_ec.shape, Ttrain_ec_0.shape, Xval_ec.shape, Tval_ec_0.shape,Xtest_ec.shape, Ttest_ec_0.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create new target arrays\n",
    "\n",
    "Create new target arrays for train, validation and test data sets. If target==square, the new array will instead have 0 . Similarly, 1 for diamond."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(200, 1)\n",
      "(200, 1)\n",
      "(200, 1)\n"
     ]
    }
   ],
   "source": [
    "#Training data target\n",
    "\n",
    "Ttrain_ec=[0]*200\n",
    "\n",
    "for i in range(len(Ttrain_ec_0)):\n",
    "    if(Ttrain_ec_0[i]=='square'):\n",
    "        Ttrain_ec[i]=[0]\n",
    "    else:\n",
    "        Ttrain_ec[i]=[1]\n",
    "Ttrain_ec=np.array(Ttrain_ec)\n",
    "Ttrain_ec.reshape(200,1)\n",
    "print(Ttrain_ec.shape)\n",
    "\n",
    "#Validation data target\n",
    "Tval_ec=[0]*200\n",
    "\n",
    "for i in range(len(Tval_ec_0)):\n",
    "    if(Tval_ec_0[i]=='square'):\n",
    "        Tval_ec[i]=[0]\n",
    "    else:\n",
    "        Tval_ec[i]=[1]\n",
    "Tval_ec=np.array(Tval_ec)\n",
    "Tval_ec.reshape(200,1)\n",
    "print(Tval_ec.shape)\n",
    "\n",
    "#Test data target\n",
    "Ttest_ec=[0]*200\n",
    "\n",
    "for i in range(len(Ttest_ec_0)):\n",
    "    if(Ttest_ec_0[i]=='square'):\n",
    "        Ttest_ec[i]=[0]\n",
    "    else:\n",
    "        Ttest_ec[i]=[1]\n",
    "Ttest_ec=np.array(Ttest_ec)\n",
    "Ttest_ec.reshape(200,1)\n",
    "print(Ttest_ec.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot a few training images from the 2 classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def draw_neg_image(image, label=''):\n",
    "    plt.imshow(-image, cmap='gray')\n",
    "    plt.xticks([])\n",
    "    plt.yticks([])\n",
    "    plt.title(label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x216 with 20 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10, 3))\n",
    "for i in range(10):\n",
    "    plt.subplot(2, 10, i + 1)\n",
    "    draw_neg_image(Xtrain_ec[i, :], Ttrain_ec[i, 0])\n",
    "\n",
    "for i in range(10):\n",
    "    plt.subplot(2, 10, i + 11)\n",
    "    draw_neg_image(Xtrain_ec[i + n_each_class, :], Ttrain_ec[i + n_each_class, 0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reshape the data sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((200, 400), (200, 400), (200, 400))"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Xtrain_ec = Xtrain_ec.reshape(Xtrain_ec.shape[0], -1)\n",
    "Xval_ec = Xval_ec.reshape(Xval_ec.shape[0], -1)\n",
    "Xtest_ec = Xtest_ec.reshape(Xtest_ec.shape[0], -1)\n",
    "Xtrain_ec.shape, Xval_ec.shape,Xtest_ec.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train on SGD and print the table with the results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SGD\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.05 [] 200 10\n",
      "Best val error is at epoch 10 with Accuracy for Training data of 100.0 and Validation data of 89.5\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.05 [] 200 50\n",
      "Best val error is at epoch 50 with Accuracy for Training data of 100.0 and Validation data of 90.0\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.05 [] 250 10\n",
      "Best val error is at epoch 20 with Accuracy for Training data of 100.0 and Validation data of 90.0\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.05 [] 250 50\n",
      "Best val error is at epoch 50 with Accuracy for Training data of 100.0 and Validation data of 90.0\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.05 [50, 50] 200 10\n",
      "Best val error is at epoch 50 with Accuracy for Training data of 100.0 and Validation data of 90.0\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.05 [50, 50] 200 50\n",
      "Best val error is at epoch 50 with Accuracy for Training data of 100.0 and Validation data of 90.0\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.05 [50, 50] 250 10\n",
      "Best val error is at epoch 20 with Accuracy for Training data of 100.0 and Validation data of 91.0\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.05 [50, 50] 250 50\n",
      "Best val error is at epoch 50 with Accuracy for Training data of 100.0 and Validation data of 90.0\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.1 [] 200 10\n",
      "Best val error is at epoch 20 with Accuracy for Training data of 100.0 and Validation data of 90.0\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.1 [] 200 50\n",
      "Best val error is at epoch 50 with Accuracy for Training data of 100.0 and Validation data of 89.5\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.1 [] 250 10\n",
      "Best val error is at epoch 20 with Accuracy for Training data of 100.0 and Validation data of 90.0\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.1 [] 250 50\n",
      "Best val error is at epoch 50 with Accuracy for Training data of 100.0 and Validation data of 90.0\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.1 [50, 50] 200 10\n",
      "Best val error is at epoch 30 with Accuracy for Training data of 100.0 and Validation data of 90.0\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.1 [50, 50] 200 50\n",
      "Best val error is at epoch 50 with Accuracy for Training data of 100.0 and Validation data of 89.0\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.1 [50, 50] 250 10\n",
      "Best val error is at epoch 20 with Accuracy for Training data of 100.0 and Validation data of 91.0\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.1 [50, 50] 250 50\n",
      "Best val error is at epoch 50 with Accuracy for Training data of 100.0 and Validation data of 90.0\n",
      "SGD TABLE :\n",
      "    Learning Rate Hidden Layers  Epochs  Epochs per Train  \\\n",
      "0            0.05            []     200                10   \n",
      "1            0.05            []     200                50   \n",
      "2            0.05            []     250                10   \n",
      "3            0.05            []     250                50   \n",
      "4            0.05      [50, 50]     200                10   \n",
      "5            0.05      [50, 50]     200                50   \n",
      "6            0.05      [50, 50]     250                10   \n",
      "7            0.05      [50, 50]     250                50   \n",
      "8            0.10            []     200                10   \n",
      "9            0.10            []     200                50   \n",
      "10           0.10            []     250                10   \n",
      "11           0.10            []     250                50   \n",
      "12           0.10      [50, 50]     200                10   \n",
      "13           0.10      [50, 50]     200                50   \n",
      "14           0.10      [50, 50]     250                10   \n",
      "15           0.10      [50, 50]     250                50   \n",
      "\n",
      "                               nnet  Train Accuracy  Val Accuracy  \n",
      "0         NeuralNetwork(400, [], 2)           100.0          89.5  \n",
      "1         NeuralNetwork(400, [], 2)           100.0          90.0  \n",
      "2         NeuralNetwork(400, [], 2)           100.0          90.0  \n",
      "3         NeuralNetwork(400, [], 2)           100.0          90.0  \n",
      "4   NeuralNetwork(400, [50, 50], 2)           100.0          90.0  \n",
      "5   NeuralNetwork(400, [50, 50], 2)           100.0          90.0  \n",
      "6   NeuralNetwork(400, [50, 50], 2)           100.0          91.0  \n",
      "7   NeuralNetwork(400, [50, 50], 2)           100.0          90.0  \n",
      "8         NeuralNetwork(400, [], 2)           100.0          90.0  \n",
      "9         NeuralNetwork(400, [], 2)           100.0          89.5  \n",
      "10        NeuralNetwork(400, [], 2)           100.0          90.0  \n",
      "11        NeuralNetwork(400, [], 2)           100.0          90.0  \n",
      "12  NeuralNetwork(400, [50, 50], 2)           100.0          90.0  \n",
      "13  NeuralNetwork(400, [50, 50], 2)           100.0          89.0  \n",
      "14  NeuralNetwork(400, [50, 50], 2)           100.0          91.0  \n",
      "15  NeuralNetwork(400, [50, 50], 2)           100.0          90.0  \n"
     ]
    }
   ],
   "source": [
    "n_epochs_list=[200,250]\n",
    "n_epochs_per_train_list=[10,50]\n",
    "n_hiddens_listof_list=[[],[50,50]]\n",
    "learning_rate_list=[0.05,0.1]\n",
    "\n",
    "##SGD\n",
    "print(\"SGD\")\n",
    "results_mnist_num_sgd_ec,df_mnist_sgd_ec=experiment(Xtrain_ec, Ttrain_ec,  Xval_ec, Tval_ec,'sgd',n_epochs_list,n_epochs_per_train_list,n_hiddens_listof_list,learning_rate_list)\n",
    "print(\"SGD TABLE :\")\n",
    "print(df_mnist_sgd_ec)\n",
    "results_array_sgd_ec=np.array(results_mnist_num_sgd_ec)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "best_sgd_ec=results_array_sgd_ec[14,:]\n",
    "nnet_1_sgd_ec=results_array_sgd_ec[14,4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Display the confusion matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Percent Correct\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<style  type=\"text/css\" >\n",
       "    #T_754b5888_18cc_11eb_ad51_5b315dbf3695row0_col0 {\n",
       "            background-color:  #08306b;\n",
       "            color:  #f1f1f1;\n",
       "        }    #T_754b5888_18cc_11eb_ad51_5b315dbf3695row0_col1 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_754b5888_18cc_11eb_ad51_5b315dbf3695row1_col0 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_754b5888_18cc_11eb_ad51_5b315dbf3695row1_col1 {\n",
       "            background-color:  #08306b;\n",
       "            color:  #f1f1f1;\n",
       "        }</style><table id=\"T_754b5888_18cc_11eb_ad51_5b315dbf3695\" ><thead>    <tr>        <th class=\"blank level0\" ></th>        <th class=\"col_heading level0 col0\" >0</th>        <th class=\"col_heading level0 col1\" >1</th>    </tr></thead><tbody>\n",
       "                <tr>\n",
       "                        <th id=\"T_754b5888_18cc_11eb_ad51_5b315dbf3695level0_row0\" class=\"row_heading level0 row0\" >0</th>\n",
       "                        <td id=\"T_754b5888_18cc_11eb_ad51_5b315dbf3695row0_col0\" class=\"data row0 col0\" >89.0</td>\n",
       "                        <td id=\"T_754b5888_18cc_11eb_ad51_5b315dbf3695row0_col1\" class=\"data row0 col1\" >11.0</td>\n",
       "            </tr>\n",
       "            <tr>\n",
       "                        <th id=\"T_754b5888_18cc_11eb_ad51_5b315dbf3695level0_row1\" class=\"row_heading level0 row1\" >1</th>\n",
       "                        <td id=\"T_754b5888_18cc_11eb_ad51_5b315dbf3695row1_col0\" class=\"data row1 col0\" >7.0</td>\n",
       "                        <td id=\"T_754b5888_18cc_11eb_ad51_5b315dbf3695row1_col1\" class=\"data row1 col1\" >93.0</td>\n",
       "            </tr>\n",
       "    </tbody></table>"
      ],
      "text/plain": [
       "<pandas.io.formats.style.Styler at 0x7f251686c670>"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "confusion_matrix(nnet_1_sgd_ec.use(Xval_ec)[0], Tval_ec)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train on ADAM and print the table with the results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ADAM\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.05 [] 200 10\n",
      "Best val error is at epoch 20 with Accuracy for Training data of 100.0 and Validation data of 90.0\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.05 [] 200 50\n",
      "Best val error is at epoch 50 with Accuracy for Training data of 100.0 and Validation data of 90.0\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.05 [] 250 10\n",
      "Best val error is at epoch 20 with Accuracy for Training data of 100.0 and Validation data of 90.0\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.05 [] 250 50\n",
      "Best val error is at epoch 50 with Accuracy for Training data of 100.0 and Validation data of 90.0\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.05 [50, 50] 200 10\n",
      "Best val error is at epoch 20 with Accuracy for Training data of 100.0 and Validation data of 91.5\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.05 [50, 50] 200 50\n",
      "Best val error is at epoch 50 with Accuracy for Training data of 100.0 and Validation data of 90.5\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.05 [50, 50] 250 10\n",
      "Best val error is at epoch 20 with Accuracy for Training data of 100.0 and Validation data of 90.5\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.05 [50, 50] 250 50\n",
      "Best val error is at epoch 50 with Accuracy for Training data of 100.0 and Validation data of 90.0\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.1 [] 200 10\n",
      "Best val error is at epoch 10 with Accuracy for Training data of 100.0 and Validation data of 90.0\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.1 [] 200 50\n",
      "Best val error is at epoch 50 with Accuracy for Training data of 100.0 and Validation data of 90.0\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.1 [] 250 10\n",
      "Best val error is at epoch 20 with Accuracy for Training data of 100.0 and Validation data of 90.0\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.1 [] 250 50\n",
      "Best val error is at epoch 50 with Accuracy for Training data of 100.0 and Validation data of 90.0\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.1 [50, 50] 200 10\n",
      "Best val error is at epoch 20 with Accuracy for Training data of 100.0 and Validation data of 90.0\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.1 [50, 50] 200 50\n",
      "Best val error is at epoch 50 with Accuracy for Training data of 100.0 and Validation data of 89.5\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.1 [50, 50] 250 10\n",
      "Best val error is at epoch 30 with Accuracy for Training data of 100.0 and Validation data of 89.5\n",
      "learning_rate,n_hiddens_list,n_epochs,n_epochs_per_train\n",
      "0.1 [50, 50] 250 50\n",
      "Best val error is at epoch 50 with Accuracy for Training data of 100.0 and Validation data of 90.0\n",
      "adam TABLE :\n",
      "    Learning Rate Hidden Layers  Epochs  Epochs per Train  \\\n",
      "0            0.05            []     200                10   \n",
      "1            0.05            []     200                50   \n",
      "2            0.05            []     250                10   \n",
      "3            0.05            []     250                50   \n",
      "4            0.05      [50, 50]     200                10   \n",
      "5            0.05      [50, 50]     200                50   \n",
      "6            0.05      [50, 50]     250                10   \n",
      "7            0.05      [50, 50]     250                50   \n",
      "8            0.10            []     200                10   \n",
      "9            0.10            []     200                50   \n",
      "10           0.10            []     250                10   \n",
      "11           0.10            []     250                50   \n",
      "12           0.10      [50, 50]     200                10   \n",
      "13           0.10      [50, 50]     200                50   \n",
      "14           0.10      [50, 50]     250                10   \n",
      "15           0.10      [50, 50]     250                50   \n",
      "\n",
      "                               nnet  Train Accuracy  Val Accuracy  \n",
      "0         NeuralNetwork(400, [], 2)           100.0          90.0  \n",
      "1         NeuralNetwork(400, [], 2)           100.0          90.0  \n",
      "2         NeuralNetwork(400, [], 2)           100.0          90.0  \n",
      "3         NeuralNetwork(400, [], 2)           100.0          90.0  \n",
      "4   NeuralNetwork(400, [50, 50], 2)           100.0          91.5  \n",
      "5   NeuralNetwork(400, [50, 50], 2)           100.0          90.5  \n",
      "6   NeuralNetwork(400, [50, 50], 2)           100.0          90.5  \n",
      "7   NeuralNetwork(400, [50, 50], 2)           100.0          90.0  \n",
      "8         NeuralNetwork(400, [], 2)           100.0          90.0  \n",
      "9         NeuralNetwork(400, [], 2)           100.0          90.0  \n",
      "10        NeuralNetwork(400, [], 2)           100.0          90.0  \n",
      "11        NeuralNetwork(400, [], 2)           100.0          90.0  \n",
      "12  NeuralNetwork(400, [50, 50], 2)           100.0          90.0  \n",
      "13  NeuralNetwork(400, [50, 50], 2)           100.0          89.5  \n",
      "14  NeuralNetwork(400, [50, 50], 2)           100.0          89.5  \n",
      "15  NeuralNetwork(400, [50, 50], 2)           100.0          90.0  \n"
     ]
    }
   ],
   "source": [
    "##ADAM\n",
    "print(\"ADAM\")\n",
    "results_mnist_num_adam_ec,df_mnist_adam_ec=experiment(Xtrain_ec, Ttrain_ec,  Xval_ec, Tval_ec,'adam',n_epochs_list,n_epochs_per_train_list,n_hiddens_listof_list,learning_rate_list)\n",
    "print(\"adam TABLE :\")\n",
    "print(df_mnist_adam_ec)\n",
    "results_array_adam_ec=np.array(results_mnist_num_adam_ec)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "best_adam_ec=results_array_adam_ec[4,:]\n",
    "nnet_1_adam_ec=results_array_adam_ec[4,4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Display the confusion matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Percent Correct\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<style  type=\"text/css\" >\n",
       "    #T_c003bf14_18cc_11eb_ad51_5b315dbf3695row0_col0 {\n",
       "            background-color:  #08306b;\n",
       "            color:  #f1f1f1;\n",
       "        }    #T_c003bf14_18cc_11eb_ad51_5b315dbf3695row0_col1 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_c003bf14_18cc_11eb_ad51_5b315dbf3695row1_col0 {\n",
       "            background-color:  #f7fbff;\n",
       "            color:  #000000;\n",
       "        }    #T_c003bf14_18cc_11eb_ad51_5b315dbf3695row1_col1 {\n",
       "            background-color:  #08306b;\n",
       "            color:  #f1f1f1;\n",
       "        }</style><table id=\"T_c003bf14_18cc_11eb_ad51_5b315dbf3695\" ><thead>    <tr>        <th class=\"blank level0\" ></th>        <th class=\"col_heading level0 col0\" >0</th>        <th class=\"col_heading level0 col1\" >1</th>    </tr></thead><tbody>\n",
       "                <tr>\n",
       "                        <th id=\"T_c003bf14_18cc_11eb_ad51_5b315dbf3695level0_row0\" class=\"row_heading level0 row0\" >0</th>\n",
       "                        <td id=\"T_c003bf14_18cc_11eb_ad51_5b315dbf3695row0_col0\" class=\"data row0 col0\" >87.0</td>\n",
       "                        <td id=\"T_c003bf14_18cc_11eb_ad51_5b315dbf3695row0_col1\" class=\"data row0 col1\" >13.0</td>\n",
       "            </tr>\n",
       "            <tr>\n",
       "                        <th id=\"T_c003bf14_18cc_11eb_ad51_5b315dbf3695level0_row1\" class=\"row_heading level0 row1\" >1</th>\n",
       "                        <td id=\"T_c003bf14_18cc_11eb_ad51_5b315dbf3695row1_col0\" class=\"data row1 col0\" >7.0</td>\n",
       "                        <td id=\"T_c003bf14_18cc_11eb_ad51_5b315dbf3695row1_col1\" class=\"data row1 col1\" >93.0</td>\n",
       "            </tr>\n",
       "    </tbody></table>"
      ],
      "text/plain": [
       "<pandas.io.formats.style.Styler at 0x7f2518a093d0>"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "confusion_matrix(nnet_1_adam_ec.use(Xval_ec)[0], Tval_ec)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Observations\n",
    "\n",
    "=============================\n",
    "\n",
    "SGD best performance:\n",
    "\n",
    "=============================\n",
    "\n",
    "Best validation accuracy of 91% was obtained in two cases:\n",
    "\n",
    "Case I:\n",
    "\n",
    " Learning Rate : 0.10  \n",
    " \n",
    " Hidden Layers : [50, 50] \n",
    " \n",
    " Epochs : 250          \n",
    " \n",
    " Epochs per train : 10  \n",
    " \n",
    " Case II:\n",
    " \n",
    "Learning Rate: 0.05    \n",
    " \n",
    "Hidden Layers: [50,50]\n",
    "\n",
    "Epochs:200 \n",
    "\n",
    "Epochs per train:50\n",
    "\n",
    "=============================\n",
    "\n",
    "ADAM best performance:\n",
    "\n",
    "=============================\n",
    "\n",
    "Best validation accuracy : 91.5%\n",
    "\n",
    " Learning Rate: 0.05 \n",
    " \n",
    " Hidden Layers : [50, 50]   \n",
    " \n",
    " Epochs : 200          \n",
    " \n",
    " Epochs per train :10  \n",
    " \n",
    " I couldn't find much correlation between accuracies and parameters. This might be because of the nature of the data. Within each class, (squares/diamonds), the images shape and border is identical. Only the size and the position varies. This might be the reason."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Additional code - not for grading"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This section contains some additional code I wrote while coding the assignment. I have left it here for future reference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is : [[1, 2, 3, 4, 5]]\n",
      "b is : [1, 2, 3, 4, 5]\n",
      "c is : [1, 2, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "a=[]\n",
    "b=[]\n",
    "b.append(1)\n",
    "b.append(2)\n",
    "b.append(3)\n",
    "b.append(4)\n",
    "b.append(5)\n",
    "a.append(b)\n",
    "print(\"a is :\",a)\n",
    "print(\"b is :\",b)\n",
    "c=[]\n",
    "for i in [0,1,3,4]:\n",
    "    c.append(a[0][i])\n",
    "print(\"c is :\",c)"
   ]
  },
  {
   "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.8.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}