diff --git a/TD2 Deep Learning.ipynb b/TD2 Deep Learning.ipynb
index 3e7d4e59b946a53dedd3ae320853c0b7ae9bd51f..0cd4d6bb284b4b40c422f980f812f97eec5dbb6f 100644
--- a/TD2 Deep Learning.ipynb	
+++ b/TD2 Deep Learning.ipynb	
@@ -77,7 +77,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 1,
    "id": "b1950f0a",
    "metadata": {},
    "outputs": [
@@ -85,34 +85,34 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "tensor([[-0.1010,  0.0150,  0.6023, -0.4321,  0.0601, -0.7947, -0.0633, -0.4281,\n",
-      "         -0.4185,  0.3594],\n",
-      "        [ 0.6899, -0.2323,  0.5128, -1.5569, -0.1932,  2.0185,  0.5506, -0.5941,\n",
-      "         -0.9255,  0.0277],\n",
-      "        [ 0.5495,  1.0768, -0.2514,  2.0165, -0.6408, -0.2965,  1.5785, -0.1222,\n",
-      "         -0.6929, -0.6487],\n",
-      "        [ 0.5564, -2.5045, -1.8880,  0.0608,  0.5207,  0.2850, -0.4227, -0.2148,\n",
-      "         -1.3494,  0.1971],\n",
-      "        [-1.4237, -1.0707, -0.0337, -0.4123,  0.5595, -0.6611,  0.8731,  0.5283,\n",
-      "          0.6025,  0.5712],\n",
-      "        [ 0.3790,  0.2682,  1.3984,  0.7761, -0.1378, -0.3734, -0.3738, -2.3047,\n",
-      "          0.8315, -1.5273],\n",
-      "        [ 0.2978, -0.6077, -0.5949, -0.5083,  0.3004, -0.7669,  1.2265,  0.5210,\n",
-      "          1.2395, -1.9199],\n",
-      "        [ 0.0766,  0.0755,  0.2504, -0.0629, -0.1655, -0.4379, -0.2917, -0.8068,\n",
-      "         -0.2307,  0.4788],\n",
-      "        [-1.1107, -0.7808, -0.0164, -1.5693, -1.1547,  0.6999,  1.1040, -0.9477,\n",
-      "          1.4114, -1.4853],\n",
-      "        [ 0.5152, -0.7931,  0.1056,  1.1417,  1.8145,  0.8698,  0.5271, -0.3346,\n",
-      "          0.7730, -1.1089],\n",
-      "        [ 0.4822,  0.3573,  2.0989, -1.1276,  1.2703,  0.4089, -0.5173, -1.4173,\n",
-      "          1.9717,  0.5561],\n",
-      "        [-0.3935, -0.6366, -1.4044, -0.6673, -0.8524,  3.1000, -1.0241, -0.8087,\n",
-      "          1.2977,  0.3041],\n",
-      "        [ 0.7923, -0.8458, -0.9809, -0.1437, -0.0761,  2.1397, -0.3085,  0.8824,\n",
-      "          0.2109, -1.5898],\n",
-      "        [ 2.0043, -1.6643, -0.2231,  0.2189,  0.1812,  0.3767,  0.3565, -0.2464,\n",
-      "         -0.0169, -0.3935]])\n",
+      "tensor([[ 0.1744,  0.3062,  1.4179,  0.7363,  0.7816, -0.6391, -0.5490, -0.1032,\n",
+      "         -0.7233,  1.0795],\n",
+      "        [-1.8096, -1.1851, -0.9042, -0.3299, -0.3000, -0.8442, -1.6851, -1.9883,\n",
+      "          0.1632,  0.8452],\n",
+      "        [-0.4502,  0.1919, -0.9135, -1.8582,  1.4426, -1.6025,  0.6635,  0.3457,\n",
+      "         -0.3581, -1.8481],\n",
+      "        [ 0.2255,  1.6756, -0.2497,  0.8539,  0.0483,  0.2417,  0.3724,  0.5303,\n",
+      "         -0.2037, -0.4232],\n",
+      "        [ 0.8002,  0.6082,  0.2864, -0.2842, -0.0505, -0.6402, -0.2886, -0.0091,\n",
+      "          0.3539,  0.4269],\n",
+      "        [ 0.7700, -0.0747, -0.6357, -0.5653,  1.0852,  1.0656,  1.6057,  1.5844,\n",
+      "         -0.1979,  0.3254],\n",
+      "        [-0.0775, -1.0266, -1.0422, -0.3306, -0.7029,  1.1253, -1.3351, -0.7437,\n",
+      "         -2.3138, -1.4818],\n",
+      "        [-1.6668, -0.3562, -0.5957,  0.2838, -0.1202, -1.7730, -1.0390,  0.4480,\n",
+      "         -0.2061,  0.5346],\n",
+      "        [-0.2674,  0.1055,  0.9712, -1.2021, -0.3147, -0.2380,  0.1491, -0.4837,\n",
+      "         -1.2815,  0.4612],\n",
+      "        [ 0.2574,  0.2940,  1.4151,  0.1612, -1.1065,  0.0487,  0.1955,  1.2402,\n",
+      "          0.5226, -0.2864],\n",
+      "        [ 0.2866,  0.3205,  0.5039,  0.4679,  0.4333, -0.4385, -0.5968,  1.1527,\n",
+      "         -0.5951,  0.0889],\n",
+      "        [-0.2915,  0.3082,  0.6077, -0.2686,  1.1659,  0.3137,  0.9237,  0.4700,\n",
+      "         -0.5402, -0.6068],\n",
+      "        [ 0.6862,  0.5634,  0.9036,  1.3329,  1.0463,  1.0102,  1.8478,  0.4959,\n",
+      "         -1.6788,  0.7492],\n",
+      "        [-0.8378,  0.9934, -1.5207, -0.2584, -0.6890, -0.8820,  0.9061, -0.7603,\n",
+      "         -0.3027, -1.6206]])\n",
       "AlexNet(\n",
       "  (features): Sequential(\n",
       "    (0): Conv2d(3, 64, kernel_size=(11, 11), stride=(4, 4), padding=(2, 2))\n",
@@ -182,7 +182,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 7,
    "id": "6e18f2fd",
    "metadata": {},
    "outputs": [
@@ -216,7 +216,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 33,
    "id": "462666a2",
    "metadata": {},
    "outputs": [
@@ -297,7 +297,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 9,
    "id": "317bf070",
    "metadata": {},
    "outputs": [
@@ -653,7 +653,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
@@ -884,27 +884,27 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 60,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Test Loss: 17.546416\n",
+      "Test Loss: 17.458092\n",
       "\n",
-      "Test Accuracy of airplane: 71% (805/1000)\n",
-      "Test Accuracy of automobile: 65% (848/1000)\n",
-      "Test Accuracy of  bird: 55% (517/1000)\n",
-      "Test Accuracy of   cat: 40% (470/1000)\n",
-      "Test Accuracy of  deer: 46% (680/1000)\n",
-      "Test Accuracy of   dog: 54% (632/1000)\n",
-      "Test Accuracy of  frog: 70% (775/1000)\n",
-      "Test Accuracy of horse: 66% (766/1000)\n",
-      "Test Accuracy of  ship: 75% (780/1000)\n",
-      "Test Accuracy of truck: 74% (783/1000)\n",
+      "Test Accuracy of airplane: 81% (807/1000)\n",
+      "Test Accuracy of automobile: 84% (832/1000)\n",
+      "Test Accuracy of  bird: 50% (512/1000)\n",
+      "Test Accuracy of   cat: 48% (491/1000)\n",
+      "Test Accuracy of  deer: 70% (685/1000)\n",
+      "Test Accuracy of   dog: 60% (629/1000)\n",
+      "Test Accuracy of  frog: 75% (780/1000)\n",
+      "Test Accuracy of horse: 77% (760/1000)\n",
+      "Test Accuracy of  ship: 79% (786/1000)\n",
+      "Test Accuracy of truck: 79% (790/1000)\n",
       "\n",
-      "Test Accuracy (Overall): 70% (7056/10000)\n"
+      "Test Accuracy (Overall): 70% (7072/10000)\n"
      ]
     }
    ],
@@ -1032,7 +1032,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 11,
    "id": "ef623c26",
    "metadata": {},
    "outputs": [
@@ -1049,7 +1049,7 @@
        "2330946"
       ]
      },
