Sequential_CNN_model_in_PyTorch.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "EGV-dq1E0dmq",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "05856722-013d-4927-913d-f73f6601885f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: keras in /usr/local/lib/python3.10/dist-packages (2.12.0)\n"
          ]
        }
      ],
      "source": [
        "# Import all necessity functions for Machine Learning\n",
        "import sys\n",
        "import math\n",
        "import string\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import seaborn as sns\n",
        "import matplotlib.pyplot as plt\n",
        "import scipy as shc\n",
        "import warnings\n",
        "import zipfile\n",
        "import cv2\n",
        "import os\n",
        "import re\n",
        "import nltk\n",
        "import random\n",
        "import requests\n",
        "from bs4 import BeautifulSoup\n",
        "import re\n",
        "from collections import Counter\n",
        "from functools import reduce\n",
        "from itertools import chain\n",
        "from wordcloud import WordCloud\n",
        "from google.colab.patches import cv2_imshow\n",
        "from keras.preprocessing import image\n",
        "from sklearn.metrics._plot.confusion_matrix import confusion_matrix\n",
        "from sklearn.model_selection import train_test_split, KFold, StratifiedKFold, GridSearchCV, RandomizedSearchCV\n",
        "from sklearn.preprocessing import StandardScaler, RobustScaler, MinMaxScaler\n",
        "from sklearn.decomposition import PCA\n",
        "from sklearn.cluster import KMeans, DBSCAN, AgglomerativeClustering\n",
        "from sklearn.feature_selection import mutual_info_classif, mutual_info_regression, SelectKBest, chi2, VarianceThreshold\n",
        "from imblearn.under_sampling import RandomUnderSampler, NearMiss\n",
        "from imblearn.over_sampling import RandomOverSampler, SMOTE, SMOTEN, SMOTENC, SVMSMOTE, KMeansSMOTE, BorderlineSMOTE, ADASYN\n",
        "from imblearn.ensemble import EasyEnsembleClassifier\n",
        "from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer\n",
        "from sklearn.naive_bayes import GaussianNB, BernoulliNB, MultinomialNB\n",
        "from sklearn.neighbors import KNeighborsClassifier, KNeighborsRegressor, NearestNeighbors\n",
        "from sklearn.linear_model import LinearRegression, LogisticRegression, SGDClassifier, SGDRegressor, Perceptron\n",
        "from sklearn.neural_network import MLPClassifier, MLPRegressor\n",
        "from sklearn.svm import SVC, SVR\n",
        "from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor, ExtraTreeClassifier, ExtraTreeRegressor\n",
        "from sklearn.ensemble import BaggingClassifier, BaggingRegressor, RandomForestClassifier, RandomForestRegressor, VotingClassifier, VotingRegressor\n",
        "from sklearn.ensemble import AdaBoostClassifier, AdaBoostRegressor, GradientBoostingClassifier, GradientBoostingRegressor, StackingClassifier, StackingRegressor\n",
        "from sklearn.metrics import classification_report, mean_absolute_error, mean_squared_error, r2_score, accuracy_score, recall_score, precision_score, f1_score, silhouette_score\n",
        "from xgboost import XGBClassifier, XGBRegressor\n",
        "\n",
        "# Download keras\n",
        "!pip install keras\n",
        "\n",
        "# Import all necessity functions for Neural Network\n",
        "import tensorflow as tf\n",
        "from keras.models import Sequential, Model\n",
        "from keras.utils import plot_model\n",
        "from keras.layers import Dense, Conv2D, LSTM, GRU, RNN, Flatten, AvgPool2D, MaxPool2D, GlobalAveragePooling2D, BatchNormalization, Dropout, LeakyReLU, ELU, PReLU,  Embedding\n",
        "from keras.activations import tanh, relu, sigmoid, softmax, swish\n",
        "from keras.regularizers import L1, L2, L1L2\n",
        "from keras.optimizers import SGD, Adagrad, Adadelta, RMSprop, Adam, Adamax, Nadam\n",
        "from keras.initializers import HeNormal, HeUniform, GlorotNormal, GlorotUniform\n",
        "from keras.losses import SparseCategoricalCrossentropy, CategoricalCrossentropy, hinge, MSE, MAE, Huber, BinaryCrossentropy\n",
        "import keras.utils as image\n",
        "from google.colab.patches import cv2_imshow\n",
        "from keras.utils import plot_model\n",
        "\n",
        "# Plotting the confusion matrix\n",
        "from mlxtend.evaluate import confusion_matrix\n",
        "from mlxtend.plotting import plot_confusion_matrix\n",
        "from sklearn.metrics import multilabel_confusion_matrix\n",
        "from sklearn.metrics import confusion_matrix"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Remove all warnings\n",
        "import warnings\n",
        "warnings.filterwarnings(\"ignore\")"
      ],
      "metadata": {
        "id": "LtNPLbXT0lkz"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#####Import the dataset"
      ],
      "metadata": {
        "id": "WULinOZQMErV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import keras\n",
        "tf.keras.datasets.mnist.load_data(path=\"mnist.npz\")\n",
        "(X_train, y_train), (X_test, y_test) = keras.datasets.mnist.load_data()\n",
        "\n",
        "print(\"X_train shape # {} \".format(X_train.shape),'\\n')\n",
        "print(\"X_test shape  # {} \".format(X_test.shape),'\\n')\n",
        "print(\"y_train shape # {} \".format(y_train.shape),'\\n')\n",
        "print(\"y_test shape  # {} \".format(y_test.shape))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WMzXAM2wMLk-",
        "outputId": "f1c1d084-0d71-462a-84b6-a13b48a22d8b"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "X_train shape # (60000, 28, 28)  \n",
            "\n",
            "X_test shape  # (10000, 28, 28)  \n",
            "\n",
            "y_train shape # (60000,)  \n",
            "\n",
            "y_test shape  # (10000,) \n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#####Display some of the dataset"
      ],
      "metadata": {
        "id": "owvvcwWRNCaL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "plt.figure(figsize = (16, 10))\n",
        "for index, data in enumerate(X_train[0:20]):\n",
        "  plt.subplot(2, 10, index + 1)\n",
        "  plt.imshow(data)\n",
        "\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 504
        },
        "id": "Ej8IuOFSNE4L",
        "outputId": "f875bc6c-17e7-4e4b-f8a7-f4b78fc6bd7a"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1600x1000 with 20 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAABjYAAAIjCAYAAACgdCKfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABtS0lEQVR4nO3deZzVdb0/8M/MsCOLgIAIBAaIO4YbampJmv5yC0utbmaWqaC5tFy7LbeyaNc01DYx65ZlpZaVLbjlDTfKcmNxJxVcWQTZZs7vj+7l+j5fnOHMnOF7vmeez8dj/nh953u+59P46jvnzIfz+TSUSqVSAgAAAAAAKIDGvAcAAAAAAACwuUxsAAAAAAAAhWFiAwAAAAAAKAwTGwAAAAAAQGGY2AAAAAAAAArDxAYAAAAAAFAYJjYAAAAAAIDCMLEBAAAAAAAUhokNAAAAAACgMExsAAAAAAAAhdFpExuzZs1KY8aMSb169Ur77LNPuuuuuzrrqWAjvSMvukce9I686B550DvyonvkQe/Ii+6RB72jPRpKpVKp2hf96U9/mt773vemyy+/PO2zzz7poosuStdcc01asGBBGjp0aKuPbWlpSU8//XTq169famhoqPbQ2MJKpVJauXJlGjFiRGps7NwPCHWkdynpXr0pSvf0rr4UpXcp6V69KUr39K6+FKV3KelevSlK9/Su/myp7rnn8WrueeTFPY88VNS7UifYe++9S9OnT9+Ym5ubSyNGjCjNnDmzzccuXry4lFLyVWdfixcv7oyqBR3pXamke/X6Vevd07v6/Kr13pVKulevX7XePb2rz69a712ppHv1+lXr3dO7+v3q7O655/nKo3elknuer3y6557nq72965aqbN26dWnevHnp/PPP33issbExTZ06Nc2dOzdz/tq1a9PatWs35tL/fIDkgHRE6pa6V3t4bGEb0vp0e/pt6tevX6c+T6W9S0n36l2tdk/v6lut9i4l3at3tdo9vatvtdq7lHSv3tVq9/Su/m2J7rnnUc49j7y455GHSnpX9YmN559/PjU3N6dhw4aF48OGDUvz58/PnD9z5sz02c9+dhMD6566NShj4f3r3tLpHwWrtHcp6V7dq9Hu6V2dq9HepaR7da9Gu6d3da5Ge5eS7tW9Gu2e3nUBW6B77nlkuOeRF/c88lBB7zp3cb7NcP7556fly5dv/Fq8eHHeQ6KL0D3yoHfkRffIg96RF90jD3pHXnSPPOgdedE9/lfVP7ExZMiQ1NTUlJYuXRqOL126NA0fPjxzfs+ePVPPnj2rPQy6mEp7l5LuUR3ueeTBPY+8uOeRB/c88uKeRx7c88iLex55cM+jI6r+iY0ePXqkyZMnpzlz5mw81tLSkubMmZOmTJlS7aeDlJLekR/dIw96R150jzzoHXnRPfKgd+RF98iD3tERVf/ERkopnXvuuemkk05Ke+65Z9p7773TRRddlFatWpVOPvnkzng6SCnpHfnRPfKgd+RF98iD3pEX3SMPekdedI886B3t1SkTG8cff3x67rnn0qc//em0ZMmSNGnSpHTjjTdmNoKBatI78qJ75EHvyIvukQe9Iy+6Rx70jrzoHnnQO9qroVQqlfIexKutWLEiDRgwIB2cjraTfR3YUFqfbknXp+XLl6f+/fvnPZxW6V59KUr39K6+FKV3KelevSlK9/SuvhSldynpXr0pSvf0rv7oHnnQO/Kie+Shkt5VfY8NAAAAAACAzmJiAwAAAAAAKAwTGwAAAAAAQGGY2AAAAAAAAArDxAYAAAAAAFAYJjYAAAAAAIDCMLEBAAAAAAAUhokNAAAAAACgMLrlPQCgNmx48+SQnzljbch/n/KDkHefe1LII2b1yFyz6ea/Vml0AABAXhbOju8VHjvs+yF/48XtM4/50zv3DLn5wYXVHxgAsMUN/u+tQ25sKIX83H7Ltsg4fGIDAAAAAAAoDBMbAAAAAABAYZjYAAAAAAAACsMeG52ooVv88TZtM6Tiayz4yJiQm/u0hPy61z8bcp8zGjLXWPKNuPfBX/f8acjPN68KeZ9rzgt53Ll3bNZYKY6Wg/bIHLv4im+FPK577G9sXkp/mzI75AV7Nmeu+dEx+7ZvgNABq47bJ+Qvf+WykD//zveGXLrn/k4fE8X3yFenhPzQu76VOad7Q1PIB55xasi9r7ur+gMD2AxNgweF3DCgf8hPThsR8pohcZ3kcZ/9e+aaLatXV2l01KKmnXcI+fo3zQp5fal7yNO3XpC5xs93OzTkfg9WaXDUtYbJO4fc0iO+L33q4L4hP3DmpZlrrC9l35t21CH3Hxdy36OfCbllzZqqPyf5aejZM+TVh+8e8m7/kf29uGivtZljUC8Wfj/um3X36G+GPOXP00PePt3b2UNKKfnEBgAAAAAAUCAmNgAAAAAAgMIwsQEAAAAAABSGPTZeQ9OO4zPHSj3jOqJPHzQw5Ff2jXtVDBoQ8593j3tbVMPvVvcL+cvfemvmnDt3/XHIj61/JeQvLX1LyCP+HNfUpfjWHxrXwvvYpT/MnDOhe9yLpaVsV41H168PeXlLXHNyjxhTSimtPXyvkHvffF98DuuQVs0rR+8d8+C41v+gK+ZuyeHk6tk945z95x8/MqeRUGRLztkv5FuO/0rI60vxnrlJfp0CW0DjLhNDXnR+78w579/1LyGfN/j3FT3HjsNOyxwb/755FV2DgnlqSYhnLTwh5D/u/IstORrqSGlK3Ktg0fvia6oL3/yTkLs3bAh5au+VIa8vZf+9bvl72Wr44y4/C3nSD98f8tjTnw65+fkXqj4GtpzyPXJvnnV5yH9ek/1z6lfHxvedGx57ovoDgy1k4WXxb0x3H3phyCtb4pvd/rdmX39uCT6xAQAAAAAAFIaJDQAAAAAAoDBMbAAAAAAAAIVhj43/0XzwG0L+xpWzMueU70GQh/Wl5pA/fcn7Qu62Krug95RrZoTc76m4RmXP5+OeG33uubMDIyQPTf37h7zqwLjW8jkXxn1W3tT75U1cpfV5zitfiuvNz7l0Ssj//Z8XZx7zx+/FdSh3+lHs4vYf7zr7PnS2pw+M//36vH5ZPOGKLTeWLaqxKXOoNDre0w4ZOj/kOQ2xy7ApL4+KazMPasz/NQC1Zd1hcf+qJ94dO3P6G27NPObsrRe2es1dv3dmyH2eia/rlu23NvOY1/1XvP/3+P09rT4HxdOw164hP3xO/N13ywHfCnmbpuzGZ41lr/N+s3rrkB9dOzTk6VsvCPmHB343c83P73VSyKW778ucQ3E1L1se8hP/LNuDcuctOBjqSumCF0OeP/GXOY2kY+7dL77BOmyfM0Lu+Rt7bNSzN/bakDn2hdGDQm60xwYFdvAeD4Xcr+z98BlPxD2eh3w7n7/v+cQGAAAAAABQGCY2AAAAAACAwjCxAQAAAAAAFIY9Nv5HzwVPhzxvzajMORO6L63qc573zL6ZY4++PCTkK1//85CXt8S1lodd/JcOjyO7KwdF88+rtgv57r2ye8R01OeG3h3yjVvFfQpOfvzQzGN+MOZPIfffyTqjneWzb7sm5C8/lP3vUY+aXv+6zLH5B8X1bifd9Z6QR1gDnE14+R37hPyLY79ZdkZDSJcvm5jK/emdcc+Fvk88EHLcgYGiee60uLfUJR+Lv2v37Bn3QSvf0yCllE56fGrIewx4MuS/f6C8d9GmrrnfoBNDHvT7Vi9BDWraZpuQF34zvq779X6Xhrx99+5lV8juqVFu9or43ua6aQeE3NIzXnP6DXGPjfJ+p5TSK8N6h9yrzVFQJE3D4r4rb9yx9T2CYHM9dUvZ31qyL6mCuWviPe79v/1gPCG+RPuXNv7Ise8bYp9nj/lD6w+AMk0N/p04neOVo/cOech5j4W89vjsPqMbnlnSoed89ozsPqRfHnZhyD9aEf/28tL5o0NuTPn8vc//EwEAAAAAgMIwsQEAAAAAABSGiQ0AAAAAAKAwTGwAAAAAAACFYfPw/1G+0colX35H5pwvvHVVyE3/2Crkv59xSavPccHzu4X88NQ+mXOalz0T8rumnBHy42fF88emv7f6nNSnDW+eHPJPJn0r5MbUo9XHn/zEIZlj9/xpx5DvOyVe8+ZX4paQQ+95JeSHX8ru+tb9izfHcW1qYzeqonvDhryHkItu31vd5jmvPNJ/C4yEolnztrgp22dmxk3nJ3Rv/Yb1g+++NXNs+IN/6fjAyE1D9/i7c83U3UP+xflfDXlEt7iZ6SlPvCXkJ762Q+Y5+v7m3pBv7hM33bv12gnxOcf/6rUH/D9W3Ds45EFtPoJa89R7xof8wEHlm8iXbxbeuh+VbRSeUkrXHRM3hWxeEDfObdhj54qegy6gX98Qjxh0d8WXeHZy/F068B/xHtf8oA3Ju6LRX7on5GN/dmKr5zesWx/y+Mfu7PAYlg2Jvzv/dEe/kKf2XtnmNd583/Eh97/5gZBb2jk2iqG5lP0vvL5P/BNrz8wZ0Lb3fOmGkE/uvzjkqZNPzzym1w0d2zz8pOm/zRyb1DM2+IOfPzbkQX+e26HnrJaKP7Fx2223pSOPPDKNGDEiNTQ0pOuuuy58v1QqpU9/+tNp2223Tb17905Tp05NixYtqtZ46aL0jrzoHnnQO/Kie+RB78iL7pEHvSMvukce9I7OVPHExqpVq9Luu++eZs2atcnvf+UrX0kXX3xxuvzyy9Odd96Z+vbtmw477LC0Zs2aDg+WrkvvyIvukQe9Iy+6Rx70jrzoHnnQO/Kie+RB7+hMFS9Fdfjhh6fDDz98k98rlUrpoosuSp/85CfT0UcfnVJK6aqrrkrDhg1L1113XTrhhBM6Nlq6LL0jL7pHHvSOvOgeedA78qJ75EHvyIvukQe9ozNVdY+Nxx57LC1ZsiRNnTp147EBAwakffbZJ82dO7dQhRw0O7tW2Da/juswNr/wYsg77/L+kB84MK7X/avvHBTy0GVtr8XdMDfuoTG2NpYwqyn11LvX0nLQHiFffEXc/2Jc9/h/5ZayFT2Pmh/Xwms6Lu4Xk1JKA/9fKeSdfjgj5Amz4rp+jYv/FvLWf85cMq3/QnPIv9gt/n/i/W+Km8Y03fzX7EVqWJ7dazlgUshv7HV7pz1XLRvT94U2zxn1p+Y2zymSrnDP2xKeeU/8F0Bv6l3+L4KaQjrp8akhD/9m19tPo96798yMPUO+6yPl+xzEdWbf8fCRIW+YFtcA7/N8dg3wUll++tS4Z9ad48ufM/rd6n6ZY+O+HX8/19uOS/Xeu5RS2u6oxys6/+cvDw/5Gwvj3mnDPlbetJSaF7S+pMNLu9qPqlxX6F5rmh9+LORP/jruJzDtxE3/y9tXe+BdF4e8x/IPhzzKHhsZXaF3pfXrQm5e8PAWH8PSt8f9XnbtcX3ZGW3vjvD003FXq61WP9rRYeWqK3Svsz07Oe6JNep3OQ2kQPQu65l1A0NuSU+EvKF3xzevLf8b49FbZfeMXl/qHZ+3V21umlvViY0lS/61WcmwYcPC8WHDhm38Xrm1a9emtWvXbswrVqyo5pDoAtrTu5R0j45zzyMP7nnkxT2PPLjnkRf3PPLgnkde3PPIg3seHVXxHhvVNnPmzDRgwICNX6NGjcp7SHQRukce9I686B550DvyonvkQe/Ii+6RB70jL7rH/6rqxMbw4f/6WPTSpUvD8aVLl278Xrnzzz8/LV++fOPX4sWLN3kevJb29C4l3aPj3PPIg3seeXHPIw/ueeTFPY88uOeRF/c88uCeR0dVdSmqsWPHpuHDh6c5c+akSZMmpZT+9XGgO++8M51++umbfEzPnj1Tz55tr19YC5qfb30t9/UrerT6/Z3f/WDIz13WlD2ppb7Wgt8S2tO7lGq3ew2Td84ce/7cV0Ke0D12bd7aENNNL+8U8gtXx9nrwS9lN2sZ8KM7Yi77fjXW7B7WFH/eL5y9OuShN1fhSbagPO95T7wtrnc4tKlPh69ZBN3GjA75uEG/avMxvR97KeSi32Xr7Z63JXQbuV3m2ANvnB3y+lJsxkNxu4T05DfiWsx9U3b/hHpXT6/zFl2yT+bYgrfHtWVbyr6/4x9PC3niRx4Pua3XiZty2unla3q37oIvnJQ5tvXi+t6ArUvc8z4Yx7nT9DNDHvXHeH/q+0BcmmHIE3Gfgvb8nls9rDbXTc5TPd3zquH1H4nvFdKJ+Yyj3nWJe14Onjt9SsgT3zM/5PL3qZtjx4/FfWi64nuMeu5daX18M7BwfdyPb0L3XpnHvDJ2XeYYrXPPS2nRxfF9ybWD43uSy5bF96ED73gqc422/l7XNDD+he/5j8R9d0d0y/4sz3l6v5CHfX9eyNkd3fJR8cTGyy+/nB5++P82d3rsscfSvffemwYNGpRGjx6dzj777HTBBRek8ePHp7Fjx6ZPfepTacSIEemYY46p5rjpYvSOvOgeedA78qJ75EHvyIvukQe9Iy+6Rx70js5U8cTGPffck970pjdtzOeee25KKaWTTjopXXnlleljH/tYWrVqVTr11FPTsmXL0gEHHJBuvPHG1KtXdjYTNpfekRfdIw96R150jzzoHXnRPfKgd+RF98iD3tGZKp7YOPjgg1Op9NofOGloaEif+9zn0uc+97kODQxeTe/Ii+6RB70jL7pHHvSOvOgeedA78qJ75EHv6ExV3WOjq9vx43F925N3PSTk2a+bE/JB75ieuUa/n96ROUZ9a+wT90bY8JUVmXPumPjLkB/bENduPPcT54W89Z+fDHlo32dDrpX1P/fe9omQH89nGIXUbdzKVr+/Zv7ALTOQLWzxRX1D3r9n+Sr4KX1/xch4YFn2/1PUt6addwh5zx/fX/E1jv/lWSG//hd+PxfZI1/fN+QFb5+VOWd5S1w7+R3z3xXyDmeW7WOwsvX7cGPfvpljLxy3W8hHb/XV+JgU90+aeE18rTjuyvreT6Oran44rtM+7pzHXuPMf6nGvmfl1u/Vep+hXPeGuF/k+lpZbJsu59kZ+2WOnXT6b0N+T/+vhdyvsfX9UTfl88+9IeTSWvsp1LPmpfFvKGc9cnzIN06sbJ80+F9NO4wL+Ydvuyzk1aW4v8sv/+PQkHsvvqvi51x06diQ73/Dd0P+0yv9so/Za23mWC1qzHsAAAAAAAAAm8vEBgAAAAAAUBgmNgAAAAAAgMKwx0YVNS9bHvILp+8Y8pO/eiXkf7/gqsw1zn/nsSGX/jYg5FFfKFtbuZUNeCiGVw7aOeTfT7y0zcd84MPnhNzvurj2e2esvUyxDL0nu/dELWoaMjjkpdMmhDzonf8M+dYJ3y+7Qq/MNS+bdUzIQ5f+pd3jo5ieOCr26ueD/7aJs+La4O965MiQJ3zpkZBrZW8iNk/TsKEh/+DY+Lu1JWXvkeV7avR4S9wHqq27auOknULe5YqHMudcMOzisiM9Q9r/3hNC3uE/4zX0kE158tNxffkNfTbx/qChLJed8vbxre/fMuOfB2eO9b7xr61dkjq3vhTvSJu6r8KmlO+FtvDkrUM+6IDK9ka7YdQlmWPZPra+p8bD6+M76OMvOy9zzuhrl8bnWPlI5hyAcqX9J4V8wvdvCHnPnvH36cQbPxzyhOsq31Pj8QumhHzPgd8oOyNOB3z8e+/PXGO7VIy/o/jEBgAAAAAAUBgmNgAAAAAAgMIwsQEAAAAAABSGPTY6Ucvf47rIJ3z2oyH/12e+lnnMvfuW7buxb4w7950R8vjvPhPyhkcfr2yQ5G63z98bcuMm5htPfuKQkHu3Y429PHRviGvYry9bfLmpwWrMneWVQbFHfdtxjZY37hFyqSku0L14alwbft2I9SE39ohrRf7hjdn1b7uXrfm9pDle81OPxn2HXmyJ6+X2acyuOD/szpUha1n9e/HkuIbotad9teyM7pnHnLb4oJDXnxS71/zck1UZG/lo6BX/e5avXbspvc+K6283vG5UyItOGxnyoVPj/gLnDP1OyKO79c48R/mK381le6U1/HRI/P6yRa85XupXU//+Ia/Ze3zI3c+P67z/Y2L292u57Guy1v8/cfMrfUL+56mjM+eUNmT3kQF4tfK15VNK6X2zrw356L7Pd/BZOv7vdc96+PiQt/tydm15+1zRlq0Grc57CGxhDd3j+4dnZuyZOeeej8TXadnXZPEe9vZJ8T3Gr74c3+uO++zfM8/RODzuL3jUEXEf3qayzdYm/SXuqTH6S8XYT2NTfGIDAAAAAAAoDBMbAAAAAABAYZjYAAAAAAAACsPEBgAAAAAAUBg2D9+CBl0xN+QZC6Znzun/pX+G/JPtfx/yA+/9VsgTR30g5B0+m52ral70aEXjpHMt+7e48c8nh8VN5FtS3HwopZTm/WGnkEenYmzsU74xZUvZtqk3PhT/d41PcZMkXtvaNXEz5JayLbJnf+LCkH81Y1LFz/Hxwd8LubFsw6lXSutCfro5/vf+1nMHhzz1T2dnnmPg32Lft/1D3BC14Yl4T3zuobgZ77CmuGF5SimV7r4vc4z60rTzDiH/5YJvlZ3Rq81rzP3nmJBHPX5/B0dFLSmtWRvynWvjPXOfntl7x/V/ujrk8t9ZbfnTK3Hj70XrS5lz3tT75ZDvWRfvgQOviq8VqT8NPXtmjq07aNeQz7n0hyG/qfeckJc2x37f/MrWIX964dGZ5/jJzleGPKJbdhyv1qsx/n/k0XcOzJyz/YJ4r21Zs6bVawKklFJT2fuWxg7+e9vyjXhTSmkTv4JbdeOOcUPzN747+7eaAf91R+YYvNov3vDdkM9M++c0EraUJafFzcLv+sg3M+eUv6Movz9dtWK7kL84/M6Y3xPzJ6buk3mOtwz4Xcjl7znuXBtfs41+R/38zcQnNgAAAAAAgMIwsQEAAAAAABSGiQ0AAAAAAKAw7LGRo4b/vjdzbPVxQ0Pe6/gzQ77z43G9tvlvimvgv3vMoZlrLj+gnQOkU2yIWwSkAY1xfe25a7JrHm9/1dPxGlUfVeUa+/QJef7XdtnEWfNCevejh4c88cOPhRx3aKA1497zt5B3njkj5FF7PdXh57j52QkhP/e7kSEPfiCuv93jxrvLrhC/PyHd0+ZzlnfgqY/vF/JePeP681e/HNejpGtY+Il4/ynfz2dzjP5SzBUuxUyNa176bMifOT3uSfa1yy/NPGa3si2ufrRiVMgX3HpUyBOujPsJdFu6POShP3kx8xxvGnVTyCfdHMe1OfdJiqWxV1zT+IXj98ic8+cvXtzqNXb+SXw/MPLmeM/r+Zv4+3fwtnFd5ZRS+snvJ4d83uDW9xUq34fmH+/LjnHK4rNCHnbV30NuWb261eeg2Mr3NdicPQ367/ds2ydRVzb1N4/vH/PWkP/9fYNDHv37uI9f0ysdf/e76JS419b8t17W4WvStSy+Pb4uTBPzGQf5eu60uGfuXz5+UcgrW7L7+D24vm/I//GRD4Xc64V4z5vzxcdDnj3mDyGX78GRUnavovJ9PfbsEZ/jnIcfCvmb096euWbL3x/KHKtFPrEBAAAAAAAUhokNAAAAAACgMExsAAAAAAAAhWGPjRpTvib0sItjXvOxuL5kn4a4IPR3x9yQuebbjj07Puba7Hps1I4XmrfKHNvw6ONbfiBlyvfUWPClXUOef/S3Mo/53eoBIT89a1zI/V66o0qjY+z5c9s+qYO2TU92+nOU63Pgc61+/5M3T8scm5Du6qzhkJOWg+Ka9BfseV1Fj3/L/Sdkjm11T+vry1Nfevw+7l3xibF7V3yNtu4tK4+O1/zN6Osz56wvxX9T1PvxHplzKLaGnnGvtPnf2C3mo1vfTyOllI5ecEzIE776aMjl7xe6jYp7YO3+q+zv648OfjDk5S1xreV9fnFeyNtOjM8xZ9efZq4591Pxf8vxJ74t5Ocvjq8Ve72QXXf61Zpu+Wur36e2lO9v1ZJZ0Tvr1t1/EvJR+54ST7jjHx0eF7Wv+cGFIW//sc5/zh0XbRMPvHXT58Fr2Wpx2xsJ9WuI5zTtFPesLO8+xbPTe+O+E79aNSzkL37nxMxjtv36X0Luk1r/m+wL58XXjudc8saQLxzx5zbHWa6poSHkj94X/44y4u/xdWKR+MQGAAAAAABQGCY2AAAAAACAwjCxAQAAAAAAFIY9NnLUcsCkzLFH3tEr5F0mPR5y+Z4a5S55cY/MsT7X37OJM6lVH/nvd2SOTUjztvg4yte0f/bcV0J+aM+4p8Yh9x2fuUbft8Y1ofsle2pQXa+7vu21Tim+L1z5nZB36d76f/ePPHNgyANOfClzTnPmCHTMht7x3wuVrz+fUnYN+rFXxr0Q4k5qFEFDt/h2asFFu4c8/6hZIf9zw9rMNY76dlxgfswVj4S8oWxPjfVTJ4e8y5f/FvJnhmZfN85e8bqQf/gfR4Y87pfxNVrTkMEhH/yWMzPXXHX88pCv3eO7IY+8OO43Uu6GVfE5vjNh+1bPp7ZMvOkDIT/45u+8xpmvbeGp8b3tBG8V6CRL3z6u7ZOgFY2b8SKtfB+Dlt7dO2k05GXe73cK+cWrh4S87YK4n0Z7vDIs/l34zG1uKjsj26t9Pzcj5CF/X9Xqc4x6+KmQi/ze2Cc2AAAAAACAwjCxAQAAAAAAFIaJDQAAAAAAoDDssdGJGvbcJeSFZ8U1RL+7/w8yjzmw17qKnmNtaX3Id7w4NntSyzMVXZNOFpddTI1l84vfPOAnmYfMShM6c0QppZSe+NyUkH/x3m+EPKF77O8b7jop5BHHPtg5AwO6vD16tL13wavNnf2GkIe+1PG1TqEt/a4uWxz+6/mMgy1r8Uf3Dnn+Ud8M+emyPTXe8aWPZq4x5rq4J9mLb46v50vv6Rfyz3eJz7FNU9zLYuers/thTPjO8yH3WXBn5pxXa37+hZD7/+SFzDn9y16yHndG3Ctk2HFPtPoc6byBZQceaP18akrPhb3jgTfnMw7y1dAz3n+WvSPu07j19dn/X7esXNmpY0oppWfO2y/k68/6StkZre8BBOW2vnJuyJd/7HWZc04bEH/vLTon/g1l3HuqPy62rNGfje8rq7E3RdM224T8z2lxQ5dx3eP96r9Wbpu5xpBvz80ca02R99Qo5xMbAAAAAABAYVQ0sTFz5sy01157pX79+qWhQ4emY445Ji1YsCCcs2bNmjR9+vQ0ePDgtNVWW6Vp06alpUuXVnXQdD26Rx70jrzoHnnQO/Kie+RB78iL7pEHvSMvukdnqmhi49Zbb03Tp09Pd9xxR/rjH/+Y1q9fnw499NC0atWqjeecc8456de//nW65ppr0q233pqefvrp9Pa3v73qA6dr0T3yoHfkRffIg96RF90jD3pHXnSPPOgdedE9OlNFe2zceOONIV955ZVp6NChad68eenAAw9My5cvT9///vfTj3/84/TmN/9rkc3Zs2enHXfcMd1xxx1p3333rd7I6VJ0jzzoHXnRPfKgd+RF98iD3pEX3SMPekdedI/O1KHNw5cvX55SSmnQoEEppZTmzZuX1q9fn6ZOnbrxnIkTJ6bRo0enuXPnbrKMa9euTWvX/t+meitWrOjIkLaobmPjZkGPnDwi5P88/uqQp20VN+1rj08s3TPkW78Zf6Zb/6CyDWOKqtDdK8XYklpCPqh3dnPGs6+cHPLrZ8fHdF8SN2BbelDcfGjQ8f8M+czRczLPcXifeSH/atWwkN9731tDHvLtvplr1LtC965ONDXEDxq+NKF75pzhv9tSo9lyulr3Fv98l5C7N9xb0eO3vSX+vq2nzdG2pK7Wu45aeUL5//55mzyPthWpe5d98NJWv9+rIeYjT7stc852Z70U8kn9f93Gs5ZtFv7js0Ied/7dmUc0b9iQOVZtQy+NG2qWWv/RpJSe6rSxtEeRelcLRn0+/vf+ybu3y5zz7n7PtHqNx976vZAP3/3EkFv+/lA7R1csReremiP3DnnAR54M+dZxl4R87N3xv2lKKaUFHds8vNu2w0N+6rjtM+f89MyvhTyiW+ubhS9tXhty91dKr3Fm/ShS72rR1+44LHPsrYdcFPKEDy0MOf4Vp+vSvWjReeNCfuiQi0Oeuzb+zeNnR71xE1d5pNrDKox2bx7e0tKSzj777LT//vunXXb51x8glixZknr06JEGDhwYzh02bFhasmTJJq8zc+bMNGDAgI1fo0aNau+Q6CJ0jzzoHXnRPfKgd+RF98iD3pEX3SMPekdedI9qa/fExvTp09P999+frr766rZPbsX555+fli9fvvFr8eLFHboe9U/3yIPekRfdIw96R150jzzoHXnRPfKgd+RF96i2di1FNWPGjHTDDTek2267LY0cOXLj8eHDh6d169alZcuWhZm2pUuXpuHDh2/iSin17Nkz9ezZ+scC4X/pHnnQO/Kie+RB78iL7pEHvSMvukce9I686B6doaKJjVKplM4888x07bXXpltuuSWNHTs2fH/y5Mmpe/fuac6cOWnatGkppZQWLFiQnnzyyTRlypTqjXoL6DZmdObY8snbhnz85+IGOKcN/GWHn/e8Z+LacXMvjXtqDLryrpC3bukae2p0pe71asj+3/Kht1we8u1v7BXyorXxZn/ygMcrft4PPx3X6bvxL5NCHv/hOyq+ZtF1pd4VRXOpbGXSdn/usLZ1pe61HLRH5thFk34U8vpS3CVjecuakPf63dkhT3ziweoMrovpSr3rDMu3r9Mb0hZQ5O7d9vLEkPfpeV/Ig5rim+5PDLm3zWu+bf7bQ35y7siQt//58pDHPRD3cyltgf006kGRe1eLrnxyv8yxE3e+ptXHrK//bQw2qcjdO+wLt4Z83uD7Wz1//if6Zw++vE+HxnDCfvFvINcN/U3mnJaU3Yfv1U56PO6P8PDsHUIe/Mv6+ztLkXtXFM0pbqzV8sqa1ziza9G9qGmnCSF//tj46ZXmUvzlePKvTgt53MKu97e51lQ0sTF9+vT04x//OF1//fWpX79+G9c6GzBgQOrdu3caMGBAOuWUU9K5556bBg0alPr375/OPPPMNGXKFLvY0yG6Rx70jrzoHnnQO/Kie+RB78iL7pEHvSMvukdnqmhi47LLLksppXTwwQeH47Nnz07ve9/7UkopXXjhhamxsTFNmzYtrV27Nh122GHp0ksvrcpg6bp0jzzoHXnRPfKgd+RF98iD3pEX3SMPekdedI/OVPFSVG3p1atXmjVrVpo1a1a7BwXldI886B150T3yoHfkRffIg96RF90jD3pHXnSPztSuzcPrQbdt454EL17RN+TTx8a1I1NK6cR+Szv0nDOeOiDkv142KXPOkJ/HNSoHray/tR27umG3PBvyxz8U1wz88vC2/5sf2GtdyAf0erzV8/+2Nq77feKtp2bOmXByXJ95fLJuH7Vv9V6r8x4CHbRmUI/MsQN6rSo70hTS71fHfbAmnHp3yGU7scAWsd2t8X7UfUZT5pyuup58PfvLm0aEvM+73xzy8t3ja7Zuz2XXfZ9w+VPxnCXxteKYNYtDdo+jFq29chMbvH51y4+D2vLQ1G9vgWfJ7nE1d03c3+iDd7435HEfXBTy4FX+7kLHvb5b75BfOHnvkAd/X89I6Z2/vCXkY7eKr/vecMfJIY8729/mWmOXQwAAAAAAoDBMbAAAAAAAAIVhYgMAAAAAACiMut1jY91he8Z8zoshf2Lcb0M+tHf5et6VW9r8SsgH/uq8kCd+cn7Ig5Zl19ezZm79a174SMiL3jEm5J3OPDPzmAffeUlFzzHxt2eEvMOlcd3vCX+L+2lAUTQ1mI8HalPDf98b8pUrhmbOObFf3Eth9c7bhtxj8T+rPi46V/ML8T3GsIv/EvNmXGNDFccDedn63hczx2a9tEPI07desKWGQye56az9Q77qjLiHwN/3v6Lqz/mjFaNCfmb9wJCv+GscU0opjftuc8jbl/2O9ncXOmr2Qdmuv9QS/yY45B8vh2yrNVJK6QvXTwv5xPdcHHLv3/bfksMpPH8hAgAAAAAACsPEBgAAAAAAUBgmNgAAAAAAgMKo2z02Hj8mztks3PWaih4/a9nrM8e+eeuhITc0N4Q88YLHQh6/9M6Q4yqP8C8bHn085HHnPJ4556hz9qromhPS3SFby5GiWvunbUJunmRF3HrT/94lmWNn/vPNIV8+6tYtNRyomgu/fVzm2Ikf+WbI237q4ZBfWLZbfMAd/6j6uAA6Q/ODCzPHfr9LXCf896mt9zQPVXFEdIamW/4a8ti7+oQ8+awPh/yDD12UucYuPeLfUd583/EhL79leMiv+2ncn2rDY0+EPD7ZP5It76MPZV/nHfe6v4XcuGptyP4mSEopbf/xuN/yUR+PvxsHp+x+zLw2n9gAAAAAAAAKw8QGAAAAAABQGCY2AAAAAACAwqjbPTYmnH5XyG87fXLHr5nuavX71ssDqK7hF/4l5CMufEPI26d7t+Bo6Azl6ySnlNI/9435banjv8NhS9vuhwsyx44/5m0h/3TcDSEf9OkTQx70rgEhNy9bXqXRAUDHtaxeHfJ2X4qv3T/xpb3bvMZW6dFW84Z2jg0606C3ZfcVuin1LTuSPQeoLp/YAAAAAAAACsPEBgAAAAAAUBgmNgAAAAAAgMIwsQEAAAAAABRG3W4eDgAAeWl+/oXMsXXTBoe849c/FPJDU78d8lETT4kXuOMf1RkcAABAwfnEBgAAAAAAUBgmNgAAAAAAgMIwsQEAAAAAABSGPTYAAGALKN93Y/xJMR+V9ip7hD01AAAANsUnNgAAAAAAgMIwsQEAAAAAABRGzS1FVSqVUkopbUjrUyrlPBg6bENan1L6v/+utUz36ktRuqd39aUovUtJ9+pNUbqnd/WlKL1LSffqTVG6p3f1R/fIg96RF90jD5X0ruYmNlauXJlSSun29NucR0I1rVy5Mg0YMCDvYbRK9+pTrXdP7+pTrfcuJd2rV7XePb2rT7Xeu5R0r17Vevf0rn7pHnnQO/Kie+Rhc3rXUKqxabeWlpb09NNPp1KplEaPHp0WL16c+vfvn/ewCm3FihVp1KhRufwsS6VSWrlyZRoxYkRqbKztlc90r/p0r216V316t3l0r/p0r216V316t3l0r/p0r216V3159i4l3evK3PPapnfV5563eXSv+opyz6u5T2w0NjamkSNHphUrVqSUUurfv78yVkleP8tantV9Nd3rPLr32vSu8+hd63Sv8+jea9O7zqN3rdO9zqN7r03vOk+eP0vd69rc816b3nUe97zW6V7nqfV7Xu1OtwEAAAAAAJQxsQEAAAAAABRGzU5s9OzZM33mM59JPXv2zHsohednWRk/r+rxs9x8flbV42dZGT+v6vGz3Hx+VtXjZ1kZP6/q8bPcfH5W1eNnWRk/r+rxs9x8flbV42dZGT+v6inKz7LmNg8HAAAAAAB4LTX7iQ0AAAAAAIByJjYAAAAAAIDCMLEBAAAAAAAURs1ObMyaNSuNGTMm9erVK+2zzz7prrvuyntINW/mzJlpr732Sv369UtDhw5NxxxzTFqwYEE4Z82aNWn69Olp8ODBaauttkrTpk1LS5cuzWnEtUfvKqd31aF7ldO9jtO7yulddehe5XSv4/SucnpXHbpXOd3rOL2rnN5Vh+5VTvc6Tu8qVxe9K9Wgq6++utSjR4/SFVdcUXrggQdKH/zgB0sDBw4sLV26NO+h1bTDDjusNHv27NL9999fuvfee0tHHHFEafTo0aWXX3554zmnnXZaadSoUaU5c+aU7rnnntK+++5b2m+//XIcde3Qu/bRu47TvfbRvY7Ru/bRu47TvfbRvY7Ru/bRu47TvfbRvY7Ru/bRu47TvfbRvY7Ru/aph97V5MTG3nvvXZo+ffrG3NzcXBoxYkRp5syZOY6qeJ599tlSSql06623lkqlUmnZsmWl7t27l6655pqN5zz00EOllFJp7ty5eQ2zZuhddehd5XSvOnSvMnpXHXpXOd2rDt2rjN5Vh95VTveqQ/cqo3fVoXeV073q0L3K6F11FLF3NbcU1bp169K8efPS1KlTNx5rbGxMU6dOTXPnzs1xZMWzfPnylFJKgwYNSimlNG/evLR+/frws504cWIaPXp0l//Z6l316F1ldK96dG/z6V316F1ldK96dG/z6V316F1ldK96dG/z6V316F1ldK96dG/z6V31FLF3NTex8fzzz6fm5uY0bNiwcHzYsGFpyZIlOY2qeFpaWtLZZ5+d9t9//7TLLruklFJasmRJ6tGjRxo4cGA4189W76pF7yqne9Whe5XRu+rQu8rpXnXoXmX0rjr0rnK6Vx26Vxm9qw69q5zuVYfuVUbvqqOoveuW9wDoHNOnT0/3339/uv322/MeCl2I3pEX3SMPekdedI886B150T3yoHfkRffIQ1F7V3Of2BgyZEhqamrK7LC+dOnSNHz48JxGVSwzZsxIN9xwQ7r55pvTyJEjNx4fPnx4WrduXVq2bFk4389W76pB79pH9zpO9yqndx2nd+2jex2ne5XTu47Tu/bRvY7TvcrpXcfpXfvoXsfpXuX0ruOK3Luam9jo0aNHmjx5cpozZ87GYy0tLWnOnDlpypQpOY6s9pVKpTRjxox07bXXpptuuimNHTs2fH/y5Mmpe/fu4We7YMGC9OSTT3b5n63etZ/edYzutZ/utZ/etZ/edYzutZ/utZ/etZ/edYzutZ/utZ/etZ/edYzutZ/utZ/etV9d9C6vXctbc/XVV5d69uxZuvLKK0sPPvhg6dRTTy0NHDiwtGTJkryHVtNOP/300oABA0q33HJL6Zlnntn4tXr16o3nnHbaaaXRo0eXbrrpptI999xTmjJlSmnKlCk5jrp26F376F3H6V776F7H6F376F3H6V776F7H6F376F3H6V776F7H6F376F3H6V776F7H6F371EPvanJio1QqlS655JLS6NGjSz169CjtvffepTvuuCPvIdW8lNImv2bPnr3xnFdeeaV0xhlnlLbeeutSnz59Sscee2zpmWeeyW/QNUbvKqd31aF7ldO9jtO7yulddehe5XSv4/SucnpXHbpXOd3rOL2rnN5Vh+5VTvc6Tu8qVw+9ayiVSqXqfPYDAAAAAACgc9XcHhsAAAAAAACvxcQGAAAAAABQGCY2AAAAAACAwjCxAQAAAAAAFIaJDQAAAAAAoDBMbAAAAAAAAIVhYgMAAAAAACgMExsAAAAAAEBhmNgAAAAAAAAKw8QGAAAAAABQGCY2AAAAAACAwjCxAQAAAAAAFIaJDQAAAAAAoDBMbAAAAAAAAIVhYgMAAAAAACgMExsAAAAAAEBhmNgAAAAAAAAKw8QGAAAAAABQGCY2AAAAAACAwjCxAQAAAAAAFIaJDQAAAAAAoDBMbAAAAAAAAIVhYgMAAAAAACgMExsAAAAAAEBhmNgAAAAAAAAKw8QGAAAAAABQGCY2AAAAAACAwjCxAQAAAAAAFIaJDQAAAAAAoDBMbAAAAAAAAIVhYgMAAAAAACgMExsAAAAAAEBhmNgAAAAAAAAKw8QGAAAAAABQGCY2AAAAAACAwjCxAQAAAAAAFIaJDQAAAAAAoDBMbAAAAAAAAIVhYgMAAAAAACgMExsAAAAAAEBhmNgAAAAAAAAKw8QGAAAAAABQGCY2AAAAAACAwjCxAQAAAAAAFIaJDQAAAAAAoDBMbAAAAAAAAIVhYgMAAAAAACgMExsAAAAAAEBhmNgAAAAAAAAKw8QGAAAAAABQGCY2AAAAAACAwjCxAQAAAAAAFIaJDQAAAAAAoDBMbAAAAAAAAIVhYgMAAAAAACgMExsAAAAAAEBhmNgAAAAAAAAKw8QGAAAAAABQGCY2AAAAAACAwjCxAQAAAAAAFIaJDQAAAAAAoDBMbAAAAAAAAIVhYgMAAAAAACgMExsAAAAAAEBhmNgAAAAAAAAKw8QGAAAAAABQGCY2AAAAAACAwjCxAQAAAAAAFIaJDQAAAAAAoDBMbAAAAAAAAIVhYgMAAAAAACgMExsAAAAAAEBhmNgAAAAAAAAKw8QGAAAAAABQGCY2AAAAAACAwjCxAQAAAAAAFIaJDQAAAAAAoDBMbAAAAAAAAIVhYgMAAAAAACgMExsAAAAAAEBhmNgAAAAAAAAKw8QGAAAAAABQGCY2AAAAAACAwjCxAQAAAAAAFIaJDQAAAAAAoDBMbAAAAAAAAIVhYgMAAAAAACgMExsAAAAAAEBhmNgAAAAAAAAKw8QGAAAAAABQGCY2AAAAAACAwjCxAQAAAAAAFIaJDQAAAAAAoDBMbAAAAAAAAIVhYgMAAAAAACgMExsAAAAAAEBhmNgAAAAAAAAKw8QGAAAAAABQGCY2AAAAAACAwjCxAQAAAAAAFIaJDQAAAAAAoDBMbAAAAAAAAIVhYgMAAAAAACgMExsAAAAAAEBhmNgAAAAAAAAKw8QGAAAAAABQGCY2AAAAAACAwjCxAQAAAAAAFIaJDQAAAAAAoDBMbAAAAAAAAIVhYgMAAAAAACgMExsAAAAAAEBhmNgAAAAAAAAKw8QGAAAAAABQGCY2AAAAAACAwjCxAQAAAAAAFIaJDQAAAAAAoDBMbAAAAAAAAIVhYgMAAAAAACgMExsAAAAAAEBhmNgAAAAAAAAKw8QGAAAAAABQGCY2AAAAAACAwjCxAQAAAAAAFIaJDQAAAAAAoDBMbAAAAAAAAIVhYgMAAAAAACgMExsAAAAAAEBhmNgAAAAAAAAKw8QGAAAAAABQGCY2AAAAAACAwjCxAQAAAAAAFIaJDQAAAAAAoDBMbAAAAAAAAIVhYgMAAAAAACgMExsAAAAAAEBhmNgAAAAAAAAKw8QGAAAAAABQGCY2AAAAAACAwjCxAQAAAAAAFIaJDQAAAAAAoDBMbAAAAAAAAIVhYgMAAAAAACgMExsAAAAAAEBhmNgAAAAAAAAKw8QGAAAAAABQGCY2AAAAAACAwjCxAQAAAAAAFIaJDQAAAAAAoDBMbAAAAAAAAIVhYgMAAAAAACgMExsAAAAAAEBhmNgAAAAAAAAKw8QGAAAAAABQGCY2AAAAAACAwjCxAQAAAAAAFIaJDQAAAAAAoDBMbAAAAAAAAIVhYgMAAAAAACgMExsAAAAAAEBhmNgAAAAAAAAKw8QGAAAAAABQGCY2AAAAAACAwjCxAQAAAAAAFIaJDQAAAAAAoDBMbAAAAAAAAIVhYgMAAAAAACgMExsAAAAAAEBhmNgAAAAAAAAKw8QGAAAAAABQGCY2AAAAAACAwjCxAQAAAAAAFIaJDQAAAAAAoDBMbAAAAAAAAIVhYgMAAAAAACgMExsAAAAAAEBhmNgAAAAAAAAKw8QGAAAAAABQGCY2AAAAAACAwjCxAQAAAAAAFIaJDQAAAAAAoDBMbAAAAAAAAIVhYgMAAAAAACgMExsAAAAAAEBhmNgAAAAAAAAKw8QGAAAAAABQGCY2AAAAAACAwjCxAQAAAAAAFIaJDQAAAAAAoDBMbAAAAAAAAIVhYgMAAAAAACgMExsAAAAAAEBhmNgAAAAAAAAKw8QGAAAAAABQGCY2AAAAAACAwjCxAQAAAAAAFIaJDQAAAAAAoDBMbAAAAAAAAIVhYgMAAAAAACgMExsAAAAAAEBhmNgAAAAAAAAKw8QGAAAAAABQGCY2AAAAAACAwjCxAQAAAAAAFIaJDQAAAAAAoDBMbAAAAAAAAIVhYgMAAAAAACgMExsAAAAAAEBhmNgAAAAAAAAKw8QGAAAAAABQGCY2AAAAAACAwjCxAQAAAAAAFIaJDQAAAAAAoDBMbAAAAAAAAIVhYgMAAAAAACgMExsAAAAAAEBhmNgAAAAAAAAKw8QGAAAAAABQGCY2AAAAAACAwjCxAQAAAAAAFIaJDQAAAAAAoDBMbAAAAAAAAIVhYgMAAAAAACgMExsAAAAAAEBhmNgAAAAAAAAKw8QGAAAAAABQGCY2AAAAAACAwjCxAQAAAAAAFIaJDQAAAAAAoDBMbAAAAAAAAIVhYgMAAAAAACgMExsAAAAAAEBhmNgAAAAAAAAKw8QGAAAAAABQGCY2AAAAAACAwjCxAQAAAAAAFIaJDQAAAAAAoDBMbAAAAAAAAIVhYgMAAAAAACgMExsAAAAAAEBhmNgAAAAAAAAKw8QGAAAAAABQGCY2AAAAAACAwjCxAQAAAAAAFEanTWzMmjUrjRkzJvXq1Svts88+6a677uqsp4KN9I686B550DvyonvkQe/Ii+6RB70jL7pHHvSO9mgolUqlal/0pz/9aXrve9+bLr/88rTPPvukiy66KF1zzTVpwYIFaejQoa0+tqWlJT399NOpX79+qaGhodpDYwsrlUpp5cqVacSIEamxsXM/INSR3qWke/WmKN3Tu/pSlN6lpHv1pijd07v6UpTepaR79aYo3dO7+rOluueex6u555EX9zzyUFHvSp1g7733Lk2fPn1jbm5uLo0YMaI0c+bMNh+7ePHiUkrJV519LV68uDOqFnSkd6WS7tXrV613T+/q86vWe1cq6V69ftV69/SuPr9qvXelku7V61etd0/v6vers7vnnucrj96VSu55vvLpnnuer/b2rluqsnXr1qV58+al888/f+OxxsbGNHXq1DR37tzM+WvXrk1r167dmEv/8wGSA9IRqVvqXu3hsYVtSOvT7em3qV+/fp36PJX2LiXdq3e12j29q2+12ruUdK/e1Wr39K6+1WrvUtK9eler3dO7+rcluueeRzn3PPLinkceKuld1Sc2nn/++dTc3JyGDRsWjg8bNizNnz8/c/7MmTPTZz/72U0MrHvq1qCMhfeve0unfxSs0t6lpHt1r0a7p3d1rkZ7l5Lu1b0a7Z7e1bka7V1Kulf3arR7etcFbIHuueeR4Z5HXtzzyEMFvevcxfk2w/nnn5+WL1++8Wvx4sV5D4kuQvfIg96RF90jD3pHXnSPPOgdedE98qB35EX3+F9V/8TGkCFDUlNTU1q6dGk4vnTp0jR8+PDM+T179kw9e/as9jDoYirtXUq6R3W455EH9zzy4p5HHtzzyIt7HnlwzyMv7nnkwT2Pjqj6JzZ69OiRJk+enObMmbPxWEtLS5ozZ06aMmVKtZ8OUkp6R350jzzoHXnRPfKgd+RF98iD3pEX3SMPekdHVP0TGymldO6556aTTjop7bnnnmnvvfdOF110UVq1alU6+eSTO+PpIKWkd+RH98iD3pEX3SMPekdedI886B150T3yoHe0V6dMbBx//PHpueeeS5/+9KfTkiVL0qRJk9KNN96Y2QgGqknvyIvukQe9q66GyTuH/P6f3BByr4b1Ic8aP6HTx1SrdI886B150T3yoHfkRffIg97RXg2lUqmU9yBebcWKFWnAgAHp4HS0nezrwIbS+nRLuj4tX7489e/fP+/htEr36ktRuqd39aUovUtJ98oVfWKjKN3Tu/pSlN6lpHv1pijd07v6o3vkQe/Ii+6Rh0p6V/U9NgAAAAAAADqLiQ0AAAAAAKAwTGwAAAAAAACF0SmbhwMA1LJFP3hDyFcf+O2Qd+8Rz3/rg8eF3CM90SnjAgAAiq9xt4khvzCzOeSbdv9hyMcd+8HMNUp331f9gUEd8YkNAAAAAACgMExsAAAAAAAAhWFiAwAAAAAAKAx7bFTTvruF+NhRfUP+zLSfhfyNhYdkLrHyvsGtPsXrP/e3kFvWrKlkhABQ97qNGR3y2GuWZs65YcR3Q24p+/7XX9gl5D7vWx/yhvYPDwAAqDNrj9gr5NmXXRjynWtGhbzr72eEvNPixZlres8BrfOJDQAAAAAAoDBMbAAAAAAAAIVhYgMAAAAAACgMe2x0wFP/vl/Ivz3jKyGP7rZVq49/9+SfZQ9Obv05D5j3oZD7/uLO1h8A1KWmrbcOefEpO4bcrWz7nWWT1oXcfauYb9//ssxzvP+R40JeuGSbSocZbHi2d+bY2OvjqqHd5szr0HPQNTVM3jnkdV9ZEfLXR9y+iUfFf9ux25VnhTx0Xtx1o89Tft92eQ0NIb746/Eh/2zXK0Ke/paTMpdoXvhI9ccF0AmWnhXf65be/FLIJ42LvxdPHfhgm9c856m4x+RTb+sTcvNzz1UyROg0TQMHZI5Nujn+f+CQ/g+E/PWj4nun5gcWVH9g1Izl79k3c+yGmV8Pea8/nB3yjucsDHnCintCtp8GVM4nNgAAAAAAgMIwsQEAAAAAABSGiQ0AAAAAAKAw7LHRAa/7waMhP31qXD9+dCf8dL/79QtDPqXbuSH3++kd1X9SoOY8NDOu7f7wkd/q4BWz+19cP/438cD4zCkdtmFac8gXvzQx5O/85tCQx/0wrm3bcv/86g+KwlkzNK7R/fuJV1Z8jT5Pxf0T+vzSnhpETf36hfyFideGPLpb7OHio4dlrjHiq/bYAGpDt5Hbhbx6dnzzevdOl4T80Pr1IX/s0Wkh/+HZuN9bSil9Z9xPQ7585J9jvvV1If9qp8GtjBg2X9O4sSGv33Zgq+d3f/7lkJ86LLu34K+Hxvdb310+Kp6wxB4x9axhj7in37Vf/FrmnA+U3RcnfPBvITe3xPe+QMf5xAYAAAAAAFAYJjYAAAAAAIDCMLEBAAAAAAAUhj02OmDDM0tCPuW7Z4b8p9O/EvK23bYK+Ver4lrMKaV0VN/VrT7njj3iY555y4aQ+8VlTCFXTTtNCLmlb8+QF727b8g/OTqu5VvuffNOzhwbddz97RxdsV3wpl906PH3rov3jq8/fViHrpdSSnc+NibkfcY+HvL4rZ7NPObTQ+4L+dytF8X8npj3v++MkAd0zf/8XV7D5LjG7Rnf/FnIjZvx7zb2/48ZIQ+98i8dHxh1rXnFipCvenb/kA953U0hrxlS6vQxweZ6/PNTQm7pHr/fa4flIf917x+2ec3Ll20f8g07b92+wZGLPW54MuTjBtwT8oTr43vbnT4fzy8981Sbz3HqXqeHfNnPLwv5AwPinpUXfv3/hfz68+wf2RWV9p8U8uMz4u/TXbZ7us1rvHv4nJCP6vvSa5z5LztcG99jjJ6QfY6mhvj68paXdgi5oVevNsdFcTT2jX+rGH5ZvAd+7bkDM49ZNy2+x0721KAKum07POTH37d95pyvn/L9kA/p3frflnf6UXwvvP3H57ZzdPnziQ0AAAAAAKAwTGwAAAAAAACFYWIDAAAAAAAoDHtsVNHImXF97tknTg75E0MWhPzw2rhOWkoppb6PZo+1YuLFL4fcUtGjof1efsc+IS85el3mnBsOmBXyhO5x3dGWVL7+eOtzrWftdHPm2LVpm1YfU69+9M5DQ75klwEhb31/XCu7XOPKV0Le8OjjHR7TuBTXrn2h7PvLBg/LPObXdzwR8pF9VmTOCdc8Yk3IA360+eOjfiw8Ke5ZdXTf50N+2/xjQ246rUfmGlsvKu46otSG+VfsGA98Nu6x0WtC6/dhaK9Xjtk75Od3jm/p+u+f3dPqb7t9M+SmhoZWn2Nz3lOcPCC+t2l8cHzIv9pp8GZchS3h5Xfumzn2mW3i6/R9//pvIU84466Qy1aO3yylu+Neaodc95GQFx13achfPvLHIX/nvOw64tS/xYfEfUUfOLD1fRg35aWW+J5hjztPDfkbu8X92RYcG7u4Kc2leN+cf/XEkIc9Zb+2ejL/GzuF/MPtLgr5vYe8N/OY5ucf6cwh0UWsPXyvkHe84G8hXzf8N5nHtJS9cmvrddz977k45D1eX9z9bH1iAwAAAAAAKAwTGwAAAAAAQGGY2AAAAAAAAArDxAYAAAAAAFAYNg/vRL+85M0ht5wZN5v65JD5HX6Oll7dO3wN2JTHf7pbyEeNj5v/fWnYZZtxlbhZ+OMbVod86J/PDLnv33qHvN3lfw+5ZdWqzXjOrqHl7w+FPODvZd9v6/HVHc5meeaEiZljR/b5U6uPeaklbnI+6oqmqo6JYtjhnvi77ofDvhHyz18eHXLDRwaE3Lzogc4ZGF3a0D8/1+r3b9vze5lj79n+XSFvePTxag6JAui2/ZjMsaE/fiHk44bc3eo1Jna/PeSR3XqG3LiJf7v2yWfjhuOfG9r6c2yO7g3xd/Ko7i+UnWHz8FrRvIm3jFet2C7kpl90/n+v118TN3ROx8W4TbcVITcNyY6p+fnynlF0D18YN7e/fdpXys6I7xF3+8v7Ql7zQvx+Sint9IWnQ95ucXwt+NWD3hNy/9nxd/bkeFtNKaV099pSyNteUfZeNfsQCqSxT9y0/gdv+W7I7390WsjNC20UTnV0Gxl/Hx/21TkhT996Qch3rc3+TeSkOz4Y8jY3xL/FrTvxxZD/8ob/CvmsnW7OXPP6XqNCblmzJnNOLfCJDQAAAAAAoDAqnti47bbb0pFHHplGjBiRGhoa0nXXXRe+XyqV0qc//em07bbbpt69e6epU6emRYsWVWu8dFF6R150jzzoHXnRPfKgd+RF98iD3pEX3SMPekdnqnhiY9WqVWn33XdPs2bN2uT3v/KVr6SLL744XX755enOO+9Mffv2TYcddlhaU6MfWaEY9I686B550DvyonvkQe/Ii+6RB70jL7pHHvSOzlTxHhuHH354Ovzwwzf5vVKplC666KL0yU9+Mh199NEppZSuuuqqNGzYsHTdddelE044oWOjLZjB350b8tw/7RDyV3+9PvOYjw6qbJ2+lz8X9xzY6q0VPbww9K66um03InNs0de2CfmhA2aHfN+62NdPPbtXyH+YtX/mmkPuXRly46q1IY976G+tjrMW1inVvc3X2Cuu47joirinxl/e+NVNPCq7Ju6rnfBvcR+W7rfMa9fYiqar9+6l900J+evbfivkltQj5E/OiWve7rgqrr/dXMWx1buu3r2OaGqI/16of2OvzDlPvDP+/t3uS4935pAKo5579/I79gn53C/8JHPO2/pWumfAJhZ/f5Ujjz4pc6zpmbi28tHbnhzyqtF9Qz7vy3Ht5cP7vNTmqL739IFlR5a0+Zi81XP3Xm3r6+7LHPvFryfEc1bMzZxTbU1rNrT6/f17xlf/T3xwh8w5I2f+papjykNX6d3maukTX6kNbYp7HVy3amDI2388vsfc8Gi23+VNa5y0U8jLy66xV8+4H+ozzXFvyJRSOuV7Hwt55KridVH3Xtuiz8U9Rsd0+0PIq/8zvoZrKsDvuFqhd60be+3zIZfvqTFt0VEhrz/4mcw1Xp/ubfU5Gh7aOeT7fxn3DDpiq/icKaX0i70ODbnxz63//S4vVd1j47HHHktLlixJU6dO3XhswIABaZ999klz53b+CyW6Jr0jL7pHHvSOvOgeedA78qJ75EHvyIvukQe9o6Mq/sRGa5Ys+deM5bBhw8LxYcOGbfxeubVr16a1a//vX3GvWLGimkOiC2hP71LSPTrOPY88uOeRF/c88uCeR17c88iDex55cc8jD+55dFRVP7HRHjNnzkwDBgzY+DVq1Ki8h0QXoXvkQe/Ii+6RB70jL7pHHvSOvOgeedA78qJ7/K+qfmJj+PDhKaWUli5dmrbddtuNx5cuXZomTZq0ycecf/756dxzz92YV6xYUTeFfHbGfiEv2yWu9Pirra/dxKMqm2t68Y7hIW+VHq3o8fWgPb1Lqb6715YHP5/dY2Phgd8OedwfTg15x3Njt5pfimstD07ZjwmWynK9rXPf1e95q6bFdcNfOCGuRbtgvyvKHpHdT+PlUtx3Zf9vnRfyqLv/HnIt7LuSt3q75zUNG5o59tx+ra/BXa77sqaQmxdWtl/Vpjz5mfg7fM122X2xyk049e4OP28t6+r3vLY0l9q+Q7V03wIDqTNFv+dte1a8H1W+n0ZKLzbH35WHfCeu8z78jvj97vdk96PK3FWfejrEp8/eI+TN2VPj5y/H9yHN7256jTOLqZ7ueS2rVrV90pZw36IQL1m2fchnDozvN1Zv3/bv3npT9Htee4wpW+v9kgNiL6YPjPfRz3wt7gk0+v0DshcdMijE9V+Pe2r8eeJ1Id+3Lt4lT7gq3mdTSul1XyzenhqVqKd7XnsccmB833nWY3EPv6ab/7olh9NldMV7Xrnn1/Vt9fuP3zg25O1Sdo+Njlq0Pnsf7b5keci1+ve8qn5iY+zYsWn48OFpzpw5G4+tWLEi3XnnnWnKlCmbfEzPnj1T//79wxdUoj29S0n36Dj3PPLgnkde3PPIg3seeXHPIw/ueeTFPY88uOfRURV/YuPll19ODz/88Mb82GOPpXvvvTcNGjQojR49Op199tnpggsuSOPHj09jx45Nn/rUp9KIESPSMcccU81x08XoHXnRPfKgd+RF98iD3pEX3SMPekdedI886B2dqeKJjXvuuSe96U1v2pj/96M/J510UrryyivTxz72sbRq1ap06qmnpmXLlqUDDjgg3XjjjalXr17VGzVdjt6RF90jD3pHXnSPPOgdedE98qB35EX3yIPe0ZkaSqVS+TL4uVqxYkUaMGBAOjgdnbo11PZCxA177RryMT+4KeT39n8s5D6NPao+hsPfekLILf+YX/Xn6IgNpfXplnR9Wr58ec1/NKxI3SvXVPazXfC5nUKeecRPQv7aF96VvUhDjIOv+UfINbM272YqSveK1Lv1h+4Z8g1XXBpyz4bKt21a0bIm5MP//dyQB/78byGX1sZ1xGtNUXqXUu10r2nwoMyxITfEdY6vet1tIa8vxRU+Dz3ltJB73Nj2XhdPfK7so82leBP83In/FfKxfV9s85rdG+L68kcc9PaQmxd13j5YRelerfSuGpp2GBfyr2/6WZuP2fXyGSGP+nyx1+suSu9S2nLdW3n8viH/11e+FvKIbj3bvMb1q4aEfOk57wy552+qv59Py5y4LvUNE3/Z5mMm/vaMkCd8cMvtM1SU7tXTPa8zvPEf8XXg+YMfDHncbz+UecyW7Nmm6F71NfbpE/IjV8Tfrw+8cXbIN78S/9j5H1/4QOaa/35+fB13VN/W9w3a/fIzQ6613896V31rjtw75N9d9q2Qj337KfEBd91X8XOsPjbuSdl7SbznNcyN+3rUIt3rfIP/e+uQfzDmTyHv+7n4/mHoj+Lf6lJKqXm3eN9c9L749+f9d417XL2h/5Mh3/ihAzPXbPjvezc94C2gkt5VdY8NAAAAAACAzmRiAwAAAAAAKAwTGwAAAAAAQGFUviA6G72w61YhH98vrlnWpzGuFdkZFpwXn2P8SZ3+lNSg+TN3DHnBMbNC3vevJ4Y89OfZNfnK99BoqdLYqB+PHRf3IGjPnhrl+jfGNXL/+ytx345PfOQNIf9iTly7fPtr4zqlKeW7FiSVe+GIHTLHrh19ccjrS/HfYfxqVVyHtOfS1SGXbx7WctAemecYus+SkP+4S+v7I/xzQ9zf5berdsycc+qAx0OecHVcu3Thv00IufnBha0+J1A8w6c/EvLm7Kkx458Hh/zQV3cJue9v7uzwuLoNHxby09NeH/JPx3217BFxbebyMaaU0na/92/kqEz5XgpDuj3X+vkvN7X6fepDy+r4Om79ytbvm2/qHV///+WCb2XOaSzbQLL8ve3Ot70/5HE/ezbkuJsb9eipE9eFPGtZfG3feH/8fV7eoSXn7Je55g8//I2Qd+7+15Bfankl5AMv/2jIo75QW3u7sGVM33ZOyC1lbTv41Pg6sPFD2a2yLxj2vVafY///PCvk5767LOSGdG8bo6xdXo0CAAAAAACFYWIDAAAAAAAoDBMbAAAAAABAYdhjowMGXTE35P1GfiTkP38wrlU7pKlv1cew7bBlVb8mxfPosd8OubkU1xRt+vngkFtWWdedyr3uupiPHP+2kP9zzPUhT+7R8XWRvzg0rkv6xRNj3nBidgXcib85I+SdvhD3UtjwxOIOj4v2axo8KOSVYxpe48z/c/MrcS+Wj/7uXSGP/9sdITdM3jnk58+N69mmlNJdu/w85Hlr47/1+NA/3hPyNhf1DnndwOxLqFNnXRbH1XtpyAvT9pnHUD+aGmKHmkt2q+qKnrxqXMhfPHNSyI+s2ibzmJfePSDkvo91fE+NcgvPjvef+//tm2VnxD01Lnpxp5CfPmFI5pqdMU7qW2mn2MMPDri91fNH/77ynQ66jdwu5OX7jgx5yT7xXj3upysz1yjdc3/Fz0v19FrcverXfNv8o0Pe/msbQm5e8HDVn5Padu+Bl4d88GfPCXnw6vj3vsZe8f3Ip0//Ueaa7/9CvMbQXy4Ieck74t6Ct/xH/Jvh0Y+el7lm/5/ckTlGffnrK2ND3r7bAyF/cXjZHhub+IxC+buOp8v2hxx836pUr3xiAwAAAAAAKAwTGwAAAAAAQGGY2AAAAAAAAArDxAYAAAAAAFAYNg+votGf+0vIRz4cN/5ZM7DteaRS2X+RX5z3lZBf332r9g2OuvbRJXuE/MVh94T8mU/Njt9/5X2Za2z1M5tS0bqev7075Obfxu//545xQ+d1w/uFvGrbuDFpSim9cNTqkB94Y+xqY2p9Y+luKbtB+cP/79shn7zrwSEv3b/sMS2Vb0xJ+7102ISQ/3Za+Qa2WWdcf0rI48+L96tuY0aHvO4rK0K+Y+IvM9d8bMO6kN91+5kh73Da/JCbJ42P53/x95u45pqQv37PW0Ie/+BfM4+hftgsnJRSGvy9uNnoHd8r3wR32SYetalj7bfsvVMyx+a++2tlR+Lv5NUt60O+6ifx/jXysfg+B8o19umTPTj+dSE+dVD/iq75lq/cljl21fv3Dvk9E+Pr09163xzy/+vzcsiPb4ivPY/a/kOZ5xg5raJh0kEN3eIfQQZOWRpyW+8HNuWI+UfFA4f8M8RSipn6V5qye8i9G+Lr8oa4n3zGmoN3Dfnjd++YOef1342vAcrfZW5zefz+vlPi+483ffj+zDX/+ZPWx0Xx3bDz1iH/8q1xE/qVo+I9cu5/fqvNa77tnvi7beQd/2jn6GqfT2wAAAAAAACFYWIDAAAAAAAoDBMbAAAAAABAYdhjoxP1/3FcA3yzVhRtiOtHHrr9R0J+5J2Xh3zG2FtD/q+dDslcsvnBhZvzzNSIdYftmTnW69a41mLLmriO+4P/b1jIEz82PeT575wVv//V8nWWUzrj8dPjgbvua3Os8GrNDy0Kuemh+P1N3QP7/zjmvWfEdUbffHK8j35leNw/ZnPMHn1LyDteEP//MfYTca1TOtcLu1a+TvLrz2t9D6Cx18S1mL8+4vY2r/mBD8e1S8dfd1fIrxy+V8i//96lbV5z4m/ODnnCqXdv+kS6rCH3tbGAM1TB7TOzay+3pOw+V6/2xm/F9xwjv2xPjXrS2K9f5ljDqG1DfnbK4JBf2CuuDn/iPq3/Lh7a4+nMsTMHtv37uDVnD8q+H9lh0jOtPuacX7835G/+Ju4f02PpqpBH3v9AO0dHtSz/ddyL5bbdfhZye3awainbl8O/6GX1dr1a/f6gB15u9fu9734k5B3uy16v0ld54y+Lj7j8F7dmznlbmlzhVSm6HjfG95CD9p9U8TVGfTHmUgfGU+vc3wEAAAAAgMIwsQEAAAAAABSGiQ0AAAAAAKAw7LFRYxp79w65fE+Nciuby9b129C86ROpGd22HxPyntfGfQmO6p9dx/2Ub5wd8rBL4rrHG55ZEvLErzfFC7wzxtHdYs9SSmntkNilnpkzoPMN/Vbs9gPfjmuCf+DPB4X8vVHZdUjbNHZ15Y+hatYPiL+nGjfxbywOuf+4kHunx0JuOWiPkI8ddFWr19ztu3HvlpRSGn1d7FrD5J1DPuObcX3nzbnmhP+0Jj2t2+rBF0L2qo1qWDRrn5C7N9ybOWd9G4srj5yzIuR6Xou5HpXvoTH/qzuG/JEDf5d5zGkD2vEa6lUe2fBKyI+vH5g555XSupB7N7S+18uOt50c8ujvNGXOabr5r61eY1xqfS+Q9uzXQPs1jRubObbo1OEhz98t7gdZ/t/oM8/G132/WDgp5PsPmJ15jt0GPhXPaWOc0PRI7Ez5a7TmF16s/nM+/FTbJ9HlPbd7n5C7N2R/N7b1Oq+e+cQGAAAAAABQGCY2AAAAAACAwjCxAQAAAAAAFIY9NmrM/At3LjvS+nrdF/7yqJDHLJxb5RFRbR//03Uhj+/2csiHfOdjmceMuqSyddsf+vjIVr9//CNvzRzrc9ejIVv3m1pQWh/XZr7lvt3jCe3YY6PhkT5tn8QW07KJ1a5bSg0VXWN9Kb6caUlr4gk7r8w85qyH54e8TdPdIV/z0t4hX/n/Dgl57PMPZa7pvglsCY294r5ou+zyRMjrS9m7Ufm9do9LPxzyqL/eWaXRkYfev4mdePj1cZ/Gl1rifhgppXTE/ONDXrR4WMgjboi/W5vWxAW8+y4s2zNo4SOZ53j8oWdDPqX/P0O++uVtQh53xpPxmi+9lLkmxfL0Edtmjj347kvKjsTXfTv9cEbI47+6IOTe794qPvyA7PP+9tH4d5XR6b7WB0rdK3970dSQ/7/zfuGICSE/tuFXOY2EWtbtlfj7d1Ov8056fGrIjWs2hFzP71Pz/38yAAAAAADAZjKxAQAAAAAAFIaJDQAAAAAAoDC67B4b3bYbEfK6q5pCfv6XozKPGTqrsn0O2hzD9mMyx/701gvLjmyVOefVtv9ZXHc0u1I5teaUn50e8m3v+mrI953+reyDTs8eerUrV8Q+v6//ZSFft2rrkFd8Jtvvpuf/2vqTUNc2dT9aMH14yAMWxoVJh3y78/f0aegWf03ts1N2/ea2vFKK+3QMv7OeV5isfa/7dVwjNB2dPWfOrj8N+bDDzwj5uUndQ96++4tlV+gR0r37XZF5jsayf9sxb23Mf/76PiEPWHRHdqBQoVLvHm2fBGWa+vcP+cnTdwl53rhvlj0i+2/X9rr7vSGP+d7DITe3+N1YZL8c98eQf/ZyfO3/nVM/kHlM0y3xtf/49M/MOa1p6R7vZwsv3ztzzhF9vxHyHWvjPmezT4svAppe8n6k6FYfG18//eTcr23irJ4h7ffv00Me98t/xNPHxP0jzz3jZ22OY/2Tfds8h66loewtSHNpy//1rKFn7P7gk+MeWW+95czMY8Yn98UuZ+9dQxz0nsUh37U2ux/lwisnhjz4ga6z/7JPbAAAAAAAAIVhYgMAAAAAACiMiiY2Zs6cmfbaa6/Ur1+/NHTo0HTMMcekBQsWhHPWrFmTpk+fngYPHpy22mqrNG3atLR06dKqDpquR/fIg96RF90jD3pHXnSPPOgdedE98qB35EX36EwVTWzceuutafr06emOO+5If/zjH9P69evToYcemlatWrXxnHPOOSf9+te/Ttdcc0269dZb09NPP53e/va3V33gdC26Rx70jrzoHnnQO/Kie+RB78iL7pEHvSMvukdnaiiVSqW2T9u05557Lg0dOjTdeuut6cADD0zLly9P22yzTfrxj3+cjjvuuJRSSvPnz0877rhjmjt3btp3333bvOaKFSvSgAED0sHp6NStoXub57fXs9fHjVX+ttfVIX9nedyMOaWUfnT+20Lu+/jLIbfc+2DIG948OeQXJ8aNgqaddlPmOT45ZP5rjPhfxt7wwZAnnhOfs+VVN4ZasKG0Pt2Srk/Lly9P/cs2PuyIInev3OMXTAm5z64vZc65bNf/avUajQ1x46tPP3ZMPOFjcQPBdG+2Z6UNG1p9jqLpjO7VU++6jX1dyAf+6sHMOR8ZFP8VxZGTDgu5+bnnqj+uMaNDfvDf4wbmDx95ecXX/NqLO4R8066dt5mge17byn83fm92+aa3KY3oFn9flm/03ZI6vtnfExvipvJvvTVu1jf+vcXaqM89b8tr2mFcyL++qe3NTHe9fEbIoz7/l6qOaUtzz+scTYMHhfzcD4aEfPserb8unPTtD2eOjb7gznig4JuFu+dFv30q/s664Pm4wfzcPbfKPKa0fl3mWGsa+8bXTy2/iu8vfjvxV5nHvNTySsjHnnVuyH2uLetlAehe6xZ9K24evujYyzLnnPzkwSEvnbIi5PINlp/8aHzteOUp8bXj5B5NmefYbVb8fTvyi37flqun3m2ObtuPCfncP/465LO+96GQR87seGfKu/zYVfF96Yxdbg35xsPivTullDb886kOj6MjdK/zNW2zTcin/eW/Qz6sz/KQd7virMw1xnyqvjYLr6R3HdpjY/nyf/1wBw3614vvefPmpfXr16epU6duPGfixIlp9OjRae7cTf+Q165dm1asWBG+oC26Rx70jrzoHnnQO/Kie+RB78iL7pEHvSMvukc1tXtio6WlJZ199tlp//33T7vs8q9ZxSVLlqQePXqkgQMHhnOHDRuWlixZssnrzJw5Mw0YMGDj16hRo9o7JLoI3SMPekdedI886B150T3yoHfkRffIg96RF92j2to9sTF9+vR0//33p6uvvrrtk1tx/vnnp+XLl2/8Wrx4cYeuR/3TPfKgd+RF98iD3pEX3SMPekdedI886B150T2qrVt7HjRjxox0ww03pNtuuy2NHDly4/Hhw4endevWpWXLloWZtqVLl6bhw4dv4kop9ezZM/UsW3duSxhweb+Qz9pur5AvHnF35jGnXvqdkH/xclzn6/tPHRDy5dvHtR/Hds+ubVquuRTXDb98eVwHf8ePLYzn19ieGp2tHrpXbswn214L7zNpcpvnROXrMOa7LmPR1WPvnr0kjqF8P41NWb/TyJC7/XVNyC0rV7b6+MZ+/TLHFn5255D/MO1rIY/p1qfVazY1ZOfnH1sf9z/6zafeFHLvdFer16wl9di9bjfNC/nE//hI5pztT499/MGYP1X0HLv/9/tDbngw271t7o37Co2/rji96Gz12LvOUHrinyFfsmz7kM8c+OiWHE5d0L1/aX79diHfvscVrZ7/oxXxXymO/lyx15Lf0uqhd99fEV+jfXLI/SHv8uOTMo8ZsXVcs/uxB+Iek/0ej6+xPvCB34R86sBbQj5vSdw3MKWU7j9vt5D73FK8PTU6Uz10L6NsB9eW8gMppZZS7Fb5PgTPnfSGkP9++iUhP7Au/s1kx9s+kHmOsQXfU6Mz1WXvNsOGRx8P+cwr4p4at5zx1ZDflD4a8uu+G9+frNsl/q0upZSem9Qr5LM+9MuQn9/wYsi/Oyb+naf5n/X92rGrdq8ti74ZX/eV76mx993vDbne9tPoqIo+sVEqldKMGTPStddem2666aY0duzY8P3Jkyen7t27pzlz5mw8tmDBgvTkk0+mKVOyL3Rgc+keedA78qJ75EHvyIvukQe9Iy+6Rx70jrzoHp2pok9sTJ8+Pf34xz9O119/ferXr9/Gtc4GDBiQevfunQYMGJBOOeWUdO6556ZBgwal/v37pzPPPDNNmTJls3axh9eie+RB78iL7pEHvSMvukce9I686B550Dvyont0poomNi677LKUUkoHH3xwOD579uz0vve9L6WU0oUXXpgaGxvTtGnT0tq1a9Nhhx2WLr300qoMlq5L98iD3pEX3SMPekdedI886B150T3yoHfkRffoTA2lUim76GGOVqxYkQYMGJAOTkenbg3dt9jzLvxu3GOjz6PZ537gzM7/P9U/1sU16z86ptizkxtK69Mt6fq0fPny1L9//7YfkKO8ukfnKEr38urd0x/bL+R7P/ytiq/xued3DfmRVdu0ev7r+z6XOfbpIfdV/Lyv9uSG1Zlj/3beeSH3/fmWW8+5KL1LyT2v3hSle/Xcu8l/i2t+f37ovZlz3jr/6JAbDyn2RodF6V1Ktd29hr3i79NHz2sI+b43fj/k7y2P+7n85ri4TEPzg3FPvnpUlO7l1btFF+8T8l3HfiNzTvdN7FPWmrfe95544Kr4uq//T+6o6HpFpXute/THk0J+8KDvZ87Z/94TQt558JKQvzPqllaf44DzZ4Q88Kr6X29e7zrf4v+I749vOS3uubF1Y9w/Y1Me2xD/nvfW6+L70h0+fm/ILWvi+bVI96rv5XfE39E///rXQ15fdv5xn477vWx9pXveq1X2agYAAAAAACBHJjYAAAAAAIDCMLEBAAAAAAAURkWbh9ezCR+8O+TGPn0y5+yw1emtXqPvri+G/Nc9f9rq+QvXr8ocO/fkM0NuSn9t9RoA7THyt/F+tdcBJ2bOuXvyT1q9RmZ/jCEdHlbGK6V1Ie96w1khj7k2rmmfUkp9f7/l9tQA+F8/XzAp5E3tsTGs98qQszsP0RUt/WRcTfm+PX/Y6vmX/ujIkEc++Jeqj4liG39WfC307rP27/A1+6dHyo6UZ0ip28Kyv6MclD3nvyddHXJjKttXaN2GkKdd/+GQJ1x7f8jZdwNQuVFfiL9L/+0LHb9vjk9x7yFd7Zqadt4h5Mu++s1Wz3/7Z+OeGoO7wJ4aHeETGwAAAAAAQGGY2AAAAAAAAArDxAYAAAAAAFAY9th4DS2rV2eOjfmPytY1OyxNqvh57akBbAkt988PedgJ2X2F9jppesgvHxjviw2PxMcc+JZ/tPqctz46rs1xbXVbvOagh9aGPOGWu9q8BkAexn0+3q/Ou2rvzDl/+/VOIY9M9kboakpTds8cG7rVC60+ZqebTw15/B9WxGt2fFgAVbH95XHvlZ17zMic86f3fDXkTz51RMh3/WGXkMd9Jv6utE8BUKsa+/XLHJv/8b4h79C9KeQ33vtvIQ/+vj01KuETGwAAAAAAQGGY2AAAAAAAAArDxAYAAAAAAFAY9tgAYJP7Cm1z2dyy3Po1nvxk698fm/5e6bAACqP5gQUhPzQ5e449NVh0Us/MsfkTrw352peHhjz+ovUhl+65v/oDA6iCDUuWhjz2E0sz53zwEweUHYn7Br3O70qgoJ48c9fMsQWHXBLyh59+Y8iD3/FUyPYRqoxPbAAAAAAAAIVhYgMAAAAAACgMExsAAAAAAEBhmNgAAAAAAAAKw+bhAAAAW8B2f2rIHjwyxm/MPCHkre+Z24kjAgCgPdYfumfIF77/u5lzJl4zPeQdLn0u5JbVj1R/YF2IT2wAAAAAAACFYWIDAAAAAAAoDBMbAAAAAABAYdhjAwAAYAvo+/M7M8eO+vleIW+d7KkBAFDruv/hnpC/Pm7nzDnj0h0hN3fqiLoen9gAAAAAAAAKw8QGAAAAAABQGDW3FFWpVEoppbQhrU+plPNg6LANaX1K6f/+u9Yy3asvReme3tWXovQuJd2rN0Xpnt7Vl6L0LiXdqzdF6Z7e1R/dIw96R150jzxU0ruam9hYuXJlSiml29Nvcx4J1bRy5co0YMCAvIfRKt2rT7XePb2rT7Xeu5R0r17Vevf0rj7Veu9S0r16Vevd07v6pXvkQe/Ii+6Rh83pXUOpxqbdWlpa0tNPP51KpVIaPXp0Wrx4cerfv3/ewyq0FStWpFGjRuXysyyVSmnlypVpxIgRqbGxtlc+073q07226V316d3m0b3q07226V316d3m0b3q07226V315dm7lHSvK3PPa5veVZ973ubRveoryj2v5j6x0djYmEaOHJlWrFiRUkqpf//+ylglef0sa3lW99V0r/Po3mvTu86jd63Tvc6je69N7zqP3rVO9zqP7r02ves8ef4sda9rc897bXrXedzzWqd7nafW73m1O90GAAAAAABQxsQGAAAAAABQGDU7sdGzZ8/0mc98JvXs2TPvoRSen2Vl/Lyqx89y8/lZVY+fZWX8vKrHz3Lz+VlVj59lZfy8qsfPcvP5WVWPn2Vl/Lyqx89y8/lZVY+fZWX8vKqnKD/Lmts8HAAAAAAA4LXU7Cc2AAAAAAAAypnYAAAAAAAACsPEBgAAAAAAUBgmNgAAAAAAgMKo2YmNWbNmpTFjxqRevXqlffbZJ9111115D6nmzZw5M+21116pX79+aejQoemYY45JCxYsCOesWbMmTZ8+PQ0ePDhttdVWadq0aWnp0qU5jbj26F3l9K46dK9yutdxelc5vasO3auc7nWc3lVO76pD9yqnex2nd5XTu+rQvcrpXsfpXeXqonelGnT11VeXevToUbriiitKDzzwQOmDH/xgaeDAgaWlS5fmPbSadthhh5Vmz55duv/++0v33ntv6YgjjiiNHj269PLLL28857TTTiuNGjWqNGfOnNI999xT2nfffUv77bdfjqOuHXrXPnrXcbrXPrrXMXrXPnrXcbrXPrrXMXrXPnrXcbrXPrrXMXrXPnrXcbrXPrrXMXrXPvXQu5qc2Nh7771L06dP35ibm5tLI0aMKM2cOTPHURXPs88+W0oplW699dZSqVQqLVu2rNS9e/fSNddcs/Gchx56qJRSKs2dOzevYdYMvasOvauc7lWH7lVG76pD7yqne9Whe5XRu+rQu8rpXnXoXmX0rjr0rnK6Vx26Vxm9q44i9q7mlqJat25dmjdvXpo6derGY42NjWnq1Klp7ty5OY6seJYvX55SSmnQoEEppZTmzZuX1q9fH362EydOTKNHj+7yP1u9qx69q4zuVY/ubT69qx69q4zuVY/ubT69qx69q4zuVY/ubT69qx69q4zuVY/ubT69q54i9q7mJjaef/751NzcnIYNGxaODxs2LC1ZsiSnURVPS0tLOvvss9P++++fdtlll5RSSkuWLEk9evRIAwcODOf62epdtehd5XSvOnSvMnpXHXpXOd2rDt2rjN5Vh95VTveqQ/cqo3fVoXeV073q0L3K6F11FLV33fIeAJ1j+vTp6f7770+333573kOhC9E78qJ75EHvyIvukQe9Iy+6Rx70jrzoHnkoau9q7hMbQ4YMSU1NTZkd1pcuXZqGDx+e06iKZcaMGemGG25IN998cxo5cuTG48OHD0/r1q1Ly5YtC+f72epdNehd++hex+le5fSu4/SufXSv43SvcnrXcXrXPrrXcbpXOb3rOL1rH93rON2rnN51XJF7V3MTGz169EiTJ09Oc+bM2XispaUlzZkzJ02ZMiXHkdW+UqmUZsyYka699tp00003pbFjx4bvT548OXXv3j38bBcsWJCefPLJLv+z1bv207uO0b32073207v207uO0b32073207v207uO0b32073207v207uO0b32073207v2q4ve5bVreWuuvvrqUs+ePUtXXnll6cEHHyydeuqppYEDB5aWLFmS99Bq2umnn14aMGBA6ZZbbik988wzG79Wr1698ZzTTjutNHr06NJNN91Uuueee0pTpkwpTZkyJcdR1w69ax+96zjdax/d6xi9ax+96zjdax/d6xi9ax+96zjdax/d6xi9ax+96zjdax/d6xi9a5966F1NTmyUSqXSJZdcUho9enSpR48epb333rt0xx135D2kmpdS2uTX7NmzN57zyiuvlM4444zS1ltvXerTp0/p2GOPLT3zzDP5DbrG6F3l9K46dK9yutdxelc5vasO3auc7nWc3lVO76pD9yqnex2nd5XTu+rQvcrpXsfpXeXqoXcNpVKpVJ3PfgAAAAAAAHSumttjAwAAAAAA4LWY2AAAAAAAAArDxAYAAAAAAFAYJjYAAAAAAIDCMLEBAAAAAAAUhokNAAAAAACgMExsAAAAAAAAhWFiAwAAAAAAKAwTGwAAAAAAQGGY2AAAAAAAAArDxAYAAAAAAFAYJjYAAAAAAIDC+P8j4EuRX5Sm9QAAAABJRU5ErkJggg==\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#####Do the normalization"
      ],
      "metadata": {
        "id": "YsmuoKI6M_Z2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "X_train = X_train/255\n",
        "X_test  = X_test/255\n",
        "\n",
        "print(\"Normalozation is completed.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KUNiP3bYM50a",
        "outputId": "729107bf-f1a8-42d9-98e6-6306d9ed925b"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Normalozation is completed.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "np.unique(y_test).shape[0]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9QdVKFqKMLwD",
        "outputId": "33864ac5-e28f-4826-ae8a-254032ff5fed"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "10"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#####Convert the data type into float with respect to PyTorch"
      ],
      "metadata": {
        "id": "1FVeeAyKP11M"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "\n",
        "X_train = np.expand_dims(X_train, 1)\n",
        "X_train = torch.tensor(data = X_train, dtype = torch.float32)\n",
        "y_train = torch.tensor(data = y_train, dtype = torch.float32)\n",
        "\n",
        "X_test  = np.expand_dims(X_test, 1)\n",
        "X_test  = torch.tensor(data = X_test, dtype = torch.float32)\n",
        "y_test  = torch.tensor(data = y_test, dtype = torch.float32)"
      ],
      "metadata": {
        "id": "5jjcFeNPP64h"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#####Initialize the DataLoader with batch_size: 64"
      ],
      "metadata": {
        "id": "OeOXtH3hOfBD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.functional as F\n",
        "import torch.optim as optim\n",
        "from torchsummary import summary\n",
        "from torch.utils.data import Dataset, DataLoader"
      ],
      "metadata": {
        "id": "M10ACt_VMLyG"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "BATCH_SIZE = 128\n",
        "train_loader = DataLoader(dataset = list(zip(X_train, y_train)), batch_size = BATCH_SIZE, shuffle = True)\n",
        "test_loader  = DataLoader(dataset = list(zip(X_test, y_test)), batch_size = BATCH_SIZE, shuffle = True)\n",
        "\n",
        "print(\"Batch size of Train # {} \".format(train_loader.batch_size),'\\n')\n",
        "print(\"Batch size of Test  # {} \".format(test_loader.batch_size),'\\n')\n",
        "\n",
        "train_data, train_label = next(iter(train_loader))\n",
        "test_data, test_label   = next(iter(test_loader))\n",
        "\n",
        "print(\"Train data shape with batch_size  # {} \".format(train_data.shape),'\\n')\n",
        "print(\"Train label shape with batch_size # {} \".format(train_label.shape),'\\n')\n",
        "\n",
        "print(\"Test data shape with batch_size   # {} \".format(test_data.shape),'\\n')\n",
        "print(\"Test label shape with batch_size  # {} \".format(test_label.shape))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "N28Jx4RYML1n",
        "outputId": "cc08b004-454d-4392-c577-7eade7b3e4ce"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Batch size of Train # 128  \n",
            "\n",
            "Batch size of Test  # 128  \n",
            "\n",
            "Train data shape with batch_size  # torch.Size([128, 1, 28, 28])  \n",
            "\n",
            "Train label shape with batch_size # torch.Size([128])  \n",
            "\n",
            "Test data shape with batch_size   # torch.Size([128, 1, 28, 28])  \n",
            "\n",
            "Test label shape with batch_size  # torch.Size([128]) \n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#####Model Building"
      ],
      "metadata": {
        "id": "LouX5lscQLj_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\"\"\"\n",
        "    Create a class named DigitClassifier that would take TWO parameters\n",
        "        1. input_channel\n",
        "        2. output_dimension\n",
        "\n",
        "    Call the super function so that it will inherit all the necessity methods from the parent class\n",
        "\"\"\"\n",
        "class DigitClassifier(nn.Module):\n",
        "  def __init__(self, input_channel = None, output_dimension = None):\n",
        "    super().__init__()\n",
        "\n",
        "    \"\"\"\n",
        "        Create a Sequential model that will take a couple of parameters like\n",
        "            1. in_channels : Define wether it is RGB or Gray. RGB-3, Gray-1\n",
        "            2. out_channels: Define the next neurons that defined with 64\n",
        "            3. kernel_size : Define the output of feature map that is used to extract the low and high level features from the image\n",
        "            4. stride : Defines the window movement while computing the feature map\n",
        "            5. padding: padding defines whether the output feature's size would be equivalent to orginal or not\n",
        "\n",
        "        Activation : ReLU, Defines whether the next neurons with respect to layer would be activated or not\n",
        "        Pooling-Layer: Defined the down sampling the feature map\n",
        "        Dropout Layer: Defined the overfitting\n",
        "        Input-Shape  : (28 * 28) * 1\n",
        "    \"\"\"\n",
        "    self.firstLayer = nn.Sequential(\n",
        "        nn.Conv2d(in_channels = input_channel, out_channels = 64, kernel_size = 3, stride = 1, padding = 1),\n",
        "        nn.ReLU(),\n",
        "        nn.MaxPool2d(kernel_size = 2, stride = 2),\n",
        "        nn.Dropout(p = 0.3)\n",
        "    )\n",
        "\n",
        "    \"\"\"\n",
        "        Create a Sequential model that will take a couple of parameters like\n",
        "            1. in_channels : Define wether it is RGB or Gray. RGB-3, Gray-1\n",
        "            2. out_channels: Define the next neurons that defined with 64\n",
        "            3. kernel_size : Define the output of feature map that is used to extract the low and high level features from the image\n",
        "            4. stride : Defines the window movement while computing the feature map\n",
        "            5. padding: padding defines whether the output feature's size would be equivalent to orginal or not\n",
        "\n",
        "        Activation : ReLU, Defines whether the next neurons with respect to layer would be activated or not\n",
        "        Pooling-Layer: Defined the down sampling the feature map\n",
        "        Dropout Layer: Defined the overfitting\n",
        "        Input-Shape : (14 * 14) * 64\n",
        "    \"\"\"\n",
        "    self.secondLayer = nn.Sequential(\n",
        "        nn.Conv2d(in_channels = 64, out_channels = 32, kernel_size = 3, stride = 1, padding = 1),\n",
        "        nn.ReLU(),\n",
        "        nn.MaxPool2d(kernel_size = 2, stride = 2),\n",
        "        nn.Dropout(p = 0.4)\n",
        "    )\n",
        "\n",
        "    \"\"\"\n",
        "    Input-Shape : (7 * 7) * 32\n",
        "    Create a fully connected layer with a couple of parameters\n",
        "    1. in_features: 7 * 7 * 32\n",
        "    2. out_features : 128\n",
        "    3. Activation : ReLU()\n",
        "    4. Dropout-rate: 0.5\n",
        "    \"\"\"\n",
        "    self.hiddenLayer1 = nn.Sequential(\n",
        "        nn.Linear(in_features = 7 * 7 * 32, out_features = 128),\n",
        "        nn.ReLU(),\n",
        "        nn.Dropout(p = 0.5)\n",
        "    )\n",
        "\n",
        "    \"\"\"\n",
        "        Create the second hidden Layer\n",
        "        1. in_features = 128\n",
        "        2. out_features = 64\n",
        "        3. Activation : ReLU\n",
        "    \"\"\"\n",
        "    self.hiddenLayer2 = nn.Sequential(\n",
        "        nn.Linear(in_features = 128, out_features = 64),\n",
        "        nn.ReLU()\n",
        "    )\n",
        "\n",
        "    \"\"\"\n",
        "        Create the output layer with\n",
        "        1. in_features = 64\n",
        "        2. out_features = output_dimension\n",
        "    \"\"\"\n",
        "    self.outputLayer = nn.Sequential(\n",
        "        nn.Linear(in_features = 64, out_features = output_dimension),\n",
        "        nn.Softmax()\n",
        "    )\n",
        "\n",
        "  def forward(self, x):\n",
        "    \"\"\"\n",
        "        For the First Layer that would take independent Features\n",
        "    \"\"\"\n",
        "    x = self.firstLayer(x)\n",
        "\n",
        "    \"\"\"\n",
        "        For the Second Layer that will take x: Inpendent Features\n",
        "    \"\"\"\n",
        "    x = self.secondLayer(x)\n",
        "\n",
        "    \"\"\"\n",
        "        For the Flatten operation that would assist us to add neural networks\n",
        "    \"\"\"\n",
        "    x = x.reshape(x.size(0), -1)\n",
        "\n",
        "    \"\"\"\n",
        "        For the First hidden Layer\n",
        "    \"\"\"\n",
        "    x = self.hiddenLayer1(x)\n",
        "\n",
        "    \"\"\"\n",
        "        For the Second Hidden Layer\n",
        "    \"\"\"\n",
        "    x = self.hiddenLayer2(x)\n",
        "\n",
        "    \"\"\"\n",
        "        For the Output Layer\n",
        "    \"\"\"\n",
        "    x = self.outputLayer(x)\n",
        "\n",
        "    return x\n"
      ],
      "metadata": {
        "id": "MCGq3w_iC6F0"
      },
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Call the model\n",
        "try:\n",
        "  model = DigitClassifier(input_channel = 1, output_dimension = 10)\n",
        "except Exception as e:\n",
        "  print(e.with_traceback())\n",
        "else:\n",
        "  print(model.parameters)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RuubWA9TC6IY",
        "outputId": "9c64527b-2132-4b34-fdc5-cc38ffc51e9a"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<bound method Module.parameters of DigitClassifier(\n",
            "  (firstLayer): Sequential(\n",
            "    (0): Conv2d(1, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
            "    (1): ReLU()\n",
            "    (2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
            "    (3): Dropout(p=0.3, inplace=False)\n",
            "  )\n",
            "  (secondLayer): Sequential(\n",
            "    (0): Conv2d(64, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
            "    (1): ReLU()\n",
            "    (2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
            "    (3): Dropout(p=0.4, inplace=False)\n",
            "  )\n",
            "  (hiddenLayer1): Sequential(\n",
            "    (0): Linear(in_features=1568, out_features=128, bias=True)\n",
            "    (1): ReLU()\n",
            "    (2): Dropout(p=0.5, inplace=False)\n",
            "  )\n",
            "  (hiddenLayer2): Sequential(\n",
            "    (0): Linear(in_features=128, out_features=64, bias=True)\n",
            "    (1): ReLU()\n",
            "  )\n",
            "  (outputLayer): Sequential(\n",
            "    (0): Linear(in_features=64, out_features=10, bias=True)\n",
            "    (1): Softmax(dim=None)\n",
            "  )\n",
            ")>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#####Define GPU"
      ],
      "metadata": {
        "id": "pqj965j4K5Pv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "device = torch.device('cuda' if torch.cuda.is_available else 'cpu')\n",
        "device"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vjmCANAlC6L8",
        "outputId": "ffe37e4d-f168-47f2-a27d-09c86f42c4a5"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "device(type='cuda')"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Add the model into GPU\n",
        "model = model.to(device)"
      ],
      "metadata": {
        "id": "nfzn_b9MLJZc"
      },
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#####Summary the model"
      ],
      "metadata": {
        "id": "kFVix6G9LFUs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "summary(model = model, input_size = X_train.shape[1:])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YnrpjTtbLHOX",
        "outputId": "442dc5c9-3956-499c-904b-698849c8716f"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "----------------------------------------------------------------\n",
            "        Layer (type)               Output Shape         Param #\n",
            "================================================================\n",
            "            Conv2d-1           [-1, 64, 28, 28]             640\n",
            "              ReLU-2           [-1, 64, 28, 28]               0\n",
            "         MaxPool2d-3           [-1, 64, 14, 14]               0\n",
            "           Dropout-4           [-1, 64, 14, 14]               0\n",
            "            Conv2d-5           [-1, 32, 14, 14]          18,464\n",
            "              ReLU-6           [-1, 32, 14, 14]               0\n",
            "         MaxPool2d-7             [-1, 32, 7, 7]               0\n",
            "           Dropout-8             [-1, 32, 7, 7]               0\n",
            "            Linear-9                  [-1, 128]         200,832\n",
            "             ReLU-10                  [-1, 128]               0\n",
            "          Dropout-11                  [-1, 128]               0\n",
            "           Linear-12                   [-1, 64]           8,256\n",
            "             ReLU-13                   [-1, 64]               0\n",
            "           Linear-14                   [-1, 10]             650\n",
            "          Softmax-15                   [-1, 10]               0\n",
            "================================================================\n",
            "Total params: 228,842\n",
            "Trainable params: 228,842\n",
            "Non-trainable params: 0\n",
            "----------------------------------------------------------------\n",
            "Input size (MB): 0.00\n",
            "Forward/backward pass size (MB): 1.08\n",
            "Params size (MB): 0.87\n",
            "Estimated Total Size (MB): 1.96\n",
            "----------------------------------------------------------------\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "LEARNING_RATE = 0.001\n",
        "loss_function = nn.CrossEntropyLoss()\n",
        "optimizer = optim.AdamW(params = model.parameters(), lr = LEARNING_RATE)"
      ],
      "metadata": {
        "id": "WAJoJoCAZlZF"
      },
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#####Train the model"
      ],
      "metadata": {
        "id": "3idUPpLEZ0wy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Initialize some varibales\n",
        "EPOCHS     = 50\n",
        "TRAIN_LOSS = []\n",
        "VAL_LOSS   = []\n",
        "TRAIN_ACC  = []\n",
        "VAL_ACC    = []\n",
        "\n",
        "# Call the model train\n",
        "model.train()\n",
        "\n",
        "\"\"\"\n",
        "    1. Run a loop with respect to EPOCHS\n",
        "\n",
        "    2. Initialize some of the crucial variables\n",
        "        1. total_train_loss: Define the total train loss with respect to epoch\n",
        "        2. total_val_loss  : Define the total validation loss with respect to epoch\n",
        "        3. train_predictions : Define the total train prediction with respect to epoch\n",
        "        4. val_predictions : Define the total validation predictions with respect to epoch\n",
        "        5. train_lables : Store all the train labels during batch size\n",
        "        6. val_labels : Store all the validation labels duirng batch size\n",
        "\n",
        "    3. Run a loop with respect to train_loader & extrac data and label\n",
        "\"\"\"\n",
        "#######################\n",
        "#      Training       #\n",
        "#######################\n",
        "\n",
        "for epoch in range(EPOCHS):\n",
        "  total_train_loss  = []\n",
        "  total_val_loss    = []\n",
        "  train_predictions = []\n",
        "  val_predictions   = []\n",
        "  train_labels      = []\n",
        "  val_labels        = []\n",
        "\n",
        "  for X_batch, y_batch in train_loader:\n",
        "    y_batch = y_batch.long()\n",
        "    # Connect GPU to X_batch & y_batch\n",
        "    X_batch = X_batch.to(device)\n",
        "    y_batch = y_batch.to(device)\n",
        "    # Do the prediction\n",
        "    train_prediction = model(X_batch)\n",
        "    train_loss = loss_function(train_prediction, y_batch)\n",
        "\n",
        "    \"\"\"\n",
        "        1. Initialize the optimizer to adjust the weight and bias\n",
        "        2. Do backward propagation with respect to train loss\n",
        "        3. Do step operation with respect to optimizer\n",
        "    \"\"\"\n",
        "\n",
        "    optimizer.zero_grad()\n",
        "    train_loss.backward()\n",
        "    optimizer.step()\n",
        "\n",
        "    # Checking CPU\n",
        "    y_batch = y_batch.cpu()\n",
        "    # Store the orginal train labels into train_labels\n",
        "    train_labels.extend(y_batch.flatten().detach().numpy())\n",
        "\n",
        "    # Store the train loss into train_loss\n",
        "    total_train_loss.append(train_loss.item())\n",
        "\n",
        "    # Store the predicted labels\n",
        "    train_predictions.extend(torch.argmax(train_prediction.cpu(), 1).flatten().detach().numpy())\n",
        "\n",
        "  # ===============================================================================================\n",
        "  # ===============================================================================================\n",
        "  \"\"\"\n",
        "      Store the train loss and accuracy into TRAIN_LOSS & TRAIN_ACC list after being completed Epoch\n",
        "  \"\"\"\n",
        "  # Store the accuracy into TRAIN_ACCURACY\n",
        "  TRAIN_ACC.append(accuracy_score(train_labels, train_predictions))\n",
        "\n",
        "  # Store the train loss into TRAIN_LOSS\n",
        "  TRAIN_LOSS.append(np.array(total_train_loss).mean())\n",
        "\n",
        "  ########################\n",
        "  #        Testing       #\n",
        "  ########################\n",
        "  model.eval()\n",
        "\n",
        "  for val_data, val_label in test_loader:\n",
        "    val_label = val_label.long()\n",
        "    # Convert GPU\n",
        "    val_data = val_data.to(device)\n",
        "    val_label = val_label.to(device)\n",
        "    # Do the prediction\n",
        "    val_prediction = model(val_data)\n",
        "    val_loss = loss_function(val_prediction, val_label)\n",
        "\n",
        "    # Checking CPU\n",
        "    val_label = val_label.cpu()\n",
        "    # Store the orginal validation labels into val_labels\n",
        "    val_labels.extend(val_label.flatten().detach().numpy())\n",
        "\n",
        "    # Store the validation loss into total_val_loss\n",
        "    total_val_loss.append(val_loss.item())\n",
        "\n",
        "    # Store the validation prediction labels\n",
        "    val_predictions.extend(torch.argmax(val_prediction.cpu(), 1).flatten().detach().numpy())\n",
        "\n",
        "  # ===============================================================================================\n",
        "  # ===============================================================================================\n",
        "  \"\"\"\n",
        "      Store the train loss and accuracy into VAL_LOSS & VAL_ACC list after being completed Epoch\n",
        "  \"\"\"\n",
        "  # Store the val loss into VAL_LOSS\n",
        "  VAL_LOSS.append(np.array(total_val_loss).mean())\n",
        "\n",
        "  # Store the validation accuracy into VAL_ACC\n",
        "  VAL_ACC.append(accuracy_score(val_labels, val_predictions))\n",
        "\n",
        "  ########################\n",
        "  #       Display        #\n",
        "  ########################\n",
        "\n",
        "  print(\"Epoch {}/{} \".format(epoch + 1, EPOCHS))\n",
        "\n",
        "  print(\"{}/{} [=========================] loss: {} - accuracy: {} - val_loss: {} - val_accuracy: {}\".format(train_loader.batch_size,\\\n",
        "                                                                                                             train_loader.batch_size,\\\n",
        "                                                                                                             np.array(total_train_loss).mean(),\\\n",
        "                                                                                                             accuracy_score(train_labels, train_predictions),\\\n",
        "                                                                                                             np.array(total_val_loss).mean(),\\\n",
        "                                                                                                             accuracy_score(val_labels, val_predictions)))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FXG-6inpZlcq",
        "outputId": "67ef5ba6-f928-434e-9938-e76e741cc492"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/50 \n",
            "128/128 [=========================] loss: 1.6999340517434485 - accuracy: 0.7697166666666667 - val_loss: 1.5146035182325146 - val_accuracy: 0.9471\n",
            "Epoch 2/50 \n",
            "128/128 [=========================] loss: 1.4996962084699033 - accuracy: 0.9629166666666666 - val_loss: 1.4887926699239997 - val_accuracy: 0.9734\n",
            "Epoch 3/50 \n",
            "128/128 [=========================] loss: 1.4880089632737865 - accuracy: 0.9743833333333334 - val_loss: 1.4855705710906018 - val_accuracy: 0.9768\n",
            "Epoch 4/50 \n",
            "128/128 [=========================] loss: 1.4815991519610765 - accuracy: 0.98005 - val_loss: 1.4824650544154494 - val_accuracy: 0.98\n",
            "Epoch 5/50 \n",
            "128/128 [=========================] loss: 1.4787672084531804 - accuracy: 0.9829833333333333 - val_loss: 1.47802994824663 - val_accuracy: 0.9838\n",
            "Epoch 6/50 \n",
            "128/128 [=========================] loss: 1.4762039977604393 - accuracy: 0.9855666666666667 - val_loss: 1.4754968730709221 - val_accuracy: 0.9861\n",
            "Epoch 7/50 \n",
            "128/128 [=========================] loss: 1.4740220051584467 - accuracy: 0.9874833333333334 - val_loss: 1.4740328909475593 - val_accuracy: 0.987\n",
            "Epoch 8/50 \n",
            "128/128 [=========================] loss: 1.4735423850098144 - accuracy: 0.9878166666666667 - val_loss: 1.4794402454472795 - val_accuracy: 0.9827\n",
            "Epoch 9/50 \n",
            "128/128 [=========================] loss: 1.4727903673135396 - accuracy: 0.9887333333333334 - val_loss: 1.4750986491577536 - val_accuracy: 0.9867\n",
            "Epoch 10/50 \n",
            "128/128 [=========================] loss: 1.4718004139755834 - accuracy: 0.9895333333333334 - val_loss: 1.4736898051032536 - val_accuracy: 0.9872\n",
            "Epoch 11/50 \n",
            "128/128 [=========================] loss: 1.4699487320141498 - accuracy: 0.9914333333333334 - val_loss: 1.47404912906357 - val_accuracy: 0.9874\n",
            "Epoch 12/50 \n",
            "128/128 [=========================] loss: 1.4706329430090084 - accuracy: 0.9906833333333334 - val_loss: 1.4719702880593795 - val_accuracy: 0.989\n",
            "Epoch 13/50 \n",
            "128/128 [=========================] loss: 1.4694371037900067 - accuracy: 0.9919166666666667 - val_loss: 1.4722069486787048 - val_accuracy: 0.9888\n",
            "Epoch 14/50 \n",
            "128/128 [=========================] loss: 1.4692409099546322 - accuracy: 0.9919833333333333 - val_loss: 1.4731608448149283 - val_accuracy: 0.9886\n",
            "Epoch 15/50 \n",
            "128/128 [=========================] loss: 1.468147372131917 - accuracy: 0.9932166666666666 - val_loss: 1.4719001190571845 - val_accuracy: 0.9891\n",
            "Epoch 16/50 \n",
            "128/128 [=========================] loss: 1.4682886709790748 - accuracy: 0.9930166666666667 - val_loss: 1.4720023040530048 - val_accuracy: 0.9888\n",
            "Epoch 17/50 \n",
            "128/128 [=========================] loss: 1.4685179813584286 - accuracy: 0.9927666666666667 - val_loss: 1.4730724835697608 - val_accuracy: 0.9888\n",
            "Epoch 18/50 \n",
            "128/128 [=========================] loss: 1.4683071522316191 - accuracy: 0.9929666666666667 - val_loss: 1.4757995273493514 - val_accuracy: 0.9858\n",
            "Epoch 19/50 \n",
            "128/128 [=========================] loss: 1.4677073724234282 - accuracy: 0.9934666666666667 - val_loss: 1.4732218467736546 - val_accuracy: 0.988\n",
            "Epoch 20/50 \n",
            "128/128 [=========================] loss: 1.4673928970467054 - accuracy: 0.9939166666666667 - val_loss: 1.4728536334218858 - val_accuracy: 0.9889\n",
            "Epoch 21/50 \n",
            "128/128 [=========================] loss: 1.466637478962636 - accuracy: 0.9945666666666667 - val_loss: 1.4765327429469628 - val_accuracy: 0.9853\n",
            "Epoch 22/50 \n",
            "128/128 [=========================] loss: 1.4677090149190126 - accuracy: 0.9935 - val_loss: 1.471577663964863 - val_accuracy: 0.989\n",
            "Epoch 23/50 \n",
            "128/128 [=========================] loss: 1.4669661910803333 - accuracy: 0.99425 - val_loss: 1.47192888169349 - val_accuracy: 0.9888\n",
            "Epoch 24/50 \n",
            "128/128 [=========================] loss: 1.4669764674802832 - accuracy: 0.9942666666666666 - val_loss: 1.4729407799394825 - val_accuracy: 0.9879\n",
            "Epoch 25/50 \n",
            "128/128 [=========================] loss: 1.4666347511287436 - accuracy: 0.9944833333333334 - val_loss: 1.472981078715264 - val_accuracy: 0.988\n",
            "Epoch 26/50 \n",
            "128/128 [=========================] loss: 1.4659743980049833 - accuracy: 0.9952333333333333 - val_loss: 1.470997461789771 - val_accuracy: 0.9898\n",
            "Epoch 27/50 \n",
            "128/128 [=========================] loss: 1.4666011661354668 - accuracy: 0.9946166666666667 - val_loss: 1.4721910561187357 - val_accuracy: 0.9887\n",
            "Epoch 28/50 \n",
            "128/128 [=========================] loss: 1.465970184757257 - accuracy: 0.9952666666666666 - val_loss: 1.4722200496287285 - val_accuracy: 0.989\n",
            "Epoch 29/50 \n",
            "128/128 [=========================] loss: 1.4657535047165111 - accuracy: 0.9954 - val_loss: 1.4715489088734495 - val_accuracy: 0.9896\n",
            "Epoch 30/50 \n",
            "128/128 [=========================] loss: 1.4653484129956535 - accuracy: 0.9958166666666667 - val_loss: 1.472603011734878 - val_accuracy: 0.9889\n",
            "Epoch 31/50 \n",
            "128/128 [=========================] loss: 1.4664666154491368 - accuracy: 0.9946833333333334 - val_loss: 1.4723951424224466 - val_accuracy: 0.9885\n",
            "Epoch 32/50 \n",
            "128/128 [=========================] loss: 1.4662745692836705 - accuracy: 0.9949 - val_loss: 1.4724673877788494 - val_accuracy: 0.9887\n",
            "Epoch 33/50 \n",
            "128/128 [=========================] loss: 1.4655731873217421 - accuracy: 0.99565 - val_loss: 1.470423962496504 - val_accuracy: 0.9906\n",
            "Epoch 34/50 \n",
            "128/128 [=========================] loss: 1.4660132467619647 - accuracy: 0.9951833333333333 - val_loss: 1.4733342596247225 - val_accuracy: 0.9874\n",
            "Epoch 35/50 \n",
            "128/128 [=========================] loss: 1.4649989973507456 - accuracy: 0.9961 - val_loss: 1.469776066043709 - val_accuracy: 0.9911\n",
            "Epoch 36/50 \n",
            "128/128 [=========================] loss: 1.4651039564279096 - accuracy: 0.9960666666666667 - val_loss: 1.471241299110123 - val_accuracy: 0.9896\n",
            "Epoch 37/50 \n",
            "128/128 [=========================] loss: 1.4656296404185833 - accuracy: 0.9956 - val_loss: 1.4700037497508376 - val_accuracy: 0.9913\n",
            "Epoch 38/50 \n",
            "128/128 [=========================] loss: 1.4647909128335492 - accuracy: 0.99635 - val_loss: 1.4706865428369256 - val_accuracy: 0.9902\n",
            "Epoch 39/50 \n",
            "128/128 [=========================] loss: 1.4651167052132743 - accuracy: 0.9961166666666667 - val_loss: 1.4707022392297093 - val_accuracy: 0.9902\n",
            "Epoch 40/50 \n",
            "128/128 [=========================] loss: 1.4647452643176895 - accuracy: 0.9964666666666666 - val_loss: 1.4697060087059117 - val_accuracy: 0.9915\n",
            "Epoch 41/50 \n",
            "128/128 [=========================] loss: 1.465112870435979 - accuracy: 0.9960833333333333 - val_loss: 1.4711743955370746 - val_accuracy: 0.9907\n",
            "Epoch 42/50 \n",
            "128/128 [=========================] loss: 1.465060275754949 - accuracy: 0.99615 - val_loss: 1.4696213459666772 - val_accuracy: 0.9913\n",
            "Epoch 43/50 \n",
            "128/128 [=========================] loss: 1.46500970458171 - accuracy: 0.9962666666666666 - val_loss: 1.4733376548260073 - val_accuracy: 0.9877\n",
            "Epoch 44/50 \n",
            "128/128 [=========================] loss: 1.4651177595419163 - accuracy: 0.9961 - val_loss: 1.4697624263884146 - val_accuracy: 0.9914\n",
            "Epoch 45/50 \n",
            "128/128 [=========================] loss: 1.4648327885914458 - accuracy: 0.9963166666666666 - val_loss: 1.4713404042811333 - val_accuracy: 0.9898\n",
            "Epoch 46/50 \n",
            "128/128 [=========================] loss: 1.4649743873681595 - accuracy: 0.9962 - val_loss: 1.4696348362331149 - val_accuracy: 0.9914\n",
            "Epoch 47/50 \n",
            "128/128 [=========================] loss: 1.4640175203270496 - accuracy: 0.9971666666666666 - val_loss: 1.468875527381897 - val_accuracy: 0.992\n",
            "Epoch 48/50 \n",
            "128/128 [=========================] loss: 1.4643536267250077 - accuracy: 0.9968166666666667 - val_loss: 1.4693435596514353 - val_accuracy: 0.9918\n",
            "Epoch 49/50 \n",
            "128/128 [=========================] loss: 1.4650123833593276 - accuracy: 0.99615 - val_loss: 1.470166767699809 - val_accuracy: 0.9907\n",
            "Epoch 50/50 \n",
            "128/128 [=========================] loss: 1.4647859032474346 - accuracy: 0.99635 - val_loss: 1.4703768672822397 - val_accuracy: 0.9908\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#####Display the loss & accuracy"
      ],
      "metadata": {
        "id": "yqCXBY2Qjl7o"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "plt.plot(np.array(TRAIN_LOSS), label = 'train_loss')\n",
        "plt.plot(np.array(VAL_LOSS), label = 'val_loss')\n",
        "plt.title('Train Vs Test Loss')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Loss')\n",
        "plt.legend()\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 487
        },
        "id": "abe2A90xkpg5",
        "outputId": "3f388449-b691-4d8f-a6af-53e0a5199d88"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plt.plot(np.array(TRAIN_ACC), label = 'train_accuracy')\n",
        "plt.plot(np.array(VAL_ACC), label = 'val_accuracy')\n",
        "plt.title('Train Vs Test accuracy')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.legend()\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 487
        },
        "id": "GjVUa2ipkpke",
        "outputId": "ffcbe279-b889-48d4-fbda-ed224a8b826c"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#####Evaluation the model performance"
      ],
      "metadata": {
        "id": "PiNdMzogjpHD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Ealuation for training\n",
        "predicted_value = []\n",
        "actual_value    = []\n",
        "\n",
        "for train_data, train_label in train_loader:\n",
        "  # Convert the data and label into GPU\n",
        "  train_data  = train_data.to(device)\n",
        "  train_label = train_label.to(device)\n",
        "\n",
        "  # Do the prediction\n",
        "  predicted = model(train_data)\n",
        "\n",
        "  # Store the train prediction and actual value\n",
        "  predicted_value.extend(torch.argmax(predicted.cpu(), 1))\n",
        "  actual_value.extend(train_label.cpu())\n",
        "\n",
        "########################\n",
        "#       Display        #\n",
        "########################\n",
        "\n",
        "print(\"ACCURACY  # {}\".format(accuracy_score(actual_value, predicted_value)),'\\n')\n",
        "print(\"PRECISION # {}\".format(precision_score(actual_value, predicted_value, average = 'macro')),'\\n')\n",
        "print(\"RECALL    # {}\".format(recall_score(actual_value, predicted_value, average = 'macro')),'\\n')\n",
        "print(\"F1_SCORE  # {}\".format(f1_score(actual_value, predicted_value, average = 'macro')))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GvqVxsdU0oCx",
        "outputId": "c1be85c1-88d7-4141-e700-8e912ac8ad2d"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "ACCURACY  # 0.9958166666666667 \n",
            "\n",
            "PRECISION # 0.995869300786184 \n",
            "\n",
            "RECALL    # 0.9957369763700374 \n",
            "\n",
            "F1_SCORE  # 0.9957963585024245\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Evaluation for testing\n",
        "predicted_value = []\n",
        "actual_value    = []\n",
        "for test_data, test_label in test_loader:\n",
        "  # Convert data and label into GPU\n",
        "  test_data  = test_data.to(device)\n",
        "  test_label = test_label.to(device)\n",
        "\n",
        "  # Do the prediction\n",
        "  predicted = model(test_data)\n",
        "\n",
        "  # Store the test predicted value and actual value\n",
        "  predicted_value.extend(torch.argmax(predicted, 1).cpu())\n",
        "  actual_value.extend(test_label.cpu())\n",
        "\n",
        "########################\n",
        "#       Display        #\n",
        "########################\n",
        "\n",
        "print(\"ACCURACY  # {}\".format(accuracy_score(actual_value, predicted_value)),'\\n')\n",
        "print(\"PRECISION # {}\".format(precision_score(actual_value, predicted_value, average = 'macro')),'\\n')\n",
        "print(\"RECALL    # {}\".format(recall_score(actual_value, predicted_value, average = 'macro')),'\\n')\n",
        "print(\"F1_SCORE  # {}\".format(f1_score(actual_value, predicted_value, average = 'macro')))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zEbm6f44y2a4",
        "outputId": "ae128ec8-086e-4da9-89d7-e0eb37db1659"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "ACCURACY  # 0.9908 \n",
            "\n",
            "PRECISION # 0.9908883620501954 \n",
            "\n",
            "RECALL    # 0.9906363205618746 \n",
            "\n",
            "F1_SCORE  # 0.9907406439470249\n"
          ]
        }
      ]
    }
  ]
}