diff --git a/TD2 Deep Learning.ipynb b/TD2 Deep Learning.ipynb
index 8eaed08179d2eb76122763bf287f1ec76104b4cf..914955a139097172c2cc84e7578aff07465025a4 100644
--- a/TD2 Deep Learning.ipynb	
+++ b/TD2 Deep Learning.ipynb	
@@ -206,12 +206,24 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 2,
       "id": "6e18f2fd",
       "metadata": {
-        "id": "6e18f2fd"
+        "id": "6e18f2fd",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "03e195b7-3c7a-4170-ceca-068b700790f8"
       },
-      "outputs": [],
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "CUDA is not available.  Training on CPU ...\n"
+          ]
+        }
+      ],
       "source": [
         "import torch\n",
         "\n",
@@ -236,12 +248,39 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 3,
       "id": "462666a2",
       "metadata": {
-        "id": "462666a2"
+        "id": "462666a2",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "efadf484-b9e7-4451-9685-278d30164520"
       },
-      "outputs": [],
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to data/cifar-10-python.tar.gz\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "100%|██████████| 170498071/170498071 [00:01<00:00, 103869184.28it/s]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Extracting data/cifar-10-python.tar.gz to data\n",
+            "Files already downloaded and verified\n"
+          ]
+        }
+      ],
       "source": [
         "import numpy as np\n",
         "from torchvision import datasets, transforms\n",
@@ -312,12 +351,31 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 8,
       "id": "317bf070",
       "metadata": {
-        "id": "317bf070"
+        "id": "317bf070",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "c3bf54b9-cce3-4017-aeab-b8041ea655e7"
       },
-      "outputs": [],
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Net(\n",
+            "  (conv1): Conv2d(3, 6, kernel_size=(5, 5), stride=(1, 1))\n",
+            "  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
+            "  (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))\n",
+            "  (fc1): Linear(in_features=400, out_features=120, bias=True)\n",
+            "  (fc2): Linear(in_features=120, out_features=84, bias=True)\n",
+            "  (fc3): Linear(in_features=84, out_features=10, bias=True)\n",
+            ")\n"
+          ]
+        }
+      ],
       "source": [
         "import torch.nn as nn\n",
         "import torch.nn.functional as F\n",
@@ -365,12 +423,64 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 9,
       "id": "4b53f229",
       "metadata": {
-        "id": "4b53f229"
+        "id": "4b53f229",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 881
+        },
+        "outputId": "8c5ea9a1-3f8a-4814-eaee-3628910f3636"
       },
