diff --git a/TD2_Deep_Learning.ipynb b/TD2_Deep_Learning.ipynb
index f1b0bc68bcd37be4dcc836f8c3b49c5831c04547..1080bd539ed40aac2f106e04aceb32299b674db6 100644
--- a/TD2_Deep_Learning.ipynb
+++ b/TD2_Deep_Learning.ipynb
@@ -33,35 +33,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "id": "330a42f5",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Requirement already satisfied: torch in c:\\users\\lenovo\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.11_qbz5n2kfra8p0\\localcache\\local-packages\\python311\\site-packages (2.1.0+cu118)\n",
-      "Requirement already satisfied: torchvision in c:\\users\\lenovo\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.11_qbz5n2kfra8p0\\localcache\\local-packages\\python311\\site-packages (0.16.0+cu118)\n",
-      "Requirement already satisfied: filelock in c:\\users\\lenovo\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.11_qbz5n2kfra8p0\\localcache\\local-packages\\python311\\site-packages (from torch) (3.9.0)\n",
-      "Requirement already satisfied: typing-extensions in c:\\users\\lenovo\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.11_qbz5n2kfra8p0\\localcache\\local-packages\\python311\\site-packages (from torch) (4.4.0)\n",
-      "Requirement already satisfied: sympy in c:\\users\\lenovo\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.11_qbz5n2kfra8p0\\localcache\\local-packages\\python311\\site-packages (from torch) (1.12)\n",
-      "Requirement already satisfied: networkx in c:\\users\\lenovo\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.11_qbz5n2kfra8p0\\localcache\\local-packages\\python311\\site-packages (from torch) (3.0)\n",
-      "Requirement already satisfied: jinja2 in c:\\users\\lenovo\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.11_qbz5n2kfra8p0\\localcache\\local-packages\\python311\\site-packages (from torch) (3.1.2)\n",
-      "Requirement already satisfied: fsspec in c:\\users\\lenovo\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.11_qbz5n2kfra8p0\\localcache\\local-packages\\python311\\site-packages (from torch) (2023.4.0)\n",
-      "Requirement already satisfied: numpy in c:\\users\\lenovo\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.11_qbz5n2kfra8p0\\localcache\\local-packages\\python311\\site-packages (from torchvision) (1.26.1)\n",
-      "Requirement already satisfied: requests in c:\\users\\lenovo\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.11_qbz5n2kfra8p0\\localcache\\local-packages\\python311\\site-packages (from torchvision) (2.31.0)\n",
-      "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in c:\\users\\lenovo\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.11_qbz5n2kfra8p0\\localcache\\local-packages\\python311\\site-packages (from torchvision) (10.1.0)\n",
-      "Requirement already satisfied: MarkupSafe>=2.0 in c:\\users\\lenovo\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.11_qbz5n2kfra8p0\\localcache\\local-packages\\python311\\site-packages (from jinja2->torch) (2.1.2)\n",
-      "Requirement already satisfied: charset-normalizer<4,>=2 in c:\\users\\lenovo\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.11_qbz5n2kfra8p0\\localcache\\local-packages\\python311\\site-packages (from requests->torchvision) (3.3.1)\n",
-      "Requirement already satisfied: idna<4,>=2.5 in c:\\users\\lenovo\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.11_qbz5n2kfra8p0\\localcache\\local-packages\\python311\\site-packages (from requests->torchvision) (3.4)\n",
-      "Requirement already satisfied: urllib3<3,>=1.21.1 in c:\\users\\lenovo\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.11_qbz5n2kfra8p0\\localcache\\local-packages\\python311\\site-packages (from requests->torchvision) (2.0.7)\n",
-      "Requirement already satisfied: certifi>=2017.4.17 in c:\\users\\lenovo\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.11_qbz5n2kfra8p0\\localcache\\local-packages\\python311\\site-packages (from requests->torchvision) (2023.7.22)\n",
-      "Requirement already satisfied: mpmath>=0.19 in c:\\users\\lenovo\\appdata\\local\\packages\\pythonsoftwarefoundation.python.3.11_qbz5n2kfra8p0\\localcache\\local-packages\\python311\\site-packages (from sympy->torch) (1.3.0)\n",
-      "Note: you may need to restart the kernel to use updated packages.\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "%pip install torch torchvision"
    ]
