DLCV_Assignment_1_HarshGupta_20961.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "KE1Rct79pdT1"
   },
   "source": [
    "# DLCV Assignment 1\n",
    "\n",
    "**Due Date: 17/02/2023 11:59PM IST**\n",
    "\n",
    "**Name:** \n",
    "Harsh Gupta\n",
    "\n",
    "**Sr. No.:**\n",
    "20961\n",
    "\n",
    "In this assignment, we will cover the following topics:\n",
    "\n",
    "1) Training a simple Linear Model \n",
    "\n",
    "2) Implementing Modules with Backprop functionality\n",
    "\n",
    "3) Implementing Convolution Module on Numpy\n",
    "\n",
    "\n",
    "It is crucial to get down to the nitty gritty of the code to implement all of these. No external packages (like caffe,pytorch etc), which directly give functions for these steps, are to be used. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Emb3Bo_NpdUl"
   },
   "source": [
    "# Training a simple Linear Model\n",
    "\n",
    "In this section, you will write the code to train a Linear Model. The goal is to classify an input $X_i$ of size $n$ into one of $m$ classes. For this, you need to consider the following:\n",
    "\n",
    "1)  **Weight Matrix** $W_{n\\times m}$: The Weights are multipled with the input $X_i$ (vector of size $n$), to find $m$ scores $S_m$ for the $m$ classes.\n",
    "\n",
    "2)  **The Loss function**:   \n",
    "  * The Cross Entropy Loss: By interpreting the scores as unnormalized log probabilities for each class, this loss tries to measure dissatisfaction with the scores in terms of the log probability of the right class:\n",
    "\n",
    "$$\n",
    "L_i = -\\log\\left(\\frac{e^{f_{y_i}}}{ \\sum_j e^{f_j} }\\right) \\hspace{0.5in} \\text{or equivalently} \\hspace{0.5in} L_i = -f_{y_i} + \\log\\sum_j e^{f_j}\n",
    "$$\n",
    "\n",
    "where $f_{ y_i }$ is the $y_i$-th element of the output of $W^T  X_i$\n",
    "\n",
    "3) **A Regularization term**: In addition to the loss, you need a Regularization term to lead to a more distributed (in case of $L_2$) or sparse (in case of $L_1$) learning of the weights. For example, with $L_2$ regularization, the loss has the following additional term:\n",
    "\n",
    "$$\n",
    "R(W) = \\sum_k\\sum_l W_{k,l}^2  \n",
    "$$\n",
    "\n",
    "Thus the total loss has the form:\n",
    "$$\n",
    "L =  \\underbrace{ \\frac{1}{N} \\sum_i L_i }_\\text{data loss} + \\underbrace{ \\lambda R(W) }_\\text{regularization loss} \\\\\\\\\n",
    "$$\n",
    "\n",
    "4) **An Optimization Procedure**: This refers to the process which tweaks the weight Matrix $W_{n\\times m}$ to reduce the loss function $L$. In our case, this refers to Mini-batch Gradient Descent algorithm. We adjust the weights $W_{n\\times m}$, based on the gradient of the loss $L$ w.r.t. $W_{n\\times m}$. This leads to:\n",
    "$$\n",
    "W_{t+1} = W_{t} - \\alpha \\frac{\\partial L}{\\partial W},\n",
    "$$\n",
    "where $\\alpha$ is the learning rate. Additionally, with \"mini-batch\" gradient descent, instead of finding loss over the whole dataset, we use a small sample $B$ of the training data to make each learning step. Hence,\n",
    "$$\n",
    "W_{t+1} = W_{t} - \\alpha \\frac{\\partial \\sum_{i \\in B}{L_{x_i}}}{\\partial W},\n",
    "$$\n",
    "where $|B|$ is the batch size."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**All downloaded Files Placed in \"data/\" folder** "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "I2neGQlEpdVD"
   },
   "source": [
    "# Question 1\n",
    "\n",
    "Train a **Single-Layer Classifier** for the MNIST dataset. \n",
    "* Use Softmax-Loss.\n",
    "* Maintain a train-validation split of the original training set for finding the right value of $\\lambda$ for the regularization, and to check for over-fitting.\n",
    "* Finally, evaluate the classification performance on the test-set.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import math\n",
    "import struct\n",
    "import pickle\n",
    "\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from tqdm import tqdm, trange\n",
    "from sklearn.model_selection import train_test_split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "jwa72NJTpdVc"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "############### Training Samples and Labels ###############\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "(60000, 28, 28)\n",
      "(60000,)\n",
      "############### Testing Samples and Labels ###############\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "(10000, 28, 28)\n",
      "(10000,)\n",
      "{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}\n"
     ]
    }
   ],
   "source": [
    "## Load The Mnist data:\n",
    "# Download data from http://yann.lecun.com/exdb/mnist/\n",
    "# load the data.\n",
    "\n",
    "\n",
    "####### train_images and labels #############\n",
    "with open('data/train-images-idx3-ubyte','rb') as f:\n",
    "    magic, size = struct.unpack(\">II\", f.read(8))\n",
    "    nrows, ncols = struct.unpack(\">II\", f.read(8))\n",
    "    train_imgs = np.fromfile(f, dtype=np.dtype(np.uint8).newbyteorder('>'))\n",
    "    train_imgs = train_imgs.reshape((size, nrows, ncols))\n",
    "    \n",
    "print(\"############### Training Samples and Labels ###############\")\n",
    "plt.imshow(train_imgs[0,:,:], cmap='gray')\n",
    "plt.show()\n",
    "\n",
    "\n",
    "with open('data/train-labels-idx1-ubyte','rb') as f:\n",
    "    magic, size = struct.unpack(\">II\", f.read(8))\n",
    "    train_labels = np.fromfile(f, dtype=np.dtype(np.uint8).newbyteorder('>'))\n",
    "    train_labels = train_labels.reshape((size,)) # (Optional)\n",
    "print(train_labels[0])\n",
    "print(train_imgs.shape)\n",
    "print(train_labels.shape)\n",
    "\n",
    "\n",
    "####### test_images and labels #############\n",
    "\n",
    "with open('data/t10k-images-idx3-ubyte','rb') as f:\n",
    "    magic, size = struct.unpack(\">II\", f.read(8))\n",
    "    nrows, ncols = struct.unpack(\">II\", f.read(8))\n",
    "    test_imgs = np.fromfile(f, dtype=np.dtype(np.uint8).newbyteorder('>'))\n",
    "    test_imgs = test_imgs.reshape((size, nrows, ncols))\n",
    "    \n",
    "print(\"############### Testing Samples and Labels ###############\")\n",
    "plt.imshow(test_imgs[0,:,:], cmap='gray')\n",
    "plt.show()\n",
    "\n",
    "\n",
    "with open('data/t10k-labels-idx1-ubyte','rb') as f:\n",
    "    magic, size = struct.unpack(\">II\", f.read(8))\n",
    "    test_labels = np.fromfile(f, dtype=np.dtype(np.uint8).newbyteorder('>'))\n",
    "    test_labels = test_labels.reshape((size,)) # (Optional)\n",
    "print(test_labels[0])\n",
    "print(test_imgs.shape)\n",
    "print(test_labels.shape)\n",
    "\n",
    "\n",
    "classes= set(test_labels)\n",
    "print(classes)\n",
    "\n",
    "    \n",
    "\n",
    "# maintain a train-val split\n",
    "\n",
    "# Now, write a generator that yields (random) mini-batches of the input data\n",
    "###### mini batch generator    \n",
    "def get_minibatch(training_x ,training_y ,batch_size=64):\n",
    "    ## Read about Python generators if required.\n",
    "\n",
    "    ## WRITE CODE HERE\n",
    "    indices = np.arange(len(training_x))\n",
    "    np.random.shuffle(indices)\n",
    "    \n",
    "    for i in range(0, len(training_x), batch_size):\n",
    "        mini_x = training_x[indices[i:i+batch_size]]\n",
    "        mini_y = training_y[indices[i:i+batch_size]]\n",
    "        yield mini_x, mini_y    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "######### train validation split ###########\n",
    "def train_val_split(X,y,train_size=0.9):\n",
    "    ids = X.shape[0]\n",
    "    r=list(range(ids))\n",
    "    np.random.shuffle(r)\n",
    "    samples = int(ids*train_size)\n",
    "    X_train, X_val, y_train, y_val = X[r[:samples]],X[r[samples:]],y[r[:samples]],y[r[samples:]]\n",
    "#     print(X_train.shape, y_train.shape,X_train.shape, y_train.shape)\n",
    "    return X_train, X_val, y_train, y_val\n",
    "\n",
    "\n",
    "train_imgs, val_imgs ,train_labels, val_labels = train_val_split(train_imgs,train_labels)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "HVMwqheRpdXo"
   },
   "outputs": [],
   "source": [
    "# Define the class for a Single Layer Classifier\n",
    "class Single_layer_classifier():\n",
    "    \n",
    "    def __init__(self, input_size, output_size):\n",
    "        \n",
    "        ## WRITE CODE HERE\n",
    "        self.weights = np.random.normal(loc=0,scale=0.001 ,size= (input_size,output_size))\n",
    "#         self.weights = np.random.rand(input_size,out///put_size)/math.sqrt(60000)\n",
    "        self.bias = np.random.normal(loc=0,scale=0.001 ,size= (1,output_size))\n",
    "        # Give the instance a weight matrix, initialized randomly\n",
    "        # One possible strategy for a good initialization is Normal (0, σ) where σ = 1e-3.\n",
    "        # Try experimenting with different values of σ.\n",
    "        \n",
    "    # Define the forward function\n",
    "    def forward(self, input_x):\n",
    "        # get the scores\n",
    "\n",
    "        scores = np.matmul(self.weights.T,input_x)    #+ self.bias.T\n",
    "        \n",
    "        \n",
    "        \n",
    "        return scores\n",
    "    \n",
    "    # Similarly a backward function\n",
    "    # we define 2 backward functions (as Loss = L_data + L_reg, grad(Loss) = grad(L1) + grad(L2))\n",
    "    \n",
    "    def backward_Ldata(self, grad_from_loss,x_i):\n",
    "        \n",
    "        # this function returns a matrix of the same size as the weights, \n",
    "        # where each element is the partial derivative of the loss w.r.t. the corresponding element of W\n",
    "        \n",
    "        x_i = x_i.reshape(x_i.shape[0],1)\n",
    "        grad_matrix =  np.matmul(x_i,grad_from_loss.T)\n",
    "        return grad_matrix\n",
    "        \n",
    "    def backward_Lreg(self):\n",
    "        \n",
    "        # this function returns a matrix of the same size as the weights, \n",
    "        # where each element is the partial derivative of the regularization-term\n",
    "        # w.r.t. the corresponding element of W\n",
    "        \n",
    "        grad_matrix = 2*self.weights\n",
    "        \n",
    "        return grad_matrix\n",
    "    \n",
    "    def backward(self,eta,lmbda,grad_matrix):\n",
    "        self.weights = self.weights - eta*(grad_matrix + lmbda*self.backward_Lreg())\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "BM3EhmY0pdYZ"
   },
   "outputs": [],
   "source": [
    "# Implement the Softmax loss function\n",
    "def loss_function(scores,input_y):\n",
    "    \n",
    "    eps = 0.001\n",
    "    fyi = sum(np.exp(scores)) + eps\n",
    "    return math.log(fyi) - scores[np.argmax(input_y)] \n",
    "\n",
    "\n",
    "def loss_backward(scores,input_y):\n",
    "    fyi = np.exp(scores)/sum(np.exp(scores))\n",
    "    fyi = fyi.reshape(10,1)                          \n",
    "    grad_from_loss = np.subtract(fyi,input_y)\n",
    "    return grad_from_loss\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create utility functions for calculating training and validation accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# WRITE CODE HERE\n",
    "def getOneHotEncoding(y):\n",
    "    one_hot = np.zeros(shape=(10,1))\n",
    "    one_hot[y] = 1.0\n",
    "    return one_hot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "AhpaaUvJpdZJ"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████| 50/50 [01:00<00:00,  1.22s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Min Loss is:  0.029397960406663266\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Finally the trainer:\n",
    "# Make an instance of Single_layer_classifier\n",
    "input_size = 784\n",
    "output_size= 10\n",
    "batch_size=50\n",
    "epochs =50\n",
    "min_loss=100\n",
    "model = Single_layer_classifier(input_size,output_size)\n",
    "\n",
    "###  Train on the train-set obtained from train-validation split\n",
    "batch_losses = []\n",
    "for epoch in trange(epochs):\n",
    "    \n",
    "    ###  Use the mini-batch generator to get each mini-batch\n",
    "    train_batches = get_minibatch(train_imgs,train_labels,batch_size)\n",
    "    for iter_num,(input_x , input_y) in enumerate(train_batches):\n",
    "        input_x = input_x\n",
    "        input_x = input_x.reshape(input_x.shape[0],-1)\n",
    "        ####### ----- batch ---- ######\n",
    "        \n",
    "        grads_emp = []\n",
    "        loss = []\n",
    "        ##### Forward Pass ##############\n",
    "        for i in range(batch_size):\n",
    "            scores = model.forward(input_x[i])\n",
    "            loss.append(loss_function(scores,getOneHotEncoding(input_y[i])))\n",
    "            grad_for_loss = loss_backward(scores,getOneHotEncoding(input_y[i]))\n",
    "            grads_emp.append(model.backward_Ldata(grad_for_loss,input_x[i]))\n",
    "            \n",
    "        ##### Backward Pass ##############\n",
    "        loss_p = sum(loss)/batch_size\n",
    "        batch_losses.append(loss_p)\n",
    "        min_loss = min(min_loss,loss_p)\n",
    "        gd = np.array(sum(grads_emp))/batch_size\n",
    "        model.backward(eta=0.000001,lmbda=0.02,grad_matrix = gd)\n",
    "    \n",
    "        ####### /----- batch ----/ ######\n",
    "        \n",
    "plt.plot(batch_losses)\n",
    "print(\"Min Loss is: \",min_loss)  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "######### training Classification Report ########\n",
      "\n",
      "\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.97      0.97      0.97      5310\n",
      "           1       0.98      0.96      0.97      6133\n",
      "           2       0.91      0.93      0.92      5232\n",
      "           3       0.91      0.91      0.91      5532\n",
      "           4       0.93      0.94      0.94      5260\n",
      "           5       0.89      0.89      0.89      4876\n",
      "           6       0.96      0.95      0.96      5398\n",
      "           7       0.93      0.95      0.94      5573\n",
      "           8       0.88      0.91      0.89      5138\n",
      "           9       0.92      0.89      0.91      5548\n",
      "\n",
      "    accuracy                           0.93     54000\n",
      "   macro avg       0.93      0.93      0.93     54000\n",
      "weighted avg       0.93      0.93      0.93     54000\n",
      "\n",
      "\n",
      "\n",
      "######### Test Classification Report ########\n",
      "\n",
      "\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.98      0.96      0.97      1003\n",
      "           1       0.98      0.97      0.97      1149\n",
      "           2       0.90      0.93      0.91       994\n",
      "           3       0.92      0.89      0.91      1036\n",
      "           4       0.93      0.94      0.93       973\n",
      "           5       0.87      0.88      0.88       880\n",
      "           6       0.94      0.94      0.94       960\n",
      "           7       0.92      0.94      0.93      1007\n",
      "           8       0.87      0.89      0.88       961\n",
      "           9       0.92      0.89      0.90      1037\n",
      "\n",
      "    accuracy                           0.92     10000\n",
      "   macro avg       0.92      0.92      0.92     10000\n",
      "weighted avg       0.92      0.92      0.92     10000\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import classification_report, confusion_matrix\n",
    "\n",
    "######### training Classification Report ########\n",
    "print(\"\\n\\n######### training Classification Report ########\\n\\n\")\n",
    "\n",
    "y_pred =[]\n",
    "for input_x in train_imgs:\n",
    "    input_x = input_x.reshape(28*28,1)\n",
    "    scores = model.forward(input_x)\n",
    "    y_pred.append(np.argmax(scores))\n",
    "print(classification_report(y_pred,train_labels))\n",
    "\n",
    "\n",
    "######### Test Classification Report ########\n",
    "print(\"\\n\\n######### Test Classification Report ########\\n\\n\")\n",
    "y_test_pred =[]\n",
    "for input_x in test_imgs:\n",
    "    input_x = input_x.reshape(28*28,1)\n",
    "    scores = model.forward(input_x)\n",
    "    y_test_pred.append(np.argmax(scores))\n",
    "\n",
    "print(classification_report(y_test_pred,test_labels))\n",
    "    \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot the training loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training_loss is as follows:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x12f958340>]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# WRITE CODE HERE\n",
    "print(\"Training_loss is as follows:\")\n",
    "plt.plot(batch_losses)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "RH22BqefpdZ4"
   },
   "source": [
    "### Find the accuracy on the validation set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "######### Validation_set Classification Report ########\n",
      "\n",
      "\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.96      0.95      0.96       634\n",
      "           1       0.97      0.97      0.97       711\n",
      "           2       0.90      0.91      0.91       606\n",
      "           3       0.89      0.89      0.89       626\n",
      "           4       0.94      0.93      0.93       554\n",
      "           5       0.85      0.85      0.85       536\n",
      "           6       0.94      0.95      0.94       583\n",
      "           7       0.93      0.93      0.93       584\n",
      "           8       0.86      0.90      0.88       553\n",
      "           9       0.91      0.89      0.90       613\n",
      "\n",
      "    accuracy                           0.92      6000\n",
      "   macro avg       0.92      0.92      0.92      6000\n",
      "weighted avg       0.92      0.92      0.92      6000\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# WRITE CODE HERE\n",
    "\n",
    "######### Validation_set Classification Report ########\n",
    "print(\"\\n\\n######### Validation_set Classification Report ########\\n\\n\")\n",
    "\n",
    "y_val_pred =[]\n",
    "for input_x in val_imgs:\n",
    "    input_x = input_x.reshape(28*28,1)\n",
    "    scores = model.forward(input_x)\n",
    "    y_val_pred.append(np.argmax(scores))\n",
    "\n",
    "print(classification_report(y_val_pred,val_labels))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "7wMDvvA4pdbN"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████| 5/5 [00:06<00:00,  1.24s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Batch size: 50, Learning rate: 0.0001, Lambda: 0, Val loss: 0.03239501638533204, Val accuracy: 0.887\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████| 5/5 [00:06<00:00,  1.24s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Batch size: 50, Learning rate: 0.0001, Lambda: 0.02, Val loss: 0.04797867607655696, Val accuracy: 0.8465\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████| 5/5 [00:06<00:00,  1.22s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Batch size: 50, Learning rate: 0.0001, Lambda: 0.002, Val loss: 0.035605541278178915, Val accuracy: 0.8721666666666666\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████| 5/5 [00:06<00:00,  1.22s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Batch size: 50, Learning rate: 1e-05, Lambda: 0, Val loss: 0.006670816285877254, Val accuracy: 0.9061666666666667\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████| 5/5 [00:06<00:00,  1.24s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Batch size: 50, Learning rate: 1e-05, Lambda: 0.02, Val loss: 0.006733110196831201, Val accuracy: 0.9065\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████| 5/5 [00:06<00:00,  1.23s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Batch size: 50, Learning rate: 1e-05, Lambda: 0.002, Val loss: 0.00660132909103699, Val accuracy: 0.9066666666666666\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████| 5/5 [00:06<00:00,  1.22s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Batch size: 50, Learning rate: 1e-06, Lambda: 0, Val loss: 0.0068735927789922895, Val accuracy: 0.9018333333333334\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████| 5/5 [00:06<00:00,  1.22s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Batch size: 50, Learning rate: 1e-06, Lambda: 0.02, Val loss: 0.006725302277242163, Val accuracy: 0.905\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████| 5/5 [00:06<00:00,  1.22s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Batch size: 50, Learning rate: 1e-06, Lambda: 0.002, Val loss: 0.006769867362025625, Val accuracy: 0.903\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████| 5/5 [00:06<00:00,  1.23s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Batch size: 50, Learning rate: 1e-07, Lambda: 0, Val loss: 0.010449563780743446, Val accuracy: 0.8433333333333334\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████| 5/5 [00:06<00:00,  1.24s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Batch size: 50, Learning rate: 1e-07, Lambda: 0.02, Val loss: 0.010595546320204102, Val accuracy: 0.8353333333333334\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████| 5/5 [00:06<00:00,  1.23s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Batch size: 50, Learning rate: 1e-07, Lambda: 0.002, Val loss: 0.010435736586312163, Val accuracy: 0.8475\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# The next step is to find the optimal value for lambda, number of epochs, learning rate and batch size. \n",
    "# CHOSE ANY TWO from the above mentioned to tune.\n",
    "# Create plot and table to show the effect of the hparams.\n",
    "etas=[0.0001,0.00001,0.000001, 0.0000001]\n",
    "lambdas=[0, 0.02, 0.002 ]\n",
    "def tune_hyperparameters(train_imgs, train_labels, val_imgs, val_labels, \n",
    "                         input_size, output_size, num_epochs=5, \n",
    "                         batch_sizes=[50], etas=etas, \n",
    "                         lambdas=lambdas):\n",
    "    \n",
    "    results = []\n",
    "    \n",
    "    for batch_size in batch_sizes:\n",
    "        for eta in etas:\n",
    "            for lmbda in lambdas:\n",
    "                \n",
    "                model = Single_layer_classifier(input_size, output_size)\n",
    "                batch_losses = []\n",
    "                \n",
    "                for epoch in trange(num_epochs):\n",
    "\n",
    "                    train_batches = get_minibatch(train_imgs, train_labels, batch_size)\n",
    "                    for iter_num, (input_x, input_y) in enumerate(train_batches):\n",
    "                        input_x = input_x\n",
    "                        input_x = input_x.reshape(input_x.shape[0], -1)\n",
    "                        grads_emp = []\n",
    "                        loss = []\n",
    "\n",
    "                        for i in range(batch_size):\n",
    "                            scores = model.forward(input_x[i])\n",
    "                            loss.append(loss_function(scores, getOneHotEncoding(input_y[i])))\n",
    "                            grad_for_loss = loss_backward(scores, getOneHotEncoding(input_y[i]))\n",
    "                            grads_emp.append(model.backward_Ldata(grad_for_loss, input_x[i]))\n",
    "\n",
    "                        loss_p = sum(loss) / batch_size\n",
    "                        batch_losses.append(loss_p)\n",
    "                        gd = np.array(sum(grads_emp)) / batch_size\n",
    "                        model.backward(eta=eta, lmbda=lmbda, grad_matrix=gd)\n",
    "\n",
    "                    val_batches = get_minibatch(val_imgs, val_labels, batch_size)\n",
    "                    val_acc = 0\n",
    "                    val_loss = 0\n",
    "                    for iter_num, (input_x, input_y) in enumerate(val_batches):\n",
    "                        input_x = input_x\n",
    "                        input_x = input_x.reshape(input_x.shape[0], -1)\n",
    "                        grads_emp = []\n",
    "                        loss = []\n",
    "                        acc = 0\n",
    "\n",
    "                        for i in range(batch_size):\n",
    "                            scores = model.forward(input_x[i])\n",
    "                            loss.append(loss_function(scores, getOneHotEncoding(input_y[i])))\n",
    "#                             grad_for_loss = loss_backward(scores, getOneHotEncoding(input_y[i]))\n",
    "#                             grads_emp.append(model.backward_Ldata(grad_for_loss, input_x[i]))\n",
    "                            predicted_label = np.argmax(scores)\n",
    "                            actual_label = input_y[i]\n",
    "                            if predicted_label == actual_label:\n",
    "                                acc += 1\n",
    "\n",
    "                        loss_p = sum(loss) / batch_size\n",
    "                        val_loss += loss_p\n",
    "                        val_acc += acc\n",
    "\n",
    "                    val_loss /= len(val_imgs)\n",
    "                    val_acc /= len(val_imgs)\n",
    "\n",
    "                    batch_losses.append(loss_p)\n",
    "\n",
    "                results.append({\n",
    "                    'batch_size': batch_size,\n",
    "                    'learning_rate': eta,\n",
    "                    'lambda': lmbda,\n",
    "                    'val_loss': val_loss,\n",
    "                    'val_accuracy': val_acc\n",
    "                })\n",
    "\n",
    "                print(f'Batch size: {batch_size}, Learning rate: {eta}, Lambda: {lmbda}, Val loss: {val_loss}, Val accuracy: {val_acc}')\n",
    "                \n",
    "    return results\n",
    "\n",
    "\n",
    "def plot_tuning_results(results):\n",
    "    # Create a table of the performance metrics\n",
    "    df = pd.DataFrame(results, columns=['lambda', 'learning_rate', 'val_loss', 'val_accuracy'])\n",
    "    df = df.pivot(index='learning_rate', columns='lambda', values='val_accuracy')\n",
    "    df = df.round(3)\n",
    "\n",
    "    # Create heatmap\n",
    "    ax = sns.heatmap(df, annot=True, cmap='coolwarm')\n",
    "    ax.invert_yaxis()\n",
    "    ax.set_title('Validation Accuracy')\n",
    "    ax.set_xlabel('lambda')\n",
    "    ax.set_ylabel('eta')\n",
    "    plt.show()\n",
    "    \n",
    "results = tune_hyperparameters(train_imgs, train_labels, val_imgs, val_labels, input_size=784, output_size=10)\n",
    "plot_tuning_results(results)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Find the best performing class and the worst performing class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The best performing class from the model trained above is : class 0 and class 1 with accuracy(97%)\n",
      "The worst performing class from the model trained above is : class 8 with accuracy (88%)\n"
     ]
    }
   ],
   "source": [
    "print(\"The best performing class from the model trained above is : class 0 and class 1 with accuracy(97%)\" )\n",
    "print(\"The worst performing class from the model trained above is : class 8 with accuracy (88%)\" )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Emb3Bo_NpdUl"
   },
   "source": [
    "# Training a Linear Classifier on MNIST from scikit-learn\n",
    "\n",
    "In this section you have to train a linear classifier from the scikit-learn library and compare its results against your implementation.\n",
    "(https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LinearRegression.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "###### Sklearn RidgeClassifier Accuracy #########\n",
      "\n",
      "############# Train Accuracy #################\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.96      0.90      0.93      5629\n",
      "           1       0.97      0.82      0.89      7148\n",
      "           2       0.81      0.91      0.85      4747\n",
      "           3       0.84      0.84      0.84      5555\n",
      "           4       0.89      0.84      0.87      5627\n",
      "           5       0.74      0.87      0.80      4134\n",
      "           6       0.93      0.89      0.91      5543\n",
      "           7       0.87      0.87      0.87      5646\n",
      "           8       0.76      0.85      0.80      4713\n",
      "           9       0.80      0.81      0.81      5258\n",
      "\n",
      "    accuracy                           0.86     54000\n",
      "   macro avg       0.86      0.86      0.86     54000\n",
      "weighted avg       0.87      0.86      0.86     54000\n",
      "\n",
      "############# Test Accuracy #################\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.96      0.91      0.93      1039\n",
      "           1       0.98      0.84      0.90      1321\n",
      "           2       0.79      0.92      0.85       889\n",
      "           3       0.87      0.85      0.86      1039\n",
      "           4       0.90      0.81      0.85      1079\n",
      "           5       0.74      0.87      0.80       750\n",
      "           6       0.91      0.88      0.90       988\n",
      "           7       0.86      0.86      0.86      1036\n",
      "           8       0.78      0.84      0.81       910\n",
      "           9       0.79      0.84      0.82       949\n",
      "\n",
      "    accuracy                           0.86     10000\n",
      "   macro avg       0.86      0.86      0.86     10000\n",
      "weighted avg       0.87      0.86      0.86     10000\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"###### Sklearn RidgeClassifier Accuracy #########\")\n",
    "from sklearn.linear_model import RidgeClassifier\n",
    "X=train_imgs.reshape(train_imgs.shape[0],-1)\n",
    "y=train_labels\n",
    "print()\n",
    "rc = RidgeClassifier().fit(X, y)\n",
    "\n",
    "####### Train Accuracy #######\n",
    "print(\"############# Train Accuracy #################\")\n",
    "\n",
    "print(classification_report(rc.predict(X),train_labels))\n",
    "\n",
    "####### Test Accuracy #######\n",
    "print(\"############# Test Accuracy #################\")\n",
    "print(classification_report(rc.predict(test_imgs.reshape(test_imgs.shape[0],-1)),test_labels))\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Compare the training and test accuracies for the your implementation and linear classifier from scikit-learn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "############## Implemented Model Accuracy ##########\n",
      "\n",
      "Test Accuracy:92.4 \t Train Accuracy: 93.03333333333333\n",
      "\n",
      "############## Sklearn RidgeClassifier Accuracy ##########\n",
      "\n",
      "Test Accuracy:86.00999999999999 \t Train Accuracy: 85.86481481481482\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "############## Implemented Model Accuracy ##########\n",
    "print(\"############## Implemented Model Accuracy ##########\\n\")\n",
    "\n",
    "print(\"Test Accuracy:{} \\t Train Accuracy: {}\\n\".format(accuracy_score(y_test_pred,test_labels)*100,accuracy_score(y_pred,train_labels)*100) )\n",
    "\n",
    "print(\"############## Sklearn RidgeClassifier Accuracy ##########\\n\")\n",
    "print(\"Test Accuracy:{} \\t Train Accuracy: {}\\n\".format(accuracy_score(rc.predict(test_imgs.reshape(test_imgs.shape[0],-1)),test_labels)*100,accuracy_score(rc.predict(train_imgs.reshape(train_imgs.shape[0],-1)),train_labels)*100) )\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "sXFJTTnkpdcp"
   },
   "source": [
    "# Implementing Backpropagation\n",
    "\n",
    "Now that you have had some experience with single layer networks, we can proceed to more complex architectures. But first we need to completely understand and implement backpropagation.\n",
    "\n",
    "## Backpropagation:\n",
    "\n",
    "Simply put, a way of computing gradients of expressions through repeated application of chain rule. If\n",
    "$$\n",
    "L = f (g (h (\\textbf{x})))\n",
    "$$\n",
    "then, by the chain rule we have:\n",
    "$$\n",
    "\\frac{\\partial L}{\\partial \\textbf{x}} = \\frac{\\partial f}{\\partial g} \\cdot \\frac{\\partial g}{\\partial h} \\cdot \\frac{\\partial h}{\\partial \\textbf{x}} \n",
    "$$\n",
    "\n",
    "** Look into the class Lecture for more detail **\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UixM41Rppdcz"
   },
   "source": [
    "# Question 2 : Scalar Backpropagation\n",
    "\n",
    "Evaluate the gradient of the following function w.r.t. the input:\n",
    "\n",
    "$$ f(x,y,z) =  log(\\sigma(\\frac{cos(\\pi \\times x)+sin(\\pi \\times y/2)}{tanh(z^2)}))$$\n",
    "where $\\sigma$ is the sigmoid function. Find gradient for the following inputs:\n",
    "  * $(x,y,z)$ =  (2,4,1)\n",
    "  * $(x,y,z)$ =  (9,14,3)\n",
    "  * $(x,y,z)$ =  (128,42,666)\n",
    "  * $(x,y,z)$ =  (52,14,28)\n",
    "\n",
    "      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Uu9zd5PLpdc_"
   },
   "outputs": [],
   "source": [
    "# To solve this problem, construct the computational graph\n",
    "# Write a class with forward and backward functions, for each node if you like\n",
    "# For eg:\n",
    "class tanh():\n",
    "    def __init__(self):\n",
    "        self.f = None\n",
    "        \n",
    "    def forward(self,x):\n",
    "        self.f = np.tanh(x)\n",
    "        return self.f\n",
    "        # save values useful for backpropagation\n",
    "    def backward(self):\n",
    "        if self.f==None:\n",
    "            print(\"Forward Propagation Not Done Yet.\")\n",
    "            return\n",
    "        else:\n",
    "            return (1-np.square(self.f))\n",
    "class log():\n",
    "    def __init__(self):\n",
    "        self.f = None\n",
    "        self.x=None\n",
    "    def forward(self,x):\n",
    "        self.f = np.log(x)\n",
    "        self.x = x\n",
    "        return self.f\n",
    "        # save values useful for backpropagation\n",
    "    def backward(self):\n",
    "        if self.f==None or self.x==None:\n",
    "            print(\"Forward Propagation Not Done Yet.\")\n",
    "            return\n",
    "        else:\n",
    "            return 1/(self.x)\n",
    "\n",
    "class Sigmoid():\n",
    "    def __init__(self):\n",
    "        self.f = None\n",
    "        \n",
    "    def forward(self,x):\n",
    "        self.f = 1/(1+np.exp(-x))\n",
    "        # save values useful for backpropagation\n",
    "    def backward(self):\n",
    "        if self.f==None:\n",
    "            print(\"Forward Propagation Not Done Yet.\")\n",
    "            return\n",
    "        else:\n",
    "            return self.f*(1-self.f)\n",
    "# CAUTION: Carefully treat the input and output dimension variation. At worst, handle them with if statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "KyqeWPF0pddy"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x:2.0  y:4.0  z:1.0     forward:-0.23823101469115085    backward:[2.1417102890343507e-16, 0.43720979194276516, -0.3069722756588883]\n",
      "\n",
      "x:9.0  y:14.0  z:3.0     forward:-1.3132617097862374    backward:[-2.5313688314302287e-15, -1.148344174369598, 2.672161875217988e-07]\n",
      "\n",
      "x:52.0  y:14.0  z:28.0     forward:-0.31326168751822253    backward:[-6.626324387577344e-15, -0.42245219681098645, -0.0]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Now write the class func\n",
    "# which constructs the graph (all operators), forward and backward functions.\n",
    "\n",
    "class Func():\n",
    "    def __init__(self):\n",
    "        # construct the graph here\n",
    "        # assign the instances of function modules to self.var\n",
    "        self.x =None\n",
    "        self.y =None\n",
    "        self.z =None\n",
    "        self.a = None\n",
    "        self.b = None\n",
    "        self.c = None\n",
    "        self.d = None\n",
    "        self.e = None\n",
    "        self.f = None\n",
    "        self.g = None\n",
    "        self.h = None\n",
    "        self.i = None\n",
    "        self.j = None\n",
    "        \n",
    "        \n",
    "        ###### x ######\n",
    "        \n",
    "        \n",
    "        \n",
    "    def forward(self,x,y,z):\n",
    "        self.x ,self.y,self.z = x,y,z\n",
    "        \n",
    "        self.a = math.pi*self.x\n",
    "        self.b = math.pi*self.y/2\n",
    "        self.c = np.square(self.z)\n",
    "        self.d = np.cos(self.a)\n",
    "        self.e = np.sin(self.b)\n",
    "        self.f = self.d + self.e\n",
    "        self.g = np.tanh(self.c)\n",
    "        self.h = np.divide(self.f,self.g)\n",
    "        self.i = 1/(1+np.exp(-self.h))\n",
    "        self.j = np.log(self.i)\n",
    "        return self.j\n",
    "        # Using the graph element's forward functions, get the output. \n",
    "        \n",
    "    \n",
    "    def backward(self):\n",
    "        # Use the saved outputs of each module, and backward() function calls\n",
    "        grad_x,grad_y,grad_z =1,1,1\n",
    "        out = 1/self.i\n",
    "        out *= self.i*(1-self.i)\n",
    "        grad_xy  = out*1/self.g\n",
    "        \n",
    "        grad_x = (-1)*np.sin(self.a)*grad_xy\n",
    "        grad_x = math.pi*(grad_x)\n",
    "        \n",
    "        grad_y = np.cos(self.b)*grad_xy\n",
    "        grad_y = math.pi*grad_y/2\n",
    "        \n",
    "        \n",
    "        grad_z = -out*self.f*(1/np.square(self.g))\n",
    "        grad_z = grad_z*(1- np.square(self.g))\n",
    "        grad_z = 2*self.z*grad_z\n",
    "        return [grad_x,grad_y,grad_z]\n",
    "    \n",
    "\n",
    "#### Initialization #####\n",
    "f= Func()\n",
    "\n",
    "######### Forward and Backward Pass ############\n",
    "x,y,z = 2.0,4.0,1.0\n",
    "print(\"x:{}  y:{}  z:{}     forward:{}    backward:{}\\n\".format(x,y,z , f.forward(x,y,z),f.backward()))\n",
    "x,y,z = 9.0,14.0,3.0\n",
    "print(\"x:{}  y:{}  z:{}     forward:{}    backward:{}\\n\".format(x,y,z , f.forward(x,y,z),f.backward()))\n",
    "\n",
    "x,y,z = 52.0,14.0,28.0\n",
    "print(\"x:{}  y:{}  z:{}     forward:{}    backward:{}\\n\".format(x,y,z , f.forward(x,y,z),f.backward()))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "rYE4dEd-pdef"
   },
   "source": [
    "## Question 3 : Modular Vector Backpropagation\n",
    "\n",
    "* Construct a Linear Layer module, implementing the forward and backward functions for arbitrary sizes.\n",
    "* Construct a ReLU module, implementing the forward and backward functions for arbitrary sizes.\n",
    "* Create a 2 layer MLP using the constructed modules.\n",
    "\n",
    "* Modifying the functions built in Question 1 , train this two layer MLP for the same data set, MNIST, with the same train-val split."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "0viOMFfFpden"
   },
   "outputs": [],
   "source": [
    "# Class for Linear Layer (If you're stuck, you can refer to code of PyTorch/Tensorflow packages) \n",
    "class Linear_Layer:\n",
    "    def __init__(self, input_size, output_size,batch_size,eta):\n",
    "        self.input= None\n",
    "        self.output= None\n",
    "        self.eta = eta\n",
    "        self.batch_size = batch_size\n",
    "        self.weights = np.random.rand(input_size, output_size)*0.01/np.sqrt(input_size)\n",
    "#         self.weights = np.random.normal(loc=0,scale=0.001 ,size= (input_size,output_size))\n",
    "\n",
    "        self.gradient_matrix = np.zeros(shape=(input_size,output_size))\n",
    "    \n",
    "    def forward(self, input_data):\n",
    "        self.input = input_data.reshape(input_data.shape[0],1)\n",
    "        self.output = np.dot( self.weights.T, self.input)\n",
    "        return self.output\n",
    "    \n",
    "    def backward_ldata(self,back_grad):\n",
    "        for_grad = np.matmul( self.weights,back_grad)\n",
    "        self.gradient_matrix = np.add(self.gradient_matrix,np.dot(self.input, back_grad.T))\n",
    "        return for_grad    \n",
    "        \n",
    "        \n",
    "    def backward(self):\n",
    "        self.weights -= eta * self.gradient_matrix/self.batch_size\n",
    "#         print(self.gradient_matrix)\n",
    "        self.gradient_matrix = np.zeros(shape=self.weights.shape)\n",
    "    \n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "zmlWuzv1pdfK"
   },
   "outputs": [],
   "source": [
    "# Class for ReLU\n",
    "class ReLU():\n",
    "    def __init__(self):\n",
    "        self.f = None\n",
    "        self.x = None\n",
    "    def forward(self,x):\n",
    "        self.f = x*(x>0)\n",
    "        self.x = x\n",
    "        return self.f\n",
    "    \n",
    "    def backward_ldata(self,back_grad):\n",
    "        return (self.x>0)*back_grad\n",
    "    \n",
    "    def backward(self):\n",
    "        return \n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ppSfRLySpdfv"
   },
   "outputs": [],
   "source": [
    "# Your 2 layer MLP \n",
    "class MLP():\n",
    "    def __init__(self):\n",
    "        self.layers = []\n",
    "        self.loss = []\n",
    "    \n",
    "    def add_layer(self,layer):\n",
    "        self.layers.append(layer)\n",
    "            \n",
    "    def predict(self, input_data):\n",
    "        samples = input_data.shape[0]\n",
    "        result = []\n",
    "\n",
    "        # run network over all samples\n",
    "        \n",
    "        for sample in input_data:\n",
    "            # forward propagation\n",
    "            \n",
    "            scores = sample\n",
    "            for layer in self.layers:\n",
    "                scores = layer.forward(scores)\n",
    "#                 print(output,end=' ')\n",
    "                \n",
    "            result.append(np.argmax(scores))\n",
    "        return result\n",
    "\n",
    "    def plot_loss(self):\n",
    "        '''\n",
    "        Plots the loss curve\n",
    "        '''\n",
    "        fig = plt.figure(figsize=(10,10))\n",
    "        plt.plot(self.loss)\n",
    "        plt.xlabel(\"Iteration\")\n",
    "        plt.ylabel(\"logloss\")\n",
    "        plt.title(\"Loss curve for training\")\n",
    "        plt.show()  \n",
    "    \n",
    "    \n",
    "    def train(self,X,y,epochs=3,batch_size=50,eta=0.001):\n",
    "        batch_losses = []\n",
    "        min_loss =10000 \n",
    "        print(\"#### training Started ####\")\n",
    "        for epoch in trange(epochs):\n",
    "            print(\"epoch:{}   Total batches: {} \".format(epoch+1,X.shape[0]/batch_size))\n",
    "            minibatch = get_minibatch(X,y,batch_size)\n",
    "            loss =0\n",
    "            for input_x , input_y in minibatch:\n",
    "                for i in range(batch_size):\n",
    "                    input_x = input_x.reshape(input_x.shape[0],-1)\n",
    "                    scores = input_x[i]\n",
    "                    ####### forward ##########\n",
    "                    for layer in self.layers:\n",
    "                        scores = layer.forward(scores)\n",
    "#                         print(\"\\n\\n\\n\\n\\n\\n\",scores)\n",
    "                        \n",
    "                        \n",
    "                    ####### log(softmax calculation)\n",
    "#                     print(scores)\n",
    "                    loss += loss_function(scores,getOneHotEncoding(input_y[i]))\n",
    "                    grad_for_loss = loss_backward(scores,getOneHotEncoding(input_y[i]))\n",
    "                    \n",
    "                    ####### backward sample wise to calculate gradient_matrix #######\n",
    "                    for layer in reversed(self.layers):\n",
    "                        grad_for_loss = layer.backward_ldata(grad_for_loss)\n",
    "\n",
    "\n",
    "            \n",
    "                self.loss.append(loss[0]/batch_size)\n",
    "#                 print(\"loss: \", self.loss[-1])\n",
    "                min_loss = min(min_loss,self.loss[-1])\n",
    "                \n",
    "                ##### weights update for each layer using backward\n",
    "                for layer in self.layers:\n",
    "                    layer.backward()\n",
    "                loss=0\n",
    "            print(\"Minimum Loss after epoch {} is  {}\".format(epoch+1,min_loss))\n",
    "#         self.plot_loss()\n",
    "        print(\"Minimum Loss: \",min_loss)\n",
    "    \n",
    "        print(\"#### training Done ####\")\n",
    "        \n",
    "    def valid(self,X,y,epochs=3,batch_size=50,eta=0.001):\n",
    "        print(\"\\n#########validation Started###########\\n\")\n",
    "        correct =0\n",
    "        total = X.shape[0]\n",
    "        loss =0\n",
    "        \n",
    "        \n",
    "        minibatch = get_minibatch(X,y,batch_size)\n",
    "        for input_x , input_y in minibatch:\n",
    "            for i in range(batch_size):\n",
    "                input_x = input_x.reshape(input_x.shape[0],-1)\n",
    "                scores = input_x[i]\n",
    "                ####### forward ##########\n",
    "                for layer in self.layers:\n",
    "                    scores = layer.forward(scores)\n",
    "\n",
    "                loss += loss_function(scores,getOneHotEncoding(input_y[i]))/total\n",
    "                correct += (np.argmax(scores)==input_y[i])\n",
    "            \n",
    "        val_acc = correct/total\n",
    "        val_loss = loss\n",
    "        print(f'Batch size: {batch_size}, Learning rate: {eta}, Val loss: {val_loss[0]}, Val accuracy: {val_acc}')\n",
    "        print(\"\\n#########validation Done###########\\n\\n\\n\\n\")\n",
    "        \n",
    "        return {\n",
    "                    'batch_size': batch_size,\n",
    "                    'learning_rate': eta,\n",
    "                    'val_loss': val_loss[0],\n",
    "                    'val_accuracy': val_acc,\n",
    "                    'epochs': epochs\n",
    "                }\n",
    "\n",
    "        \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "MyDbNSeRpdgL",
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#### training Started ####\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  0%|                                                     | 0/2 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:1   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 50%|██████████████████████▌                      | 1/2 [01:27<01:27, 87.77s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 1 is  0.002226901060507558\n",
      "epoch:2   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████| 2/2 [02:54<00:00, 87.42s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 2 is  0.0002697490593355667\n",
      "Minimum Loss:  0.0002697490593355667\n",
      "#### training Done ####\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "####### hyperparameters ########\n",
    "epochs = 2\n",
    "batch_size =20\n",
    "output_size = 10\n",
    "input_size = 784\n",
    "eta = 0.01\n",
    "\n",
    "# Train the MLP\n",
    "mlp = MLP()\n",
    "\n",
    "##### add layer #####\n",
    "mlp.add_layer(Linear_Layer(input_size,512,batch_size,eta))\n",
    "mlp.add_layer(ReLU())\n",
    "\n",
    "mlp.add_layer(Linear_Layer(512,256,batch_size,eta))\n",
    "mlp.add_layer(ReLU())\n",
    "mlp.add_layer(Linear_Layer(256,10,batch_size,eta))\n",
    "\n",
    "\n",
    "mlp.train(train_imgs,train_labels,epochs,batch_size,eta)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot the training loss and training accuracy plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Plot of training Loss is as follows: \n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlcAAAJcCAYAAADU/IFHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAAsTAAALEwEAmpwYAABaTUlEQVR4nO3dd3xb1eH+8efY2SELkkAgIWZD2BBW2aOstIW2QEvppP21paVfOiEUSlvKSKFQRhml7F0aNgESRiCD7L23s3diZziO1/n9IcmWZY0r6VxdSf68eeWFrXHv0ZV876MzjbVWAAAAcKMk6AIAAAAUE8IVAACAQ4QrAAAAhwhXAAAADhGuAAAAHCJcAQAAOES4AtAqGGO+boxZaYzZYYw5PujySJIx5o/GmCddPxZAsAzzXAHFyRhTLukn1tqPgy5LPjDGLJH0W2vt246295mkF621BB4AzVBzBSAvGWPaON5kf0lzMixLaQbPcV1+AAWCcAW0MsaY9saYB4wxa8L/HjDGtA/f19MY854xpsIYs8UYM9oYUxK+7yZjzGpjzHZjzAJjzPkJtt/RGHOfMWa5MabSGDMmfNs5xphVMY8tN8ZcEP75L8aYocaYF40x2yT90RizyxizZ9TjjzfGbDLGtA3/fq0xZp4xZqsxZrgxpn+C17tDUqmkGeEaLBljjjDGfBZ+rXOMMV+Les6zxpjHjDHvG2N2Sjo3Zpt3SjpT0r/CzYz/Ct9ujTG/NMYskrQofNuD4ebIbcaYKcaYM6O28xdjzIvhn8vCz/+BMWZF+HXekuFjOxpjngsfl3nGmBtjjz0A/xCugNbnFkmnSjpO0rGSTpZ0a/i+30laJamXpL0l/VGSNcYcJul6SSdZa7tIukhSeYLt/0PSiZK+JGlPSTdKavBYtsskDZXUXdK9ksZJ+mbU/d+RNNRaW2uMuSxcvm+Eyzta0iuxG7TW7rbW7hH+9Vhr7UHhcPaupBGSekv6laSXwq8zel93SuoiaUzMNm8J7+96a+0e1trro+6+XNIpkgaEf5+k0LHeU9LLkv5njOmQ5BicIekwSedLus0Yc0QGj/2zpDJJB0r6sqTvJtkGAMcIV0Drc42k2621G6y1GyX9VdL3wvfVSuojqb+1ttZaO9qGOmbWS2ovaYAxpq21ttxauyR2w+Farmsl3WCtXW2trbfWfmGt3e2xbOOstW9ZaxustbsUCiNXh7dtJH07fJsk/VzS3dbaedbaOkl3STouXu1VHKdK2kPSEGttjbX2U0nvRfYV9ra1dmy4LNUey69wmbaEyy9r7YvW2s3W2jpr7X0KHcfDkjz/r9baXdbaGZJmKBSA033sVZLustZutdaukvRQGuUHkCXCFdD67CtpedTvy8O3SaHaosWSRhhjlhpjBkuStXaxpF9L+oukDcaYV40x+6qlnpI6SGoRvDxaGfP765JOM8b0kXSWQjVgo8P39Zf0YLhZr0LSFklG0n4e9rOvpJXW2ugateUxz40ti1fNnmeM+X24aa4yXM5uCh2nRNZF/VylUAhM97H7xpQj09cCIAOEK6D1WaNQMInYP3ybrLXbrbW/s9YeKOlrkn4b6VtlrX3ZWntG+LlW0t/jbHuTpGpJB8W5b6ekTpFfwp3Ee8U8ptnwZWvtVoWa7r6lUDPdq7ZpiPNKST+z1naP+tfRWvtFyiMQer39Iv3JwvaXtDpRWeJIdH/j7eH+VTcqVJPUw1rbXVKlQiHQT2sl9Y36vZ/P+wMQhXAFFLe2xpgOUf/aKNQv6VZjTC9jTE9Jt0mKdJT+ijHm4HATXKVCzYENxpjDjDHnhTu+V0vapTj9qMI1QU9Lut8Ys68xptQYc1r4eQsldTDGDAr3ebpVoSayVF6W9H1JV6ipSVCSHpd0szHmyHDZuxljrvR4XCYoVNNzozGmrTHmHElflfSqx+dL0nqF+jQl00VSnaSNktoYY26T1DWNfWTqNYWOTQ9jzH4K9ZcDkCOEK6C4va9QEIr8+4ukOyRNljRT0ixJU8O3SdIhkj6WtEOhzuSPWmtHKhSChihUM7VOoU7gNyfY5+/D252kUFPd3yWVWGsrJf1C0pMK1RDtVKjzfCrvhMu1Lty3SJJkrX0zvO1Xw6MLZ0u6xMP2ZK2tUShMXRJ+TY9K+r61dr6X54c9KOmK8Ii8RH2ahkv6UKFguVyhYJqLJrrbFTq2yxR6P4dK8trvDUCWmEQUAIqcMeY6Sd+21p4ddFmA1oCaKwAoMsaYPsaY040xJeHpJX4n6c2gywW0FswgDADFp52kf0s6QFKFQn3JHg2yQEBrQrMgAACAQzQLAgAAOJRXzYI9e/a0ZWVlQRcDAAAgpSlTpmyy1sbO15df4aqsrEyTJ08OuhgAAAApGWOWx7udZkEAAACHCFcAAAAOEa4AAAAcIlwBAAA4RLgCAABwiHAFAADgEOEKAADAIcIVAACAQ4QrAAAAhwhXAAAADhGuAAAAHCJcAQAAOES4AgAAcIhwBQAA4BDhCgAAwCHCFQAAgEOEKwAAAIcIVwAAAA4RrgAAABwiXAEAADhEuAIAAHCIcAUAAOAQ4SpL1lp9/+mJGrlgQ9BFAQAAeYBwlaWa+gaNWrhRP3t+StBFAQAAeYBwBQAA4BDhCgAAwCHCFQAAgEOEKwAAAIcIV45Y2aCLAAAA8gDhKktGJugiAACAPEK4AgAAcIhwBQAA4BDhCgAAwCHClSOW/uwAAECEKwAAAKcIV44YBg0CAAARrgAAAJwiXAEAADhEuAIAAHCIcOUIowUBAIBEuMoaHdkBAEA0whUAAIBDhCsAAACHCFcAAAAOEa4AAAAcIlxliVGCAAAgGuEKAADAIcIVAACAQ4QrAAAAhwhXAAAADhGuHKFfOwAAkAhXAAAAThGuAAAAHCJcAQAAOES4AgAAcIhwBQAA4BDhKkuWcYIAACAK4QoAAMAhwhUAAIBDhCsAAACHCFcAAAAOEa4csZaO7QAAgHAFAADgFOEKAADAIcIVAACAQ4QrAAAAhwhXAAAADhGussQgQQAAEI1wBQAA4BDhCgAAwCHCFQAAgEOEKwAAAIcIV47Qrx0AAEiEKwAAAKcIVwAAAA4RrgAAABzyPVwZY0qNMdOMMe/5vS8AAICg5aLm6gZJ83KwHwAAgMD5Gq6MMX0lDZL0pJ/7AQAAyBd+11w9IOlGSQ2JHmCM+akxZrIxZvLGjRt9Lg4AAIC/fAtXxpivSNpgrZ2S7HHW2iestQOttQN79erlV3EAAAByws+aq9Mlfc0YUy7pVUnnGWNe9HF/AAAAgfMtXFlrb7bW9rXWlkn6tqRPrbXf9Wt/AAAA+YB5rhyxrH8DAAAktcnFTqy1n0n6LBf7AgAACBI1VwAAAA4RrgAAABwiXAEAADhEuAIAAHCIcJUlRgkCAIBohCsAAACHCFcAAAAOEa4AAAAcIlwBAAA4RLgCAABwiHAFAADgEOEKAADAIcIVAACAQ4QrAAAAhwhXAAAADhGuAAAAHCJcZcmKxQUBAEATwhUAAIBDhCsAAACHCFcAAAAOEa4AAAAcIlwBAAA4RLgCAABwiHAFAADgEOEKAADAIcIVAACAQ4QrAAAAhwhXWbKsfgMAAKIQrgAAABwiXAEAADhEuAIAAHCIcAUAAOAQ4QoAAMAhwhUAAIBDhCsAAACHCFcAAAAOEa4AAAAcIlwBAAA4RLjKEqvfAACAaIQrAAAAhwhXAAAADhGuAAAAHCJcAQAAOES4AgAAcIhwBQAA4BDhCgAAwCHCFQAAgEOEKwAAAIcIVwAAAA4RrrJkLQvgAACAJoQrAAAAhwhXAAAADhGuAAAAHCJcAQAAOES4AgAAcIhwBQAA4BDhCgAAwCHCFQAAgEOEKwAAAIcIVwAAAA4RrrLE4jcAACAa4QoAAMAhwhUAAIBDhCsAAACHCFcAAAAOEa4AAAAcIlwBAAA4RLgCAABwiHAFAADgEOEKAADAIcIVAACAQ4SrLFnWvwEAAFEIVwAAAA4RrgAAABwiXAEAADhEuAIAAHCIcAUAAOAQ4QoAAMAhwhUAAIBDhCsAAACHCFcAAAAOEa4AAAAcIlwBAAA4RLjKFmsLAgCAKIQrAAAAhwhXAAAADhGuAAAAHCJcAQAAOES4AgAAcIhwBQAA4BDhCgAAwCHCFQAAgEOEKwAAAIcIVwAAAA4RrrJkWf8GAABEIVwBAAA4RLjKgZq6Bl39xHhNXbE16KIAAACfEa5yYOmmHRq3dLNufn1W0EUBAAA+I1wBAAA4RLjKITq/AwBQ/AhXAAAADvkWrowxHYwxE40xM4wxc4wxf/VrXwAAAPmijY/b3i3pPGvtDmNMW0ljjDEfWGvH+7jPvGRkgi4CAADIEd/ClbXWStoR/rVt+B+djgAAQFHztc+VMabUGDNd0gZJH1lrJ8R5zE+NMZONMZM3btzoZ3EAAAB852u4stbWW2uPk9RX0snGmKPiPOYJa+1Aa+3AXr16+VkcX9g06uLSeSwAAChMORktaK2tkDRS0sW52B8AAEBQ/Bwt2MsY0z38c0dJX5Y036/9AQAA5AM/Rwv2kfScMaZUoRD3mrX2PR/3l7cMgwUBAGg1/BwtOFPS8X5tHwAAIB8xQzsAAIBDhKscYrAgAADFj3AFAADgEOEKAADAIcJVDjBYEACA1oNwBQAA4BDhKkt0UgcAANEIVwAAAA4RrnLIsnIzAABFj3AFAADgEOEKAADAIcJVDrBwMwAArQfhCgAAwCHCFQAAgEOEqxxirCAAAMWPcAUAAOAQ4QoAAMAhwlWWvE0MynBBAABaC8IVAACAQ4QrAAAAhwhXucRwQQAAih7hCgAAwCHCFQAAgEOEqxxgbUEAAFoPwhUAAIBDhCsAAACHCFcAAAAOEa4AAAAcIlwBAAA4RLjKUjrzgjKHKAAAxY9wlQPMxAAAQOtBuAIAAHCIcAUAAOAQ4SqHrKXXFQAAxY5wBQAA4BDhCgAAwCHCFQAAgEOEqxygpxUAAK0H4QoAAMAhwlUOUYMFAEDxI1xlycvsCszAAABA60G4AgAAcIhwBQAA4BDhKidoFwQAoLUgXAEAADhEuAIAAHCIcJUDjBYEAKD1IFwBAAA4RLjKIWqwAAAofoQrAAAAhwhXOUCFFQAArQfhKkuW6AQAAKIQrnKIIAYAQPEjXOUAHdkBAGg9CFcAAAAOEa4AAAAcIlzlAH2tAABoPQhXAAAADhGucoiO7QAAFD/CVQ4QqgAAaD3SDlfGmBJjTFc/CgMAAFDoPIUrY8zLxpiuxpjOkmZLmmuM+YO/RQMAACg8XmuuBlhrt0m6XNIHkg6Q9D2/CpUvZqys0IE3D9OGbdWJH+ShyY9mQQAAWg+v4aqtMaatQuHqHWttrVrBesTPflGuBiuNXrQp6KIAAIAC4TVc/VtSuaTOkkYZY/pL2uZXofy0c3eddtXUB10MAABQpDyFK2vtQ9ba/ay1l9qQ5ZLO9blsvjjyz8N1wt8+avx95ZYqrdhc5es+mUQUAIDWw2uH9hvCHdqNMeYpY8xUSef5XDbn1of7Tu2qbaq5OvOekTrr3pFxH29yUioAAFBMvDYLXhvu0H6hpB4KdWYf4lupfDJ0yqrGn6evrGh2X7JO667qnejYDgBA8fMariKVOJdKesFaO0cFWLHz5OiljT9f/shYNTQ0pZ3567a3fELBvUIAABA0r+FqijFmhELhargxpoukBv+K5Y+tVbXNfr/9vbmNP/tZqUSNFQAArUcbj4/7saTjJC211lYZY/aS9CPfSpUjz35R7ulxlnQEAAA88jpasEFSX0m3GmP+IelL1tqZvpbMB0vuujStx5uYdsE5ayoJWgAAICmvowWHSLpB0tzwv/8zxtzlZ8H8UFqSuBNVstBkJY1csEGDHhqjVyet9KFkAACgWHhtFrxU0nHhGiwZY56TNE3SH/0qWK7Fi1YmKost27hTkrQgpuM79VgAACCa1w7tktQ96udujsuRMwvvuCTu7Z/O2yBJamiwen3KKtXVR/XXt01Bi2ZBAACQjNeaq7slTTPGjFRogoKzJA32rVQ+atcmfp58Yfxy/e3yozR06irdOHSmZq+pbLZMTjazMpDHAABoPTyFK2vtK8aYzySdFL7pJmvtOt9K5bO9u7bX+m274963dWeNJOmZseVx7ycnAQCAZJKGK2PMCTE3RaY439cYs6+1dqo/xfJXfUP6EcmY7GcUpUkRAIDil6rm6r4k91kV4PqCknTWIb30xrTVce9LlaEyyUfZLNy8YXu1KqtqdcjeXTLeBgAAyJ2k4cpae26uCpJLd3/z6IThKh4r29ShPccNg2f8faRq6hpUPmRQTvcLAAAy46nPlTHmG3FurpQ0y1q7wW2R/Ne+TWnc2+sbrOK1GL4+ZbW+emwfn0sVX01dwa0yBABAq5bO8jenSRoZ/v0cSVMkHWCMud1a+4IPZcu5g/74ftzbJ5Zv8RSuzv3HZ7pwwN763YWHNRuVSFcrAABaD6/zXLWRdIS19pvW2m9KGqBQn6tTJN3kV+HyyZ/eniMpeVBatmmn/j1qqf43hVncAQBorbyGq37W2vVRv28I37ZFUq37YuUvL5VQiUYjrqmsdlsYAACQd7yGq8+MMe8ZY35gjPmBpHfCt3WWVOFb6fJQbM3Vzt11LR7z8bzm3dBoFQQAoPXw2ufql5K+IemM8O/PSXrdhiZuKsoRhV5d92LLqb5GLdwYQEkAAEA+8DpDuzXGjJFUo1BFzETLjJiSpAXrt6d+EAAAaDU8NQsaY66SNFHSFZKukjTBGHOFnwXLX+lnSnIoAACth9dmwVsknRSZ08oY00vSx5KG+lWwfEVOAgAAyXjt0F4SM1no5jSeCwAA0Gp4rbn60BgzXNIr4d+/JSn+jJtFbvGGHY0/vzh+uafnDJu51q/iAACAPOO1Q/sfjDHflHR6+KYnrLVv+les/DV5+dbGn299a3bKx89eXaknxyzzs0gAACCPeK25krX2dUmv+1iWojJq4UaddWgv7YgzDxYAACheSftNGWO2G2O2xfm33RizLVeFLETff3qiVm6pCroYAAAgx5LWXFlru+SqIIVmV019ysfsrKmTyUFZAABA/mDEX4Y+nEMndQAA0FKrDVcnH7BnVs8fu3izo5IAAIBi0mrD1Qs/Pjmr5w+dssrT44yhYRAAgNak1YYrk0VvqNmrKx2WBAAAFJNWG65KsqhQ+srDY9wVBAAAFBXfwpUxpp8xZqQxZq4xZo4x5ga/9pUJmusAAIAfPE8imoE6Sb+z1k41xnSRNMUY85G1dq6P+/QsV9GKDAcAQOviW82VtXattXZq+OftkuZJ2s+v/aWL0AMAAPyQkz5XxpgyScdLmhDnvp8aYyYbYyZv3LgxF8WJ7Nf/fTCFKAAArY7v4coYs4dCaxL+2lrbYskca+0T1tqB1tqBvXr18rs4OWVlgy4CAADIMV/DlTGmrULB6iVr7Rt+7itfUXcFAEDr4udoQSPpKUnzrLX3+7UfAACAfOJnzdXpkr4n6TxjzPTwv0t93F/WDtvb7TrV9LkCAKD18W0qBmvtGLXyVjH6XAEA0Pq02hna4/EjDDHlAwAArQvhKorrZjyaBQEAaH0IV1G+PGBv9dyjvbPtvTFtlSp31TrbHgAAyH+tOlwN+cbRGv7rsxp/Ly0xmnzrBc62/+/Pl+o3/53hbHsAACD/+bm2YN779sn7+74Paq4AAGhdWnXNVaygxva9PX21vnT3J6pvYHQhAACFrlXXXOWLwa/P0q7aelXX1qtze94SAAAKGTVX0WwwNUeR6RqotwIAoPARrqJEws0eOa49ikzYcMbfP9Wn89fndN8AAMAtwlUcf7z0iJzuz4SrriqqavWXd+bmdN8AAMAtwpWk3375UElNrYJtS3M7+Wf0LO4smQMAQGEjXKmpWS4SbKLjTfs2/h8i5nEHAKB4EK4UZ/2/qHT17q/OyGlZAupTDwAAHCFcRYkEm+imuU7tSn3fr4lKd4QrAAAKG+FKTeEmkmuiA06fbh2d7qts8DANn7NOklRT16Axiza1rDkDAAAFi3Cl0JqCklQSE3K+NbCfL/2hfvbCFEnSkA/m67tPTVBFFUvkAABQLJgOXNL3T+uvVVur9POzD5IkXX78fpqyfKtuvPgwX/e7ZOMOX7cPAAByj3AlqVO7Nrrj8qMbf+/QtlT3XnmsJMn61AmKBZ0BAChONAumYIzRY9ec4Hy7lzwwKu6MVtZaHfGnD3XrW7Oc7zOfbKuu1ezVlUEXAwAA5whXHhy1Xzfn21xTWZ3wvl219Xpx/IqU29heXetbzZrffvj0RH3l4TFBFwMAAOcIVx7kcjSf16i0YnOVjv7LCL04frmv5fHL1BUVQRcBAABfEK4K1LLNOyVJI+YW9kLPhVrzBgBAIoQrAAAAhwhXHrieSDQZrxU5zDsKAEB+Ilx5UFpidPg+XYIuRlGiVRAAUGwIV3lm3bbEowgBAED+I1x5ZAJYAPD1Katyvs9co+IKAFBsCFd57Hf/mxF0EQAAQJoIVwAAAA4RrgKUzRxPr05aEd6Gq9IEg3muAADFhnBVgFZuqdL7s9YFXQwAABAH4aoA1dQ3BF0EZ6i3AgAUG8IVAhHA4EsAAHKCcFWAorspWep+AADIK4SrInDi3z7Sk6OXBl2MjNCfHQBQbAhXRWDzzhrdMWxe0MUAAAAiXHlGFyF/0KwJACg2hCsEgrAKAChWhKuCRG0PAAD5inDl0c2XHt748wc3nBlgSYoLHdoBAMWGcOXRmYf0Uq8u7SVJe3ZuF3BpmhrVCCcAAOQXwlUaIkEm+AkwSVQAAOQrwlUaIosMlwSfrgqe4RgCAIoU4SoNkfqiEmN008WHq0+3DoGWpxjQrAkAKDaEqzT03CPU16q0xOi6cw7SuJvPD6QcFVW1gezXJeqtAADFqk3QBSgkz197ikYv2qhuHds62d7G7bszet4tb852sn8AAOAeNVdp2KdbB105sJ+z7c1ftz2j5+3YXdf4c6E3qzFDOwCg2BCuAAAAHCJcIVCFXvMGAEAswlURmbhsS9BF8IyZGAAAxYpwVeCi+yyt3FIVYEkAAIBEuHLmB6f1V9lenQItQyG2sBVCmaet2KqP5q4PuhgAgAJBuHLkr5cdpY7tcj+zhWHGKN99/dEv9P+enxx0MQAABYJwVYBsVC/wQp/KwNKjHQBQZAhXDlGH5B01bgCAYkW4KkCJFj2mFggAgOARrhzyc3qBy/41RjNWViR9TCFGq0IsMwAAyRCuHPjFOQdJ8jdczVhVqcseGauauobmfa5IJwAA5BUWbs5S+ZBBjT/noh/R8s07fd9HLhEOAQDFhpqrAlOfLI0UUlChPzsAoEgRrhxiSRcAAEC4KiIFOedVARYZAIBkCFcO5ariqpjyyGuTVwZdBAAAnCJcFZjYTvPRQasQO4ff+f68oIuQlvXbqlU2eJimrdgadFEAAHmKcOVSDjpdPf75Et/3kQuF2j1t7OJNkqTnxy0PuCQAgHzFVAwO5SIwvDltdQ72AgAAMkXNlUNBjxYswFZBAACKDuGq0EUlqkLscwUAQLEhXDlUqP2IAACAO4SrIpJonqsRc9apbPAwrdhcleMSJRZ0EyoAAH4hXDl03TkHS5L679UpZ/v0MnHoW9NDneBnra70uzgAALR6hCuHvjxgb5UPGaQT9u+Rs30Waj+rXCxyDQBAEAhXPjipbM9A9ltIQSu6xm3Jxh2auaoiuMIAAOAQ4coHV5/cT+9cf3rQxSgY59/3ub72r7FBFwMAACcIVz4wxujIfbvlZF82wc/5jmZBAECxIlwVk0JqFwQAoEgRrgqc9RCo8jFzMRUDAKBYEa58QnYAAKB1IlwVkUQVVNQSAQCQO4QrIA352MQKAMgvhCuf5Kq2qNlowQQXfgIBAAC5Q7gqcIUanAq1pZImVgBAKoSrVoBAAABA7hCuikiiaRkKtXYrHz0ztjzoIgAA8hzhyicmD6uL8rBIBWfW6sqgiwAAyHOEqwKXzvI31GABAOA/wlURSRSe8qHGavnmnSobPEwfzForKT9r9gAAcIFwVegKZPmb2au3SZLenbkm4JIAAOAvwlUrQmURAAD+I1z5aOjPT/N9HzNWNXWwdtXnasG67Vq8YUfmhSoA941YoB89MzHoYhScX70yTef947OgiwEAea1N0AUoZif27xF0ETy56t/jVFFVoxG/OVuSdNEDoyRJ5UMGOduHTRn9cuvhTxcHXYSC9O4MmnUBIBXClY+MMTq49x45qwVKNM9VU3ni3z5x2RYfSpOgDOG52WmhBAAUK5oFfRZkiKiurddtb8/Wturaxtvmrd2mDduqAywVAADFjZqrIvba5JV6ftzyZrdd8uBotS01WnTnpQGVCgCA4kbNVRFraIjfTFhb763/09NjlrksDgAArQLhyme5nP7AWqlyV23qB3p034gFzrY1fulmZ9ty6a/vzgm6CACAIkO4CkBpiT+J65WJK3TsX0fk5TQKL45f0fyGPOnRzkLMAADXCFcBuPjIfXzZ7tJNO0P/35h/4Qr+G7lgg656fFzC5mAAQG4QrnxmAqiiCXLdvpELNujT+etTPi7dEs5eXak5ayqb3bZhe7X+75VpqqqpS3Nrxen/Xp6mieVbtIPjAQCBIlwFIU+axPzwo2cm6dpnJ6d8XLp1K195eIwGPTSm2W3/GL5A78xYw8SWAIC8QrgKQo5abYKswSpkf313jn7x0pSgi5FX6uobNHTKqqCL0czWnTXauH130MUAgBZ8C1fGmKeNMRuMMbP92kchiOSbx645IXf7zNmeMmCa/S8vPTO2XO/PWhd0MdLmZ2Z/9oty/f5/M3zcQ/qO/9tHOunOj4MuBgC04GfN1bOSLvZx+wWl/16dc7YvKqzg2uadNUEXAQAKhm/hylo7SlLuFq0rJIQfp02WKZZUbDX4WAH5b/GGHdq8g+bsYhd4nytjzE+NMZONMZM3btwYdHF8Y3PV0apApFpkGgCK0QX3f65z/vFZ0MWAzwIPV9baJ6y1A621A3v16hV0cZwLolN5ol2mW5KdNfU578S8aP12PfbZkpzuEwByaXt1bqdLqayqVdngYRo2c21O9+tVXX1D0EVwLvBw1VrksqIm0dxamRTh35/7E3QShc5vPvaF/v7hfFXX1qfeBg1hAJDS0k2hiaWfGL004JK0NGLOOh18yweat3Zb0EVxinDls749OkqSOrYrDbgkmcl14111begbTCF3yl+/rVq3vDlLtUX4bQxAAcvD7hgfzwtNOj1zVUWwBXHMz6kYXpE0TtJhxphVxpgf+7WvfHbfVcfq0WtO0EG99mi87VsD+/m708h0Bw4Cil99oxKVrRj6pt3y5my9NGGFPluQvA/h/SMWaEKeLmgNALmUh7kvK36OFrzaWtvHWtvWWtvXWvuUX/vKZ107tNWlR/dpdttZh/ZS+ZBBOS9LJlkrqM97MTT5pQqmD326WN96YnyOShOc+garmjpq8YBc+erDY3RyvDng8rBJoBjO9fHQLNiKRF/qj799hP47aUXOy5Dqz6gYvr2UhF8k6yeHfO+pCTr01g+CLgbQasxaXakN8VYvyOMTbP6WLDOEqyLk5XvA1qpa3fJm/k6eX8jNg5Evh0w3EfLFEpo+kdyG7dUqGzxMI+dvCLooRYml0HKPcBWgrx27ry/bTfSHVBdTleLp7y3LfLB04w7NXeN9FEgxxJFINXcxvBYgF2avrpQkPT+uPNiCIDDpxL+LHxilnz4/2beyuNAm6AK0Zg9dfbzembEmZ/u7b8SCtJ+TaUA45a6P1aldGy3btDPu/cXcPFgS/spSyK8BKAS76+r1yMgl+sU5B6lD28IckY2QdE6X89dt1/x1230riwvUXBUhE/P/iOWbq5r9Xluf+dV/5ZaqpPev37Y7YbBKJpOmtHzLMJGaqwbSFeCrF8Yt10OfLNITo/Jv/qZ8lI9npGJtsSRcFTG//pBGL9qoM+8ZmdNat0LS2OfK5/2sq6z2eQ9AfotMNry7LvWkw0AuEa6QVLyapPlrQ9WxM1dW+Lhf3zbtu0ifNz87tA+fs06n3v2JPl9YvOtxAqkU8nkCxY0+Vzn0p68M0IG9Ovu+H5fVrF7PXUs37lB7B30eUu1vXWW19u7aXsaYvK1OjhTLzxP/9HCwnb26UmcfWnxrcgJwJ09Plc0UW1Cm5iqHfnzGATr3sN6+78ePSdl27q7Tk6OXqiHB5E3n3fe5Th/yqeftpRoanGgqhlPv/kTPjC33vJ8gNM1zlduzRZGdm7Jy3O0j9ODHi3Kyr5q6Br03c03RTb3xwvjl+sHTE4MuBopcvn5Jzhbhqoh5+czeO3y+p23d9f483TFsnj4KrwOVcZlShSoP16fxeb5kTEljs6B/+yjS85EzFVW1+ufHC3Oyr/tGLND1L08ruibaP701O+evKdM/mWKd5bvYff3RsXpl4sqgi+ELwlUr98jIJUnvjwSEbdV1kpo6kEabtmKr83JNX1mhBXk+1DahNGuupizfqlEOLmKFcHmx1jZ+hsoGD8toepB8syY8sKByV23AJWl9iquu0H/5Vrk6bUVF0EXwDeGqCFXV1DnblpeZ0r/+6BfO9hfxnf9M0EUPjJKktCYhzQfpTiL6zce+0PdbSfPLY58v0eF/+lBbdtZIkh7+dHHAJcpeIYRaFyqqahrfN8C1Ql6VIx7CVRH66QtTgi6CU5c+NDroIrRgrdVDnyzShu3Vstbqg1lrVVcfWpy4seUzB+eK6H4+hXBqentaaPqO9duYRqLQHHf7Rzrhbx8FXQxkoVj7N+UjwhWSWrlll16Z6H6B50L/G5+5ulL3f7RQ33tyon74zCRd99JUPfZZqIk109e2eMMOz48t1JNk07qLwZYDxSXXfw/VtfX67WvTC+5LQj7/3eVz2TJBuEJKN78xK+gi5J368KjJBeu3N3b6XVO5S1LmNUivTc6uY2em15clG3fo+NtHaE3FLufbbrGdSGf/PK1nS3YMgrZicxXNcjGCuiAPn7NOb0xdrTuGzQumAMh7hKsiNXXFVqdf51wPM3c6F1cAJ9h4+8y2HEFVRr06cYW2VtXqvZnpz7i/pmKXbnh1WtyBDvHkYg6wTI1auFFfGvKpPpi1NqPn+/2azrp3pE67+5OMnlu5q1a/e22Gdux21x8TQGKEqyL1DR86mbuQy4vryi1VqqjK/Tf9jENSBk+MPo6ZHtL2bUKTv+6ubUj7uX95Z47enr5Gny3wNtoxn5sF54QHTkxfVZHW83LZJLW7Lv33SJIe/WyxXp+6Ss+PK3dboCJnrdXpQz5NWKtcKHObFWo3gkJGuCpif3prdtBFCNSZ94zU+fd9nvHzywYPSzi8Pt7JKvY8u2N3necaHSn5XD27auq1cftuz9tKR7s2odNAphfudDStu5j6ojR3zTYNvONjbd7hz+tOqDCul3HNWVOpssHDVJ5g0XSv80EVSmiI8DM7rK7YpRuHzvRxD5AK+s8uLsIV0mKM0Z3vZ9/PIFffpDZn2Uclnbm2YgPD7e/N1Zf/6T3cJTsmVzz+hU668+Pkz/e8p+ZKw1PKZzejvLfnNk5T4eHh/x61RJt27NboRZuyKJd3xfDt/vUpqyVJH8dO9htzvO8cNjfpigrjl25xXbSkMp0ENF/77gGEKzS6+4N59MlwbOUW7x2kk11e5sTM9eXHjNR+X6a2V9dq1upKz/sqsMqTgrrQ/2f0Mq1O0nl/V60/54GvPjxGj4wsgrnNCjSJ5/NntDCPaGIs3IxG//58aVoXtJ01dXrui/IM9+btT2l3XeJmtUTnt5VbqvTFkua1HWMWbdKrk1boX985wXMJpcTNI750aM+kz1WCn73YmWazZbbGRNVA5XOzU7olK4iLQp4UctbqSs1aXalfnntw0EXxJNHHNJ8/v4Wq2I4o4SpP/PiMA/TUmGVBF0M1afS7yW5NKG9/Sh/P3ZD2ls+8Z2Sz39dvq9Z3n5ogSfrXd9LenGfZnhzSqY2KF8QitY5ez/sXPTBKq7bu0h8uOszzfr2UI5F8P3k2DbbI95JmoIBeUvmmnZqyfKu+eWJf70/KUU1SdW29Dv/ThzquX/ec7A+Fi3CVJzq1Kw26CElF+h4tXh/8en8j5qa3ePStUR37rbW+VenX1jfohlenaW1lYUwsuGpr82YhF5nCWqtt1XXq1rFt8selsc0CbYFBhr768Bht313nKVxl+5mdVL5F3Tq21aF7d/H0+Iqq0ACX6SsrsttxjrGwde4RruDJovDs4Q9luRZc04XS4RxcKS7VflRExLvgT1y2JatglVGzoIPX5jK8PPrZEt07fIEm/PF87d21Q8LHFWPtUF6/pAK6tm7PYb/PKx8fJ0kqHzIo7v35/JYiv9GhPU/k9Ym5iLg6zvG2U5JlSknn2fl6rRw+Z50kaV2KkOnlfcj1n0Smc3AVROdmzi9OFMJbXbCK7CJIuMoT+TyKww8uT1LpVnn7VWtSku1fk6uDEn55M1ZWaMLSzVltqqauQcf+dYTeTTF7e+whTXWEuUh5M2bRJi3Moin+jamrtDVqOpJUx33zjt16ZuyygrvO8XHKb9ZafTp/fVHWWCdCuEIzufrwx5sQ8+kMO/SnE0ytpJ01/oyQK81BzdWNQ2eott7boIPLHhmrbz0x3vP+N+3YrXlrm0/5UFFVo8pdtWlNKeFN/l4OV2ypCroIjb771ARd+M9RGT13+ead+u1rM/SrV6Z5fs4Nr07XX9+dq/lpzO8WJC9/+cPnrNOrGS4+X2xhIJOXs7Zyl8oGD9PYxZnPN/fyxBW69tnJGjplVeKyZbz1/ES4Qt64b8SCoIuQlZISt4GhocFqw/bmzWuvTV6lL5Y01Ua5qPGM1PwNnbJKlzw4utl9v/vfDG/byN+s5FnkOIyYu14rNqcfsLK9Ds9eXel5NvqnxyxT2eBhjQuIxxOZcX/9Nu/9ACt2hWq56urTfzEL12/PyzDysxemaHCcxecXpVkjuHH7bm2vbr5iQ32DTfoeFIPJ5VslhQJSpiILoqfzWSx0hKs8kYfnpKLk58k/65qrmKff/9FCnXznJ3FPSJFXUVFVqxuHztCuqNq4qSu2ZlWOaF5nR48c1mRHYFpUufI9jMWG2kRGL9qorY7Wr/zKw2P01YfHeHrsPcPnS/I2dUouTi2jFm7Uhf8clXANvlhe1vycsnxLwuWnXBiXZpP5SXd+rAvub16L+MHsdbrycbfruN45bK5ufqNpuZ2GBquJy3I7Y35cXKPSQrjKE3xu/Wuuy8a26vgjl+KFg8iIykzF9h37ZH5ojq94TagPh0dtPvtFuV6bvEqvTmr6VvmjZydlVY50pNPf7T+j02v2zXUtSLqBb3ddvb731ETPi1Z7scbjaNPI4InslizyLlWIW7ox9NmPXUkgkdvenpPyMd98bJx++MxET9vzK6x7ObpTV1Q43ed/Ri9rNofg02OX6ap/j9NnC9Kf8y8i0fGpq2/Q3BTvWeS5I7PYf0RVTb0+mLU26+0UAsJVwPr26JjyMWcc3DMHJSksmc4zk+6l6P89P7nx58hIOCk30ztEwoWXC0c215Z8r0XKV+l24ncpnXDl4u11PeDG68oAs8PLJSWUR1X+DT41ES5aHwquqUbgZuKe4Qt06UOjtdjDF8MqB19+H/1sia57aWrc9zXyVs5eHVp8PJuBHPmAcBWwq0/eP+VjUk3I6FKtz/0HXF3HyzftbNza5PKtKhs8LElTTvPXlGkZmoUrHy6licoVWzuUj/1apNC34HXhJkw/y/jqxBUatyS7UZCFLvKJaLChgQiPjFyceKmmDLbv9+jlYgz0lz0yVgf98X3n221I40tWuqaHa902eezr58r2BC0CkvTezFDN1kdpThadbwhXeSLZtSiX0zS8PCHzTou51Ka06Uzz5rTVkqST7/xEK1OM9Ip3nGvqGpIuYhsRHXLSnf5h/NLNKhs8TJPL86DvhE/uGDZP67d5O0lnc50Y/MYsXf0f76Mgi1HTnFxWv//fDN07fIGmrqjQxPLsQmekI/sDHy/KtojOVdXU6YlRS9SQpx3IZ8XUxkRqYGauqmi87aUJyzPevotZ1hNdZ5JtOajZ3Qs9gBOuAtZ4kkwSoApiksIca5NgZN7jny+Jc2vTY+Md51venKXTh3zauDafF+kG3oc+CV2srgjPCB1Py2bB0P+znj8rBVefrk/nZ98nA96UlkSaBUMLcEuhkWuzV7fsP5PO+7s7jbVFcyE6DNzz4QLd9f58vT+7ZZ8dvwJANhWwH89bH/5/09/FLW/OTvTwxGWI/MBloKAQrgJ29H7dJEnHJ1kItEObUt18yeE5KlFhaJNW4kh+hox01Kyq8R6u0p+41MM2Y9JVJMAV47pgXr4wRA4ZXy5aiu5zleqzZZX8L2DGygp95z/j01q0PVbkPfIaRjL5TG8LT4NQXes+AO7M4ZI76fIyEjfjbQc0lCrefvO1u0OmCFcBO/OQXhp/8/m6+Kg+6tIh8VKPPz7jgByWKv+VZjinVDZ/v9HX+FxMNFlI5xoXRbXW6r2Za+Je5Hfu9r9JKNsQl+zicNXj43Stw1GcJsPRgvFe4U2vz9QXSzZ76tScr5Zt2qEjb/swZbeARAbe8bHjEkXJ8g85EkTqAvrs5/q7TbGsVkK4ygP7dAstcHtQrz0SPibbdeuKTXqHI/mDN+0IzbkTdH+z2NcUmdrB77c+m+1n+tx4T/ts4UZd//I03fdRy8lk//7hfN31/nx9GDWoIJF8/AY8sXxL2s2myUaHRa+DmOo9iL577lpvUyXEytUhjZ3Wwib8pflNb01fo5019Y2dodO1K8HoxWwu9JHauWwPXeTY3/zGLM+jLNO1tnKXfvLcpLS6Rrj2xKilzX4v9Bp7wlUeSfZHSLZqLr1aBm+nt0yX33GlEE8miS66mVxQKqtCzT7xQkVkdNGuOMPBywYPy5tOzk+OXqpRC93Me/WXdxLPBRWpuPVScxX9iLenJ18jMlPpnp+yCvSZPzWv1NY36IXxy9OaviFZ+Pl0/nqVDR6mtZXel6qKfHzu/2ihPp63Qe+nOQdVXX2DBtz2oefJY5t23PImr3O8FQrCVT5JOJTaxg0TFx+5j7q0T9yUmI/emr5G787w5wSfrZSLDeekFPmzXz+lG4VSHYPoJpPoP6Odu+s8N3dF7yOz6QtCIya//3TiiS8jk21mq6nPlZPN5UT0iFxXXxZj50IqpC+hT49Zpj+9NTvlsjJea2JfnhAKODNXpZgbLI7Gwxazq23VtUnnFKyqrVdVTb1uf3du2vssdoSrPJLuebJ31/b65ol9fSmLn/70dvojZmIlOoe+FLdpL2q0YLKDHPCFKtGFwdMkollcVbKpMct0t/EuGC2aYOJ05E33Lfrxc5N0wf2fe3psOgMaMnXefd7KIkk7PZTHy4U313njG4+O1d0fzGtx+2//Oz3xkxIUMv7nJGRdZbWGz2k5F9LmHbs1LMPmwZb7z/y5qf42KsJL+2xLsMTPlY9/oW88OrZZgN68I/GyQdk177d88s7ddTrmLyNaNNc1e174/06b4gvoC0MyhKs8ku7n06iwvqlFpPM6f/ny1IT3vZLhQqKJjlnQf9PZvJXpnNx219U3W69we56NlIp7HKLmdYonOphFP2L8Um/zin2+cKP+MWJh8jLk0Nw125Ku69h0UUu9LTeDDTw+TlZTV1To35+3vCBnslRPs2fEvCmJ1nT8yfOT9cuXp3peBNtvmeaOSeVbNXVFRbNjcNEDoxI+PpP9NY7Ibfy96cnPjStP+fzGUaLed+n58YV4bYtGuMojqTpP3nRx8+kYgg4DQUrvDy/6wpt46Hqqk39wHcvT33Gydch++dI0nXLXJ42/R+bgylY6x8f1ZzfldAQpHjA+zUV84+7T0Yt6ecIKXfrQaDcb80HssXxr2uq0B4NkVFvq8fiu2hpqfkw1uq5Qrt1evzh5eT0JtxQ1QKJpv973mYdjSAJHuCoA/+/MAyVJx/bt1uK+QuwEvbsu+xEvmb7ubBbZnRVngkYvausbPI06SvSaYkNLbX3LbcVW6//wmcTD/iOTG7pkbZrfmH08Gce7GBVS36Tn06kx8Fqj5Gg6gHj7/PV/p2v+usTrwNXWN6iuPrO5qayV1sSsnpDqgp7NGfG1ySs1uXyLKqpqAh05Fy0XH92lG3e2uM1bd4TQ/1Od3wrxOpUtwlUeiXeyeOf603VEn66h++M8pxCrTl1MApjpVAzJmgpSXX/mZTiM/ZBbPvDUPJWwz1XM7/d/tDDu41zbujNx/46IzD9/6c7PlLz5YeT8DTroj+/rP6OWqjrOPFmpwkWilzF3zTY9OzbYUaTJJF3ZIYflSOaQWz7Qwbd8oEnlWzN6/peGfJr2KDYpswB/49CZuuLxcTru9o90alTtbiacHf94U1BYq88WbEgwSjbxC6+tb9D1L08Nr82afej2GprSmdIi3iMbGqyeGLUkJ/0iXSFc5ZF4n/PoD2/8+1unNOdHb/xpzpptCWeiztfJ62JrpVZv9X8CU8nbYq6Znpu99RUKPciY1CHuupemqr7B6s735+nnL0yJs63Exi3ZrEkJ1ny89KHR+kuCkVCxn5cbX5+ZvJA+SFRj+OToZfprVLmznyA16ueo270E8LjSLM60Fd6CmZG0YbubvlY7dtd5qkVMJdF5xeshiPf8d2eu1Q+fmaQXo9YqTPYWR+5bvGGH3pu5Vre+NTu8bTec9mePLFQddduwWWt11/vzdc+HLefAy1eFNY6/yLkeno6WXp20MmF1f9D9BhJdAGNvzVUxE02smEi2fa48HX8PjxmzuGVH8GTbLuRFoBO9rHXbqrUuatBCdA3F+fd9lmBbNsmAgaifrVXkU3n83z5q/riYp6czh1MyDbbla83Fl6G73p/v27azKX2kqXT11pZzWmVzHku/Y3roGbvrGvTapJW66qR+cR8XW8OVbhkj56J8aar1gpqrAhLvZFKIzYJOZDFD+4yoVeqjBb1obb69lb9JNnQ+LPrzl25n2MTbbHkksj02flyIgwzjTTO027TPAUvi9K9JRzov+6kxiYfxp7XPmJ2ed99n+uZjXzjZdr6L9zlrvC3qvY/XRDc5QY1sIkOnrGpsaky3n1SymttM/v4K/dpGuMoj8b41Jrp4Nd1f4J/ADG3Y5r3qPx+XQ0lHi7c4Ry8n24twMsnekpkJwq+U/kk6epmYQpGsc3is8+77PKNFweM+JsnFNNO/oURrcKZ71rKyzZ6zdOPOuH03m50vA27m97os0b3DF2hLkubVeKOYvb62Kx4fl/T+2E1PWb5VQ6eu8rRtv0SXacryLSobPEwzkkxkmq8IVwWstQYrKTRCyatP0lzTLSi3vxe/b0+hjLRJq1kwycU6XqjLdg3DRLuLdOyNlezSNX/dNlXV1GV86Z69Ov0ZtLOVzReM2Oems6nPHS0FlEnxK3fV6osliecKyyeZLpkU79yQbaSMLEPl5W8u9n2prq3Xhu0tl7Fp0SzocfR0ZD3ORHO+DfnAv2bbbBGu8kjKuXpaPL6Avo7nkUIJK4Xk9/+boeWbvXe0T+eTm90M8pFRhvH3uCXBRJSSdNPQls0cu+vqdfEDo3Xdi4knt03lKw+P0filmzMefRorF9+xmvW5SvLuxd6zckv8de5y8cXw2mcm6Tv/mRD3vukrK/SntxOv3eiHSGiJJ9nhSNos6HEb6fASfF6fsipu/6fvPz1RJ9+Z3SjLaKn6aj3++RJn+3KNcJVHHrr6eF123L66amD8JW3iNhv6XSg4V5lguYtEYk+a8U59f06yyG8uJOr8virByMbYj7K11lM4u+n1WWmVK1XNVZuS+H9BRtJ/4yxGG+mgPXHZFm3Ylnih2a/9a0zcRaYjvv3EeF3yYNNEoel+UUrVXaDl470OmY9zWx58h3v2i/LGsnnt1By7EHD0tAWjHdWoxdt2rMjxW7TBe3Nvs+fH3Wbo1uiPb7Im8NiQUlPXoIF3fJR03cBEpq3Yqt/9b0bcUbkTl3nr45UPnym/Ea7yyGH7dNGD3z5e91xxrH52Vmji0L32aJfw8cYY0pVjmZxs0jUmybImXvg9YsZljejUFRXx9xF1yZiwdLP+/uECPRgzU3x0MbKtbUx/FFRzZYOH6eGY8sVb1y5i5qrKpH3HYk3z+XPn5T0dl2CWeit3gxVcSPfLScQzX5Qnvf/SBzOfFX96nPc6naVhbnh1ekb7jc7MTXPBpd7jum3V2pRgncJU729V+EvDmMWbNHRK8v5ZtfUNOu3uT/T+bO/zlEXvvpB7vjAVQ5668eLD9d1T+6tPt46Nt3Xp0DbAErUOrpaCcSndKRGyVV3boIpdGc5f1Ch0ivzEw2zw33oi9VQIGfe5SrUmYRpB4b6PFurHZx7Q9NwUF7F0MkjV7jSnvYgKm64uQH97b67679XJzcZSiBR53tptGjFnvY7p183JdquS1BZG16LGe2/mZtFMmyy8zlxVoRFz1mnPzom/KCfftrfbXPPysUq1bFRFVa3WViau4U26/wIOVhI1V3mrtMSo357NT3Qn9u+hx645odlt9B9yKxdHc8iH81os6ZHMgx/nNvD95PlJOu3uTz09NtXn7+3pa+LfkaPaj8hSQYl2l+j2fP+rSrdZMBvWxplkypHLHxmrf368UPVxlnRKJNkaoA94/FtxfcySbW/s4s36aZwmtMz31bSzuB3as3xt6Q1MyWxb6RYx0ajTfEa4KjCXHN2n8edM5rhBcrnoaLtyyy79OkEzQGSm8OhRTjuzXPJhyvL05roZu9j7IsaZDndPe8LcLN8WGx61P6l8i96dEQp8789aq4nL0l+wuXGbqQagpPEi/Zw2YPGGHUmbkrdXN93naeb8JI9JdwHnyOLK6bz6oJsl4/G3SPGmYghp9neR1iS+qfuIxfNhGs17LsS+pEK63hGu0Op4WSbCbzUJFrK98vFxmr6yotkop2wWm5ak/4xaltXz/XDNk/FHcfklcjG58vFx+tUr0yRJv3hpasIZuBPWdOXJhb3ZNdXDZ/aViS0750ckqwmSwn2uohdudhAlImUO6lrpOsxm8rn4cM66jPeVbH9eipJoFGcqP09jlGx1bb3+9enitPeRL39j2SJcFTBjaBR0zct6ei4kO39scrQ2WsSHc9apLkGYy1aiT+C9wxdktNhutMhJ1pjmtSvZbCtbcWsMEj7W+06zWrIki+fu2F3X7B30UubI/hLNEZYJLx3u35mRoIk5D7w5Lf2JN5dmOEnvM1+Uq7ou1Lfs4ajw4upaYCVV1dTpvZnZ/f3+Z9RSPZtgEMHYxZu8DZyJ+UMrpOBFuCpw5x/RO+giFJVpCUa3OZfjs0Suz0njl27RL17KfC6oaLtq6rM+0afdDJloO1HvW5DzzMVdIiiDq2vsCMh4EtWUrKnMrPZDauqL1zjgwMNz6jNoQkzE9VsXWzO4q6Zeux0NRIkt69/em6vt1U0jJssGD9PKJH2SLvvXGN2UxqLi//58if789hzN8jDZbbIwXpXk9T8xaqlen7rac5ki6huCXaIsHYSrAndi/z1VPmSQvnTQXkEXpWDkQ22fo/VsPSukb3yxRi3Kfk6i+gabdC6iWF46wLs8ptnWzEnSbRlMilnX0PzymKi5yCb42ZW0jmWGBz6XfwMD/vyhHsqgSSweL525F6zb3vi42NA/Y1Wlp6AUsTXFCL9EXRrSlSwQRsSeq99KNEAmDxGuCtihe3dp/LmQL565lg+HKp2TnQuu+5j84X8zdMDNw5xuM5FSBx3hTrrz42aTdqYSXTMQrdl8Tx62M2dNZcrlblZuqdIvX06vli/eEclkxndrU3/ZiP3suKyxizQr7/R57rZYfp8DXJ6PF23YkfIxU1Zs1cxV7s4pyf7kfvfaDG/bSHF/4i8w6R+8nbvr9MDHC33r/pAJ5rkqQD33aK9NO3brgqgmwaAXKYU7yZZkyZTr8P2/FJMHulSSYBb1dC1Y732G7GufnRz/jrRqWKRBD41J+pCN23frzHtGptzULIcXzmhe+1j50QRaNrgpnN/8hveZ913VCPnllYnpjZh0YenG1AHMlehFphN9LLzUSqU6KRljPDd13//RQj01Zpn2695RVw7s5+1JPiNcFbIcznVTTPKhWTCZG+OsaZevNvo4ACBy4U81C3QuNRs15+Bv7qQ7P/b0uK/+K3FIm7Mmm8kv03/O+m3Vzic0dtXU5JmPJ8x0gmKs6OCSTL6f78+8Z6QO7Nk56WO8tNLHGzATb9BRZPLYnH+OkqBZsJDl+R8Y8odfzZBe1xIrFv/8aGHjzy5naM9GNjP4L1jnrTYv+rW8Njl/wm6mgjh1euk75XWFiNjy5+O48aUpRpNm2tqS7AtJPoVOwlUBildVytI43uViotB8c+Xj4yRJQz6IP69TPppUvjXoIrTw3LjljT8HeiJ39BEet3RziwWOUwlylKQrQbyE33roq+T11JRsslYXry0X58hENVeZTM4bXdzVFbv0t/fmpjWAxQ+EqyJxzxXHBF0EFIDHP18SdBE8WbJxh7Oh7PE88PHC1A9KItkadhHDM5wkMt/ETsVQBNkqb2VaA1Uf0JuSzV6rUgxiSOdIREbbvj19tX773+l6aswyTV0R7JczwlWR2LNzO5UPGRR0MQAnzr/vc1+373UNumQqd8UfURjxfFQtl2tB1r0Warb6cHZT2M3XAUCZVhh9NLdpgXQXr63C46Ca6P2m67kUfx/GeD8ekSWtJpVv1bZw0Aq44opwVYh+ec5BkqSuHWkKRPHKz8tfk9o86jzrJxv+LyLVcjkRuZ5eIZV126q1K1zj+MjI/KzBzZcOCy6ndci1yJQkQTdfE64K0A9PP0DlQwapQ9vSoIuCAjIt4GpyuPHKxBVakuHSKS54vWYd+efh/hYkA+WbgztuXrjo6lTozbbRocjL4Ui09BA1VwBy4uuPfhF0EdKS7xeJzTvcz0fmRTZD/TOxaP2OZtWIM1ZV5HT/LqUzkWwQXHQkz/e/m2TqG2xjc6GRt7D5m//GHygQdNMv4QoAMvBhkXRYT2XCss3Nfp+2okITlm5O8Oj8l89ld9EsOCzLBdOD9Pb09NcbTIiaKyC38qVfA1AIrG15nVpdkfmizUH7z+ilQRchMQcnp0/nb8h+IwGprm3qx/jKxJVZ1eTRLAgAcXjtOA1/NdiWTU1BX7iKUdngYaqpax2DJBIpjUok6SxXFU/Q5w/CFQAgoXh9Vxqs1UKPs7vDO6/L3xQrl5OXjlm8ydm2MkG4QquTalkGAE1CzYI25jarv7w7N6ASFa+3p68JugiBKnEYrp4YFWzzL+EKQF6i5Sk/rK3c1aIZkGZB+KG0iBJJEb0UAEWFC3heeHH8ihbrtGUzMzeQyNTlFUEXwRnCFYC8VNNKZkAvBPUx4aqQR6QxTiJ/vTC++ZI4OVg/2jeEKwBAUkEtDIzWLdOFrPMB4QoAkFRss2AhK+TaEBQOwhUAIKnFG3YEXQS0QoUchAlXaDSwf4+giwAgD1330tSgi+BMRVVt0EVAK0C4QqMrTuwbdBEAwFeTl28NugjwaMgH84MuQsYIV0WqV5f2QRcBAIBWiXBVpH5/4aFBFwEAgFaJcNVK9e3RsdnvN118eEAlAQCguBCuWoF4tVh7tG/T7Pc2JaagR2YAAJAvCFetwPXnHdLittg+WUEHq0e+c0KwBQAAwBHCVZFKd2Zbl6uRR3RuV+r5scW0YCcAoHXjktYKnVTWQ3+77Khmt51y4J5ZLzWwd1dGKAIA0Cb1Q1CQjPTij0+JG3ie/MFJ6taxrUqM1GClGbddqG6d2mrO6m1ui5BGbRhLlwEAigU1V0XmoF6dJUmXHbevzjikpw7Zu0uz+4f93xnq1rGtpFCwkqRO7cPNd45bBtPZXLKly16/7ktZlwUAgFwhXBWZD244S7P+cqHat2nZ3+mo/brqyH27tbg9k/5WH/76zBa3ZVP71JDkySf276HRN56b+cYBAMghwlWRademRF06tG1x+/y/Xaw3f3F63OeUhLOVl4j1g9P6a8ldl+rwfbq2uO/E/j1066Ajmm5IssEFd1ys9m2aPn7JwpUk9duzk4fSAQAQPMJVK9GhbanaxgzJu/eKY7T/np2S9o3aPybUtGtTotJwGnvieyc2u699mxJ1DI8QvPrkfknDWvs2pWoT3s715x5MnysAQNGgQ3srduXAfrpyYL+kj7Fqnnqig1hsHioxRqXh+xsavJfjZ2cfqJq6NJ6QA/t176jVFbuCLgYAoABRc4VGPeMs9hxbo2SS3Hfu4b0b+2/VW5tytGDksVbSXntkNo1D7DI+rrzy/071ZbsAgOJHuEKjcw7tpWP6Nu/wHpuPzjq0V9znHtu3m7567L4qKYnUXNnG5w75xtF68vsDWz4pfH82TYI3ZrEm4rH9ujf7/Q8XHdb4897dmLNLUuPIUgCAd4QrNDLG6I7LQ5OLfv+0/nEfc/rBPRt/jvSZkkJ9uqSmmdajO6hfeOQ+umDA3ol3nEW4Oq5v94yf2z7JtPClAa4HdN7hvQPbdyxbQJ3hOqWxIgAA+IlwhWaO6dtd5UMG6fj9u6d87LmH99aJ/Xs0u+3iI/to0NF9dNMlhzc2ISa6QPcMNwWaLD6F2WSgI/p0aTZiMVppSfMNz7jtwqTbuuvrR0uSunfKvqbn6R+elPU2XPErW52doAY0G9efd7DzbQJAJghXiOvo/bpLki49qk/Cx5SWGP3+wsOa3daxXakeueYE9enWsUWfq8NiJjR98Sen6O5vHK2ucaaOkKSvHbuv3vvVGY2/33PFMfrbZUc2/n79uQerb4+Oeu9XZ+iUA/b09Lqi3TJogJ75UVOQiS5udNkvP25fdUsRmk4O73/Pzu087btPtw5plDR9Q75xtJPtpJoiIxPP/ugkPXftyc7nLguythEAovkarowxFxtjFhhjFhtjBvu5L7h1cO89tPSuS3XTxYfr2tMP0FmH9kq6EHOyS3Dkvg9uaD7x6H7dO+rqk/dv8fgPf32mzj+8t+654hgdtV9TH7CrBvbT904r05+/OkDfOWV//f6iw2SM0VH7ddN/f3Za4+PaeVgF+q6vH612bUqaTbZ6clnzgPa9U0NNo3/+aijQ/fBLZXG3VWKamki97FtSY/OrH741sJ++HXVcTyprXrv4i3MO8jzrvR8VV+ccFmr2TGfusq4dUg9srks2zX/AYipCddlx++qT350d97Ef//YsLbv7Uj3wreMktXz/0nXmIaGm/BsvPkyL77xEI35zVlbbQ25cNbBv48+JmryX3X1proqDNPkWrowxpZIekXSJpAGSrjbGDPBrf3CvpMSopMTotq8O0PPXnqw5t1/c4jGdw0vn9Ioz0rCpWbBpe9edc1BjE1qse755jF6/7ks6fJ+ueuqHJzX244r1o9MPiLuN8iGDNOPPF2rqbV/Wv793ov52+VH6T7yO9Gq64ETK/+UBe2tgTLi67asDNP7m89UjXBv1h4sO0+8vPFQ3XXy4zju8t3ru0S68jTbqv1cn3XD+IS32d9XAvvrmCX0V6/wj9lb5kEE6sFdnXXr0Po23x858f9R+LSdrjfXij0/RTeGO/a/+9FTd8fXmwe35a0+JKVM/tS1tfrV/6SenNKsV3H/PTjr5gD31yHdO0JH7Ji7DqD+cq99ccKjuv+rYFvd9/NuWF/FHrzmh2e8/OeMA/eWrA3TroCP0jRP2S7if6trQVB2f/O5svf3LlpPhdmhbErcpO9EAjFijbzw37qoDrkSvgnBM32568NvHJxwscHDvLjLG6PLj91P5kEGNXwAiYT9dA/uHPtf7dO2gNqUlOjSmBrlQxQscQ39+WpxHehf7dxGE8w7vrbd+ebq+G/V+X3f2QXEfa4zRwjsu8b1MPzv7QN/3UWz8nOfqZEmLrbVLJckY86qkyyTN9XGfyLFj+nbXvVcco4uP2qfFfX+46DANfmOWunZs+pjdlGR031UnJZ9zy4vIBeuiI5vK8//OPED/Gb1MD3zrOH04e52+dXK/xlqTw/fpqke+c4LOPix0ES4fMqjxeW1LS7RPVPNd5/ZtdP15h0iSrtNBWlu5S6fd/anuveJYGWP0my8fKikUADqGJ23t3qmt6husXp+6Sgf16qwlG3c2K++nvztHkjRl+VaVGDXOfP/DL5VpYFkPdevYVt97aqKe/uFANTRIvbu2V9cObTV/3Xa9OH65xizepDMO6anTD95L155R1mLZo2P7dVfHdqUa9n9naNBDYyRJZT07a97a5ot0n35wT51+cE899Olibdy+Wz8/+yB955RQ7deJZT30yMjF+v2Fh6m+weo3/52uzTtq9LXj9tX+e3XSDRccosqqWh2+Txc9fPXx+sVLU7Voww4d3LuLyocMUtngYZKk8Tef3+x4StKtX2n6vlVb36A3pq6O+77+6Iwy/fvzpTqwZ2cZY/TBDWfq1rdm64+XHqFO7Up1RJ/QcfvoN2dpwrItuvWt2ZKkWy49QqMWblTPPdpp044aSaGaoBmrKhvnVpt4y/nq3aVlM+2j15ygX7w0VZI0/NdnaeSCDXp5wgqt2FIVv4ynl+mZseVx7/vuqf01dMoq7dhd1/jFINIc/vsLD9U/RiyM+7zQMTpCt745WzdferiuOXV/XfzA6ISPjefn5xyoXl3a6/LjmsLrAT07a9mmnS0ee/25B+tfIxdLkh675gRdF379x/brrn9ccYy+/M9Rics56Ai1b1uqP701W5cctY8+mL2uxWMuOWof7dOtg645ZX9dcH/zbf3+wkPVtrRE5x+xt7p1bKtO7Up12SNjtXjDjrj7u3DA3npr+ppmtw0s21O3DjpCFVW1ja8jHY9ec6K6d2qrKx8fl/RxbUuN3vzF6erQtkT99uykMYs26cfPTU57f/HcePFhLVbAiPflNaJdgn6jEd84Yb+Ef1fRvndqf70wfrm6d2qriqraZvfdfMkR+vrx+zV+9gb276HJy7em3ObPzj5Qq7fu0sqtuzRjZUXcx3z/tP46dO8ujX+zycy9/SINuG14s9sG9OmquTHnM6nlJNe5ZvwaDWSMuULSxdban4R//56kU6y118c87qeSfipJ+++//4nLly/3pTxo3dZU7NK+3f2ZE8uLlVuq1L1TW7VvU6r6Bts4k3026husqmvr1bl9/O9I26pr1T6q6XNdZbVWV+zSif17yFqrJ0cv086aOl198v7au2soXOyuq1ddvU24TS8qq2q1fnt1Yw3J1p016tC21NNrnlS+Rft07aDddfX6fOEmHdO3m/bs3E4H9dpD1sPcaRHvzVyjA3p21pH7dlN1bb3alZZoW3Wtauob1LtLB1lrdePQmbrwyH305aiRrE+MWqIZKyvVYK0e++6JmrWqUp3al+qgXns0PmbD9mq1b1OqP74xS+cd3ltVtfXq272jzj28txau365VW6v06fwNOvmAvdSxbalmr67U9ecd3GKFhGhLN+7Qs1+U69ZBA1JeLFdX7NIf35ilGy44RJ8v2Kgj+nRR907tdHLZniopMVq8Ybu6d2qn574o19eO3bfF4u2xausbVFVTr5q6hhYX8Q9nr9PBvffQwb1Dr3/DtmrtrmtQ5a5ajV+6WecfsbemrdiqHp3a6dzDe6u+wWr55p3q1aW9vvvkhMYvTFec2FcvjFuuK0/s19h/sb7Bak3FrqTNw9NXVuj2d+foa8fuqwsG7K2ObUs1bNZaHdGnqwb06aqfvTBFFx25t845rLeslfbfq2lbG7ZXq11piVZsqVKndm20vbpWu2rqddMbM7X/np30p68MUJ9uHRuPQWSAjbVW//p0sQ7qvYcmLtuiH36pTJW7anVsv+6asbJC1bX1OuXAveK+L0+OXqoffqlM+3bvqKFTVung3nto+ooKfeeU/VVVU6/ddfWNNYgRQ6es0qqtVbr06D567LMluveKYxrvr6qp0+tTVum7p/bX5OVbddS+3TR1xVbd8Op0PXftSY1rxW7esVvvz16n5Zt26sj9uurcw3qrtMSott6qR6e2sjZUvtr6Bm2tqtHO3fU669Beqm+wuuyRMXr46hN0QM/Oen/WWp1+cE917dBGD36ySBcduY86ti1VWc/OkqSZqyq0dONOfeWYPlpdsUvrKqv11vQ1Or5fd41csEEn9u+hA3p2VmmJUZuSEp1xSNPo8uraeq3aWqUuHdpqw7bdOmq/rho+Z73OP6K32paWaOWWKo1csEFnHtJL++/ZSYNfn6n/TVmlC47YW3d9/Sj1jjpHTVi6RZPKt+jrx++n/nt11q1vzVavLu01dvEmXXf2QclHpztmjJlirW3RRBJ4uIo2cOBAO3mym/QPAADgp0Thys8O7aslRbfz9A3fBgAAULT8DFeTJB1ijDnAGNNO0rclvePj/gAAAALnW4d2a22dMeZ6ScMllUp62lo7x6/9AQAA5AM/RwvKWvu+pPf93AcAAEA+YYZ2AAAAhwhXAAAADhGuAAAAHCJcAQAAOES4AgAAcIhwBQAA4BDhCgAAwCHCFQAAgEOEKwAAAIcIVwAAAA4RrgAAABwiXAEAADhEuAIAAHCIcAUAAOAQ4QoAAMAhwhUAAIBDhCsAAACHCFcAAAAOEa4AAAAcMtbaoMvQyBizUdJyn3fTU9Imn/eBljjuweC4B4PjHgyOezBa83Hvb63tFXtjXoWrXDDGTLbWDgy6HK0Nxz0YHPdgcNyDwXEPBse9JZoFAQAAHCJcAQAAONQaw9UTQRegleK4B4PjHgyOezA47sHguMdodX2uAAAA/NQaa64AAAB8Q7gCAABwqNWEK2PMxcaYBcaYxcaYwUGXp9AZY542xmwwxsyOum1PY8xHxphF4f/3CN9ujDEPhY/9TGPMCVHP+UH48YuMMT8I4rUUEmNMP2PMSGPMXGPMHGPMDeHbOfY+MsZ0MMZMNMbMCB/3v4ZvP8AYMyF8fP9rjGkXvr19+PfF4fvLorZ1c/j2BcaYiwJ6SQXFGFNqjJlmjHkv/DvH3WfGmHJjzCxjzHRjzOTwbZxnvLLWFv0/SaWSlkg6UFI7STMkDQi6XIX8T9JZkk6QNDvqtnskDQ7/PFjS38M/XyrpA0lG0qmSJoRv31PS0vD/e4R/7hH0a8vnf5L6SDoh/HMXSQslDeDY+37cjaQ9wj+3lTQhfDxfk/Tt8O2PS7ou/PMvJD0e/vnbkv4b/nlA+PzTXtIB4fNSadCvL9//SfqtpJclvRf+nePu/zEvl9Qz5jbOMx7/tZaaq5MlLbbWLrXW1kh6VdJlAZepoFlrR0naEnPzZZKeC//8nKTLo25/3oaMl9TdGNNH0kWSPrLWbrHWbpX0kaSLfS98AbPWrrXWTg3/vF3SPEn7iWPvq/Dx2xH+tW34n5V0nqSh4dtjj3vk/Rgq6XxjjAnf/qq1dre1dpmkxQqdn5CAMaavpEGSngz/bsRxDwrnGY9aS7jaT9LKqN9XhW+DW3tba9eGf14nae/wz4mOP+9LFsJNHscrVIvCsfdZuGlquqQNCl0klkiqsNbWhR8SfQwbj2/4/kpJe4njnokHJN0oqSH8+17iuOeClTTCGDPFGPPT8G2cZzxqE3QBUJystdYYwzwfPjHG7CHpdUm/ttZuC305D+HY+8NaWy/pOGNMd0lvSjo82BIVP2PMVyRtsNZOMcacE3BxWpszrLWrjTG9JX1kjJkffSfnmeRaS83Vakn9on7vG74Nbq0PVwUr/P8N4dsTHX/elwwYY9oqFKxesta+Eb6ZY58j1toKSSMlnaZQ80fkS2r0MWw8vuH7u0naLI57uk6X9DVjTLlC3TnOk/SgOO6+s9auDv9/g0JfJk4W5xnPWku4miTpkPAIk3YKdXR8J+AyFaN3JEVGg/xA0ttRt38/PKLkVEmV4arl4ZIuNMb0CI86uTB8GxII9x95StI8a+39UXdx7H1kjOkVrrGSMaajpC8r1N9tpKQrwg+LPe6R9+MKSZ/aUA/fdyR9Ozyq7QBJh0iamJMXUYCstTdba/taa8sUOm9/aq29Rhx3XxljOhtjukR+Vuj8MFucZ7wLukd9rv4pNJphoUL9JG4JujyF/k/SK5LWSqpVqB39xwr1bfhE0iJJH0vaM/xYI+mR8LGfJWlg1HauVahz6WJJPwr6deX7P0lnKNQXYqak6eF/l3LsfT/ux0iaFj7usyXdFr79QIUu0osl/U9S+/DtHcK/Lw7ff2DUtm4Jvx8LJF0S9GsrlH+SzlHTaEGOu7/H+kCFRlfOkDQncs3kPOP9H8vfAAAAONRamgUBAABygnAFAADgEOEKAADAIcIVAACAQ4QrAAAAhwhXAPKKMWZH+P9lxpjvON72H2N+/8Ll9gFAIlwByF9lktIKV1GzdifSLFxZa7+UZpkAICXCFYB8NUTSmcaY6caY34QXTr7XGDPJGDPTGPMzSTLGnGOMGW2MeUfS3PBtb4UXnJ0TWXTWGDNEUsfw9l4K3xapJTPhbc82xswyxnwratufGWOGGmPmG2NeMtELOQJAHCzcDCBfDZb0e2vtVyQpHJIqrbUnGWPaSxprjBkRfuwJko6y1i4L/36ttXZLeKmaScaY1621g40x11trj4uzr29IOk7SsZJ6hp8zKnzf8ZKOlLRG0liF1rsb4/rFAige1FwBKBQXKrR+2XRJExRaiuOQ8H0To4KVJP2fMWaGpPEKLRx7iJI7Q9Ir1tp6a+16SZ9LOilq26ustQ0KLTdU5uC1AChi1FwBKBRG0q+stc0WfjXGnCNpZ8zvF0g6zVpbZYz5TKE15zK1O+rnenHeBJACNVcA8tV2SV2ifh8u6TpjTFtJMsYcaozpHOd53SRtDQerwyWdGnVfbeT5MUZL+la4X1cvSWcptPAvAKSNb2AA8tVMSfXh5r1nJT2oUJPc1HCn8o2SLo/zvA8l/dwYM0/SAoWaBiOekDTTGDPVWntN1O1vSjpN0gxJVtKN1tp14XAGAGkx1tqgywAAAFA0aBYEAABwiHAFAADgEOEKAADAIcIVAACAQ4QrAAAAhwhXAAAADhGuAAAAHPr/qSZuNssjKi8AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "############ Training Accuracy Using MLP #################\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      0.95      0.97      5546\n",
      "           1       0.99      0.98      0.99      6053\n",
      "           2       0.97      0.97      0.97      5320\n",
      "           3       0.93      0.99      0.96      5194\n",
      "           4       0.97      0.98      0.97      5229\n",
      "           5       0.98      0.94      0.96      5064\n",
      "           6       0.98      0.97      0.98      5403\n",
      "           7       0.97      0.97      0.97      5727\n",
      "           8       0.95      0.96      0.96      5248\n",
      "           9       0.94      0.97      0.95      5216\n",
      "\n",
      "    accuracy                           0.97     54000\n",
      "   macro avg       0.97      0.97      0.97     54000\n",
      "weighted avg       0.97      0.97      0.97     54000\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x864 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Use the same utility functions defined in the previous question\n",
    "# WRITE CODE HERE\n",
    "\n",
    "from sklearn.metrics import classification_report, confusion_matrix\n",
    "print(\"Plot of training Loss is as follows: \")\n",
    "mlp.plot_loss()\n",
    "\n",
    "\n",
    "print(\"############ Training Accuracy Using MLP #################\")\n",
    "y_train_pred =mlp.predict(train_imgs.reshape(train_imgs.shape[0],-1))\n",
    "print(classification_report(y_train_pred,train_labels))\n",
    "plt.figure(figsize=(10,12))\n",
    "sns.heatmap(confusion_matrix(y_train_pred,train_labels))\n",
    "plt.show()\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "RH22BqefpdZ4"
   },
   "source": [
    "### Find the accuracy on the validation set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "############ Validation Accuracy Using MLP #################\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.99      0.94      0.96       655\n",
      "           1       0.99      0.98      0.98       713\n",
      "           2       0.95      0.97      0.96       602\n",
      "           3       0.92      0.98      0.95       590\n",
      "           4       0.97      0.97      0.97       545\n",
      "           5       0.96      0.93      0.95       552\n",
      "           6       0.97      0.96      0.97       590\n",
      "           7       0.97      0.94      0.96       596\n",
      "           8       0.92      0.93      0.93       570\n",
      "           9       0.93      0.96      0.94       587\n",
      "\n",
      "    accuracy                           0.96      6000\n",
      "   macro avg       0.96      0.96      0.96      6000\n",
      "weighted avg       0.96      0.96      0.96      6000\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 720x864 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# WRITE CODE HERE\n",
    "print(\"############ Validation Accuracy Using MLP #################\")\n",
    "y_val_pred = mlp.predict(val_imgs.reshape(val_imgs.shape[0],-1))\n",
    "plt.figure(figsize=(10,12))\n",
    "print(classification_report(y_val_pred,val_labels))\n",
    "# sns.heatmap(confusion_matrix(y_val_pred,val_labels))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "7wMDvvA4pdbN"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#### training Started ####\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  0%|                                                    | 0/20 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:1   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  5%|██▏                                         | 1/20 [01:25<27:10, 85.84s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 1 is  0.0010416226253118666\n",
      "epoch:2   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 10%|████▍                                       | 2/20 [02:58<26:54, 89.67s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 2 is  0.0001674336388945541\n",
      "epoch:3   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 15%|██████▌                                     | 3/20 [04:27<25:24, 89.66s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 3 is  7.315402871315158e-05\n",
      "epoch:4   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 20%|████████▊                                   | 4/20 [05:54<23:35, 88.46s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 4 is  3.930303325185847e-05\n",
      "epoch:5   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 25%|███████████                                 | 5/20 [07:20<21:55, 87.73s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 5 is  9.771428521077042e-06\n",
      "epoch:6   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 30%|█████████████▏                              | 6/20 [08:47<20:20, 87.19s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 6 is  9.771428521077042e-06\n",
      "epoch:7   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 35%|███████████████▍                            | 7/20 [10:12<18:46, 86.66s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 7 is  2.7247563663124197e-06\n",
      "epoch:8   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 40%|█████████████████▌                          | 8/20 [11:38<17:16, 86.38s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 8 is  1.4386375770669702e-07\n",
      "epoch:9   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 45%|███████████████████▊                        | 9/20 [13:06<15:54, 86.81s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 9 is  1.4386375770669702e-07\n",
      "epoch:10   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 50%|█████████████████████▌                     | 10/20 [14:36<14:39, 87.91s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 10 is  7.618698383282663e-09\n",
      "epoch:11   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 55%|███████████████████████▋                   | 11/20 [16:04<13:10, 87.78s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 11 is  7.618698383282663e-09\n",
      "epoch:12   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 60%|█████████████████████████▊                 | 12/20 [17:31<11:42, 87.82s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 12 is  7.618698383282663e-09\n",
      "epoch:13   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 65%|███████████████████████████▉               | 13/20 [18:55<10:06, 86.64s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 13 is  4.513532125827169e-09\n",
      "epoch:14   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 70%|██████████████████████████████             | 14/20 [20:19<08:34, 85.68s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 14 is  1.5180264156811063e-09\n",
      "epoch:15   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 75%|████████████████████████████████▎          | 15/20 [21:43<07:05, 85.13s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 15 is  1.5180264156811063e-09\n",
      "epoch:16   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 80%|██████████████████████████████████▍        | 16/20 [23:08<05:40, 85.11s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 16 is  2.4107666973804954e-10\n",
      "epoch:17   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 85%|████████████████████████████████████▌      | 17/20 [24:32<04:14, 84.90s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 17 is  2.4107666973804954e-10\n",
      "epoch:18   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 90%|██████████████████████████████████████▋    | 18/20 [25:56<02:49, 84.51s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 18 is  6.798792639983731e-11\n",
      "epoch:19   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 95%|████████████████████████████████████████▊  | 19/20 [27:25<01:25, 85.93s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 19 is  4.831157696116861e-12\n",
      "epoch:20   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████| 20/20 [28:50<00:00, 86.50s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 20 is  4.831157696116861e-12\n",
      "Minimum Loss:  4.831157696116861e-12\n",
      "#### training Done ####\n",
      "\n",
      "#########validation Started###########\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Batch size: 20, Learning rate: 0.01, Val loss: 0.24971678913742026, Val accuracy: 0.9615\n",
      "\n",
      "#########validation Done###########\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "#### training Started ####\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  0%|                                                    | 0/20 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:1   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  5%|██▏                                         | 1/20 [01:21<25:40, 81.06s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 1 is  0.02114657130335786\n",
      "epoch:2   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 10%|████▍                                       | 2/20 [02:42<24:19, 81.09s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 2 is  0.004071801649244798\n",
      "epoch:3   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 15%|██████▌                                     | 3/20 [04:04<23:11, 81.83s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 3 is  0.0029937710008960928\n",
      "epoch:4   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 20%|████████▊                                   | 4/20 [05:26<21:47, 81.74s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 4 is  0.0010397891296398142\n",
      "epoch:5   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 25%|███████████                                 | 5/20 [06:47<20:21, 81.45s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 5 is  0.0003826938029020432\n",
      "epoch:6   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 30%|█████████████▏                              | 6/20 [08:08<18:59, 81.43s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 6 is  0.00017559442018249882\n",
      "epoch:7   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 35%|███████████████▍                            | 7/20 [09:30<17:38, 81.46s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 7 is  4.0107928294155216e-05\n",
      "epoch:8   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 40%|█████████████████▌                          | 8/20 [10:51<16:15, 81.31s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 8 is  3.1680980992163656e-05\n",
      "epoch:9   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 45%|███████████████████▊                        | 9/20 [12:14<14:59, 81.80s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 9 is  3.1680980992163656e-05\n",
      "epoch:10   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 50%|█████████████████████▌                     | 10/20 [13:35<13:37, 81.77s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 10 is  3.1680980992163656e-05\n",
      "epoch:11   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 55%|███████████████████████▋                   | 11/20 [15:04<12:33, 83.73s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 11 is  1.606521189028598e-05\n",
      "epoch:12   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 60%|█████████████████████████▊                 | 12/20 [16:29<11:13, 84.16s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 12 is  4.0223345478196396e-06\n",
      "epoch:13   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 65%|███████████████████████████▉               | 13/20 [17:52<09:47, 84.00s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 13 is  3.119141594147834e-06\n",
      "epoch:14   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 70%|██████████████████████████████             | 14/20 [19:16<08:23, 83.86s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 14 is  1.5517241657647674e-06\n",
      "epoch:15   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 75%|████████████████████████████████▎          | 15/20 [20:39<06:58, 83.76s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 15 is  1.5517241657647674e-06\n",
      "epoch:16   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 80%|██████████████████████████████████▍        | 16/20 [22:02<05:34, 83.55s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 16 is  1.5517241657647674e-06\n",
      "epoch:17   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 85%|████████████████████████████████████▌      | 17/20 [23:25<04:09, 83.28s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 17 is  1.5517241657647674e-06\n",
      "epoch:18   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 90%|██████████████████████████████████████▋    | 18/20 [24:49<02:46, 83.49s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 18 is  2.8591068197414414e-07\n",
      "epoch:19   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 95%|████████████████████████████████████████▊  | 19/20 [26:11<01:23, 83.09s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 19 is  1.0511632922316494e-07\n",
      "epoch:20   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████| 20/20 [27:34<00:00, 82.71s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 20 is  1.0511632922316494e-07\n",
      "Minimum Loss:  1.0511632922316494e-07\n",
      "#### training Done ####\n",
      "\n",
      "#########validation Started###########\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Batch size: 50, Learning rate: 0.01, Val loss: 0.10036837081243245, Val accuracy: 0.9818333333333333\n",
      "\n",
      "#########validation Done###########\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "#### training Started ####\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  0%|                                                    | 0/20 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:1   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  5%|██▏                                         | 1/20 [01:25<27:04, 85.52s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 1 is  1.0562171589768408\n",
      "epoch:2   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 10%|████▍                                       | 2/20 [02:50<25:35, 85.29s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 2 is  0.056530133913219635\n",
      "epoch:3   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 15%|██████▌                                     | 3/20 [04:14<24:01, 84.81s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 3 is  0.01180651304355016\n",
      "epoch:4   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 20%|████████▊                                   | 4/20 [05:40<22:38, 84.93s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 4 is  0.0026633679574651127\n",
      "epoch:5   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 25%|███████████                                 | 5/20 [07:06<21:24, 85.62s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 5 is  0.0015428327063828462\n",
      "epoch:6   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 30%|█████████████▏                              | 6/20 [08:33<20:01, 85.82s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 6 is  0.0012589635338326132\n",
      "epoch:7   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 35%|███████████████▍                            | 7/20 [09:57<18:30, 85.43s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 7 is  0.0005629781670939416\n",
      "epoch:8   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 40%|█████████████████▌                          | 8/20 [11:22<17:03, 85.27s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 8 is  0.0004247388008105091\n",
      "epoch:9   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 45%|███████████████████▊                        | 9/20 [12:47<15:36, 85.15s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 9 is  0.00015657070932189042\n",
      "epoch:10   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 50%|█████████████████████▌                     | 10/20 [14:12<14:09, 84.95s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 10 is  0.00015657070932189042\n",
      "epoch:11   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 55%|███████████████████████▋                   | 11/20 [15:36<12:44, 84.95s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 11 is  8.970847114087022e-05\n",
      "epoch:12   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 60%|█████████████████████████▊                 | 12/20 [17:02<11:21, 85.21s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 12 is  7.157006713454095e-05\n",
      "epoch:13   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 65%|███████████████████████████▉               | 13/20 [18:28<09:58, 85.48s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 13 is  2.505651649977736e-05\n",
      "epoch:14   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 70%|██████████████████████████████             | 14/20 [19:53<08:31, 85.19s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 14 is  2.505651649977736e-05\n",
      "epoch:15   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 75%|████████████████████████████████▎          | 15/20 [21:18<07:05, 85.08s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 15 is  1.2501413255971982e-05\n",
      "epoch:16   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 80%|██████████████████████████████████▍        | 16/20 [22:43<05:40, 85.15s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 16 is  4.696669905079887e-06\n",
      "epoch:17   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 85%|████████████████████████████████████▌      | 17/20 [24:09<04:15, 85.26s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 17 is  4.696669905079887e-06\n",
      "epoch:18   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 90%|██████████████████████████████████████▋    | 18/20 [25:34<02:50, 85.23s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 18 is  4.6457937813215725e-06\n",
      "epoch:19   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 95%|████████████████████████████████████████▊  | 19/20 [27:00<01:25, 85.48s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 19 is  4.6457937813215725e-06\n",
      "epoch:20   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████| 20/20 [28:25<00:00, 85.30s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 20 is  4.6457937813215725e-06\n",
      "Minimum Loss:  4.6457937813215725e-06\n",
      "#### training Done ####\n",
      "\n",
      "#########validation Started###########\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Batch size: 20, Learning rate: 0.001, Val loss: 0.09781944724525686, Val accuracy: 0.9758333333333333\n",
      "\n",
      "#########validation Done###########\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "#### training Started ####\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  0%|                                                    | 0/20 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:1   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  5%|██▏                                         | 1/20 [01:22<25:59, 82.11s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 1 is  1.8409429652243574\n",
      "epoch:2   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 10%|████▍                                       | 2/20 [02:45<24:54, 83.02s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 2 is  1.544555876869909\n",
      "epoch:3   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 15%|██████▌                                     | 3/20 [04:08<23:27, 82.78s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 3 is  1.00410961442972\n",
      "epoch:4   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 20%|████████▊                                   | 4/20 [05:30<22:00, 82.56s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 4 is  0.48412053294600016\n",
      "epoch:5   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 25%|███████████                                 | 5/20 [06:52<20:36, 82.41s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 5 is  0.08696209842243441\n",
      "epoch:6   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 30%|█████████████▏                              | 6/20 [08:16<19:18, 82.74s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 6 is  0.035526590543383384\n",
      "epoch:7   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 35%|███████████████▍                            | 7/20 [09:38<17:54, 82.64s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 7 is  0.02187165500822049\n",
      "epoch:8   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 40%|█████████████████▌                          | 8/20 [11:00<16:31, 82.60s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 8 is  0.01954434352521661\n",
      "epoch:9   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 45%|███████████████████▊                        | 9/20 [12:23<15:07, 82.45s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 9 is  0.012952235801522018\n",
      "epoch:10   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 50%|█████████████████████▌                     | 10/20 [13:45<13:42, 82.30s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 10 is  0.008216585209513792\n",
      "epoch:11   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 55%|███████████████████████▋                   | 11/20 [15:07<12:20, 82.32s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 11 is  0.008128688230875803\n",
      "epoch:12   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 60%|█████████████████████████▊                 | 12/20 [16:30<10:59, 82.45s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 12 is  0.004235386429466441\n",
      "epoch:13   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 65%|███████████████████████████▉               | 13/20 [17:53<09:39, 82.84s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 13 is  0.004075996571711898\n",
      "epoch:14   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 70%|██████████████████████████████             | 14/20 [19:16<08:15, 82.62s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 14 is  0.0019304154041210175\n",
      "epoch:15   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 75%|████████████████████████████████▎          | 15/20 [20:37<06:51, 82.39s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 15 is  0.0019304154041210175\n",
      "epoch:16   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 80%|██████████████████████████████████▍        | 16/20 [22:02<05:32, 83.21s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 16 is  0.0019253820542025934\n",
      "epoch:17   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 85%|████████████████████████████████████▌      | 17/20 [23:27<04:11, 83.69s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 17 is  0.001870760897184205\n",
      "epoch:18   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 90%|██████████████████████████████████████▋    | 18/20 [24:48<02:45, 82.90s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 18 is  0.001212861627658519\n",
      "epoch:19   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 95%|████████████████████████████████████████▊  | 19/20 [26:10<01:22, 82.43s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 19 is  0.001212861627658519\n",
      "epoch:20   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████| 20/20 [27:32<00:00, 82.61s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 20 is  0.001212861627658519\n",
      "Minimum Loss:  0.001212861627658519\n",
      "#### training Done ####\n",
      "\n",
      "#########validation Started###########\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Batch size: 50, Learning rate: 0.001, Val loss: 0.09849921475169572, Val accuracy: 0.9716666666666667\n",
      "\n",
      "#########validation Done###########\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "#### training Started ####\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  0%|                                                    | 0/20 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:1   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  5%|██▏                                         | 1/20 [01:27<27:35, 87.15s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 1 is  1.8406799281912878\n",
      "epoch:2   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 10%|████▍                                       | 2/20 [02:52<25:48, 86.05s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 2 is  1.5783284469072334\n",
      "epoch:3   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 15%|██████▌                                     | 3/20 [04:18<24:20, 85.90s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 3 is  1.5783284469072334\n",
      "epoch:4   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 20%|████████▊                                   | 4/20 [05:43<22:49, 85.58s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 4 is  1.567001763511163\n",
      "epoch:5   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 25%|███████████                                 | 5/20 [07:08<21:21, 85.42s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 5 is  1.567001763511163\n",
      "epoch:6   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 30%|█████████████▏                              | 6/20 [08:33<19:53, 85.28s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 6 is  1.567001763511163\n",
      "epoch:7   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 35%|███████████████▍                            | 7/20 [09:58<18:28, 85.26s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 7 is  1.2838032305850722\n",
      "epoch:8   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 40%|█████████████████▌                          | 8/20 [11:26<17:12, 86.00s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 8 is  1.2333775751127942\n",
      "epoch:9   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 45%|███████████████████▊                        | 9/20 [12:51<15:44, 85.87s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 9 is  1.1311739114505595\n",
      "epoch:10   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 50%|█████████████████████▌                     | 10/20 [14:16<14:15, 85.58s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 10 is  1.0035000172537192\n",
      "epoch:11   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 55%|███████████████████████▋                   | 11/20 [15:41<12:48, 85.34s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 11 is  0.6482233979726983\n",
      "epoch:12   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 60%|█████████████████████████▊                 | 12/20 [17:06<11:22, 85.28s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 12 is  0.47514894226941723\n",
      "epoch:13   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 65%|███████████████████████████▉               | 13/20 [18:31<09:55, 85.14s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 13 is  0.47514894226941723\n",
      "epoch:14   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 70%|██████████████████████████████             | 14/20 [19:56<08:30, 85.06s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 14 is  0.4324491333025768\n",
      "epoch:15   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 75%|████████████████████████████████▎          | 15/20 [21:22<07:06, 85.40s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 15 is  0.238490572419074\n",
      "epoch:16   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 80%|██████████████████████████████████▍        | 16/20 [22:47<05:41, 85.33s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 16 is  0.2113745880583881\n",
      "epoch:17   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 85%|████████████████████████████████████▌      | 17/20 [24:12<04:15, 85.19s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 17 is  0.13849759118690852\n",
      "epoch:18   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 90%|██████████████████████████████████████▋    | 18/20 [25:37<02:50, 85.17s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 18 is  0.09950238873951474\n",
      "epoch:19   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 95%|████████████████████████████████████████▊  | 19/20 [27:02<01:25, 85.11s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 19 is  0.02422709314165914\n",
      "epoch:20   Total batches: 2700.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████| 20/20 [28:28<00:00, 85.41s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 20 is  0.02368188296107987\n",
      "Minimum Loss:  0.02368188296107987\n",
      "#### training Done ####\n",
      "\n",
      "#########validation Started###########\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Batch size: 20, Learning rate: 0.0001, Val loss: 0.2761667628286763, Val accuracy: 0.9233333333333333\n",
      "\n",
      "#########validation Done###########\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "#### training Started ####\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  0%|                                                    | 0/20 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:1   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  5%|██▏                                         | 1/20 [01:20<25:31, 80.61s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 1 is  2.2367673860151838\n",
      "epoch:2   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 10%|████▍                                       | 2/20 [02:42<24:25, 81.42s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 2 is  2.0967247593800904\n",
      "epoch:3   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 15%|██████▌                                     | 3/20 [04:02<22:53, 80.77s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 3 is  1.9113896835776347\n",
      "epoch:4   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 20%|████████▊                                   | 4/20 [05:23<21:32, 80.75s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 4 is  1.8465604849764892\n",
      "epoch:5   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 25%|███████████                                 | 5/20 [06:45<20:19, 81.33s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 5 is  1.8465604849764892\n",
      "epoch:6   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 30%|█████████████▏                              | 6/20 [08:05<18:53, 80.99s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 6 is  1.8167534589321541\n",
      "epoch:7   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 35%|███████████████▍                            | 7/20 [09:25<17:28, 80.62s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 7 is  1.7550894409155944\n",
      "epoch:8   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 40%|█████████████████▌                          | 8/20 [10:46<16:07, 80.63s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 8 is  1.7550894409155944\n",
      "epoch:9   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 45%|███████████████████▊                        | 9/20 [12:08<14:50, 80.95s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 9 is  1.7550894409155944\n",
      "epoch:10   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 50%|█████████████████████▌                     | 10/20 [13:28<13:26, 80.68s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 10 is  1.7462079329281135\n",
      "epoch:11   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 55%|███████████████████████▋                   | 11/20 [14:49<12:07, 80.83s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 11 is  1.727185137677881\n",
      "epoch:12   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 60%|█████████████████████████▊                 | 12/20 [16:09<10:44, 80.58s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 12 is  1.727185137677881\n",
      "epoch:13   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 65%|███████████████████████████▉               | 13/20 [17:30<09:24, 80.58s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 13 is  1.7085050180630912\n",
      "epoch:14   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 70%|██████████████████████████████             | 14/20 [18:49<08:02, 80.34s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 14 is  1.7085050180630912\n",
      "epoch:15   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 75%|████████████████████████████████▎          | 15/20 [20:10<06:42, 80.43s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 15 is  1.705299279434174\n",
      "epoch:16   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 80%|██████████████████████████████████▍        | 16/20 [21:31<05:22, 80.57s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 16 is  1.645752767661571\n",
      "epoch:17   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 85%|████████████████████████████████████▌      | 17/20 [22:52<04:02, 80.81s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 17 is  1.587412299470017\n",
      "epoch:18   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 90%|██████████████████████████████████████▋    | 18/20 [24:13<02:41, 80.70s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 18 is  1.5098248033167823\n",
      "epoch:19   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 95%|████████████████████████████████████████▊  | 19/20 [25:33<01:20, 80.58s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 19 is  1.4973972095718393\n",
      "epoch:20   Total batches: 1080.0 \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████| 20/20 [26:53<00:00, 80.70s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum Loss after epoch 20 is  1.297866392375142\n",
      "Minimum Loss:  1.297866392375142\n",
      "#### training Done ####\n",
      "\n",
      "#########validation Started###########\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Batch size: 50, Learning rate: 0.0001, Val loss: 1.7813382354148313, Val accuracy: 0.23616666666666666\n",
      "\n",
      "#########validation Done###########\n",
      "\n",
      "\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Find the optimal value of learning rate and batch size. \n",
    "# Use the same tuning strategy as the previous question\n",
    "# Create plot and table to show the effect of the hparams.\n",
    "####### hyperparameters ########\n",
    "# epochs_s = [2,5]\n",
    "epochs = 20\n",
    "etas = [0.01,0.001,0.0001]     # ,0.0001,0.00001\n",
    "batch_size =50\n",
    "batch_sizes = [20,50]\n",
    "output_size = 10\n",
    "input_size = 784\n",
    "\n",
    "val_results =[]\n",
    "for eta in etas:\n",
    "    for batch_size in batch_sizes:\n",
    "        \n",
    "        mlp1 = MLP()\n",
    "        ##### add layer #####\n",
    "        mlp1.add_layer(Linear_Layer(input_size,512,batch_size,eta))\n",
    "        mlp1.add_layer(ReLU())\n",
    "\n",
    "        mlp1.add_layer(Linear_Layer(512,256,batch_size,eta))\n",
    "        mlp1.add_layer(ReLU())\n",
    "        mlp1.add_layer(Linear_Layer(256,10,batch_size,eta))\n",
    "        mlp1.train(train_imgs,train_labels,epochs,batch_size,eta)\n",
    "        val_results.append(mlp1.valid(val_imgs,val_labels,epochs,batch_size,eta))\n",
    "        \n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "######## Data Generated for 20 epochs ##########\n",
      "\n",
      "   batch_size  learning_rate  val_loss  val_accuracy  epochs\n",
      "0          20         0.0100  0.249717      0.961500      20\n",
      "1          50         0.0100  0.100368      0.981833      20\n",
      "2          20         0.0010  0.097819      0.975833      20\n",
      "3          50         0.0010  0.098499      0.971667      20\n",
      "4          20         0.0001  0.276167      0.923333      20\n",
      "5          50         0.0001  1.781338      0.236167      20\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWwAAAEXCAYAAACJen67AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAAsTAAALEwEAmpwYAAAtdUlEQVR4nO3debxd0/3/8df73iSSkMgkswgSYqiiScTQqBYNVdqvllYHfFW+Ldqixg5oSgdttf226DdUaanwozQlYlZDDQkVJISIIXMiMzLe+/n9sfe9Ofe6wzlxzj1D3s/HYz/u2Xuts9c61/G5K2uvQRGBmZmVvqpiV8DMzLLjgG1mViYcsM3MyoQDtplZmXDANjMrEw7YZmZlwgHbAJAUkoakr/8o6UfZ5N2Mcr4i6b7NrafZlswBu0JImixpXBPXj5G0UFK7bO8VEd+MiJ/koU6D0+BeX3ZE3BQRh3/Ye7dQ5o6SaiVdXagyzIrFAbty3AB8VZIaXf8acFNEbCxCnYrh68By4HhJW7VlwZKq27I82/I4YFeOO4GewMfrLkjqDhwF/EXSSElPSlohaYGkP0jq0NSNJF0v6dKM83PT98yX9N+N8n5G0n8krZI0R9IlGcmPpj9XSHpX0v6STpL0eMb7D5A0RdLK9OcBGWmPSPqJpCckrZZ0n6Rezf0C0j9WXwd+CGwAPtso/RhJz6d1fV3SmPR6D0l/Tj/fckl3ptcb1DW9ltl1dL2kqyVNkvQecEgrvw8kHSTp3+l/hzlpGSMkLcoM+JL+S9K05j6rbZkcsCtERKwBbiUJWHWOA16JiGlADXAW0AvYH/gUcFpr902D2jnAYcBQ4NBGWd5Ly+wGfAb4lqTPpWmj05/dImKbiHiy0b17AHcD/0vyx+YK4G5JPTOynQCcDPQGOqR1ac5BwEBgAsnv4sSMskYCfwHOTes6GngzTf4r0BnYIy3nNy2U0dgJwGVAF+BxWvh9SNoBuAf4PbAdsDfwfERMAZYCmV1FX0vra1bPAbuy3AB8QVLH9Pzr6TUi4tmIeCoiNkbEm8D/AQdncc/jgD9HxEsR8R5wSWZiRDwSES9GRG1EvADcnOV9IQlor0XEX9N63Qy8QsOW8Z8j4tWMP0h7t3C/E4F7ImI58DdgjKTeadopwHURcX9a13kR8YqkfsARwDcjYnlEbIiIf2VZf4B/RMQT6T3XtvL7OAF4ICJuTstZGhHPp2k3AF+F+j9kn04/g1k9B+wKEhGPA+8An5O0MzCS9H96SbtIuit9ALkK+ClJa7s1/YE5GedvZSZK2k/Sw5KWSFoJfDPL+9bd+61G194CBmScL8x4/T6wTVM3ktQJ+CJwE0Damn+bJEgCbA+83sRbtweWpUF+c2T+blr7fTRXB4Abgc9K2prkj+RjEbFgM+tkFcoBu/L8haRl/VXg3ohYlF6/mqT1OjQiugLfBxo/oGzKApJAU2dQo/S/AROB7SNiW+CPGfdtbSnI+cAOja4NAuZlUa/GPg90Ba5K/ygtJAn8dd0ic4Cdm3jfHKCHpG5NpL1H0lUCgKS+TeRp/Blb+n00VwciYh7wJPBfJN0hf20qn23ZHLArz19I+plPJe0OSXUBVgHvShoGfCvL+90KnCRpd0mdgYsbpXchaaGuTfuJT8hIWwLUAjs1c+9JwC6STpDUTtLxwO7AXVnWLdOJwHXAR0i6TfYGDgQ+KukjwJ+AkyV9SlKVpAGShqWt2HtIAn13Se0l1fW9TwP2kLR32s10SRb1aOn3cRNwqKTj0s/bU9LeGel/Ac5LP8PfN+N3YBXOAbvCpP3T/wa2Jmnp1TmHJHisBq4BbsnyfvcAvwUeAmalPzOdBoyTtBq4iCTA1733fZIHck+koyJGNbr3UpJRLN8jeeh2HnBURLyTTd3qSBpA8hD1txGxMON4FpgMnBgRz5A8vPwNsBL4F5ta918jGVXyCrAYODOt36vAOOAB4DWSh4qtaen38TZwZPp5lwHPAx/NeO8daZ3uSH93Zg3IGxiYlQ5JrwP/ExEPFLsuVnrcwjYrEZKOJekTb/yvGDMAsp6ubGaFI+kRkv77r0VEbZGrYyXKXSJmZmXCXSJmZmWipLtEHhq8l5v/9gFr5q0rdhWsBH1mw8xs5hW06O72u2Ydc/JRXq5KOmCbmbUltW/zGJwTB2wzs1RVOwdsM7OyoPal/VjPAdvMLOUWtplZmXAftplZmaju5C4RM7Oy4C4RM7MyoWoHbDOzslDlgG1mVh5U5YBtZlYWqjtUF7sKLXLANjNLuYVtZlYm3IdtZlYmPErEzKxMqMoTZ8zMyoL7sM3MykS1V+szMysP7hIxMysT7hIxMysTpT6sr7Tb/2ZmbUhVyvpo9V7SGEkzJc2SdEET6TtIelDSC5IekTSwtXs6YJuZpVRVlfXR4n2kauBK4Ahgd+DLknZvlO1XwF8iYi9gHPCz1urngG1mlqpqV5X10YqRwKyImB0R64EJwDGN8uwOPJS+friJ9A/WL8fPY2ZWsXLpEpE0VtLUjGNsxq0GAHMyzuem1zJNA/4rff15oIukni3Vzw8dzcxSuQzri4jxwPgPUdw5wB8knQQ8CswDalp6gwO2mVkqj6NE5gHbZ5wPTK/Vi4j5pC1sSdsAx0bEihbrl6/amZmVuzyOEpkCDJW0o6QOwJeAiQ3KknpJqovBFwLXtXZTB2wzs1RVu+qsj5ZExEbgDOBe4GXg1oiYLmmcpKPTbJ8AZkp6FegDXNZa/YrSJSJpWES8Uoyyzcyak8+ZjhExCZjU6NpFGa9vA27L5Z7F6sO+DxhUpLLNzJq0xa4lIul/m0sCuhWqXDOzzbUlryVyMvA9YF0TaV8uYLllp8fBBzL0ovNRdRULbvk7b13d8NlDxwH9GHb5ODr06M6GlSuZceb3WbdwEQBb9e/Lbj+/hK3694UIpp18Omvnzi/Gx7A82+7wj7P7FT9A1VXMue7/8fovr2mQ3mlQf/a65qd02K4HG5at4PkTz2XtvOR7Mexn59L7iINRVRVLHnyCGWe12j1qbMEtbJKnpC9FxL8bJ0i6pIDllpeqKnYd933+89WxrFu4iOETb2bJ/Y/w/qzZ9VmGfP97LPz7P1l4+0S67z+Snc/7DjPO/gEAu19xGW/+4RqWP/4U1Z07EbVRrE9i+VRVxR7/exFPH3Eya+cu4qCnbmPRXQ/x7suv12fZ7RfnM/fGO5n31zvp+YlR7HrZ95h20nl0338fuh+wL4/umzzbOuBff6PH6JEse/SZYn2a8qHSbmEX8s/JF4Dnm0qIiB0LWG5Z6br3nrz/1tusnTOP2LCRxf+czHaHH9IgT+ehO7H8308DsPzJZ+h1WJLeechOqLqa5Y8/BUDN+2uoXbu2bT+AFUS3kXvx/utvseaNucSGDcy/5W76fPZTDfJss9vOLH04+W+/9JGn6tMjguqOHajq0J6qrTqg9u1Zv/idNv8M5Shfo0QKVr9C3TgilkXE+wCSekjqUaiyytlWffqwbv6i+vN1CxaxVZ/eDfK8+/KrbDfmUAC2+/SnaNdlG9p125bOO+3AxlWr2fOPVzDi7lvY+cKzocT/SWfZ6di/D2vmLqw/XztvER0H9GmQZ9ULr9D384cD0Pdzh9G+6za079GNFU89z9JHnubQOY9z6JzHeee+x3j3ldlY6/K5Wl8hFOz/bkmDJE2QtAR4GnhG0uL02uBClVuJZl32a7rt9zFG3H0L3UYNZ+2CRVBbi6rb0W3Evsy67NdMPfoEOg0aSL8vtLp+jFWIl8+/nJ4fH8FBU+6gx+iRrJm7kKipofPOg9hm2M48OPhgHtxhND0PGUX3Az9W7OqWhXyt1lcohezDvgX4LfCViKiB+iUHv0iyctWopt6ULqAyFuCsHgM4qktlN8zXLVrEVv03tZy26teHdYsWN8izfvESXvrm2QBUd+7EdmMOZeOq1axbuIjVL89k7Zxkxus79z1E1332YsGtd7TdB7CCWDt/EZ0G9q0/7zigT/0DxTrrFizm2eO+DUD11p3p+/nD2bhyNYNOOY7lT0+j5r33AVg8+TG6j9qH5U8823YfoEyV+iiRQv6Z6BURt9QFa4CIqImICUCzK1JFxPiIGB4Rwys9WAOsnjadzoN3oOPAAah9O3p/dgzv3P9Igzztu3erfxiyw2nfqA/Iq6a9RLuuXWjfozsA3Q8YyXuvvY6Vv5VTXmTrIYPpNHggat+e/sd/hkV3PdQgT/ue3eu/F0POH8vc628HYM2c+fQcPQJVV6N27eg5egTvvuLvRTZKvUukkC3sZyVdBdzApmUGtwdOBP5TwHLLStTU8OpFP2Xvv1yNqquZf+udvPfa6+x41mmsfnEG7zzwCN1GjWDn874DEax45jlmXpQO0aqtZdZlv2afm64BidUvzWD+hNuL+4EsL6Kmhpe+O46Rd1+LqquZe/3tvDtjFrtc/B1WPPsSi+96iJ4Hj2TYpWcTESx7fCrTv/1jABbcfi89DxnF6P/8k4hgyX2Psfjuh4v8icpEiT8DUkRhhoGlC56cQrIod906sHOBfwJ/ioimxmc38NDgvTxGzT5gzbxWvzq2BfrMhpkfutn7zkWnZB1zeo37U5s3swvWwk53Wbg6PczMSt6W3IfdLElHFaNcM7MWVVVlfxSjekUpFUYUqVwzs2ZtyQ8dkTSMhn3Y84CJEXFxIcs1M9scm/YTKE2FnDhzPsl4awHPpIeAmyVdUKhyzcw2l9pVZ30UQyFb2KcAe0TEhsyLkq4ApgM/L2DZZmY525IfOtYC/Zu43i9NMzMrLarK/iiCQrawzwQelPQamybODAKGkOx1ZmZWUkq9hV3IcdiTJe0CjKThQ8cpmdPVzcxKRonPdCzoKJGIqAWeKmQZZmb5ojxuYCBpDPA7oBq4NiJ+3ih9EMnSHd3SPBekG/c2q1ib8JqZlZx8jf5IVya9EjiMZEmOKZImRsSMjGw/BG6NiKsl7U6yw/rglu5b2u1/M7O2lL+HjiOBWRExO12mYwLJnJRMAXRNX28LtLoZq1vYZmZ18vfQcQCbBltA0srer1GeS4D7JH0b2Bo4tNXq5at2ZmblTqrK4dBYSVMzjrE5Fvdl4PqIGAgcCfxVrUy1dAvbzKxODi3siBgPjG8meR7J+v91BqbXMp0CjEnv9aSkjkAvYDHNcAvbzCyVxz0dpwBDJe2Y7g3wJWBiozxvA58CkLQb0BFY0tJN3cI2M6tTnZ9RIhGxUdIZwL0kQ/aui4jpksYBUyNiIvA94BpJZ5E8gDwpWtlRxgHbzKxOHsdhp2OqJzW6dlHG6xnAgbnc0wHbzCyVRVdHUWUdsCX1Jvlr0B9YA7xE0rT3Qk5mVhlKfD3sVgO2pEOAC4AeJLudLybpHP8csLOk24BfR8SqAtbTzKzwKmDxpyOBUyPi7cYJktoBR5FMv7w9z3UzM2tTytNDx0JpNWBHxLktpG0E7sxnhczMiqbcu0QySfoMsAdJlwgAETEu35UyMyuKPI4SKYRcHjr+EegMHAJcC3yBZJ9GM7PKUOKjRHKp3QER8XVgeUT8GNgf2KUw1TIzK4IK2iJsTfrzfUn9gaUk+zOamVWGChglUucuSd2AXwLPkUylvLYQlTIzK4qqMh8lkuHyiFgH3C7pLpIHj2sLUy0zsyKooD7sJ+teRMS6iFiZec3MrOxJ2R9FkM1Mx74kuyd0krQPUFfTriSjRszMKkMFjMP+NHASyQLcV2RcXwV8vwB1MjMrjhLvEslmpuMNwA2Sjo2INp1+vn7ZhrYszspEu65eZNIKpMQnzuTy5+QJSX+SdA+ApN0lnVKgepmZtb2q6uyPYlQvh7x/Jtk9oX96/ipwZr4rZGZWNFVV2R/FqF4OeXtFxK1ALdQv/FRTkFqZmRVBSFkfxZBLZ+B7knqSTJhB0ihgZUFqZWZWDBUwSqTO2SS7/u4s6QlgO5IFoMzMKkOlBOyIeE7SwcCuJGOxZ0aEh3GYWcWIPD5MlDQG+B3JrunXRsTPG6X/hmT1U0jmtPSOiG4t3fPD7OnYWZL3dDSzypGnvmlJ1cCVJLtxzQWmSJqY7pQOQESclZH/28A+rd3XezqamdXJ3+iPkcCsiJgNIGkCcAwwo5n8XwYubu2m3tPRzCyVx9EfA4A5Gedzgf2ayihpB2BH4KHWbprVno6SqiQdlw7ry0zzno5mVjlyeOgoaSwwNuPS+IgYvxmlfgm4LSJaHSadVR92RNRKOg+4tdXMZmZlKnII2Glwbi5AzwO2zzgfmF5rypeA07MpM5dhfQ9IOge4BXiv7mJELMvhHmZmJSuPo0SmAEMl7UgSqL8EnNA4k6RhQHeyXKo6l4B9fPoz8y9BADvlcA8zs9KVpz7siNgo6QyS5TyqgesiYrqkccDUiJiYZv0SMCEiIpv75jIOe8dcK21mVlbyOHEmIiYBkxpdu6jR+SW53DOXcdjtgW8Bo9NLjwD/58kzZlYpirVGSLZy6RK5GmgPXJWefy299o18V8rMrCgqZWo6MCIiPppx/pCkafmukJlZsdSqtHdNz+XPSY2knetOJO2El1c1s0qiquyPIsilhX0u8LCk2SSLP+0AnFyQWpmZFUHF9GFHxIOShpKs1gfJan3rClMtM7O2l8vEmWJotXaSDqp7HRHrIuKF9FiXpneVtGchK2lm1iak7I8iyKaFfayky4HJwLPAEpLV+oaQrOW6A/C9gtXQzKyNlHoLO5vFn86S1AM4Fvgi0I9kPeyXScZhP17YKpqZtY1SHyWS7eJPy4Br0sPMrDKV+EPHrNv/kvpI+pOke9Lz3SWdsjmFSvLoEjMrOUFV1kcx5FLq9SQLmfRPz18FztzMcn+8me8zMyuYkLI+iiGXcdi9IuJWSRdC/WpUzU6ckfRCc0lAnxzKNTNrE2X/0DHDe5J6kiypiqRRwMoW8vcBPg0sb3RdwL9zqaSZWVsISrsPO5eAfTYwkWTj3SeA7UhGjTTnLmCbiHi+cYKkR3Io18ysTdTmbwODgsglYE8HDiaZ6ShgJi30gUdEsw8kI+IDOy+YmRVbJbWwn4yIfUkCNwCSngP2be4NkkSy3fuA9NI84Jlsd1cwM2tLZd+HLakvScDtJGkfqP8T1BXo3ML7DidZO/s1Nm0+ORAYIum0iLjvw1S8kvQ69CB2+8X3obqKuTfcxhu/ubZBesft+/ORKy+lQ68ebFi+kmmnnse6+YsA2GXcOWz36YNRlVj68L95+byfFuMjWJ71+uRBDPvZBaiqmrk33s4bv2v0nRjYjz1/fykdenZnw/KVvPCtC1g3fxE9DhrJrpeeX59v66E78sKp57B40kNt/RHKUiW0sD8NnEQSbK/IuL4a+H4L7/sdcGhEvJl5Md2UchKwWy4VrVhVVez+6x8x5ZhTWDtvEfs/ciuLJz3MezNfr88y7NJzmTfhH8z/2z/oMXo/drnkbF4cez7dRu5N91H78MT+xwAw6r6b6HHQCJY9PqVYn8byoaqK3S7/AVOPPZW18xex/wO3sHhyw+/EruPOZf4tE5k/4R/0+Ph+7PKjM3nxWxey7PFnePITxwLQvtu2fHzqPbzzsJ/xZ6vUW9it1i4iboiIQ4CTIuKQjOPoiPh7C29tB8xt4vo8kp1rDOg2fC/en/02a96cS2zYwMLbJ9HnM59skGfrYUNY9q+nAVj26NP0OXJTetVWW1HVoT1VW3VA7dqxbvHSNq2/5d+2+36E99+Yw5q3ku/Egjsm0fuIQxrk2WbXnVn2aPqdeOxpeh/xyQ/cp8/Rh7PkgceoXbO2TepdCWpVnfVRDLksr3q7pM8Ae5As/lR3fVwzb7kOmCJpAjAnvbY9yS7Bf9q86laerfr1Zs3chfXna+cvYtvhezXIs/qlV+hz9GG8dfVf6fPZw2jXdRva9+jGimeeZ9ljT3PIq4+CxNvjb+K9V2e39UewPOvYrw9r5y2oP187fxHdPtb4OzGT3kcdytvjb6T3UYfSrss2tO++LRuWbxpp2/e/juCtq25os3pXglLvEsllavofgeOBb5P0Y3+RZKW+JkXEz4CvpHn3Tw8BX0nTmitnrKSpkqZOWr8i2+pVtJk/uJzuB47ggMdup/tBw1k7byFRU0PnnQax9a4788huh/DIsE/Q8+BRdN//Y8WurrWBmRf/kh4HDmf/h2+jxwHDWTt/IVFTW5/eoU8vuuw2lHceeqKItSw/+ZzpKGmMpJmSZkm6oJk8x0maIWm6pL+1ds9cRokcEBF7SXohIn4s6dfAPS29ISJmADPS1f7qFpFqUUSMB8YDTO66W8WPJlm3YDGdBvatP+/Yv0/9A8X6PAuX8PxXvwNA9dad6Xv04WxcuZqBJ36RlVOmUfPe+wAsuf8xuo3cm+VPPtt2H8Dybu2CRXQc0K/+vGP/Pqxd0MR34sQzgeQ70eezh7Fx1er69L7HjGHR3Q8SGze2SZ0rRUR+WtiSqoErgcNIuoanSJqYxsS6PEOBC4EDI2K5pN6t3TeXHva6jrD3JfUHNpAstdpchQdJmiBpMfA08Iykxem1wTmUW9FWPvsinXfagU47DEDt29P32CNZPOnhBnna9+hWv4rYTmefytwbk0cHa+cuoPuBI1B1NWrXjh4HDufdjAdTVp5W/eclOu80iE6Dku9Ev88fyeJ7mv9O7HjmN5h30x0N0vsdeyQL/z6prapcMfK4+NNIYFZEzI6I9cAE4JhGeU4FroyI5QARsbi1m+bSwv6npG7AL4HnSKaot7Tc6i3Ab0m6QGqg/q/OF9PKj8qh7IoVNTXMOPdSht9xLaquYu5f/867r8xiyA++zcrnXmLJPQ/T4+Mj2eWSsyGCZU9MZcb3kscGC++8l56j9+PAp/4BEbzzwOMsmfxIcT+QfWhRU8PL51/Gx/7feFRdxby/3cF7M19nyAVnsPL56SyZ/DA9DhzJ0B+dCREsf3IqM867tP79HbfvT8cBfVn2hEcL5SqXPmxJY4GxGZfGpz0EkAyFnpORNhfYr9Etdknv8wRQDVwSEZNbLDObOSySqoBREfHv9HwroGNENLuWiKTXImJormmZtoQuEcud2pf20Csrjk8vnf6h+zNeeX1u1jFn2M4Dmy1P0heAMRHxjfT8a8B+EXFGRp67SHoqjiMZNv0o8JGIWNHcfbP65kdELUl/TN35upaCdepZSVdJ2k9S//TYT9JVwH+yKdfMrC0FyvpoxTySUXF1BrJpAmGducDEiNgQEW+QLFndYkM2l6bKg5KOTaebZ+PrwIska1/fmx6XAC8BX8uhXDOzNhGhrI9WTAGGStpRUgeS4cwTG+W5E/gEgKReJF0kLY7LzaUP+39IVuzbKGktyRC9iIiuTWVOO9qvTg8zs5KXr3HY6X4BZ5A0VKuB6yJiuqRxwNSImJimHS5pBlADnBsRLc58y6oPOxuS9oiI6a3nBElHRcRdreVzH7Y1xX3Y1pR89GG/NGth1jFnzyF923yWTT6/+X/NIe+IPJZrZpYXeezDLohcukRa84FPIGkYydjDzOVVJ0bExXks18wsL2qitP/1ls/aNfinhKTzScZbC3gmPQTc3Nw0TTOzYtqSWtiNnQLsEREbMi9KuoJkE4SfF7BsM7Oc5WtqeqHks4W9vtF5LdC/iXz90jQzs5JSMS1sSU1tBbYSeCsiNkZE46nmZ5KM3X6NTVM0BwFDgDMwMysxpd7CzqVL5CqS/RtfIOmL3pOka2NbSd9qvOVXREyWtAsf3NNxSt3aImZmpaS2xB865hKw5wOn1I21lrQ7MA44D/g78IE9GtMp7U/loZ5mZgVX6n21uQTsXTInxkTEDEnDImJ29rPVzcxKVyV1iUyXdDXJUD1Idp+Zka7ct6H5t5mZlYdS3yIsl4B9EnAaycNEgCeAc0iC9SFNv8XMrHxUTAs7ItYAv06Pxt7NW43MzIqkYlrYkg4kWR51h8z3RcRO+a+WmVnbq6mUFjbwJ+As4FmSpQDNzCpKxXSJACsjosVd0s3MylmeVpsumFwC9sOSfkky5npd3cWIeC7vtTIzK4LaSunDZtOOv8MzrgXwyfxVx8yseCqmSyQiPHTPzCpa2XeJSPpqRNwo6eym0iPiivxXy8ys7VXCKJGt059dClkRM7NiK/sukYj4v/TnjwtfHTOz4slnl4ikMcDvSHZNvzYift4o/STglySrmAL8ISKubemeuUyc2Q44FRhMw4kz/53tPczMSlm+RolIqgauBA4D5gJTJE2MiBmNst4SEVnvD5DLKJF/AI8BD+CJM2ZWgfLYwh4JzIqI2QCSJpBsSN44YOckl4DdOSLO/zCFmZmVspra7FvYksYCYzMujY+I8enrAWzaaQuSVvZ+fNCxkkYDrwJnRcScJvLUy2V7hbskHZlDfjOzshKRyxHjI2J4xjG+9RIa+CcwOCL2Au4HbmjtDbkE7O+SBO01klZJWi1pVY4VNDMrWXnchHcesH3G+UA2PVxMyopYGhF1s8avBT7W2k2zCtiSqoAxEVEVEZ0iomtEdImIrtm838ysHNRG9kcrpgBDJe0oqQPwJWBiZgZJ/TJOjwZebu2mWfVhR0StpD8A+2STP1/6HbBdWxZnZeL09j8pdhWsBH06D/fI10PHiNgo6QzgXpJhfddFxHRJ44CpETER+I6ko4GNwDKSTWJalMtDxwclHQv8PaLUJ3CameUun5EtIiYBkxpduyjj9YXAhbncM5eA/T/A2cBGSWsBJWW6W8TMKkMuo0SKIZfFnzw13cwqWqn3HeTSwkZSd2Ao0LHuWkQ8mu9KmZkVQxYPE4sql6np3yAZ2jcQeB4YBTyJ18M2swpR6os/5ToOewTwVro29j7AikJUysysGHKZOFMMuXSJrI2ItZKQtFVEvCJp14LVzMysjdXUFrsGLcslYM+V1A24E7hf0nLgrUJUysysGCrmoWNEfD59eYmkh4FtgckFqZWZWRFUzENHAEkHAUMj4s/p+tgDgDcKUjMzszZWMS1sSReT7Ji+K/BnoD1wI3BgYapmZta2aiuoD/vzJCNDngOIiPmSPJnGzCpGxbSwgfUREZICQNLWrb3BzKyclPookVzGYd8q6f+AbpJOJdkq7JrCVMvMrO1FRNZHMeQySuRXkg4DVpH0Y18UEfcXrGZmZm2skrpESAO0g7SZVaSyf+goaTXQ1N8dL69qZhWl7FvYXlbVzLYUFTVxxsysktXW5BKx235lPwdsM7OUW9hmZmWi1PuwcxmHbWZW0WprI+ujNZLGSJopaZakC1rId6ykkDS8tXsWJWBLGl+Mcs3MWpKvDQwkVQNXAkcAuwNflrR7E/m6kGwO83Q29StYl4ikHs0lAUcWqlwzs81Vk79O7JHArIiYDSBpAnAMMKNRvp8AvwDOzeamhezDXkKywUHmo9RIz3sXsFwzs80SOUyckTQWGJtxaXxE1PUeDADmZKTNBfZr9P59ge0j4m5JRQ/Ys4FPRcTbjRMkzWkiv5lZUeWyRkganDere1dSFXAFcFIu7ytkH/Zvge7NpF1ewHLNzDZLbW32RyvmAdtnnA9Mr9XpAuwJPCLpTWAUMLG1B48Fa2FHxJUtpP2+UOWamW2uPK7CNwUYKmlHkkD9JeCEjHJWAr3qziU9ApwTEVNbumlBx2FLGkbS0T4gvTQPmBgRLxeyXDOzzZGvZ44RsVHSGcC9QDVwXURMlzQOmBoREzfnvoUcJXI+8GVgAvBMenkgcLOkCRHx80KVbWa2OXKbmt6yiJgETGp07aJm8n4im3sWsoV9CrBHRGzIvCjpCmA64IBtZiUlmwkxxVTIgF0L9CcZ2pepX5pmqS4fG0n/b30HVVWxbPLdLL71pgbp7Xv3YfuzLqBdt27UrF7F25dfyoZ3ltBxpyEM/PbZVHfemqitZfHNf2XFow8V6VNYvu23b3e+e+oQqqrEXfcv4MbbGg6uOv6YgRx1eF9qaoIVqzbws9/NZNGSdfXpnTtVc+NVI3jsqXf4zf/Nauvql6Vi7SSTrUIG7DOBByW9xqbxiIOAIcAZBSy3vFRVMeD0s5j9/bPZ8M4Shv7veFY+9Tjr3t70d67/qaex/MF7Wf7AZLb56L70PXksc355GbXr1vL2L3/K+vlzadejJ7v84VpWPfsMte+9W8QPZPlQVQVnf3MoZ/3oBRYvXce1V+zL408v5c0579fneXX2u3zj7OdYt66Wzx3Rj9NO3omLL9/0eOjUrw5m2vQVRah9+cplHHYxFGxYX0RMBnYBfkzS8X4vcAmwa5pmQOddd2P9gnmsX7iA2LiRFf96kG33P6hBno6DBvPu888B8O6059h2VJK+ft5c1s+fC8DGZUvZuGI57bbt1qb1t8LYbWhX5i5Yw/xFa9m4MXjg0cUctF/PBnn+8+IK1q1LIsz0mavZrudW9Wm77rwN3bt14Jn/LG/Tepe72oisj2Io9Foi0cRR4n/D2lb7nr1Yv2Rx/fmGd5bQvud2DfKsmT2LbQ8cDcC2B46meuutqe7ScKOfTrvshtq1Z/2CeVj5265nBxa/s6l7Y8nSdQ0CcmNHHdaXp59dBoAEZ5yyM1de93rB61lpKmYT3lxJOhy4CniNTQPGBwJDJJ0WEfcVquxKM/+aqxhw+ln0OGwM7770AuuXLCYyRu6369GTQef9gDm/+mnprw9peXf4J3ozbEgXzrjweQA+f2R/npy6jCVL1xe3YmWoJo+jRAqhkH3YvwMOjYg3My+mA8knAbs19abM+fk/3H0IX9i+XwGrWHwblr5Dh+02La3Svtd2bFi6pEGejcuW8tZPfghAVcdObHvg6Pp+6qrOndlx3C9YeP01vP9K43VlrFwtWbqe3r02tai367kVS5au+0C+4R/txtePG8QZF05jw8Yk2Ow5rCsf3WNbPn9kfzp1qqZ9O7FmbQ1/vOGNNqt/uYoteJRIO5IFTxqbB7Rv7k2Z8/OnjRld2r+9PHh/5it06D+QDn36sWHpErod/Cne+sW4Bnmqu25LzepVEEHv47/CsvuSoZ1q147BP7qM5Q/cy8rH/1WM6luBvPLaKrbv34l+fTqyZOk6Dh3dmx//quF8s6E7bcO5p+/C9y5+kRUrN42eHffrV+pfH/GpPgwb0sXBOkvF6pvOViED9nXAlHRZwbpRItuTTNH8UwHLLS+1Ncy76rfsdNmvoKqKZfdNYt1bb9Lna//NmtdmsuqpJ9hmr73pd/L/QATvvjSNeVf+BoBtRx/CNh/5KO26dqXHYWMAePvXP2PtbA/hKnc1tXDFH2dxxY8/QlWVuPuBhbzx9vuc8pXBvPLaap54Zimnn7wTnTpW85MLkmWWFy1ZywWXTi9yzctbqbewVcjO83TB7qP54NT0rP7tviW0sC13p7f/SbGrYCXo8X8e/KF3xT39VyuyjjlXntOtzXfhLehaImlgnlG3mUFELCtkeWZmH0apP3Qs2LA+SYMkTZC0mGT7m2ckLU6vDS5UuWZmm6vUh/UVchz2LcAdQL+IGBoRQ0impd9JsiCUmVlJyecmvIVQyIDdKyJuiYiaugsRURMRE4CeLbzPzKwoSr2FXcg+7GclXQXcQMNRIicC/ylguWZmm6XUR4kUMmB/nWSJ1R+zaZTIXOCfeFifmZWgLTZgR8R64Or0MDMreTU1pb3UUaEXf2qSpKOKUa6ZWUtKvQ+7KAEbGFGkcs3MmlXqo0SKtQnvxYUs18xsc5R6H3YhJ86cTzLeWiSb8D6Tvr5Z0gWFKtfMbHPls0tE0hhJMyXNairmSfqmpBclPS/p8XQpjxZ5E14zs1TmOvMfhqRq4ErgMJLRcVMkNV5H6W8R8cc0/9HAFcCYlu7rTXjNzFJ5HCUyEpgVEbMB0lVLjwHqA3ZErMrIvzXJjlwt8ia8ZmapXPqwMzdbSY1P1/OH5Lld5jb3c4H9mrjH6cDZQAfgk62VWchx2JMl7ULylybzoeOUzOnqZmalIpeAnbnZymaXF3ElcKWkE4AfkswEb1ahl1etBZ4qZBlmZvlSG3nrEplHshRHnYFs2tu2KRPIYpJhscZhm5mVnKiNrI9WTAGGStpRUgeSnbYmZmaQNDTj9DMkG5a3qKAtbDOzclKbp4eOEbFR0hnAvUA1cF1ETJc0DpgaEROBMyQdCmwAltNKdwg4YJuZ1avN07A+gIiYBExqdO2ijNffzfWeDthmZqlSn+nogG1mlor8PXQsCAdsM7OUW9hmZmXCAdvMrEzU1JT2nD4HbDOzVL4WfyoUB2wzs5S7RMzMyoRHiZiZlYlibf2VLQdsM7NU7UY/dDQzKwvuEjEzKxN+6GhmViZKfVifstn914pP0tiM7YfMAH8vtjTewKB8jG09i22B/L3Ygjhgm5mVCQdsM7My4YBdPtxPaU3x92IL4oeOZmZlwi1sM7My4YBtZlYmHLBLkKTtJT0saYak6ZK+m17vIel+Sa+lP7sXu67WdiS9KelFSc9Lmppe83diC+KAXZo2At+LiN2BUcDpknYHLgAejIihwIPpuW1ZDomIvSNieHru78QWxAG7BEXEgoh4Ln29GngZGAAcA9yQZrsB+FxRKmilxN+JLYgDdomTNBjYB3ga6BMRC9KkhUCfYtXLiiKA+yQ9K6luhqO/E1sQL/5UwiRtA9wOnBkRqyTVp0VESPKYzC3LQRExT1Jv4H5Jr2Qm+jtR+dzCLlGS2pME65si4u/p5UWS+qXp/YDFxaqftb2ImJf+XAzcAYzE34ktigN2CVLSlP4T8HJEXJGRNBE4MX19IvCPtq6bFYekrSV1qXsNHA68hL8TWxTPdCxBkg4CHgNeBOoW6P0+ST/2rcAg4C3guIhYVpRKWpuStBNJqxqSrsy/RcRlknri78QWwwHbzKxMuEvEzKxMOGCbmZUJB2wzszLhgG1mViYcsM3MyoQDtplZmXDAtrySNFjSSznkP0lS/yzy/OFD1mucpEM/zD3Mis1riVixnUQyY29+IQuJiIsKeX+ztuAWthVCO0k3SXpZ0m2SOku6SNIUSS9JGq/EF4DhwE3povydJI2Q9G9J0yQ9UzcdG+gvaXK6UP/lzRUsqVrS9Wk5L0o6K71+vaQvSBqelvV8mh5p+s7p/Z+V9JikYQX/LZnlyAHbCmFX4KqI2A1YBZwG/CEiRkTEnkAn4KiIuA2YCnwlIvYGaoBbgO9GxEeBQ4E16T33Bo4HPgIcL2n7ZsreGxgQEXtGxEeAP2cmRsTUdAOAvYHJwK/SpPHAtyPiY8A5wFUf7ldgln/uErFCmBMRT6SvbwS+A7wh6TygM9ADmA78s9H7dgUWRMQUgIhYBZAuK/tgRKxMz2cAOwBzmih7NrCTpN8DdwP3NVVBSccD+wKHp8vYHgD8v4wlbLfK8TObFZwDthVC4wVqgqTFOjwi5ki6BOiY4z3XZbyuoZnvbkQsl/RR4NPAN4HjgP/OzCNpT+ASYHRE1EiqAlakrW6zkuUuESuEQZL2T1+fADyevn4nbc1+ISPvaqCun3om0E/SCABJXSTl1KiQ1AuoiojbgR+StKIz07sBNwNfj4glUN+Sf0PSF9M8SoO+WUlxC9sKYSbJxsHXATOAq4HuJKNBFgJTMvJeD/xR0hpgf5J+6t9L6kTSf53rULwBwJ/TVjPAhY3SjyHpTrmmrvsjbVl/Bbha0g+B9sAEYFqOZZsVlJdXNTMrE+4SMTMrE+4SsbIl6Wk+OJrjaxHxYjHqY1Zo7hIxMysT7hIxMysTDthmZmXCAdvMrEw4YJuZlYn/D5yqU7UfDOu4AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_hyperparam_results(results):\n",
    "    # Create a table of the performance metrics\n",
    "    df = pd.DataFrame(results, columns=['batch_size', 'learning_rate', 'val_loss', 'val_accuracy','epochs'])\n",
    "    \n",
    "    print(df)\n",
    "    df = df.pivot(index='learning_rate', columns='batch_size', values='val_accuracy')\n",
    "    df = df.round(3)\n",
    "\n",
    "    # Create heatmap\n",
    "    ax = sns.heatmap(df, annot=True, cmap='coolwarm')\n",
    "    ax.invert_yaxis()\n",
    "    ax.set_title('Validation Accuracy')\n",
    "    ax.set_xlabel('batch_size')\n",
    "    ax.set_ylabel('learning_rate(or)eta)')\n",
    "    plt.show()\n",
    "print(\"\\n######## Data Generated for 20 epochs ##########\\n\")\n",
    "plot_hyperparam_results(val_results)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "BDrq0GfKpdb8"
   },
   "source": [
    "### Report final performance on MNIST test set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "############ Test Accuracy Using MLP #################\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.99      0.93      0.96      1043\n",
      "           1       0.99      0.98      0.99      1146\n",
      "           2       0.96      0.97      0.96      1023\n",
      "           3       0.93      0.98      0.96       959\n",
      "           4       0.97      0.96      0.97       986\n",
      "           5       0.98      0.94      0.96       933\n",
      "           6       0.97      0.96      0.96       968\n",
      "           7       0.96      0.96      0.96      1025\n",
      "           8       0.93      0.95      0.94       949\n",
      "           9       0.93      0.97      0.95       968\n",
      "\n",
      "    accuracy                           0.96     10000\n",
      "   macro avg       0.96      0.96      0.96     10000\n",
      "weighted avg       0.96      0.96      0.96     10000\n",
      "\n",
      "The best and worst performing class is mentioned in given classification report of model trained above ......\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 720x864 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# WRITE CODE HERE\n",
    "print(\"############ Test Accuracy Using MLP #################\")\n",
    "y_test_pred = mlp.predict(test_imgs.reshape(test_imgs.shape[0],-1))\n",
    "plt.figure(figsize=(10,12))\n",
    "print(classification_report(y_test_pred,test_labels))\n",
    "# sns.heatmap(confusion_matrix(y_test_pred,test_labels))\n",
    "print(\"The best and worst performing class is mentioned in given classification report of model trained above ......\" )\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "KX-cXeY3pdhr"
   },
   "source": [
    "\n",
    "# Implementing a Convolution Module with Numpy\n",
    "\n",
    "* This topic will require you to implement the Convolution operation using Numpy.\n",
    "* We will use the Module for tasks like Blurring.\n",
    "* Finally, we implement Backpropagation for the convolution module.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "kHeieqicpdhz"
   },
   "source": [
    "# Question 4\n",
    "\n",
    "* Implement a naive Convolution module, with basic functionalities: kernel_size, padding, stride and dilation\n",
    "  \n",
    "* Test out the convolution layer by using it to do gaussian blurring on 10 random images of CIFAR-10 dataset\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "YoVvSEj0pdh5"
   },
   "outputs": [],
   "source": [
    "## Define a class Convolution Layer, which is initialized with the various required params:\n",
    "class Convolution_Layer():\n",
    "    \n",
    "    def __init__(self,in_channels,out_channels,filter_size, bias=True, stride=1, padding=0, dilation=1,eta=0.00001):\n",
    "        self.weights = np.random.normal(loc=0,scale=0.001 ,size= (out_channels,filter_size[0],filter_size[1],in_channels))//np.sqrt(np.product(filter_size)*in_channels*out_channels)\n",
    "        self.filter_size = filter_size\n",
    "        self.out_channels = out_channels\n",
    "        self.in_channels = in_channels\n",
    "        self.stride = stride\n",
    "        self.padding = 0 and padding\n",
    "        self.dilation = dilation\n",
    "        self.output= None\n",
    "        self.eta = eta\n",
    "        self.gradient_matrix = np.zeros(shape= (filter_size[0],filter_size[1],in_channels))\n",
    "        \n",
    "        print(\"Filter Weights Shape: \",self.weights.shape)\n",
    "         \n",
    "        # For an untrained layer, set random initial filter weights\n",
    "    def convolve2D(self,Input,filter_w,mode=\"default\"):\n",
    "#         print(\"Convolve2D:\\n\") \n",
    "#         print(Input.shape)\n",
    "        input_shape = Input.shape\n",
    "        filter_shape = filter_w.shape\n",
    "        df = len(filter_shape)\n",
    "        di = len(input_shape)\n",
    "        if di!=df: print(\"Dimension are different ie.e x shape {}!= f_shape{}\".format(di,df))\n",
    "        pdd= [(filter_shape[0]-1,filter_shape[0]-1),(filter_shape[1]-1,filter_shape[1]-1)]\n",
    "        \n",
    "        output = np.zeros(shape=(self.weights.shape[1],self.weights.shape[2]))\n",
    "        \n",
    "        if(mode==\"full\"):\n",
    "            Input = np.pad(Input,pdd)\n",
    "            output =np.zeros(shape=(self.input_v.shape[0],self.input_v.shape[1]))\n",
    "            \n",
    "        for i in range(0,output.shape[0],self.stride):\n",
    "            for j in range(0,output.shape[1],self.stride):\n",
    "                output[i,j] = np.sum(np.multiply(filter_w,Input[i:i+filter_shape[0],j:j+filter_shape[1]]))\n",
    "        \n",
    "        return output\n",
    "            \n",
    "    def forward(self,input_v,mode=\"\"):\n",
    "        h,w,d = input_v.shape\n",
    "#         \n",
    "        \n",
    "        input_v = np.pad(input_v,[(self.padding, self.padding), (self.padding, self.padding),(0,0)],mode='constant')\n",
    "        self.input_v = input_v\n",
    "        hd,wd,dd = (h-self.filter_size[0]+2*self.padding)//self.stride + 1,(w-self.filter_size[1]+2*self.padding)//self.stride + 1, self.out_channels\n",
    "        output = np.zeros(shape=(hd,wd,dd))\n",
    "\n",
    "\n",
    "        for k in range(0,self.out_channels):\n",
    "            for i in range(0,output.shape[0],self.stride):\n",
    "                for j in range(0,output.shape[1],self.stride):\n",
    "                    output[i,j,k] = np.sum(np.multiply(self.weights[k,:,:,:],input_v[i:i+self.filter_size[0],j:j+self.filter_size[1],:self.in_channels]))\n",
    "        self.output = output\n",
    "\n",
    "        return output\n",
    "\n",
    "\n",
    "\n",
    "    def backward(self, output_gradient):\n",
    "        input_gradient = np.zeros(shape=self.input_v.shape)\n",
    "        \n",
    "        weight_gradient = np.zeros(shape=self.weights.shape)\n",
    "        \n",
    "        for i in range(0,self.out_channels):\n",
    "            for j in range(0,self.in_channels):\n",
    "                weight_gradient[i,:,:,j] = self.convolve2D(self.input_v[:,:,j],output_gradient[:,:,i])\n",
    "                input_gradient[:,:,j] += self.convolve2D(output_gradient[:,:,i],self.weights[i,:,:,j],mode=\"full\")\n",
    "        self.weights -= self.eta*weight_gradient\n",
    "        return input_gradient\n",
    "        \n",
    "    \n",
    "    def set_weights(self, new_weights):\n",
    "            \n",
    "        self.weights = new_weights\n",
    "        \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "def unpickle(file):\n",
    "    with open(file, 'rb') as fo:\n",
    "        dict = pickle.load(fo, encoding='bytes')\n",
    "    return dict\n",
    "\n",
    "    \n",
    "\n",
    "def gaussian_filter(image, kernel_size, sigma,cl):\n",
    "    \n",
    "    ########## kernel Implementation ##############\n",
    "    kernel = np.zeros((kernel_size, kernel_size))\n",
    "    for i in range(kernel_size):\n",
    "        for j in range(kernel_size):\n",
    "            kernel[i,j] = np.exp(-((i-kernel_size//2)**2 + (j-kernel_size//2)**2) / (2*sigma**2))\n",
    "    \n",
    "    kernel = kernel / np.sum(kernel)\n",
    "    kernel = kernel.reshape(1,kernel_size,kernel_size,1)\n",
    "    \n",
    "    \n",
    "    cl.set_weights(kernel)\n",
    "    filtered_image = np.zeros(shape=(image.shape[0]-kernel_size+1,image.shape[1]-kernel_size+1,3))\n",
    "    \n",
    "    for i in range(image.shape[2]):\n",
    "        filtered_image[:,:,i] = cl.forward(image[:,:,i:i+1])[:,:,0]\n",
    "    return filtered_image\n",
    "\n",
    "    \n",
    "  \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "TDoqiua8pdia"
   },
   "source": [
    "### Download CIFAR-10 images and load it in a numpy array (https://www.cs.toronto.edu/~kriz/cifar.html)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "s=unpickle(\"data/cifar-10-batches-py/data_batch_1\")    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initialize a conv layer. Set weights for gaussian blurring (do not train the filter for this part). Visualise the filters using matplotlib\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Filter Weights Shape:  (1, 3, 3, 1)\n"
     ]
    }
   ],
   "source": [
    "b_imgs=[]\n",
    "for i in range(5):\n",
    "    img = s[b'data'][i].reshape(3,32,32).transpose(1,2,0)\n",
    "    b_imgs.append(img)\n",
    "    \n",
    "       \n",
    "cl = Convolution_Layer(1,1,(3,3))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generate output for the first 5 images of the training set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# WRITE CODE HERE\n",
    "## gaussian blurring here ######\n",
    "\n",
    "filtered_images = [[],[],[]]\n",
    "for image in b_imgs[:5]:\n",
    "    f_img = gaussian_filter(image,3,3,cl)\n",
    "    f_img = f_img.astype(np.uint8)\n",
    "    \n",
    "    filtered_images[0].append(f_img[:,:,0])   # for Ist channel\n",
    "    filtered_images[1].append(f_img[:,:,1])   # for IInd channel\n",
    "    filtered_images[2].append(f_img[:,:,2])   # for IIIrd channel\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Use matplotlib to show the input and corresponding blurred output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 20 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "rows=5\n",
    "cols = 4\n",
    "img_count = 0\n",
    "\n",
    "fig, axes = plt.subplots(nrows=rows, ncols=cols, figsize=(15,15))\n",
    "\n",
    "for i in range(5):\n",
    "    axes[i, 0].imshow(b_imgs[i])\n",
    "    axes[i, 1].imshow(filtered_images[0][i])    \n",
    "    axes[i, 2].imshow(filtered_images[1][i])    \n",
    "    axes[i, 3].imshow(filtered_images[2][i])  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "zmsPeOEOpdi8"
   },
   "source": [
    "## Question 5\n",
    "<br>\n",
    "Now we will use this module for training a simple Convolution Layer using CIFAR-10 images. \n",
    "\n",
    "* The goal is to learn a set of weights, by using the backpropagation function created. To test the backpropagation, instead of training a whole network, we will train only a single layer.\n",
    "  * Instantiate a Convolution  layer $C_0$ with 20 filters, each with size 5$\\times$5 (RGB image, so 3 input channels). Load the given numpy array of size (20,3,5,5), which represents the weights of a convolution layer. Set the given values as the filter weights for $C_0$. Take 100 CIFAR-10 images. Save the output of these 100 images generated from this Convolution layer $C_0$. \n",
    "  \n",
    "  * Now, initialize a new convolution layer $C$ with weight values sampled from uniform distribution [-1,1]. Use the $L_2$ loss between the output of this layer $C$ and the output generated in the previous step to learn the filter weights of $C_0$.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b'broodmare_s_001836.png'\n",
      "(100, 32, 32, 3) (100,)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "b_imgs = []\n",
    "b_labels  = np.array(s[b'labels'])\n",
    "###### choose the 100 shuffled images at random from 1st batch #######\n",
    "for j in range(10000):\n",
    "    img = s[b'data'][j].reshape(3,32,32).transpose(1,2,0)\n",
    "    b_imgs.append(img)\n",
    "b_imgs = np.array(b_imgs)    \n",
    "ind = list(range(10000))\n",
    "np.random.shuffle(ind)\n",
    "\n",
    "\n",
    "\n",
    "train_imgs =b_imgs[ind[:100],:]\n",
    "train_labels = b_labels[ind[:100]]\n",
    "    \n",
    "    \n",
    "######## 15th example chosen from Dataset #####\n",
    "print(s[b'filenames'][ind[15]])\n",
    "print(train_imgs.shape,train_labels.shape)\n",
    "plt.imshow(train_imgs[15])\n",
    "train_labels[15]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "p8dGnMHOpdjD"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(20, 3, 5, 5)\n",
      "(20, 5, 5, 3)\n",
      "Filter Weights Shape:  (20, 5, 5, 3)\n"
     ]
    }
   ],
   "source": [
    "## Load filter weights from given numpy array \"C0_weights.npy\".\n",
    "## Init a conv layer C_0 with these given weights\n",
    "x= train_imgs\n",
    "train_imgs = (x - x.mean(axis=(0,1,2), keepdims=True)) / x.std(axis=(0,1,2), keepdims=True)\n",
    "\n",
    "C0_weights = np.load(\"data/C0_weights.npy\")\n",
    "print(C0_weights.shape)\n",
    "C0_weights = C0_weights.transpose(0,2,3,1)\n",
    "print(C0_weights.shape)\n",
    "\n",
    "## For all images get output. Store in numpy array.\n",
    "C0_layer = Convolution_Layer(3,20,(5,5))\n",
    "C0_layer.set_weights(C0_weights)\n",
    "C0_output_imgs = []\n",
    "for i in range(100):\n",
    "    C0_output = C0_layer.forward(train_imgs[i])\n",
    "    C0_output_imgs.append(C0_output)\n",
    "C0_output_imgs = np.array(C0_output_imgs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(100, 28, 28, 20)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C0_output_imgs.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "nhhHA4UCpdji"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Filter Weights Shape:  (20, 5, 5, 3)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.34it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 1/100 and avg_loss: 156.32080721050914\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.35it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 2/100 and avg_loss: 88.48919729777423\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.35it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 3/100 and avg_loss: 70.36822297032934\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.35it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 4/100 and avg_loss: 60.155696625816354\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.34it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 5/100 and avg_loss: 53.325330491332316\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.33it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 6/100 and avg_loss: 48.310188040081975\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.33it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 7/100 and avg_loss: 44.405730275737874\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.35it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 8/100 and avg_loss: 41.244458417083905\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.38it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 9/100 and avg_loss: 38.613377446631894\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 10/100 and avg_loss: 36.379018899955675\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 11/100 and avg_loss: 34.45255226527642\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 12/100 and avg_loss: 32.771876428058484\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 13/100 and avg_loss: 31.291738938607043\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.39it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 14/100 and avg_loss: 29.977990373395226\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.39it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 15/100 and avg_loss: 28.804102028316336\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 16/100 and avg_loss: 27.74897647403419\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 17/100 and avg_loss: 26.79552125944458\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.39it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 18/100 and avg_loss: 25.929686320759412\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.39it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 19/100 and avg_loss: 25.139791335053822\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 20/100 and avg_loss: 24.416039880479307\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 21/100 and avg_loss: 23.750157802372897\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 22/100 and avg_loss: 23.13511687227496\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 23/100 and avg_loss: 22.564918910882874\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 24/100 and avg_loss: 22.03442407622934\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 25/100 and avg_loss: 21.539212292779773\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 26/100 and avg_loss: 21.075470135230077\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 27/100 and avg_loss: 20.639897648683903\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.39it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 28/100 and avg_loss: 20.229631034471968\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.39it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 29/100 and avg_loss: 19.8421781256278\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 30/100 and avg_loss: 19.4753642792864\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.41it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 31/100 and avg_loss: 19.127286823969087\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 32/100 and avg_loss: 18.79627657972244\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.41it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 33/100 and avg_loss: 18.48086525792713\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 34/100 and avg_loss: 18.179757771168898\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 35/100 and avg_loss: 17.891808659253087\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.41it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 36/100 and avg_loss: 17.616001977233243\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.41it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 37/100 and avg_loss: 17.35143410369176\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 38/100 and avg_loss: 17.097299018596107\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 39/100 and avg_loss: 16.85287567440635\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.41it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 40/100 and avg_loss: 16.61751714515574\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 41/100 and avg_loss: 16.390641288599426\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.41it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 42/100 and avg_loss: 16.171722698269036\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.41it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 43/100 and avg_loss: 15.9602857569933\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.41it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 44/100 and avg_loss: 15.75589863242266\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.42it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 45/100 and avg_loss: 15.558168079352578\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.41it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 46/100 and avg_loss: 15.36673493399845\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.41it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 47/100 and avg_loss: 15.18127020250492\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.41it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 48/100 and avg_loss: 15.001471660416252\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.41it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 49/100 and avg_loss: 14.8270608920404\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 50/100 and avg_loss: 14.657780708972227\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.41it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 51/100 and avg_loss: 14.493392895805613\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 52/100 and avg_loss: 14.333676238508204\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 53/100 and avg_loss: 14.178424797266558\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 54/100 and avg_loss: 14.027446391005794\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.41it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 55/100 and avg_loss: 13.880561265391226\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 56/100 and avg_loss: 13.7376009200522\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 57/100 and avg_loss: 13.598407074130991\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 58/100 and avg_loss: 13.462830752139302\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.41it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 59/100 and avg_loss: 13.3307314745721\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.41it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 60/100 and avg_loss: 13.201976539846026\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.41it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 61/100 and avg_loss: 13.076440385947398\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 62/100 and avg_loss: 12.954004021737976\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 63/100 and avg_loss: 12.834554519210801\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.41it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 64/100 and avg_loss: 12.71798455914645\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.41it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 65/100 and avg_loss: 12.60419202361799\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 66/100 and avg_loss: 12.493079629653293\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.39it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 67/100 and avg_loss: 12.384554599106817\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 68/100 and avg_loss: 12.27852836043471\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.39it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 69/100 and avg_loss: 12.174916278622337\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 70/100 and avg_loss: 12.073637409993633\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 71/100 and avg_loss: 11.974614279048138\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 72/100 and avg_loss: 11.877772674831517\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.39it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 73/100 and avg_loss: 11.783041464659162\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.39it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 74/100 and avg_loss: 11.690352423283176\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.39it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 75/100 and avg_loss: 11.59964007582989\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.39it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 76/100 and avg_loss: 11.510841553039423\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 77/100 and avg_loss: 11.423896457518241\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.41it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 78/100 and avg_loss: 11.338746739870627\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.41it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 79/100 and avg_loss: 11.2553365837108\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.41it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 80/100 and avg_loss: 11.173612298675684\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.41it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 81/100 and avg_loss: 11.093522220661754\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.39it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 82/100 and avg_loss: 11.015016618599308\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 83/100 and avg_loss: 10.938047607156905\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 84/100 and avg_loss: 10.862569064837352\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 85/100 and avg_loss: 10.788536556987584\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 86/100 and avg_loss: 10.71590726329762\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 87/100 and avg_loss: 10.644639909410326\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.37it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 88/100 and avg_loss: 10.574694702304946\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 89/100 and avg_loss: 10.506033269153026\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 90/100 and avg_loss: 10.43861859937716\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 91/100 and avg_loss: 10.372414989671055\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 92/100 and avg_loss: 10.307387991763582\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 93/100 and avg_loss: 10.243504362731825\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 94/100 and avg_loss: 10.180732017686667\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 95/100 and avg_loss: 10.119039984671947\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 96/100 and avg_loss: 10.058398361633008\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.41it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 97/100 and avg_loss: 9.998778275323861\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 98/100 and avg_loss: 9.940151842033877\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 99/100 and avg_loss: 9.882492130025799\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████| 100/100 [00:18<00:00,  5.40it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epochs 100/100 and avg_loss: 9.825773123585753\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# for part 2 we need to write a class for the  L2 loss\n",
    "class L2_loss():\n",
    "    def ___init__(self):\n",
    "        self.f =None\n",
    "    \n",
    "    def forward(self, C0_output,C_output):\n",
    "        # Conv. output is of dimension (batchsize,channels,height,width)\n",
    "        # calculate the L2 norm of (C0_output - C_output)\n",
    "        self.f = C0_output-C_output\n",
    "        loss = np.linalg.norm(self.f)\n",
    "        \n",
    "        return loss\n",
    "    def backward(self,output_grad):\n",
    "        \n",
    "        # from the loss, and the conv. output, get the grad at each location\n",
    "        grad = -2*self.f\n",
    "        # The grad is of the shape (batchsize,channels,height,width)\n",
    "        return grad\n",
    "\n",
    "# Now Init a new conv layer C and a L2 loss layer\n",
    "C_weights = np.random.uniform(-1,1,size=C0_weights.shape)/np.sqrt(np.product(C0_weights.shape))\n",
    "\n",
    "C_layer = Convolution_Layer(3,20,(5,5))\n",
    "C_layer.set_weights(C_weights)\n",
    "\n",
    "# Train the new conv-layer C using the L2 loss to learn C_0, i.e., the set of given weights.\n",
    "epochs=100\n",
    "l2_loss = L2_loss()\n",
    "for epoch in range(epochs):\n",
    "    loss= 0\n",
    "    \n",
    "    for i in trange(train_imgs.shape[0]):\n",
    "\n",
    "        ## forward ###\n",
    "        C_output = C_layer.forward(train_imgs[i])\n",
    "        loss += l2_loss.forward(C0_output_imgs[i],C_output)/train_imgs.shape[0]\n",
    "\n",
    "        ### backward ####\n",
    "        loss_backward = l2_loss.backward(loss)\n",
    "        C_layer.backward(loss_backward)\n",
    "    \n",
    "    \n",
    "    print(\"epochs {}/{} and avg_loss: {}\".format(epoch+1,epochs,loss))\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Filter Weights Shape:  (20, 5, 5, 3)\n",
      "6.122678630579903\n",
      "9.510801660581873\n",
      "15.174464141338136\n",
      "5.0170420791171\n",
      "7.806960260646706\n",
      "4.768377295950659\n",
      "6.699546760432663\n",
      "9.821276874770943\n",
      "13.16160206628492\n",
      "18.980827352397476\n",
      "4.967112407765804\n",
      "5.146595521010078\n",
      "5.241666973725947\n",
      "10.797770565158283\n",
      "12.375903419199508\n",
      "6.271141726936732\n",
      "7.431025460899855\n",
      "16.38714102161456\n",
      "15.072524017684728\n",
      "15.598048208390889\n",
      "7.241726849021507\n",
      "27.12680101458788\n",
      "6.373120682562012\n",
      "7.4284969947271735\n",
      "11.26137497081683\n",
      "12.206657453577037\n",
      "6.622623984010958\n",
      "20.82943082422038\n",
      "6.783697298582141\n",
      "7.345469629847861\n",
      "6.507265995932246\n",
      "9.642205756198999\n",
      "4.873235796923667\n",
      "15.871640840608029\n",
      "17.418980413039137\n",
      "20.134800994447364\n",
      "2.815429482782505\n",
      "8.721736988508011\n",
      "5.604441983738715\n",
      "18.393923522364457\n",
      "4.655587669822809\n",
      "5.17297105385233\n",
      "13.740627613356445\n",
      "10.126075326062894\n",
      "8.092650719612998\n",
      "4.8012276563756755\n",
      "11.553436538497532\n",
      "4.88438630397847\n",
      "14.981573139958321\n",
      "12.233043418017813\n",
      "5.7351521262507195\n",
      "6.25206960977871\n",
      "15.281159743248326\n",
      "8.70428274097869\n",
      "5.185426895015211\n",
      "7.746625669679799\n",
      "11.329690932305553\n",
      "17.469759126153367\n",
      "5.2201702951158655\n",
      "5.902005579589643\n",
      "5.715054601934176\n",
      "16.032784489228625\n",
      "6.5239212561420015\n",
      "10.687595427127693\n",
      "10.114156555178788\n",
      "11.783379290608655\n",
      "4.051591994509468\n",
      "13.955105873430064\n",
      "4.128955896454127\n",
      "15.436435927018993\n",
      "7.2400081883890826\n",
      "1.976374703669666\n",
      "4.241931440869285\n",
      "10.713162845798093\n",
      "2.4887553932866613\n",
      "3.613502815777622\n",
      "5.890073583188283\n",
      "24.922635029093787\n",
      "9.906772731188903\n",
      "12.908041885774653\n",
      "8.033205566047949\n",
      "9.339810581604707\n",
      "15.423740418720326\n",
      "5.587231094888289\n",
      "12.113673355379882\n",
      "10.443020098211084\n",
      "7.327258605176408\n",
      "8.2685100075103\n",
      "17.4971704071006\n",
      "27.28766624758453\n",
      "7.510117762231438\n",
      "8.259751900169547\n",
      "12.370755301763888\n",
      "6.229094105525738\n",
      "6.802175284639916\n",
      "10.023377528552418\n",
      "1.3989581593686857\n",
      "8.232635632973658\n",
      "5.96898507382484\n",
      "9.249660088660114\n",
      "L2 distance between output from new_trained_Convolution Layer C and the outputs generated from C_0 is as follows:\n",
      "8405.809667796364\n"
     ]
    }
   ],
   "source": [
    "# Print L2 dist between output from the new trained convolution layer C and the outputs generated from C_0.\n",
    "C11_layer = Convolution_Layer(3,20,(5,5))\n",
    "C11_layer.set_weights(C_layer.weights)\n",
    "C11_output_imgs = []\n",
    "for i in range(100):\n",
    "    C11_output = C11_layer.forward(train_imgs[i])\n",
    "    C11_output_imgs.append(C0_output)\n",
    "    print(np.linalg.norm(C11_output-C0_output_imgs[i]))\n",
    "C11_output_imgs = np.array(C11_output_imgs)\n",
    "\n",
    "\n",
    "print(\"L2 distance between output from new_trained_Convolution Layer C and the outputs generated from C_0 is as follows:\")\n",
    "print(np.linalg.norm(C0_output_imgs-C11_output_imgs))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11.759698765834825\n"
     ]
    }
   ],
   "source": [
    "print(np.linalg.norm(C_layer.weights - C0_weights))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "colab": {
   "collapsed_sections": [],
   "name": "DLCV_Assignment_2-edit.ipynb",
   "provenance": []
  },
  "interpreter": {
   "hash": "6945496b114ae6c8dbcad4f53e4fc084fdd8255c08c862c02a1152642bece680"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}