-     "execution_count": 14,
+     "execution_count": 11,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1081,7 +1081,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 12,
    "id": "c4c65d4b",
    "metadata": {},
    "outputs": [
@@ -1098,7 +1098,7 @@
        "659678"
       ]
      },
-     "execution_count": 15,
+     "execution_count": 12,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1114,7 +1114,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 59,
    "metadata": {},
    "outputs": [
     {
@@ -1128,20 +1128,20 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Test Loss: 17.422753\n",
+      "Test Loss: 17.652650\n",
       "\n",
-      "Test Accuracy of airplane: 80% (800/1000)\n",
-      "Test Accuracy of automobile: 86% (860/1000)\n",
-      "Test Accuracy of  bird: 53% (536/1000)\n",
-      "Test Accuracy of   cat: 46% (466/1000)\n",
-      "Test Accuracy of  deer: 69% (699/1000)\n",
-      "Test Accuracy of   dog: 61% (616/1000)\n",
-      "Test Accuracy of  frog: 77% (775/1000)\n",
-      "Test Accuracy of horse: 76% (760/1000)\n",
+      "Test Accuracy of airplane: 81% (815/1000)\n",
+      "Test Accuracy of automobile: 84% (843/1000)\n",
+      "Test Accuracy of  bird: 50% (504/1000)\n",
+      "Test Accuracy of   cat: 48% (481/1000)\n",
+      "Test Accuracy of  deer: 70% (703/1000)\n",
+      "Test Accuracy of   dog: 60% (605/1000)\n",
+      "Test Accuracy of  frog: 75% (754/1000)\n",
+      "Test Accuracy of horse: 77% (779/1000)\n",
       "Test Accuracy of  ship: 79% (795/1000)\n",
-      "Test Accuracy of truck: 78% (785/1000)\n",
+      "Test Accuracy of truck: 79% (793/1000)\n",
       "\n",
-      "Test Accuracy (Overall): 70% (7092/10000)\n"
+      "Test Accuracy (Overall): 70% (7072/10000)\n"
      ]
     }
    ],