@@ -77,7 +52,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 1,
    "id": "b1950f0a",
    "metadata": {},
    "outputs": [
@@ -85,34 +60,34 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "tensor([[ 1.1553, -0.0581,  1.1725, -1.3031, -0.9055, -0.1700,  0.0107,  0.8367,\n",
-      "         -0.2644, -0.6796],\n",
-      "        [-2.6043,  0.7077,  0.0745, -1.3235, -0.4293,  0.8440, -0.5132, -1.5214,\n",
-      "         -0.1487, -0.0486],\n",
-      "        [-0.1820, -1.6224, -0.0613,  2.1617, -0.7577, -2.1852, -0.9381, -1.0193,\n",
-      "          0.9782, -0.2095],\n",
-      "        [ 0.8775, -1.1787,  1.9619, -0.3757, -0.1272, -0.5044,  0.2797, -0.4006,\n",
-      "         -0.0049,  1.3381],\n",
-      "        [ 0.4456,  0.9702, -1.3660,  0.3815,  0.7726,  1.0481, -0.2187,  0.7539,\n",
-      "          0.8051, -0.3459],\n",
-      "        [-0.0264,  0.4671,  1.0657, -1.4862,  0.1840,  0.5508,  2.1805, -2.2760,\n",
-      "          0.4900,  0.6758],\n",
-      "        [ 0.5677, -0.6335,  0.4963, -0.6345, -1.3937,  0.0058, -1.0223,  0.1338,\n",
-      "          1.0379, -1.0666],\n",
-      "        [-1.4058,  0.1023,  0.1497, -0.1281,  1.9152,  0.4198,  1.1238,  0.1918,\n",
-      "         -1.6397,  0.3763],\n",
-      "        [ 1.9420, -1.5595, -0.5459, -0.3907, -1.0549,  0.1562,  0.3648,  0.3389,\n",
-      "         -0.3080,  1.5482],\n",
-      "        [-0.3655,  0.7948, -0.2838,  1.1157,  0.8409, -0.4002,  0.4719,  0.4816,\n",
-      "          1.3133,  0.3462],\n",
-      "        [-0.5456,  0.0077, -0.0711, -0.6751, -0.8400, -1.3242,  0.1949,  0.9132,\n",
-      "          0.2796, -0.8041],\n",
-      "        [ 0.9780, -0.0140,  1.7110,  0.0161, -0.8130,  1.1785,  0.5801, -0.3049,\n",
-      "          1.1432,  1.3139],\n",
-      "        [-0.6483,  0.3786, -0.2267, -0.3947,  0.2875, -1.3313, -1.6920, -0.7404,\n",
-      "          1.9661,  0.6756],\n",
-      "        [-0.5101,  0.2471, -1.1457, -0.7987, -1.8677, -0.9626,  0.4831, -0.9440,\n",
-      "         -0.0813, -1.0011]])\n",
+      "tensor([[-5.8924e-01,  2.1220e+00,  1.9458e+00, -1.3186e+00, -9.7570e-02,\n",
+      "          7.9640e-01, -1.6654e+00, -1.6353e+00,  9.2206e-06,  8.7219e-01],\n",
+      "        [-8.2591e-01,  1.0598e+00, -1.0381e+00, -1.6884e-01,  1.3910e-01,\n",
+      "          9.4575e-01, -8.9953e-01, -1.4905e-02, -5.1178e-01, -2.7737e-01],\n",
+      "        [-1.1482e+00,  2.9044e-01, -4.7778e-01,  1.1531e-02, -5.0711e-01,\n",
+      "          8.6026e-02,  9.1611e-01, -1.1916e+00, -1.5993e+00,  6.8025e-01],\n",
+      "        [ 1.8637e+00,  9.3719e-01,  1.9201e-01,  1.7796e-01,  1.2529e-01,\n",
+      "         -1.5584e+00, -4.8589e-01, -1.0694e-01,  1.1896e+00,  1.5170e+00],\n",
+      "        [-5.4430e-01,  8.3538e-01,  3.2014e-01,  1.4140e+00, -1.9518e-02,\n",
+      "         -9.9845e-01, -2.3777e-01,  7.4762e-01,  1.3153e+00,  7.1071e-01],\n",
+      "        [-7.1822e-01, -1.4507e+00,  7.9309e-01, -1.5367e+00,  5.1508e-01,\n",
+      "         -8.9456e-01, -2.3076e+00,  5.5256e-01, -2.9351e+00, -4.5846e-01],\n",
+      "        [-8.8017e-01, -1.5886e+00, -1.0726e+00, -5.1527e-01, -1.0166e+00,\n",
+      "          1.1196e+00,  2.2907e+00,  4.7045e-01,  6.5176e-02, -3.8003e-01],\n",
+      "        [-1.6367e+00, -6.1370e-01, -1.3276e-01,  1.2225e+00, -4.1115e-01,\n",
+      "         -4.3862e-01,  5.9012e-02, -9.8958e-01, -2.9922e-01, -1.8661e+00],\n",
+      "        [ 6.4152e-01,  4.0064e-01, -1.0230e+00,  5.1555e-01, -1.7135e+00,\n",
+      "         -4.8497e-01,  1.0353e+00,  5.1067e-01,  1.0871e+00,  1.0828e+00],\n",
+      "        [ 2.7377e-01, -7.0140e-01,  4.5986e-01, -6.5572e-01, -1.4944e-01,\n",
+      "          3.6845e-01,  7.6481e-01, -5.4602e-01, -3.0768e-01,  1.2102e+00],\n",
+      "        [-1.1149e+00,  6.2832e-01, -7.7844e-01, -8.9476e-02, -2.1547e-01,\n",
+      "          1.3613e-02, -4.6081e-01,  3.9298e-01, -4.2523e-01,  4.6146e-01],\n",
+      "        [-9.5144e-01, -1.5101e+00,  9.3765e-01,  1.4225e-01,  8.7158e-01,\n",
+      "          1.0917e+00, -9.4545e-01,  2.6401e-01,  4.8634e-01, -6.9427e-01],\n",
+      "        [ 4.8155e-01, -1.0618e+00,  1.4245e+00, -1.2025e+00, -1.3219e-01,\n",
+      "          3.3985e-01,  3.0212e-01, -4.0114e-01, -5.5227e-01,  2.1337e+00],\n",
+      "        [ 1.0462e+00, -4.0807e-01, -5.7568e-01, -1.4289e+00,  1.0102e+00,\n",
+      "         -1.0233e+00, -2.2472e+00,  1.0844e+00, -7.9381e-01,  5.0162e-01]])\n",
       "AlexNet(\n",
       "  (features): Sequential(\n",
       "    (0): Conv2d(3, 64, kernel_size=(11, 11), stride=(4, 4), padding=(2, 2))\n",
@@ -145,7 +120,17 @@
    ],
    "source": [
     "import torch\n",
-    "\n",
+    "import numpy as np\n",
+    "from torchvision import datasets, transforms\n",
+    "from torch.utils.data.sampler import SubsetRandomSampler\n",
+    "import torch.nn as nn\n",
+    "import torch.nn.functional as F\n",
+    "import torch.optim as optim\n",
+    "import matplotlib.pyplot as plt\n",
+    "import os\n",
+    "import torch.quantization\n",
+    "import json\n",
+    "from PIL import Image\n",
     "N, D = 14, 10\n",
     "x = torch.randn(N, D).type(torch.FloatTensor)\n",
     "print(x)\n",
@@ -182,7 +167,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 2,
    "id": "6e18f2fd",
    "metadata": {},
    "outputs": [
@@ -195,7 +180,7 @@
     }
    ],
    "source": [
-    "import torch\n",
+    "\n",
     "\n",
     "# check if CUDA is available\n",
     "train_on_gpu = torch.cuda.is_available()\n",
@@ -216,7 +201,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 3,
    "id": "462666a2",
    "metadata": {},
    "outputs": [
@@ -230,9 +215,7 @@
     }
    ],
    "source": [
-    "import numpy as np\n",
-    "from torchvision import datasets, transforms\n",
-    "from torch.utils.data.sampler import SubsetRandomSampler\n",
+    "\n",
     "\n",
     "# number of subprocesses to use for data loading\n",
     "num_workers = 0\n",
@@ -297,7 +280,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 4,
    "id": "317bf070",
    "metadata": {},
    "outputs": [
@@ -317,8 +300,7 @@
     }
    ],
    "source": [
-    "import torch.nn as nn\n",
-    "import torch.nn.functional as F\n",
+    "\n",
     "\n",
     "# define the CNN architecture\n",
     "\n",
@@ -344,11 +326,11 @@
     "\n",
     "\n",
     "# create a complete CNN\n",
-    "model = Net()\n",
-    "print(model)\n",
+    "model_1 = Net()\n",
+    "print(model_1)\n",
     "# move tensors to GPU if CUDA is available\n",
     "if train_on_gpu:\n",
-    "    model.cuda()"
+    "    model_1.cuda()"
    ]
   },
   {
@@ -361,7 +343,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 5,
    "id": "4b53f229",
    "metadata": {},
    "outputs": [
@@ -369,61 +351,61 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Epoch: 0 \tTraining Loss: 43.868549 \tValidation Loss: 39.570542\n",
-      "Validation loss decreased (inf --> 39.570542).  Saving model ...\n",
-      "Epoch: 1 \tTraining Loss: 36.195879 \tValidation Loss: 32.029579\n",
-      "Validation loss decreased (39.570542 --> 32.029579).  Saving model ...\n",
-      "Epoch: 2 \tTraining Loss: 30.961746 \tValidation Loss: 29.930227\n",
-      "Validation loss decreased (32.029579 --> 29.930227).  Saving model ...\n",
-      "Epoch: 3 \tTraining Loss: 28.380143 \tValidation Loss: 27.383593\n",
-      "Validation loss decreased (29.930227 --> 27.383593).  Saving model ...\n",
-      "Epoch: 4 \tTraining Loss: 26.609379 \tValidation Loss: 25.630681\n",
-      "Validation loss decreased (27.383593 --> 25.630681).  Saving model ...\n",
-      "Epoch: 5 \tTraining Loss: 25.228773 \tValidation Loss: 24.972364\n",
-      "Validation loss decreased (25.630681 --> 24.972364).  Saving model ...\n",
-      "Epoch: 6 \tTraining Loss: 24.106138 \tValidation Loss: 24.264588\n",
-      "Validation loss decreased (24.972364 --> 24.264588).  Saving model ...\n",
-      "Epoch: 7 \tTraining Loss: 23.138273 \tValidation Loss: 23.708663\n",
-      "Validation loss decreased (24.264588 --> 23.708663).  Saving model ...\n",
-      "Epoch: 8 \tTraining Loss: 22.270021 \tValidation Loss: 23.530803\n",
-      "Validation loss decreased (23.708663 --> 23.530803).  Saving model ...\n",
-      "Epoch: 9 \tTraining Loss: 21.354291 \tValidation Loss: 22.471311\n",
-      "Validation loss decreased (23.530803 --> 22.471311).  Saving model ...\n",
-      "Epoch: 10 \tTraining Loss: 20.613555 \tValidation Loss: 22.069605\n",
-      "Validation loss decreased (22.471311 --> 22.069605).  Saving model ...\n",
-      "Epoch: 11 \tTraining Loss: 19.884603 \tValidation Loss: 22.567473\n",
-      "Epoch: 12 \tTraining Loss: 19.194082 \tValidation Loss: 22.128961\n",
-      "Epoch: 13 \tTraining Loss: 18.520741 \tValidation Loss: 21.539472\n",
-      "Validation loss decreased (22.069605 --> 21.539472).  Saving model ...\n",
-      "Epoch: 14 \tTraining Loss: 17.920634 \tValidation Loss: 21.376756\n",
-      "Validation loss decreased (21.539472 --> 21.376756).  Saving model ...\n",
-      "Epoch: 15 \tTraining Loss: 17.302807 \tValidation Loss: 21.674213\n",
-      "Epoch: 16 \tTraining Loss: 16.675798 \tValidation Loss: 21.587345\n",
-      "Epoch: 17 \tTraining Loss: 16.145350 \tValidation Loss: 21.348169\n",
-      "Validation loss decreased (21.376756 --> 21.348169).  Saving model ...\n",
-      "Epoch: 18 \tTraining Loss: 15.571500 \tValidation Loss: 21.862647\n",
-      "Epoch: 19 \tTraining Loss: 15.024691 \tValidation Loss: 21.804351\n",
-      "Epoch: 20 \tTraining Loss: 14.487721 \tValidation Loss: 21.531065\n",
-      "Epoch: 21 \tTraining Loss: 14.034568 \tValidation Loss: 21.796746\n",
-      "Epoch: 22 \tTraining Loss: 13.519650 \tValidation Loss: 22.408303\n",
-      "Epoch: 23 \tTraining Loss: 13.066309 \tValidation Loss: 23.018654\n",
-      "Epoch: 24 \tTraining Loss: 12.629155 \tValidation Loss: 22.899327\n",
-      "Epoch: 25 \tTraining Loss: 12.105263 \tValidation Loss: 24.197905\n",
-      "Epoch: 26 \tTraining Loss: 11.618184 \tValidation Loss: 24.667808\n",
-      "Epoch: 27 \tTraining Loss: 11.245077 \tValidation Loss: 24.160339\n",
-      "Epoch: 28 \tTraining Loss: 10.786976 \tValidation Loss: 24.304690\n",
-      "Epoch: 29 \tTraining Loss: 10.413645 \tValidation Loss: 25.813572\n"
+      "Epoch: 0 \tTraining Loss: 43.378945 \tValidation Loss: 37.534217\n",
+      "Validation loss decreased (inf --> 37.534217).  Saving model ...\n",
+      "Epoch: 1 \tTraining Loss: 34.343955 \tValidation Loss: 32.349840\n",
+      "Validation loss decreased (37.534217 --> 32.349840).  Saving model ...\n",
+      "Epoch: 2 \tTraining Loss: 30.806036 \tValidation Loss: 29.145299\n",
+      "Validation loss decreased (32.349840 --> 29.145299).  Saving model ...\n",
+      "Epoch: 3 \tTraining Loss: 28.630288 \tValidation Loss: 28.434799\n",
+      "Validation loss decreased (29.145299 --> 28.434799).  Saving model ...\n",
+      "Epoch: 4 \tTraining Loss: 26.962422 \tValidation Loss: 27.143118\n",
+      "Validation loss decreased (28.434799 --> 27.143118).  Saving model ...\n",
+      "Epoch: 5 \tTraining Loss: 25.590344 \tValidation Loss: 26.188523\n",
+      "Validation loss decreased (27.143118 --> 26.188523).  Saving model ...\n",
+      "Epoch: 6 \tTraining Loss: 24.329372 \tValidation Loss: 25.016885\n",
+      "Validation loss decreased (26.188523 --> 25.016885).  Saving model ...\n",
+      "Epoch: 7 \tTraining Loss: 23.258511 \tValidation Loss: 23.744379\n",
+      "Validation loss decreased (25.016885 --> 23.744379).  Saving model ...\n",
+      "Epoch: 8 \tTraining Loss: 22.283808 \tValidation Loss: 23.032502\n",
+      "Validation loss decreased (23.744379 --> 23.032502).  Saving model ...\n",
+      "Epoch: 9 \tTraining Loss: 21.437031 \tValidation Loss: 22.921947\n",
+      "Validation loss decreased (23.032502 --> 22.921947).  Saving model ...\n",
+      "Epoch: 10 \tTraining Loss: 20.588990 \tValidation Loss: 22.088936\n",
+      "Validation loss decreased (22.921947 --> 22.088936).  Saving model ...\n",
+      "Epoch: 11 \tTraining Loss: 19.811905 \tValidation Loss: 22.587189\n",
+      "Epoch: 12 \tTraining Loss: 19.123620 \tValidation Loss: 21.755673\n",
+      "Validation loss decreased (22.088936 --> 21.755673).  Saving model ...\n",
+      "Epoch: 13 \tTraining Loss: 18.497675 \tValidation Loss: 21.942630\n",
+      "Epoch: 14 \tTraining Loss: 17.852816 \tValidation Loss: 21.932077\n",
+      "Epoch: 15 \tTraining Loss: 17.251354 \tValidation Loss: 21.707757\n",
+      "Validation loss decreased (21.755673 --> 21.707757).  Saving model ...\n",
+      "Epoch: 16 \tTraining Loss: 16.719265 \tValidation Loss: 22.491421\n",
+      "Epoch: 17 \tTraining Loss: 16.119002 \tValidation Loss: 22.045470\n",
+      "Epoch: 18 \tTraining Loss: 15.587754 \tValidation Loss: 21.740500\n",
+      "Epoch: 19 \tTraining Loss: 15.052405 \tValidation Loss: 22.119651\n",
+      "Epoch: 20 \tTraining Loss: 14.572571 \tValidation Loss: 22.519353\n",
+      "Epoch: 21 \tTraining Loss: 14.125367 \tValidation Loss: 24.025316\n",
+      "Epoch: 22 \tTraining Loss: 13.533694 \tValidation Loss: 23.514559\n",
+      "Epoch: 23 \tTraining Loss: 13.080140 \tValidation Loss: 24.261488\n",
+      "Epoch: 24 \tTraining Loss: 12.658047 \tValidation Loss: 24.357848\n",
+      "Epoch: 25 \tTraining Loss: 12.231944 \tValidation Loss: 24.462697\n",
+      "Epoch: 26 \tTraining Loss: 11.806727 \tValidation Loss: 25.935711\n",
+      "Epoch: 27 \tTraining Loss: 11.362395 \tValidation Loss: 26.394804\n",
+      "Epoch: 28 \tTraining Loss: 10.929406 \tValidation Loss: 26.953419\n",
+      "Epoch: 29 \tTraining Loss: 10.504231 \tValidation Loss: 26.891173\n"
      ]
     }
    ],
    "source": [
-    "import torch.optim as optim\n",
+    "\n",
     "\n",
     "criterion = nn.CrossEntropyLoss()  # specify loss function\n",
-    "optimizer = optim.SGD(model.parameters(), lr=0.01)  # specify optimizer\n",
+    "optimizer = optim.SGD(model_1.parameters(), lr=0.01)  # specify optimizer\n",
     "\n",
     "n_epochs = 30  # number of epochs to train the model\n",
     "train_loss_list = []  # list to store loss to visualize\n",
+    "valid_loss_list = []\n",
     "valid_loss_min = np.Inf  # track change in validation loss\n",
     "\n",
     "for epoch in range(n_epochs):\n",
@@ -432,7 +414,7 @@
     "    valid_loss = 0.0\n",
     "\n",
     "    # Train the model\n",
-    "    model.train()\n",
+    "    model_1.train()\n",
     "    for data, target in train_loader:\n",
     "        # Move tensors to GPU if CUDA is available\n",
     "        if train_on_gpu:\n",
@@ -440,7 +422,7 @@
     "        # Clear the gradients of all optimized variables\n",
     "        optimizer.zero_grad()\n",
     "        # Forward pass: compute predicted outputs by passing inputs to the model\n",
-    "        output = model(data)\n",
+    "        output = model_1(data)\n",
     "        # Calculate the batch loss\n",
     "        loss = criterion(output, target)\n",
     "        # Backward pass: compute gradient of the loss with respect to model parameters\n",
@@ -451,13 +433,13 @@
     "        train_loss += loss.item() * data.size(0)\n",
     "\n",
     "    # Validate the model\n",
-    "    model.eval()\n",
+    "    model_1.eval()\n",
     "    for data, target in valid_loader:\n",
     "        # Move tensors to GPU if CUDA is available\n",
     "        if train_on_gpu:\n",
     "            data, target = data.cuda(), target.cuda()\n",
     "        # Forward pass: compute predicted outputs by passing inputs to the model\n",
-    "        output = model(data)\n",
+    "        output = model_1(data)\n",
     "        # Calculate the batch loss\n",
     "        loss = criterion(output, target)\n",
     "        # Update average validation loss\n",
@@ -467,6 +449,7 @@
     "    train_loss = train_loss / len(train_loader)\n",
     "    valid_loss = valid_loss / len(valid_loader)\n",
     "    train_loss_list.append(train_loss)\n",
+    "    valid_loss_list.append(valid_loss)\n",
     "\n",
     "    # Print training/validation statistics\n",
     "    print(\n",
@@ -482,7 +465,7 @@
     "                valid_loss_min, valid_loss\n",
     "            )\n",
     "        )\n",
-    "        torch.save(model.state_dict(), \"model_cifar.pt\")\n",
+    "        torch.save(model_1.state_dict(), \"model_1_cifar.pt\")\n",
     "        valid_loss_min = valid_loss"
    ]
   },