-      "outputs": [],
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Epoch: 0 \tTraining Loss: 44.038732 \tValidation Loss: 39.409209\n",
+            "Validation loss decreased (inf --> 39.409209).  Saving model ...\n",
+            "Epoch: 1 \tTraining Loss: 35.157346 \tValidation Loss: 31.752622\n",
+            "Validation loss decreased (39.409209 --> 31.752622).  Saving model ...\n",
+            "Epoch: 2 \tTraining Loss: 30.638388 \tValidation Loss: 29.289384\n",
+            "Validation loss decreased (31.752622 --> 29.289384).  Saving model ...\n",
+            "Epoch: 3 \tTraining Loss: 28.499834 \tValidation Loss: 27.327754\n",
+            "Validation loss decreased (29.289384 --> 27.327754).  Saving model ...\n",
+            "Epoch: 4 \tTraining Loss: 26.784333 \tValidation Loss: 27.843559\n",
+            "Epoch: 5 \tTraining Loss: 25.244284 \tValidation Loss: 26.936346\n",
+            "Validation loss decreased (27.327754 --> 26.936346).  Saving model ...\n",
+            "Epoch: 6 \tTraining Loss: 23.937883 \tValidation Loss: 24.311266\n",
+            "Validation loss decreased (26.936346 --> 24.311266).  Saving model ...\n",
+            "Epoch: 7 \tTraining Loss: 22.804158 \tValidation Loss: 22.877894\n",
+            "Validation loss decreased (24.311266 --> 22.877894).  Saving model ...\n",
+            "Epoch: 8 \tTraining Loss: 21.733578 \tValidation Loss: 22.296608\n",
+            "Validation loss decreased (22.877894 --> 22.296608).  Saving model ...\n",
+            "Epoch: 9 \tTraining Loss: 20.862017 \tValidation Loss: 21.442494\n",
+            "Validation loss decreased (22.296608 --> 21.442494).  Saving model ...\n",
+            "Epoch: 10 \tTraining Loss: 19.986339 \tValidation Loss: 21.860503\n",
+            "Epoch: 11 \tTraining Loss: 19.199303 \tValidation Loss: 21.217101\n",
+            "Validation loss decreased (21.442494 --> 21.217101).  Saving model ...\n",
+            "Epoch: 12 \tTraining Loss: 18.541731 \tValidation Loss: 21.502720\n",
+            "Epoch: 13 \tTraining Loss: 17.861395 \tValidation Loss: 21.135662\n",
+            "Validation loss decreased (21.217101 --> 21.135662).  Saving model ...\n",
+            "Epoch: 14 \tTraining Loss: 17.303609 \tValidation Loss: 21.811283\n",
+            "Epoch: 15 \tTraining Loss: 16.740100 \tValidation Loss: 22.032390\n"
+          ]
+        },
+        {
+          "output_type": "error",
+          "ename": "KeyboardInterrupt",
+          "evalue": "ignored",
+          "traceback": [
+            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
+            "\u001b[0;32m<ipython-input-9-e3e3eae4d15a>\u001b[0m in \u001b[0;36m<cell line: 10>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     26\u001b[0m         \u001b[0mloss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcriterion\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtarget\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     27\u001b[0m         \u001b[0;31m# Backward pass: compute gradient of the loss with respect to model parameters\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 28\u001b[0;31m         \u001b[0mloss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     29\u001b[0m         \u001b[0;31m# Perform a single optimization step (parameter update)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     30\u001b[0m         \u001b[0moptimizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/_tensor.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(self, gradient, retain_graph, create_graph, inputs)\u001b[0m\n\u001b[1;32m    490\u001b[0m                 \u001b[0minputs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    491\u001b[0m             )\n\u001b[0;32m--> 492\u001b[0;31m         torch.autograd.backward(\n\u001b[0m\u001b[1;32m    493\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgradient\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minputs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    494\u001b[0m         )\n",
+            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/autograd/__init__.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables, inputs)\u001b[0m\n\u001b[1;32m    249\u001b[0m     \u001b[0;31m# some Python versions print out the first line of a multi-line function\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    250\u001b[0m     \u001b[0;31m# calls in the traceback and some print out the last line\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 251\u001b[0;31m     Variable._execution_engine.run_backward(  # Calls into the C++ engine to run the backward pass\n\u001b[0m\u001b[1;32m    252\u001b[0m         \u001b[0mtensors\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    253\u001b[0m         \u001b[0mgrad_tensors_\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
+          ]
+        }
+      ],
       "source": [
         "import torch.optim as optim\n",
         "\n",
@@ -448,21 +558,37 @@
         "id": "13e1df74"
       },
       "source": [
-        "Does overfit occur? If so, do an early stopping."
+        "Does overfit occur? If so, do an early stopping. We did an early stopping at the 15th Epoch because Validation Loss started increasing."
       ]
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 12,
       "id": "d39df818",
       "metadata": {
-        "id": "d39df818"
+        "id": "d39df818",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 472
+        },
+        "outputId": "f3f4d989-197c-4a6c-847c-c263ee6057c1"
       },
-      "outputs": [],
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
       "source": [
         "import matplotlib.pyplot as plt\n",
-        "\n",
-        "plt.plot(range(n_epochs), train_loss_list)\n",
+        "n_epochs_stop = 16 # Here we stop the execution before the overfit\n",
+        "plt.plot(range(n_epochs_stop), train_loss_list)\n",
         "plt.xlabel(\"Epoch\")\n",
         "plt.ylabel(\"Loss\")\n",
         "plt.title(\"Performance of Model 1\")\n",
@@ -481,12 +607,37 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 13,
       "id": "e93efdfc",
       "metadata": {
-        "id": "e93efdfc"
+        "id": "e93efdfc",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "18910a1e-0d81-456d-809b-e171771b9e6a"
       },
-      "outputs": [],
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Test Loss: 21.102371\n",
+            "\n",
+            "Test Accuracy of airplane: 73% (730/1000)\n",
+            "Test Accuracy of automobile: 83% (839/1000)\n",
+            "Test Accuracy of  bird: 55% (558/1000)\n",
+            "Test Accuracy of   cat: 40% (406/1000)\n",
+            "Test Accuracy of  deer: 41% (415/1000)\n",
+            "Test Accuracy of   dog: 57% (573/1000)\n",
+            "Test Accuracy of  frog: 73% (730/1000)\n",
+            "Test Accuracy of horse: 70% (707/1000)\n",
+            "Test Accuracy of  ship: 66% (663/1000)\n",
+            "Test Accuracy of truck: 72% (723/1000)\n",
+            "\n",
+            "Test Accuracy (Overall): 63% (6344/10000)\n"
+          ]
+        }
+      ],
       "source": [
         "model.load_state_dict(torch.load(\"./model_cifar.pt\"))\n",
         "\n",