@@ -1233,6 +1233,464 @@
     "Try training aware quantization to mitigate the impact on the accuracy (doc available here https://pytorch.org/docs/stable/quantization.html#torch.quantization.quantize_dynamic)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Training aware quantization"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Net(\n",
+      "  (quant): QuantStub()\n",
+      "  (conv1): Conv2d(3, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
+      "  (conv2): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "  (conv3): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "  (fc1): Linear(in_features=1024, out_features=512, bias=True)\n",
+      "  (fc2): Linear(in_features=512, out_features=64, bias=True)\n",
+      "  (fc3): Linear(in_features=64, out_features=10, bias=True)\n",
+      "  (dequant): DeQuantStub()\n",
+      ")\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Define new model to be quantized\n",
+    "\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import torch.nn.functional as F\n",
+    "\n",
+    "class Net(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(Net, self).__init__()\n",
+    "        self.quant = torch.ao.quantization.QuantStub()\n",
+    "        self.conv1 = nn.Conv2d(3, 16, 3, padding=1)\n",
+    "        self.pool = nn.MaxPool2d(2, 2)\n",
+    "        self.conv2 = nn.Conv2d(16, 32, 3, padding=1)\n",
+    "        self.conv3 = nn.Conv2d(32, 64, 3, padding=1)\n",
+    "        self.fc1 = nn.Linear(64 * 4 * 4, 512)\n",
+    "        self.fc2 = nn.Linear(512, 64)\n",
+    "        self.fc3 = nn.Linear(64, 10)\n",
+    "        self.dequant = torch.ao.quantization.DeQuantStub()\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.quant(x)\n",
+    "        x = self.pool(F.relu(self.conv1(x)))\n",
+    "        x = self.pool(F.relu(self.conv2(x)))\n",
+    "        x = self.pool(F.relu(self.conv3(x)))\n",
+    "        x = x.reshape(-1, 64 * 4 * 4)\n",
+    "\n",
+    "        # We only use dropouts during training to prevent overfit\n",
+    "        if self.training:\n",
+    "            x = F.dropout(F.relu(self.fc1(x)), p=0.5)\n",
+    "            x = F.dropout(F.relu(self.fc2(x)), p=0.2)\n",
+    "        else:\n",
+    "            x = F.relu(self.fc1(x))\n",
+    "            x = F.relu(self.fc2(x))\n",
+    "\n",
+    "        x = self.fc3(x)\n",
+    "        x = self.dequant(x)\n",
+    "\n",
+    "        return x\n",
+    "\n",
+    "\n",
+    "# create a complete CNN\n",
+    "modelQ = Net()\n",
+    "print(modelQ)\n",
+    "# move tensors to GPU if CUDA is available\n",
+    "if train_on_gpu:\n",
+    "    modelQ.cuda()\n",
+    "\n",
+    "modelQ.eval()\n",
+    "\n",
+    "# attach a global qconfig, which contains information about what kind\n",
+    "# of observers to attach. Use 'x86' for server inference and 'qnnpack'\n",
+    "# for mobile inference. \n",
+    "modelQ.qconfig = torch.ao.quantization.get_default_qat_qconfig('qnnpack')\n",
+    "\n",
+    "# Prepare the model for QAT. This inserts observers and fake_quants in\n",
+    "# the model needs to be set to train for QAT logic to work\n",
+    "# the model that will observe weight and activation tensors during calibration.\n",
+    "modelQ_prepared = torch.ao.quantization.prepare_qat(modelQ.train())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch: 0 \tTraining Loss: 40.045232 \tValidation Loss: 36.881491\n",
+      "Validation loss decreased (inf --> 36.881491).  Saving model ...\n",
+      "Epoch: 1 \tTraining Loss: 33.849110 \tValidation Loss: 31.121534\n",
+      "Validation loss decreased (36.881491 --> 31.121534).  Saving model ...\n",
+      "Epoch: 2 \tTraining Loss: 30.736283 \tValidation Loss: 28.696419\n",
+      "Validation loss decreased (31.121534 --> 28.696419).  Saving model ...\n",
+      "Epoch: 3 \tTraining Loss: 28.706360 \tValidation Loss: 26.644605\n",
+      "Validation loss decreased (28.696419 --> 26.644605).  Saving model ...\n",
+      "Epoch: 4 \tTraining Loss: 27.099919 \tValidation Loss: 25.140330\n",
+      "Validation loss decreased (26.644605 --> 25.140330).  Saving model ...\n",
+      "Epoch: 5 \tTraining Loss: 25.571749 \tValidation Loss: 23.812149\n",
+      "Validation loss decreased (25.140330 --> 23.812149).  Saving model ...\n",
+      "Epoch: 6 \tTraining Loss: 24.219007 \tValidation Loss: 22.375885\n",
+      "Validation loss decreased (23.812149 --> 22.375885).  Saving model ...\n",
+      "Epoch: 7 \tTraining Loss: 22.869210 \tValidation Loss: 21.742033\n",
+      "Validation loss decreased (22.375885 --> 21.742033).  Saving model ...\n",
+      "Epoch: 8 \tTraining Loss: 21.688536 \tValidation Loss: 21.108260\n",
+      "Validation loss decreased (21.742033 --> 21.108260).  Saving model ...\n",
+      "Epoch: 9 \tTraining Loss: 20.553527 \tValidation Loss: 19.736301\n",
+      "Validation loss decreased (21.108260 --> 19.736301).  Saving model ...\n",
+      "Epoch: 10 \tTraining Loss: 19.505035 \tValidation Loss: 19.381001\n",
+      "Validation loss decreased (19.736301 --> 19.381001).  Saving model ...\n",
+      "Epoch: 11 \tTraining Loss: 18.645353 \tValidation Loss: 18.074507\n",
+      "Validation loss decreased (19.381001 --> 18.074507).  Saving model ...\n",
+      "Epoch: 12 \tTraining Loss: 17.806487 \tValidation Loss: 18.007345\n",
+      "Validation loss decreased (18.074507 --> 18.007345).  Saving model ...\n",
+      "Epoch: 13 \tTraining Loss: 16.956523 \tValidation Loss: 17.211487\n",
+      "Validation loss decreased (18.007345 --> 17.211487).  Saving model ...\n",
+      "Epoch: 14 \tTraining Loss: 16.246275 \tValidation Loss: 17.320531\n",
+      "Epoch: 15 \tTraining Loss: 15.538230 \tValidation Loss: 16.931274\n",
+      "Validation loss decreased (17.211487 --> 16.931274).  Saving model ...\n",
+      "Epoch: 16 \tTraining Loss: 14.808365 \tValidation Loss: 16.743996\n",
+      "Validation loss decreased (16.931274 --> 16.743996).  Saving model ...\n",
+      "Epoch: 17 \tTraining Loss: 14.153474 \tValidation Loss: 16.541944\n",
+      "Validation loss decreased (16.743996 --> 16.541944).  Saving model ...\n",
+      "Epoch: 18 \tTraining Loss: 13.504873 \tValidation Loss: 16.297930\n",
+      "Validation loss decreased (16.541944 --> 16.297930).  Saving model ...\n",
+      "Epoch: 19 \tTraining Loss: 12.900541 \tValidation Loss: 15.848574\n",
+      "Validation loss decreased (16.297930 --> 15.848574).  Saving model ...\n",
+      "Epoch: 20 \tTraining Loss: 12.307625 \tValidation Loss: 15.725110\n",
+      "Validation loss decreased (15.848574 --> 15.725110).  Saving model ...\n",
+      "Epoch: 21 \tTraining Loss: 11.645832 \tValidation Loss: 16.500948\n",
+      "Epoch: 22 \tTraining Loss: 11.253199 \tValidation Loss: 15.730872\n",
+      "Epoch: 23 \tTraining Loss: 10.738303 \tValidation Loss: 16.101557\n",
+      "Early stopping after 23 epochs.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch.optim as optim\n",
+    "\n",
+    "criterion = nn.CrossEntropyLoss()  # specify loss function\n",
+    "optimizer = optim.SGD(modelQ_prepared.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",
+    "validation_loss_list = [] # We also want to track validation loss to check for overfitting\n",
+    "valid_loss_min = np.Inf  # track change in validation loss\n",
+    "\n",
+    "\n",
+    "patience = 3 # We add this paramter to stop the training if loss doesn't improve after 3 epochs\n",
+    "\n",
+    "\n",
+    "for epoch in range(n_epochs):\n",
+    "    # Keep track of training and validation loss\n",
+    "    train_loss = 0.0\n",
+    "    valid_loss = 0.0\n",
+    "\n",
+    "    # Train the model\n",
+    "    modelQ_prepared.train()\n",
+    "    for data, target in train_loader:\n",
+    "        # Move tensors to GPU if CUDA is available\n",
+    "        if train_on_gpu:\n",
+    "            data, target = data.cuda(), target.cuda()\n",
+    "        # 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 = modelQ_prepared(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",
+    "        loss.backward()\n",
+    "        # Perform a single optimization step (parameter update)\n",
+    "        optimizer.step()\n",
+    "        # Update training loss\n",
+    "        train_loss += loss.item() * data.size(0)\n",
+    "\n",
+    "    # Validate the model\n",
+    "    modelQ_prepared.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 = modelQ_prepared(data)\n",
+    "        # Calculate the batch loss\n",
+    "        loss = criterion(output, target)\n",
+    "        # Update average validation loss\n",
+    "        valid_loss += loss.item() * data.size(0)\n",
+    "\n",
+    "    # 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",
+    "    validation_loss_list.append(valid_loss)\n",
+    "\n",
+    "    # Print training/validation statistics\n",
+    "    print(\n",
+    "        \"Epoch: {} \\tTraining Loss: {:.6f} \\tValidation Loss: {:.6f}\".format(\n",
+    "            epoch, train_loss, valid_loss\n",
+    "        )\n",
+    "    )\n",
+    "\n",
+    "    # Save model if validation loss has decreased\n",
+    "    if valid_loss <= valid_loss_min:\n",
+    "        print(\n",
+    "            \"Validation loss decreased ({:.6f} --> {:.6f}).  Saving model ...\".format(\n",
+    "                valid_loss_min, valid_loss\n",
+    "            )\n",
+    "        )\n",
+    "        modelQ_int8 = torch.ao.quantization.convert(modelQ_prepared)\n",
+    "        torch.save(modelQ_int8.state_dict(), \"modelQ_cifar_exo_2.pt\")\n",
+    "        valid_loss_min = valid_loss\n",
+    "        patience_counter = 0\n",
+    "    else:\n",
+    "        patience_counter += 1\n",
+    "\n",
+    "    if patience_counter >= patience:\n",
+    "        print(f\"Early stopping after {epoch} epochs.\")\n",
+    "        break"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt \n",
+    "\n",
+    "plt.plot(range(len(train_loss_list)), train_loss_list)\n",
+    "plt.plot(range(len(validation_loss_list)), validation_loss_list)\n",
+    "plt.xlabel(\"Epoch\")\n",
+    "plt.ylabel(\"Loss\")\n",
+    "plt.title(\"Quantized aware training\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "model:  int8  \t Size (KB): 591.47\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "591470"
+      ]
+     },
+     "execution_count": 55,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Check size of quantized aware model\n",
+    "\n",
+    "print_size_of_model(modelQ_int8, \"int8\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Reminder:\n",
+    "\n",
+    "model_initial:  fp32  \t Size (KB): 2330.946\n",
+    "2330946\n",
+    "\n",
+    "model_quantized:  int8  \t Size (KB): 659.678\n",
+    "659678\n",
+    "\n",
+    "model_training_aware_quantization:  int8  \t Size (KB): 591.47\n",
+    "591470 \n",
+    "\n",
+    "-> Size of the network is reduced even more! \n",
+    "Let's check the performance to see if it matches the initial network"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Test Loss: 15.758679\n",
+      "\n",
+      "Test Accuracy of airplane: 77% (773/1000)\n",
+      "Test Accuracy of automobile: 84% (847/1000)\n",
+      "Test Accuracy of  bird: 60% (606/1000)\n",
+      "Test Accuracy of   cat: 59% (591/1000)\n",
+      "Test Accuracy of  deer: 69% (692/1000)\n",
+      "Test Accuracy of   dog: 60% (603/1000)\n",
+      "Test Accuracy of  frog: 78% (784/1000)\n",
+      "Test Accuracy of horse: 78% (782/1000)\n",
+      "Test Accuracy of  ship: 84% (842/1000)\n",
+      "Test Accuracy of truck: 82% (823/1000)\n",
+      "\n",
+      "Test Accuracy (Overall): 73% (7343/10000)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# track test loss\n",
+    "test_loss = 0.0\n",
+    "class_correct3 = list(0.0 for i in range(10))\n",
+    "class_total3 = list(0.0 for i in range(10))\n",
+    "\n",
+    "modelQ_int8.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 = modelQ_int8(data)\n",
+    "    # calculate the batch loss\n",
+    "    loss = criterion(output, target)\n",
+    "    # update test loss\n",
+    "    test_loss += loss.item() * data.size(0)\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_correct3[label] += correct[i].item()\n",
+    "        class_total3[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_total3[i] > 0:\n",
+    "        print(\n",
+    "            \"Test Accuracy of %5s: %2d%% (%2d/%2d)\"\n",
+    "            % (\n",
+    "                classes[i],\n",
+    "                100 * class_correct3[i] / class_total3[i],\n",
+    "                np.sum(class_correct3[i]),\n",
+    "                np.sum(class_total3[i]),\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",
+    "    % (\n",
+    "        100.0 * np.sum(class_correct3) / np.sum(class_total3),\n",
+    "        np.sum(class_correct3),\n",
+    "        np.sum(class_total3),\n",
+    "    )\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Results are similar but better on average.\n",
+    "Accuracy results on classes where original model was weak have also improved."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "accuracy_original = [correct / total for correct, total in zip(class_correct, class_total)]\n",
+    "accuracy_quantized = [correct / total for correct, total in zip(class_correct2, class_total2)]\n",
+    "accuracy_quantized_aware = [correct / total for correct, total in zip(class_correct3, class_total3)]\n",
+    "\n",
+    "width = 0.25  # Adjusted width for better separation\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(10, 6))  # Adjusted figure size\n",
+    "rects1 = ax.bar(x - width, accuracy_original, width, label='Original Model', color='#1f77b4')\n",
+    "rects2 = ax.bar(x, accuracy_quantized, width, label='Quantized Model', color='#ff7f0e')\n",
+    "rects3 = ax.bar(x + width, accuracy_quantized_aware, width, label='Quantized Aware Model', color='#2ca02c')\n",
+    "\n",
+    "# Adding labels and title\n",
+    "ax.set_xlabel('Classes')\n",
+    "ax.set_ylabel('Accuracy')\n",
+    "ax.set_title('Accuracy Comparison by Class')\n",
+    "ax.set_xticks(x)\n",
+    "ax.set_xticklabels(classes)\n",
+    "ax.legend()\n",
+    "\n",
+    "# Adding a grid for better readability\n",
+    "ax.grid(axis='y', linestyle='--', alpha=0.7)\n",
+    "\n",
+    "# Adding data labels above each bar\n",
+    "def add_labels(rects):\n",
+    "    for rect in rects:\n",
+    "        height = rect.get_height()\n",
+    "        ax.annotate('%.2f' % height,\n",
+    "                    xy=(rect.get_x() + rect.get_width() / 2, height),\n",
+    "                    xytext=(0, 3),  # 3 points vertical offset\n",
+    "                    textcoords=\"offset points\",\n",
+    "                    ha='center', va='bottom')\n",
+    "\n",
+    "add_labels(rects1)\n",
+    "add_labels(rects2)\n",
+    "add_labels(rects3)\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "201470f9",