@@ -496,13 +479,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 6,
    "id": "d39df818",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -512,9 +495,13 @@
     }
    ],
    "source": [
-    "import matplotlib.pyplot as plt\n",
     "\n",
-    "plt.plot(range(n_epochs), train_loss_list)\n",
+    "\n",
+    "fig_1,ax_1 = plt.subplots()\n",
+    "ax_1.plot(range(n_epochs), train_loss_list, label = 'train_loss')\n",
+    "ax_1.legend()\n",
+    "ax_1.plot(range(n_epochs), valid_loss_list, label = 'valid_loss')\n",
+    "ax_1.legend()\n",
     "plt.xlabel(\"Epoch\")\n",
     "plt.ylabel(\"Loss\")\n",
     "plt.title(\"Performance of Model 1\")\n",
@@ -530,46 +517,46 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Test Loss: 21.238544\n",
+      "Test Loss: 21.662193\n",
       "\n",
-      "Test Accuracy of airplane: 57% (572/1000)\n",
-      "Test Accuracy of automobile: 78% (782/1000)\n",
-      "Test Accuracy of  bird: 48% (481/1000)\n",
-      "Test Accuracy of   cat: 49% (495/1000)\n",
-      "Test Accuracy of  deer: 69% (693/1000)\n",
-      "Test Accuracy of   dog: 48% (488/1000)\n",
-      "Test Accuracy of  frog: 69% (695/1000)\n",
-      "Test Accuracy of horse: 67% (673/1000)\n",
-      "Test Accuracy of  ship: 77% (773/1000)\n",
-      "Test Accuracy of truck: 70% (700/1000)\n",
+      "Test Accuracy of airplane: 67% (674/1000)\n",
+      "Test Accuracy of automobile: 75% (750/1000)\n",
+      "Test Accuracy of  bird: 52% (529/1000)\n",
+      "Test Accuracy of   cat: 47% (470/1000)\n",
+      "Test Accuracy of  deer: 60% (600/1000)\n",
+      "Test Accuracy of   dog: 49% (490/1000)\n",
+      "Test Accuracy of  frog: 68% (683/1000)\n",
+      "Test Accuracy of horse: 66% (660/1000)\n",
+      "Test Accuracy of  ship: 68% (684/1000)\n",
+      "Test Accuracy of truck: 74% (747/1000)\n",
       "\n",
-      "Test Accuracy (Overall): 63% (6352/10000)\n"
+      "Test Accuracy of model 1 (Overall): 62% (6287/10000)\n"
      ]
     }
    ],
    "source": [
-    "model.load_state_dict(torch.load(\"./model_cifar.pt\"))\n",
+    " model_1.load_state_dict(torch.load(\"./model_1_cifar.pt\"))\n",
     "\n",
     "# track test loss\n",
     "test_loss = 0.0\n",
     "class_correct = list(0.0 for i in range(10))\n",
     "class_total = list(0.0 for i in range(10))\n",
-    "\n",
-    "model.eval()\n",
+    "accuracy_per_class_m1 =  list(0.0 for i in range(10))\n",
+    "model_1.eval()\n",
     "# iterate over test data\n",
     "for data, target in test_loader:\n",
     "    # move tensors to GPU if CUDA is available\n",
     "    if train_on_gpu:\n",
     "        data, target = data.cuda(), target.cuda()\n",
     "    # forward pass: compute predicted outputs by passing inputs to the model\n",
-    "    output = model(data)\n",
+    "    output = model_1(data)\n",
     "    # calculate the batch loss\n",
     "    loss = criterion(output, target)\n",
     "    # update test loss\n",
@@ -595,20 +582,22 @@
     "\n",
     "for i in range(10):\n",
     "    if class_total[i] > 0:\n",
+    "        accuracy_per_class_m1 = 100 * class_correct[i] / class_total[i]\n",
     "        print(\n",
     "            \"Test Accuracy of %5s: %2d%% (%2d/%2d)\"\n",
     "            % (\n",
     "                classes[i],\n",
-    "                100 * class_correct[i] / class_total[i],\n",
+    "                accuracy_per_class_m1,\n",
     "                np.sum(class_correct[i]),\n",
     "                np.sum(class_total[i]),\n",
     "            )\n",
     "        )\n",
+    "        \n",
     "    else:\n",
     "        print(\"Test Accuracy of %5s: N/A (no training examples)\" % (classes[i]))\n",
     "\n",
     "print(\n",
-    "    \"\\nTest Accuracy (Overall): %2d%% (%2d/%2d)\"\n",
+    "    \"\\nTest Accuracy of model 1 (Overall): %2d%% (%2d/%2d)\"\n",
     "    % (\n",
     "        100.0 * np.sum(class_correct) / np.sum(class_total),\n",
     "        np.sum(class_correct),\n",
@@ -626,7 +615,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
@@ -646,8 +635,7 @@
     }
    ],
    "source": [
-    "import torch.nn as nn\n",
-    "import torch.nn.functional as F\n",
+    "\n",
     "\n",
     "# define the CNN architecture\n",
     "\n",
@@ -658,12 +646,14 @@
     "        self.conv1 = nn.Conv2d(3, 16, 3, padding=1)\n",
     "        # H_out(conv1) = W_out(conv1) = (H_in + 2*padding - Kernel)/stride + 1 = (32 + 2 - 3)/1 + 1 = 32\n",
     "        # Size(conv1_out) = 32*32*16\n",
-    "        self.pool = nn.MaxPool2d(2, 2)  # pool = 16*16\n",
+    "        self.pool = nn.MaxPool2d(2, 2)  # After Maxpooling2D new size of image equal =  16*16\n",
     "        # H_out(conv2) = W_out(conv2) = (H_in + 2*padding - Kernel)/stride + 1 = (16 + 2 - 3)/1 + 1 = 16\n",
+    "                                        # After Maxpooling2D new size of image equal =  8*8\n",
     "        self.conv2 = nn.Conv2d(16, 32, 3, padding=1)\n",
     "        # H_out(conv3) = W_out(conv3) = (H_in + 2*padding - Kernel)/stride + 1 = (16 + 2 - 3)/1 + 1 = 8\n",
+    "                                        # After Maxpooling2D new size of image equal =  4*4\n",
     "        self.conv3 = nn.Conv2d(32, 64, 3, padding=1)  \n",
-    "        self.fc1 = nn.Linear(64 * 4 * 4, 512)\n",
+    "        self.fc1 = nn.Linear(64 * 4 * 4, 512)   \n",
     "        self.fc2 = nn.Linear(512, 64)\n",
     "        self.fc3 = nn.Linear(64, 10)\n",
     "\n",
@@ -679,8 +669,8 @@
     "\n",
     "\n",
     "# create a complete CNN\n",
-    "model = Second_Net()\n",
-    "print(model)\n",
+    "model_2 = Second_Net()\n",
+    "print(model_2)\n",
     "# move tensors to GPU if CUDA is available\n",
     "# if train_on_gpu:\n",
     "  #  model.cuda()"
@@ -695,67 +685,64 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Epoch: 0 \tTraining Loss: 44.580487 \tValidation Loss: 40.655719\n",
-      "Validation loss decreased (inf --> 40.655719).  Saving model ...\n",
-      "Epoch: 1 \tTraining Loss: 37.395407 \tValidation Loss: 34.004712\n",
-      "Validation loss decreased (40.655719 --> 34.004712).  Saving model ...\n",
-      "Epoch: 2 \tTraining Loss: 31.076469 \tValidation Loss: 28.947368\n",
-      "Validation loss decreased (34.004712 --> 28.947368).  Saving model ...\n",
-      "Epoch: 3 \tTraining Loss: 27.819081 \tValidation Loss: 26.298716\n",
-      "Validation loss decreased (28.947368 --> 26.298716).  Saving model ...\n",
-      "Epoch: 4 \tTraining Loss: 25.659337 \tValidation Loss: 25.099186\n",
-      "Validation loss decreased (26.298716 --> 25.099186).  Saving model ...\n",
-      "Epoch: 5 \tTraining Loss: 23.534661 \tValidation Loss: 23.580557\n",
-      "Validation loss decreased (25.099186 --> 23.580557).  Saving model ...\n",
-      "Epoch: 6 \tTraining Loss: 21.658956 \tValidation Loss: 22.173245\n",
-      "Validation loss decreased (23.580557 --> 22.173245).  Saving model ...\n",
-      "Epoch: 7 \tTraining Loss: 19.803460 \tValidation Loss: 21.094384\n",
-      "Validation loss decreased (22.173245 --> 21.094384).  Saving model ...\n",
-      "Epoch: 8 \tTraining Loss: 18.147863 \tValidation Loss: 19.315424\n",
-      "Validation loss decreased (21.094384 --> 19.315424).  Saving model ...\n",
-      "Epoch: 9 \tTraining Loss: 16.645522 \tValidation Loss: 19.678809\n",
-      "Epoch: 10 \tTraining Loss: 15.231918 \tValidation Loss: 17.332762\n",
-      "Validation loss decreased (19.315424 --> 17.332762).  Saving model ...\n",
-      "Epoch: 11 \tTraining Loss: 13.963853 \tValidation Loss: 17.392996\n",
-      "Epoch: 12 \tTraining Loss: 12.640484 \tValidation Loss: 17.975388\n",
-      "Epoch: 13 \tTraining Loss: 11.419415 \tValidation Loss: 17.060967\n",
-      "Validation loss decreased (17.332762 --> 17.060967).  Saving model ...\n",
-      "Epoch: 14 \tTraining Loss: 10.121284 \tValidation Loss: 17.496235\n",
-      "Epoch: 15 \tTraining Loss: 8.883715 \tValidation Loss: 17.553297\n",
-      "Epoch: 16 \tTraining Loss: 7.629162 \tValidation Loss: 18.591316\n",
-      "Epoch: 17 \tTraining Loss: 6.462874 \tValidation Loss: 20.458817\n",
-      "Epoch: 18 \tTraining Loss: 5.431612 \tValidation Loss: 19.972335\n",
-      "Epoch: 19 \tTraining Loss: 4.461186 \tValidation Loss: 22.878541\n",
-      "Epoch: 20 \tTraining Loss: 3.639514 \tValidation Loss: 22.700774\n",
-      "Epoch: 21 \tTraining Loss: 3.053722 \tValidation Loss: 24.948127\n",
-      "Epoch: 22 \tTraining Loss: 2.251474 \tValidation Loss: 26.497270\n",
-      "Epoch: 23 \tTraining Loss: 1.806678 \tValidation Loss: 29.242567\n",
-      "Epoch: 24 \tTraining Loss: 1.558967 \tValidation Loss: 30.254290\n",
-      "Epoch: 25 \tTraining Loss: 1.469055 \tValidation Loss: 30.540426\n",
-      "Epoch: 26 \tTraining Loss: 1.545504 \tValidation Loss: 32.255079\n",
-      "Epoch: 27 \tTraining Loss: 1.368537 \tValidation Loss: 32.683681\n",
-      "Epoch: 28 \tTraining Loss: 0.980868 \tValidation Loss: 35.020791\n",
-      "Epoch: 29 \tTraining Loss: 0.884202 \tValidation Loss: 34.967844\n"
+      "Epoch: 0 \tTraining Loss: 44.557753 \tValidation Loss: 39.817679\n",
+      "Validation loss decreased (inf --> 39.817679).  Saving model ...\n",
+      "Epoch: 1 \tTraining Loss: 36.209753 \tValidation Loss: 33.034412\n",
+      "Validation loss decreased (39.817679 --> 33.034412).  Saving model ...\n",
+      "Epoch: 2 \tTraining Loss: 31.099305 \tValidation Loss: 29.910456\n",
+      "Validation loss decreased (33.034412 --> 29.910456).  Saving model ...\n",
+      "Epoch: 3 \tTraining Loss: 28.188536 \tValidation Loss: 26.678592\n",
+      "Validation loss decreased (29.910456 --> 26.678592).  Saving model ...\n",
+      "Epoch: 4 \tTraining Loss: 25.639184 \tValidation Loss: 24.843114\n",
+      "Validation loss decreased (26.678592 --> 24.843114).  Saving model ...\n",
+      "Epoch: 5 \tTraining Loss: 23.317273 \tValidation Loss: 22.223353\n",
+      "Validation loss decreased (24.843114 --> 22.223353).  Saving model ...\n",
+      "Epoch: 6 \tTraining Loss: 21.301518 \tValidation Loss: 20.623540\n",
+      "Validation loss decreased (22.223353 --> 20.623540).  Saving model ...\n",
+      "Epoch: 7 \tTraining Loss: 19.542947 \tValidation Loss: 20.162958\n",
+      "Validation loss decreased (20.623540 --> 20.162958).  Saving model ...\n",
+      "Epoch: 8 \tTraining Loss: 17.999442 \tValidation Loss: 18.675086\n",
+      "Validation loss decreased (20.162958 --> 18.675086).  Saving model ...\n",
+      "Epoch: 9 \tTraining Loss: 16.535020 \tValidation Loss: 18.128589\n",
+      "Validation loss decreased (18.675086 --> 18.128589).  Saving model ...\n",
+      "Epoch: 10 \tTraining Loss: 15.174483 \tValidation Loss: 17.162074\n",
+      "Validation loss decreased (18.128589 --> 17.162074).  Saving model ...\n",
+      "Epoch: 11 \tTraining Loss: 13.864482 \tValidation Loss: 17.209080\n",
+      "Epoch: 12 \tTraining Loss: 12.617755 \tValidation Loss: 17.270458\n",
+      "Epoch: 13 \tTraining Loss: 11.389589 \tValidation Loss: 17.112058\n",
+      "Validation loss decreased (17.162074 --> 17.112058).  Saving model ...\n",
+      "Epoch: 14 \tTraining Loss: 10.064839 \tValidation Loss: 17.678218\n",
+      "Epoch: 15 \tTraining Loss: 8.780338 \tValidation Loss: 17.519580\n",
+      "Epoch: 16 \tTraining Loss: 7.626408 \tValidation Loss: 18.112166\n",
+      "Epoch: 17 \tTraining Loss: 6.316284 \tValidation Loss: 19.413389\n",
+      "Epoch: 18 \tTraining Loss: 5.235316 \tValidation Loss: 20.455955\n",
+      "Epoch: 19 \tTraining Loss: 4.317387 \tValidation Loss: 22.437315\n",
+      "Epoch: 20 \tTraining Loss: 3.492141 \tValidation Loss: 24.581517\n",
+      "Epoch: 21 \tTraining Loss: 2.814595 \tValidation Loss: 23.857926\n",
+      "Epoch: 22 \tTraining Loss: 2.292130 \tValidation Loss: 27.540117\n",
+      "Epoch: 23 \tTraining Loss: 1.958200 \tValidation Loss: 29.974592\n",
+      "Epoch: 24 \tTraining Loss: 1.703906 \tValidation Loss: 29.493216\n",
+      "Epoch: 25 \tTraining Loss: 1.515222 \tValidation Loss: 31.318798\n",
+      "Epoch: 26 \tTraining Loss: 1.304394 \tValidation Loss: 31.898265\n",
+      "Epoch: 27 \tTraining Loss: 1.135672 \tValidation Loss: 33.532167\n",
+      "Epoch: 28 \tTraining Loss: 1.063874 \tValidation Loss: 33.580899\n",
+      "Epoch: 29 \tTraining Loss: 0.910804 \tValidation Loss: 35.744193\n"
      ]
     }
    ],
    "source": [
-    "import torch.optim as optim \n",
-    "import numpy as np\n",
-    "model = Second_Net()\n",
     "\n",
     "criterion = nn.CrossEntropyLoss()  # specify loss function\n",
-    "optimizer = optim.SGD(model.parameters(), lr=0.01)  # specify optimizer\n",
-    "\n",
-    "n_epochs = 30  # number of epochs to train the model\n",
-    "train_loss_list = []  # list to store loss to visualize\n",
+    "optimizer = optim.SGD(model_2.parameters(), lr=0.01)  # specify optimizer\n",
+    "train_loss_list_2 = []  # list to store loss to visualize\n",
+    "valid_loss_list_2 = []\n",
     "valid_loss_min = np.Inf  # track change in validation loss\n",
     "\n",
     "for epoch in range(n_epochs):\n",
@@ -764,7 +751,7 @@
     "    valid_loss = 0.0\n",
     "\n",
     "    # Train the model\n",
-    "    model.train()\n",
+    "    model_2.train()\n",
     "    for data, target in train_loader:\n",
     "        # Move tensors to GPU if CUDA is available\n",
     "        if train_on_gpu:\n",
@@ -772,7 +759,7 @@
     "        # Clear the gradients of all optimized variables\n",
     "        optimizer.zero_grad()\n",
     "        # Forward pass: compute predicted outputs by passing inputs to the model\n",
-    "        output = model(data)\n",
+    "        output = model_2(data)\n",
     "        # Calculate the batch loss\n",
     "        loss = criterion(output, target)\n",
     "        # Backward pass: compute gradient of the loss with respect to model parameters\n",
@@ -783,13 +770,13 @@
     "        train_loss += loss.item() * data.size(0)\n",
     "\n",
     "    # Validate the model\n",
-    "    model.eval()\n",
+    "    model_2.eval()\n",
     "    for data, target in valid_loader:\n",
     "        # Move tensors to GPU if CUDA is available\n",
     "        if train_on_gpu:\n",
     "            data, target = data.cuda(), target.cuda()\n",
     "        # Forward pass: compute predicted outputs by passing inputs to the model\n",
-    "        output = model(data)\n",
+    "        output = model_2(data)\n",
     "        # Calculate the batch loss\n",
     "        loss = criterion(output, target)\n",
     "        # Update average validation loss\n",
@@ -798,7 +785,8 @@
     "    # Calculate average losses\n",
     "    train_loss = train_loss / len(train_loader)\n",
     "    valid_loss = valid_loss / len(valid_loader)\n",
-    "    train_loss_list.append(train_loss)\n",
+    "    train_loss_list_2.append(train_loss)\n",
+    "    valid_loss_list_2.append(valid_loss)\n",
     "\n",
     "    # Print training/validation statistics\n",
     "    print(\n",
@@ -814,10 +802,47 @@
     "                valid_loss_min, valid_loss\n",
     "            )\n",
     "        )\n",
-    "        torch.save(model.state_dict(), \"new_model_cifar.pt\")\n",
+    "        torch.save(model_2.state_dict(), \"model_2_cifar.pt\")\n",
     "        valid_loss_min = valid_loss"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Plot Loss in function epoch for the new model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "\n",
+    "fig_2,ax_2 = plt.subplots()\n",
+    "ax_2.plot(range(n_epochs), train_loss_list_2, label = 'train_loss')\n",
+    "ax_2.legend()\n",
+    "ax_2.plot(range(n_epochs), valid_loss_list_2, label = 'valid_loss')\n",
+    "ax_2.legend()\n",
+    "plt.xlabel(\"Epoch\")\n",
+    "plt.ylabel(\"Loss\")\n",
+    "plt.title(\"Performance of Model 2\")\n",
+    "plt.show()"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -834,43 +859,36 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Test Loss: 17.203986\n",
+      "Test Accuracy of airplane: 71% (711/1000)\n",
+      "Test Accuracy of automobile: 74% (745/1000)\n",
+      "Test Accuracy of  bird: 57% (578/1000)\n",
+      "Test Accuracy of   cat: 65% (656/1000)\n",
+      "Test Accuracy of  deer: 57% (578/1000)\n",
+      "Test Accuracy of   dog: 57% (574/1000)\n",
+      "Test Accuracy of  frog: 79% (793/1000)\n",
+      "Test Accuracy of horse: 74% (742/1000)\n",
+      "Test Accuracy of  ship: 84% (846/1000)\n",
+      "Test Accuracy of truck: 81% (819/1000)\n",
       "\n",
-      "Test Accuracy of airplane: 74% (742/1000)\n",
-      "Test Accuracy of automobile: 80% (804/1000)\n",
-      "Test Accuracy of  bird: 56% (567/1000)\n",
-      "Test Accuracy of   cat: 63% (631/1000)\n",
-      "Test Accuracy of  deer: 70% (706/1000)\n",
-      "Test Accuracy of   dog: 47% (472/1000)\n",
-      "Test Accuracy of  frog: 85% (850/1000)\n",
-      "Test Accuracy of horse: 72% (726/1000)\n",
-      "Test Accuracy of  ship: 81% (813/1000)\n",
-      "Test Accuracy of truck: 83% (830/1000)\n",
-      "\n",
-      "Test Accuracy (Overall): 71% (7141/10000)\n"
+      "Test Accuracy (Overall): 70% (7042/10000)\n"
      ]
     }
    ],
    "source": [
-    "model.load_state_dict(torch.load(\"./new_model_cifar.pt\"))\n",
+    "model_2.load_state_dict(torch.load(\"./model_2_cifar.pt\"))\n",
     "\n",
-    "# track test loss\n",
-    "test_loss = 0.0\n",
     "class_correct2 = list(0.0 for i in range(10))\n",
     "class_total2 = list(0.0 for i in range(10))\n",
-    "\n",
-    "model.eval()\n",
+    "accuracy_per_class_m2 = list(0.0 for i in range(10))\n",
+    "model_2.eval()\n",
     "# iterate over test data\n",
     "for data, target in test_loader:\n",
     "    # move tensors to GPU if CUDA is available\n",
     "    if train_on_gpu:\n",
     "        data, target = data.cuda(), target.cuda()\n",
     "    # forward pass: compute predicted outputs by passing inputs to the model\n",
-    "    output = model(data)\n",
-    "    # calculate the batch loss\n",
-    "    loss = criterion(output, target)\n",
-    "    # update test loss\n",
-    "    test_loss += loss.item() * data.size(0)\n",
+    "    output = model_2(data)\n",
+    "\n",
     "    # convert output probabilities to predicted class\n",
     "    _, pred = torch.max(output, 1)\n",
     "    # compare predictions to true label\n",
@@ -886,21 +904,20 @@
     "        class_correct2[label] += correct2[i].item()\n",
     "        class_total2[label] += 1\n",
     "\n",
-    "# average test loss\n",
-    "test_loss = test_loss / len(test_loader)\n",
-    "print(\"Test Loss: {:.6f}\\n\".format(test_loss))\n",
     "\n",
     "for i in range(10):\n",
     "    if class_total2[i] > 0:\n",
+    "        accuracy_per_class_m2 =  100 * class_correct2[i] / class_total2[i]\n",
     "        print(\n",
     "            \"Test Accuracy of %5s: %2d%% (%2d/%2d)\"\n",
     "            % (\n",
     "                classes[i],\n",
-    "                100 * class_correct2[i] / class_total2[i],\n",
+    "                accuracy_per_class_m2,\n",
     "                np.sum(class_correct2[i]),\n",
     "                np.sum(class_total2[i]),\n",
     "            )\n",
     "        )\n",
+    "       \n",
     "    else:\n",
     "        print(\"Test Accuracy of %5s: N/A (no training examples)\" % (classes[i]))\n",
     "\n",
@@ -911,7 +928,8 @@
     "        np.sum(class_correct2),\n",
     "        np.sum(class_total2),\n",
     "    )\n",
-    ")"
+    ")\n",
+    "\n"
    ]
   },
   {
@@ -923,19 +941,336 @@
   },
   {
    "cell_type": "markdown",
+   "id": "944991a2",
    "metadata": {},
    "source": [
-    "Plot Loss in function epoch for the new model"
+    "Build a new network with the following structure.\n",
+    "\n",
+    "- It has 3 convolutional layers of kernel size 3 and padding of 1.\n",
+    "- The first convolutional layer must output 16 channels, the second 32 and the third 64.\n",
+    "- At each convolutional layer output, we apply a ReLU activation then a MaxPool with kernel size of 2.\n",
+    "- Then, three fully connected layers, the first two being followed by a ReLU activation and a dropout whose value you will suggest.\n",
+    "- The first fully connected layer will have an output size of 512.\n",
+    "- The second fully connected layer will have an output size of 64.\n",
+    "\n",
+    "Compare the results obtained with this new network to those obtained previously."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    " Exercise 2: Quantization: try to compress the CNN to save space\n",
+    " \n",
+    " Quantization doc is available from https://pytorch.org/docs/stable/quantization.html#torch.quantization.quantize_dynamicThe Exercise is to quantize post training the above CNN model. Compare the size reduction and the impact on the classification accuracy The size of the model is simply the size of the file."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 15,
    "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "model:  fp32  \t Size (KB): 251.278\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "251278"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\n",
+    "\n",
+    "\n",
+    "def print_size_of_model(model, label=\"\"):\n",
+    "    torch.save(model.state_dict(), \"temp.p\")\n",
+    "    size = os.path.getsize(\"temp.p\")\n",
+    "    print(\"model: \", label, \" \\t\", \"Size (KB):\", size / 1e3)\n",
+    "    os.remove(\"temp.p\")\n",
+    "    return size\n",
+    "\n",
+    "\n",
+    "print_size_of_model(model_1, \"fp32\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    " Post training quantization of model 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "model:  int8  \t Size (KB): 76.522\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "76522"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\n",
+    "\n",
+    "\n",
+    "quantized_model_1 = torch.quantization.quantize_dynamic(model_1, dtype=torch.qint8)\n",
+    "print_size_of_model(quantized_model_1, \"int8\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Post otraining quantization of model 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "model:  fp32  \t Size (KB): 2330.946\n",
+      "model:  int8  \t Size (KB): 659.806\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "659806"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "print_size_of_model(model_2, \"fp32\")\n",
+    "quantized_model_2 = torch.quantization.quantize_dynamic(model_2, dtype=torch.qint8)\n",
+    "print_size_of_model(quantized_model_2, \"int8\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Classification test of quantized model 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Test Accuracy of airplane: 67% (679/1000)\n",
+      "Test Accuracy of automobile: 75% (751/1000)\n",
+      "Test Accuracy of  bird: 53% (532/1000)\n",
+      "Test Accuracy of   cat: 46% (464/1000)\n",
+      "Test Accuracy of  deer: 59% (598/1000)\n",
+      "Test Accuracy of   dog: 49% (491/1000)\n",
+      "Test Accuracy of  frog: 68% (682/1000)\n",
+      "Test Accuracy of horse: 65% (658/1000)\n",
+      "Test Accuracy of  ship: 67% (679/1000)\n",
+      "Test Accuracy of truck: 74% (746/1000)\n",
+      "\n",
+      "Test Accuracy of quantized model 1 (Overall): 62% (6280/10000)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# quantized_model_1.load_state_dict(torch.load(\"./quantizedmodel_cifar.pt\"))\n",
+    "\n",
+    "\n",
+    "\n",
+    "class_correct = list(0.0 for i in range(10))\n",
+    "class_total = list(0.0 for i in range(10))\n",
+    "accuracy_per_class_q1 = list(0.0 for i in range(10))\n",
+    "quantized_model_1.eval()\n",
+    "# iterate over test data\n",
+    "for data, target in test_loader:\n",
+    "    # move tensors to GPU if CUDA is available\n",
+    "    if train_on_gpu:\n",
+    "        data, target = data.cuda(), target.cuda()\n",
+    "    # forward pass: compute predicted outputs by passing inputs to the model\n",
+    "    output = quantized_model_1(data)\n",
+    "   \n",
+    "    \n",
+    "    # convert output probabilities to predicted class\n",
+    "    _, pred = torch.max(output, 1)\n",
+    "    # compare predictions to true label\n",
+    "    correct_tensor = pred.eq(target.data.view_as(pred))\n",
+    "    correct = (\n",
+    "        np.squeeze(correct_tensor.numpy())\n",
+    "        if not train_on_gpu\n",
+    "        else np.squeeze(correct_tensor.cpu().numpy())\n",
+    "    )\n",
+    "    # calculate test accuracy for each object class\n",
+    "    for i in range(batch_size):\n",
+    "        label = target.data[i]\n",
+    "        class_correct[label] += correct[i].item()\n",
+    "        class_total[label] += 1\n",
+    "\n",
+    "for i in range(10):\n",
+    "    if class_total[i] > 0:\n",
+    "        print(\n",
+    "            \"Test Accuracy of %5s: %2d%% (%2d/%2d)\"\n",
+    "            % (\n",
+    "                classes[i],\n",
+    "                100 * class_correct[i] / class_total[i],\n",
+    "                np.sum(class_correct[i]),\n",
+    "                np.sum(class_total[i]),\n",
+    "            )\n",
+    "        )\n",
+    "        accuracy_per_class_q1[i] = (class_correct[i]/class_total[i])*100\n",
+    "    else:\n",
+    "        print(\"Test Accuracy of quantized model 1 %5s: N/A (no training examples)\" % (classes[i]))\n",
+    "\n",
+    "print(\n",
+    "    \"\\nTest Accuracy of quantized model 1 (Overall): %2d%% (%2d/%2d)\"\n",
+    "    % (\n",
+    "        100.0 * np.sum(class_correct) / np.sum(class_total),\n",
+    "        np.sum(class_correct),\n",
+    "        np.sum(class_total),\n",
+    "    )\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Classification test of quantized model 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Test Accuracy of airplane: 70% (703/1000)\n",
+      "Test Accuracy of automobile: 74% (743/1000)\n",
+      "Test Accuracy of  bird: 58% (582/1000)\n",
+      "Test Accuracy of   cat: 65% (652/1000)\n",
+      "Test Accuracy of  deer: 57% (579/1000)\n",
+      "Test Accuracy of   dog: 57% (579/1000)\n",
+      "Test Accuracy of  frog: 79% (795/1000)\n",
+      "Test Accuracy of horse: 73% (736/1000)\n",
+      "Test Accuracy of  ship: 84% (845/1000)\n",
+      "Test Accuracy of truck: 81% (819/1000)\n",
+      "\n",
+      "Test Accuracy of quantized model 2 (Overall): 70% (7033/10000)\n"
+     ]
+    }
+   ],
+   "source": [
+    "#  quantized_model_2.load_state_dict(torch.load(\"./model_cifar.pt\"))\n",
+    "\n",
+    "\n",
+    "\n",
+    "class_correct = list(0.0 for i in range(10))\n",
+    "class_total = list(0.0 for i in range(10))\n",
+    "accuracy_per_class_q2 = list(0.0 for i in range(10))\n",
+    "quantized_model_2.eval()\n",
+    "# iterate over test data\n",
+    "for data, target in test_loader:\n",
+    "    # move tensors to GPU if CUDA is available\n",
+    "    if train_on_gpu:\n",
+    "        data, target = data.cuda(), target.cuda()\n",
+    "    # forward pass: compute predicted outputs by passing inputs to the model\n",
+    "    output = quantized_model_2(data)\n",
+    "   \n",
+    "    \n",
+    "    # convert output probabilities to predicted class\n",
+    "    _, pred = torch.max(output, 1)\n",
+    "    # compare predictions to true label\n",
+    "    correct_tensor = pred.eq(target.data.view_as(pred))\n",
+    "    correct = (\n",
+    "        np.squeeze(correct_tensor.numpy())\n",
+    "        if not train_on_gpu\n",
+    "        else np.squeeze(correct_tensor.cpu().numpy())\n",
+    "    )\n",
+    "    # calculate test accuracy for each object class\n",
+    "    for i in range(batch_size):\n",
+    "        label = target.data[i]\n",
+    "        class_correct[label] += correct[i].item()\n",
+    "        class_total[label] += 1\n",
+    "\n",
+    "for i in range(10):\n",
+    "    if class_total[i] > 0:\n",
+    "        print(\n",
+    "            \"Test Accuracy of %5s: %2d%% (%2d/%2d)\"\n",
+    "            % (\n",
+    "                classes[i],\n",
+    "                100 * class_correct[i] / class_total[i],\n",
+    "                np.sum(class_correct[i]),\n",
+    "                np.sum(class_total[i]),\n",
+    "            )\n",
+    "        )\n",
+    "        accuracy_per_class_q2[i] = (class_correct[i]/class_total[i])*100\n",
+    "    else:\n",
+    "        print(\"Test Accuracy of quantized model 2 %5s: N/A (no training examples)\" % (classes[i]))\n",
+    "\n",
+    "print(\n",
+    "    \"\\nTest Accuracy of quantized model 2 (Overall): %2d%% (%2d/%2d)\"\n",
+    "    % (\n",
+    "        100.0 * np.sum(class_correct) / np.sum(class_total),\n",
+    "        np.sum(class_correct),\n",
+    "        np.sum(class_total),\n",
+    "    )\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Comparison accuracy result between model 1 and quantized model 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -945,12 +1280,16 @@
     }
    ],
    "source": [
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "plt.plot(range(n_epochs), train_loss_list)\n",
-    "plt.xlabel(\"Epoch\")\n",
-    "plt.ylabel(\"Loss\")\n",
-    "plt.title(\"Performance of Model 1\")\n",
+    "fig_4, ax_4 = plt.subplots()\n",
+    "w = 0.4\n",
+    "x = [\"airplane\", \"automobile\", \"bird\", \"car\", \"deer\", \"dog\", \"frog\", \"horse\", \"ship\", \"truck\"]\n",
+    "bar1 = np.arange(len(x))\n",
+    "bar2 = [i+w for i in bar1]\n",
+    "ax_4.bar(bar1,accuracy_per_class_m1,w,label=\"Original model\")\n",
+    "ax_4.bar(bar2,accuracy_per_class_q1,w,label=\"quantized model\")\n",
+    "ax_4.legend()\n",
+    "plt.xlabel(\"Class\")\n",
+    "plt.ylabel(\"Accuracy\")\n",
     "plt.show()"
    ]
   },
@@ -958,24 +1297,199 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Comparison of the results obtained between new model and original model"
+    "Comparison accuracy result between model 2 and quantized model 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig_5, ax_5 = plt.subplots()\n",
+    "w = 0.4\n",
+    "x = [\"airplane\", \"automobile\", \"bird\", \"car\", \"deer\", \"dog\", \"frog\", \"horse\", \"ship\", \"truck\"]\n",
+    "bar1 = np.arange(len(x))\n",
+    "bar2 = [i+w for i in bar1]\n",
+    "ax_5.bar(bar1,accuracy_per_class_m2,w,label=\"Original model\")\n",
+    "ax_5.bar(bar2,accuracy_per_class_q2,w,label=\"Quantized_model\")\n",
+    "ax_5.legend()\n",
+    "plt.xlabel(\"Class\")\n",
+    "plt.ylabel(\"Accuracy\")\n",
+    "plt.show()"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "944991a2",
    "metadata": {},
    "source": [
-    "Build a new network with the following structure.\n",
+    " **Exercise 3: working with pre-trained models.**"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "PyTorch offers several pre-trained models https://pytorch.org/vision/0.8/models.htmlWe will use ResNet50 trained on ImageNet dataset (https://www.image-net.org/index.php). Use the following code with the files imagenet-simple-labels.json that contains the imagenet labels and the image dog.png that we will use as test."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
     "\n",
-    "- It has 3 convolutional layers of kernel size 3 and padding of 1.\n",
-    "- The first convolutional layer must output 16 channels, the second 32 and the third 64.\n",
-    "- At each convolutional layer output, we apply a ReLU activation then a MaxPool with kernel size of 2.\n",
-    "- Then, three fully connected layers, the first two being followed by a ReLU activation and a dropout whose value you will suggest.\n",
-    "- The first fully connected layer will have an output size of 512.\n",
-    "- The second fully connected layer will have an output size of 64.\n",
     "\n",
-    "Compare the results obtained with this new network to those obtained previously."
+    "# Choose an image to pass through the model\n",
+    "test_image = \"dog.png\"\n",
+    "\n",
+    "# Configure matplotlib for pretty inline plots\n",
+    "#%matplotlib inline\n",
+    "#%config InlineBackend.figure_format = 'retina'\n",
+    "\n",
+    "# Prepare the labels\n",
+    "with open(\"imagenet-simple-labels.json\") as f:\n",
+    "    labels = json.load(f)\n",
+    "\n",
+    "# First prepare the transformations: resize the image to what the model was trained on and convert it to a tensor\n",
+    "data_transform = transforms.Compose(\n",
+    "    [\n",
+    "        transforms.Resize((224, 224)),\n",
+    "        transforms.ToTensor(),\n",
+    "        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n",
+    "    ]\n",
+    ")\n",
+    "# Load the image\n",
+    "\n",
+    "image = Image.open(test_image)\n",
+    "plt.imshow(image), plt.xticks([]), plt.yticks([])\n",
+    "\n",
+    "# Now apply the transformation, expand the batch dimension, and send the image to the GPU\n",
+    "# image = data_transform(image).unsqueeze(0).cuda()\n",
+    "image = data_transform(image).unsqueeze(0)\n",
+    "\n",
+    "# Download the model if it's not there already. It will take a bit on the first run, after that it's fast\n",
+    "model_3 = models.resnet50(pretrained=True)  #  pretrained=True : permet d'obtenir les valeurs des poids après le pré-entrainement.\n",
+    "print(model_3)\n",
+    "# Send the model to the GPU\n",
+    "# model.cuda()\n",
+    "# Set layers such as dropout and batchnorm in evaluation mode\n",
+    "model_3.eval()\n",
+    "\n",
+    "# Get the 1000-dimensional model output\n",
+    "out = model_3(image)\n",
+    "# Find the predicted class\n",
+    "print(\"Predicted class is: {}\".format(labels[out.argmax()]))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Size of resnet50 model :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print_size_of_model(model_3, \"fp32\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Post training quantization of resnet50 model :  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "quantized_model_3 = torch.quantization.quantize_dynamic(model_3, dtype=torch.qint8)\n",
+    "print_size_of_model(quantized_model_3, \"int8\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Test classification of quantized resnet50 model : "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "from PIL import Image\n",
+    "\n",
+    "# Choose an image to pass through the model\n",
+    "test_image = \"dog.png\"\n",
+    "\n",
+    "# Configure matplotlib for pretty inline plots\n",
+    "#%matplotlib inline\n",
+    "#%config InlineBackend.figure_format = 'retina'\n",
+    "\n",
+    "# Prepare the labels\n",
+    "with open(\"imagenet-simple-labels.json\") as f:\n",
+    "    labels = json.load(f)\n",
+    "\n",
+    "# First prepare the transformations: resize the image to what the model was trained on and convert it to a tensor\n",
+    "data_transform = transforms.Compose(\n",
+    "    [\n",
+    "        transforms.Resize((224, 224)),\n",
+    "        transforms.ToTensor(),\n",
+    "        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n",
+    "    ]\n",
+    ")\n",
+    "# Load the image\n",
+    "\n",
+    "image = Image.open(test_image)\n",
+    "plt.imshow(image), plt.xticks([]), plt.yticks([])\n",
+    "\n",
+    "# Now apply the transformation, expand the batch dimension, and send the image to the GPU\n",
+    "# image = data_transform(image).unsqueeze(0).cuda()\n",
+    "image = data_transform(image).unsqueeze(0)\n",
+    "\n",
+    "# Download the model if it's not there already. It will take a bit on the first run, after that it's fast\n",
+    "model_3 = models.resnet50(pretrained=True)  #  pretrained=True : permet d'obtenir les valeurs des poids après le pré-entrainement.\n",
+    "print(model_3)\n",
+    "# Send the model to the GPU\n",
+    "# model.cuda()\n",
+    "# Set layers such as dropout and batchnorm in evaluation mode\n",
+    "model_3.eval()\n",
+    "\n",
+    "# Get the 1000-dimensional model output\n",
+    "out = model_3(image)\n",
+    "# Find the predicted class\n",
+    "print(\"Predicted class is: {}\".format(labels[out.argmax()]))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    " Experiments:Study the code and the results obtained. Possibly add other images downloaded from the internet.What is the size of the model? Quantize it and then check if the model is still able to correctly classify the other images.Experiment with other pre-trained CNN models."
    ]
   }
  ],