diff --git a/TD2 Deep Learning.ipynb b/TD2 Deep Learning.ipynb
index 72a622eab595c661339ee6858e2181a8f99e7183..af8ad09547297fa295146f37a4da3104fe5703ae 100644
--- a/TD2 Deep Learning.ipynb	
+++ b/TD2 Deep Learning.ipynb	
@@ -41,37 +41,18 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Collecting torch\n",
-      "  Downloading torch-2.2.2-cp311-none-macosx_10_9_x86_64.whl (150.8 MB)\n",
-      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m150.8/150.8 MB\u001b[0m \u001b[31m3.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0m\n",
-      "\u001b[?25hCollecting torchvision\n",
-      "  Downloading torchvision-0.17.2-cp311-cp311-macosx_10_13_x86_64.whl (1.7 MB)\n",
-      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.7/1.7 MB\u001b[0m \u001b[31m2.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0ma \u001b[36m0:00:01\u001b[0m\n",
-      "\u001b[?25hCollecting filelock\n",
-      "  Downloading filelock-3.16.1-py3-none-any.whl (16 kB)\n",
+      "Requirement already satisfied: torch in /usr/local/lib/python3.11/site-packages (2.2.2)\n",
+      "Requirement already satisfied: torchvision in /usr/local/lib/python3.11/site-packages (0.17.2)\n",
+      "Requirement already satisfied: filelock in /usr/local/lib/python3.11/site-packages (from torch) (3.16.1)\n",
       "Requirement already satisfied: typing-extensions>=4.8.0 in /Users/youcefkessi/Library/Python/3.11/lib/python/site-packages (from torch) (4.12.2)\n",
-      "Collecting sympy\n",
-      "  Downloading sympy-1.13.3-py3-none-any.whl (6.2 MB)\n",
-      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m6.2/6.2 MB\u001b[0m \u001b[31m3.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0m\n",
-      "\u001b[?25hCollecting networkx\n",
-      "  Downloading networkx-3.4.2-py3-none-any.whl (1.7 MB)\n",
-      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.7/1.7 MB\u001b[0m \u001b[31m4.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0m\n",
-      "\u001b[?25hCollecting jinja2\n",
-      "  Using cached jinja2-3.1.4-py3-none-any.whl (133 kB)\n",
-      "Collecting fsspec\n",
-      "  Downloading fsspec-2024.10.0-py3-none-any.whl (179 kB)\n",
-      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m179.6/179.6 kB\u001b[0m \u001b[31m3.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0ma \u001b[36m0:00:01\u001b[0m\n",
-      "\u001b[?25hRequirement already satisfied: numpy in /usr/local/lib/python3.11/site-packages (from torchvision) (1.24.3)\n",
-      "Collecting pillow!=8.3.*,>=5.3.0\n",
-      "  Downloading pillow-11.0.0-cp311-cp311-macosx_10_10_x86_64.whl (3.2 MB)\n",
-      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m3.2/3.2 MB\u001b[0m \u001b[31m3.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0m\n",
-      "\u001b[?25hCollecting MarkupSafe>=2.0\n",
-      "  Downloading MarkupSafe-3.0.2-cp311-cp311-macosx_10_9_universal2.whl (14 kB)\n",
-      "Collecting mpmath<1.4,>=1.1.0\n",
-      "  Downloading mpmath-1.3.0-py3-none-any.whl (536 kB)\n",
-      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m536.2/536.2 kB\u001b[0m \u001b[31m1.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0ma \u001b[36m0:00:01\u001b[0m\n",
-      "\u001b[?25hInstalling collected packages: mpmath, sympy, pillow, networkx, MarkupSafe, fsspec, filelock, jinja2, torch, torchvision\n",
-      "Successfully installed MarkupSafe-3.0.2 filelock-3.16.1 fsspec-2024.10.0 jinja2-3.1.4 mpmath-1.3.0 networkx-3.4.2 pillow-11.0.0 sympy-1.13.3 torch-2.2.2 torchvision-0.17.2\n",
+      "Requirement already satisfied: sympy in /usr/local/lib/python3.11/site-packages (from torch) (1.13.3)\n",
+      "Requirement already satisfied: networkx in /usr/local/lib/python3.11/site-packages (from torch) (3.4.2)\n",
+      "Requirement already satisfied: jinja2 in /usr/local/lib/python3.11/site-packages (from torch) (3.1.4)\n",
+      "Requirement already satisfied: fsspec in /usr/local/lib/python3.11/site-packages (from torch) (2024.10.0)\n",
+      "Requirement already satisfied: numpy in /usr/local/lib/python3.11/site-packages (from torchvision) (1.24.3)\n",
+      "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /usr/local/lib/python3.11/site-packages (from torchvision) (11.0.0)\n",
+      "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.11/site-packages (from jinja2->torch) (3.0.2)\n",
+      "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.11/site-packages (from sympy->torch) (1.3.0)\n",
       "\n",
       "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m23.0.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m24.3.1\u001b[0m\n",
       "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpython3.11 -m pip install --upgrade pip\u001b[0m\n",
@@ -94,7 +75,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 2,
    "id": "b1950f0a",
    "metadata": {},
    "outputs": [
@@ -102,34 +83,34 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "tensor([[ 0.1382,  1.9183,  0.7486, -0.0892, -2.3127, -0.4286,  0.9899,  0.3222,\n",
-      "         -0.5292,  0.9530],\n",
-      "        [-0.0399, -0.7634, -0.0202, -1.0406,  1.5965,  0.3020,  1.1578, -0.9197,\n",
-      "         -0.8526,  0.7884],\n",
-      "        [-0.7136,  0.5239,  0.6765, -1.0706, -0.2336, -0.3412, -0.6827, -0.3706,\n",
-      "         -0.0637,  1.2051],\n",
-      "        [-0.0992, -0.7170,  0.5943, -0.9738,  1.0573,  0.1999,  0.7378,  0.8637,\n",
-      "         -0.9122, -0.6693],\n",
-      "        [-0.2444,  0.0670,  0.5475,  0.4482,  0.1415,  0.2580,  0.5002, -0.6960,\n",
-      "         -0.2279, -1.1721],\n",
-      "        [-0.1691, -1.6504, -0.0027,  0.6255,  1.1239, -1.3190,  0.5333, -0.0546,\n",
-      "         -0.8585,  1.7737],\n",
-      "        [-0.4489,  0.6278,  0.1549, -0.8478, -0.2015, -0.0471,  1.5053,  0.4634,\n",
-      "          1.2918, -0.8495],\n",
-      "        [-0.2506,  0.6510,  0.1217,  1.2895,  0.2822, -1.3349, -0.3043, -0.1663,\n",
-      "          0.7939, -0.8179],\n",
-      "        [ 1.6928, -0.6658,  1.1638, -0.7703, -1.7227, -0.1917,  0.7573, -0.3033,\n",
-      "          0.1029,  0.1487],\n",
-      "        [ 0.3055, -0.1415, -0.9022,  0.1677,  0.1224, -0.4547,  0.7145, -1.1752,\n",
-      "         -1.5985, -1.0561],\n",
-      "        [-0.2934, -0.8208,  0.1982,  1.0242,  0.2430, -1.7429,  0.0303, -1.4033,\n",
-      "          0.0555, -0.4570],\n",
-      "        [-1.4168, -0.3432, -0.2924,  0.7476, -0.0764, -0.3595,  0.0453, -0.9992,\n",
-      "         -1.5226,  0.6131],\n",
-      "        [ 0.5159,  1.9472, -1.5132,  1.4804,  1.0425,  1.6437, -0.7786,  0.0994,\n",
-      "         -0.6477, -0.0729],\n",
-      "        [-0.2263, -0.2381,  0.7496,  0.9289,  0.2377, -0.1626, -0.9950,  0.1790,\n",
-      "          0.9828, -1.4597]])\n",
+      "tensor([[-0.9795,  0.7523,  0.8343, -0.0598,  0.3667, -2.0467, -0.6454,  0.5932,\n",
+      "         -1.4877, -1.4277],\n",
+      "        [ 0.2857,  1.2235, -1.1033, -0.2778, -1.5773, -1.9997, -0.8219, -0.4121,\n",
+      "         -0.2512, -0.9691],\n",
+      "        [ 0.4293, -0.6780, -0.6763, -0.5158,  1.7610,  0.8322, -1.4890,  0.6857,\n",
+      "          0.3931, -1.7304],\n",
+      "        [ 0.2365, -0.2215,  0.0878, -1.3077, -2.2274,  0.0471,  0.4229,  0.2999,\n",
+      "          1.6608, -0.4597],\n",
+      "        [-0.7914, -0.6193,  0.3148,  0.2495, -0.8671, -0.1750, -0.2270,  0.0452,\n",
+      "         -0.8493, -0.4726],\n",
+      "        [-0.2461,  0.5174,  0.0432, -1.6498,  0.1466,  0.4093, -0.4276,  0.9521,\n",
+      "          2.0915,  1.0765],\n",
+      "        [ 0.6324,  0.6887,  0.3230,  1.0649, -1.7234, -0.5458, -0.2392,  0.3203,\n",
+      "         -0.8843,  0.7544],\n",
+      "        [-0.2075,  0.5479, -1.6141,  1.3578, -0.8545, -0.0216, -0.3450, -0.0836,\n",
+      "          0.2637,  0.8819],\n",
+      "        [ 0.3133,  1.3201, -0.6707,  0.0446, -0.1030,  0.2500,  0.9326,  0.6421,\n",
+      "          1.0294, -0.1829],\n",
+      "        [ 1.0690, -0.7387, -0.0121,  0.3317,  0.2573,  0.1225,  1.0007,  0.1241,\n",
+      "         -0.1426,  1.4330],\n",
+      "        [-0.7790, -0.7018,  0.5592,  0.0154,  0.1271, -0.4686, -0.3782, -0.0503,\n",
+      "         -1.0020,  2.3186],\n",
+      "        [ 0.7689, -1.0463, -1.6566,  0.9265,  1.0589, -0.4197,  0.0226, -0.7334,\n",
+      "         -0.8651,  0.0277],\n",
+      "        [ 1.0587,  0.8789,  0.8870,  0.9864, -0.5615,  1.2596,  1.2531,  1.2855,\n",
+      "         -0.2959, -0.1690],\n",
+      "        [ 0.3559,  0.4418,  0.1828,  0.6727, -0.0380,  0.8039,  1.0082,  0.0988,\n",
+      "         -0.5981,  0.0457]])\n",
       "AlexNet(\n",
       "  (features): Sequential(\n",
       "    (0): Conv2d(3, 64, kernel_size=(11, 11), stride=(4, 4), padding=(2, 2))\n",
@@ -199,7 +180,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 3,
    "id": "6e18f2fd",
    "metadata": {},
    "outputs": [
@@ -233,7 +214,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 4,
    "id": "462666a2",
    "metadata": {},
    "outputs": [
@@ -241,21 +222,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to data/cifar-10-python.tar.gz\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100.0%\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Extracting data/cifar-10-python.tar.gz to data\n",
+      "Files already downloaded and verified\n",
       "Files already downloaded and verified\n"
      ]
     }
@@ -328,7 +295,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 5,
    "id": "317bf070",
    "metadata": {},
    "outputs": [
@@ -392,7 +359,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 6,
    "id": "4b53f229",
    "metadata": {},
    "outputs": [
@@ -400,49 +367,51 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Epoch: 0 \tTraining Loss: 43.554762 \tValidation Loss: 38.943442\n",
-      "Validation loss decreased (inf --> 38.943442).  Saving model ...\n",
-      "Epoch: 1 \tTraining Loss: 34.872761 \tValidation Loss: 32.725993\n",
-      "Validation loss decreased (38.943442 --> 32.725993).  Saving model ...\n",
-      "Epoch: 2 \tTraining Loss: 30.709429 \tValidation Loss: 29.464331\n",
-      "Validation loss decreased (32.725993 --> 29.464331).  Saving model ...\n",
-      "Epoch: 3 \tTraining Loss: 28.485044 \tValidation Loss: 28.414431\n",
-      "Validation loss decreased (29.464331 --> 28.414431).  Saving model ...\n",
-      "Epoch: 4 \tTraining Loss: 26.830099 \tValidation Loss: 26.364449\n",
-      "Validation loss decreased (28.414431 --> 26.364449).  Saving model ...\n",
-      "Epoch: 5 \tTraining Loss: 25.469640 \tValidation Loss: 26.365138\n",
-      "Epoch: 6 \tTraining Loss: 24.304000 \tValidation Loss: 24.570287\n",
-      "Validation loss decreased (26.364449 --> 24.570287).  Saving model ...\n",
-      "Epoch: 7 \tTraining Loss: 23.247810 \tValidation Loss: 23.820702\n",
-      "Validation loss decreased (24.570287 --> 23.820702).  Saving model ...\n",
-      "Epoch: 8 \tTraining Loss: 22.400491 \tValidation Loss: 23.790809\n",
-      "Validation loss decreased (23.820702 --> 23.790809).  Saving model ...\n",
-      "Epoch: 9 \tTraining Loss: 21.533881 \tValidation Loss: 23.234611\n",
-      "Validation loss decreased (23.790809 --> 23.234611).  Saving model ...\n",
-      "Epoch: 10 \tTraining Loss: 20.718155 \tValidation Loss: 23.801281\n",
-      "Epoch: 11 \tTraining Loss: 19.985109 \tValidation Loss: 22.480761\n",
-      "Validation loss decreased (23.234611 --> 22.480761).  Saving model ...\n",
-      "Epoch: 12 \tTraining Loss: 19.240459 \tValidation Loss: 22.505575\n",
-      "Epoch: 13 \tTraining Loss: 18.551414 \tValidation Loss: 22.415395\n",
-      "Validation loss decreased (22.480761 --> 22.415395).  Saving model ...\n",
-      "Epoch: 14 \tTraining Loss: 17.908126 \tValidation Loss: 21.999896\n",
-      "Validation loss decreased (22.415395 --> 21.999896).  Saving model ...\n",
-      "Epoch: 15 \tTraining Loss: 17.369180 \tValidation Loss: 22.417102\n",
-      "Epoch: 16 \tTraining Loss: 16.773355 \tValidation Loss: 22.192228\n",
-      "Epoch: 17 \tTraining Loss: 16.176232 \tValidation Loss: 21.979470\n",
-      "Validation loss decreased (21.999896 --> 21.979470).  Saving model ...\n",
-      "Epoch: 18 \tTraining Loss: 15.706412 \tValidation Loss: 22.365677\n",
-      "Epoch: 19 \tTraining Loss: 15.168052 \tValidation Loss: 22.861357\n",
-      "Epoch: 20 \tTraining Loss: 14.587228 \tValidation Loss: 23.245590\n",
-      "Epoch: 21 \tTraining Loss: 14.180318 \tValidation Loss: 24.290684\n",
-      "Epoch: 22 \tTraining Loss: 13.679101 \tValidation Loss: 23.016075\n",
-      "Epoch: 23 \tTraining Loss: 13.202287 \tValidation Loss: 23.932568\n",
-      "Epoch: 24 \tTraining Loss: 12.708487 \tValidation Loss: 25.336128\n",
-      "Epoch: 25 \tTraining Loss: 12.288698 \tValidation Loss: 25.429984\n",
-      "Epoch: 26 \tTraining Loss: 11.907723 \tValidation Loss: 25.383014\n",
-      "Epoch: 27 \tTraining Loss: 11.487043 \tValidation Loss: 25.936636\n",
-      "Epoch: 28 \tTraining Loss: 11.127419 \tValidation Loss: 28.218890\n",
-      "Epoch: 29 \tTraining Loss: 10.661623 \tValidation Loss: 27.170219\n"
+      "Epoch: 0 \tTraining Loss: 43.975669 \tValidation Loss: 38.347677\n",
+      "Validation loss decreased (inf --> 38.347677).  Saving model ...\n",
+      "Epoch: 1 \tTraining Loss: 34.997114 \tValidation Loss: 31.994015\n",
+      "Validation loss decreased (38.347677 --> 31.994015).  Saving model ...\n",
+      "Epoch: 2 \tTraining Loss: 31.149257 \tValidation Loss: 29.776703\n",
+      "Validation loss decreased (31.994015 --> 29.776703).  Saving model ...\n",
+      "Epoch: 3 \tTraining Loss: 28.815007 \tValidation Loss: 27.427899\n",
+      "Validation loss decreased (29.776703 --> 27.427899).  Saving model ...\n",
+      "Epoch: 4 \tTraining Loss: 27.052385 \tValidation Loss: 26.452557\n",
+      "Validation loss decreased (27.427899 --> 26.452557).  Saving model ...\n",
+      "Epoch: 5 \tTraining Loss: 25.561286 \tValidation Loss: 25.019063\n",
+      "Validation loss decreased (26.452557 --> 25.019063).  Saving model ...\n",
+      "Epoch: 6 \tTraining Loss: 24.222937 \tValidation Loss: 24.275458\n",
+      "Validation loss decreased (25.019063 --> 24.275458).  Saving model ...\n",
+      "Epoch: 7 \tTraining Loss: 23.071588 \tValidation Loss: 23.836704\n",
+      "Validation loss decreased (24.275458 --> 23.836704).  Saving model ...\n",
+      "Epoch: 8 \tTraining Loss: 22.091297 \tValidation Loss: 22.734067\n",
+      "Validation loss decreased (23.836704 --> 22.734067).  Saving model ...\n",
+      "Epoch: 9 \tTraining Loss: 21.208610 \tValidation Loss: 22.307053\n",
+      "Validation loss decreased (22.734067 --> 22.307053).  Saving model ...\n",
+      "Epoch: 10 \tTraining Loss: 20.421559 \tValidation Loss: 21.723610\n",
+      "Validation loss decreased (22.307053 --> 21.723610).  Saving model ...\n",
+      "Epoch: 11 \tTraining Loss: 19.685223 \tValidation Loss: 21.840338\n",
+      "Epoch: 12 \tTraining Loss: 19.035864 \tValidation Loss: 21.749165\n",
+      "Epoch: 13 \tTraining Loss: 18.402592 \tValidation Loss: 21.629479\n",
+      "Validation loss decreased (21.723610 --> 21.629479).  Saving model ...\n",
+      "Epoch: 14 \tTraining Loss: 17.791936 \tValidation Loss: 21.097066\n",
+      "Validation loss decreased (21.629479 --> 21.097066).  Saving model ...\n",
+      "Epoch: 15 \tTraining Loss: 17.219881 \tValidation Loss: 21.093654\n",
+      "Validation loss decreased (21.097066 --> 21.093654).  Saving model ...\n",
+      "Epoch: 16 \tTraining Loss: 16.631275 \tValidation Loss: 20.932878\n",
+      "Validation loss decreased (21.093654 --> 20.932878).  Saving model ...\n",
+      "Epoch: 17 \tTraining Loss: 16.143030 \tValidation Loss: 21.765923\n",
+      "Epoch: 18 \tTraining Loss: 15.585900 \tValidation Loss: 21.552932\n",
+      "Epoch: 19 \tTraining Loss: 15.082865 \tValidation Loss: 21.752597\n",
+      "Epoch: 20 \tTraining Loss: 14.584362 \tValidation Loss: 22.326752\n",
+      "Epoch: 21 \tTraining Loss: 14.197031 \tValidation Loss: 21.679743\n",
+      "Epoch: 22 \tTraining Loss: 13.676794 \tValidation Loss: 22.989129\n",
+      "Epoch: 23 \tTraining Loss: 13.237653 \tValidation Loss: 23.331841\n",
+      "Epoch: 24 \tTraining Loss: 12.802143 \tValidation Loss: 23.089242\n",
+      "Epoch: 25 \tTraining Loss: 12.411929 \tValidation Loss: 23.204556\n",
+      "Epoch: 26 \tTraining Loss: 11.942305 \tValidation Loss: 23.184003\n",
+      "Epoch: 27 \tTraining Loss: 11.593721 \tValidation Loss: 23.960704\n",
+      "Epoch: 28 \tTraining Loss: 11.164415 \tValidation Loss: 24.723535\n",
+      "Epoch: 29 \tTraining Loss: 10.773485 \tValidation Loss: 24.439442\n"
      ]
     }
    ],
@@ -530,36 +499,31 @@
    "metadata": {},
    "source": [
     "Yes, overfitting occurs.\n",
-    "- Training loss steadily decreases throughout the epochs, reaching very low values.\n",
-    "- Validation loss decreases initially but starts to increase after epoch 17 while the training loss continues to decrease, suggesting that the model is overfitting to the training data and not generalizing well to the validation data."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "086dc438",
-   "metadata": {},
-   "source": [
-    "To address this, I can implement early stopping.  \n",
-    "Given that the validation loss decreases until epoch 17, then rises again afterwards, it is clear that overfitting begins at this point.\n",
-    "So, i do an early stopping at 17 epochs."
+    "- The validation loss consistently decreases from epoch 0 to epoch 15, showing the model is learning and generalizing well initially.\n",
+    "- Starting from epoch 16, the validation loss begins to stagnate and fluctuate, with occasional improvements.\n",
+    "- From epoch 17 onward, validation loss increases steadily, indicating overfitting as the training loss continues to decrease.\n",
+    "\n",
+    "- The lowest validation loss is observed at epoch 15 (21.093654), after which performance starts to degrade.\n",
+    "- Overfitting Trend: The divergence between training and validation losses beyond epoch 15 indicates the model is overfitting the training data.\n",
+    "\n",
+    "- Do early stopping at epoch 16 to prevent overfitting and preserve the best model."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 7,
    "id": "d39df818",
    "metadata": {},
    "outputs": [
     {
-     "ename": "ModuleNotFoundError",
-     "evalue": "No module named 'matplotlib'",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
-      "Cell \u001b[0;32mIn[18], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mmatplotlib\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mpyplot\u001b[39;00m \u001b[39mas\u001b[39;00m \u001b[39mplt\u001b[39;00m\n\u001b[1;32m      3\u001b[0m plt\u001b[39m.\u001b[39mplot(\u001b[39mrange\u001b[39m(n_epochs), train_loss_list)\n\u001b[1;32m      4\u001b[0m plt\u001b[39m.\u001b[39mxlabel(\u001b[39m\"\u001b[39m\u001b[39mEpoch\u001b[39m\u001b[39m\"\u001b[39m)\n",
-      "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'matplotlib'"
-     ]
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
     }
    ],
    "source": [
@@ -582,7 +546,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 8,
    "id": "e93efdfc",
    "metadata": {},
    "outputs": [
@@ -590,20 +554,20 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Test Loss: 33.489301\n",
+      "Test Loss: 21.151382\n",
       "\n",
-      "Test Accuracy of airplane: 71% (714/1000)\n",
-      "Test Accuracy of automobile: 72% (727/1000)\n",
-      "Test Accuracy of  bird: 46% (464/1000)\n",
-      "Test Accuracy of   cat: 31% (312/1000)\n",
-      "Test Accuracy of  deer: 57% (571/1000)\n",
-      "Test Accuracy of   dog: 58% (584/1000)\n",
-      "Test Accuracy of  frog: 64% (641/1000)\n",
-      "Test Accuracy of horse: 69% (692/1000)\n",
-      "Test Accuracy of  ship: 61% (619/1000)\n",
-      "Test Accuracy of truck: 64% (645/1000)\n",
+      "Test Accuracy of airplane: 66% (666/1000)\n",
+      "Test Accuracy of automobile: 80% (803/1000)\n",
+      "Test Accuracy of  bird: 59% (599/1000)\n",
+      "Test Accuracy of   cat: 49% (491/1000)\n",
+      "Test Accuracy of  deer: 55% (550/1000)\n",
+      "Test Accuracy of   dog: 44% (443/1000)\n",
+      "Test Accuracy of  frog: 78% (784/1000)\n",
+      "Test Accuracy of horse: 63% (636/1000)\n",
+      "Test Accuracy of  ship: 77% (777/1000)\n",
+      "Test Accuracy of truck: 65% (659/1000)\n",
       "\n",
-      "Test Accuracy (Overall): 59% (5969/10000)\n"
+      "Test Accuracy (Overall): 64% (6408/10000)\n"
      ]
     }
    ],
@@ -687,6 +651,366 @@
     "Compare the results obtained with this new network to those obtained previously."
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "36f1add8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Net_2(\n",
+      "  (conv1): Conv2d(3, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\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",
+      "  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\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",
+      "  (dropout): Dropout(p=0.5, inplace=False)\n",
+      ")\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import torch.nn.functional as F\n",
+    "\n",
+    "# Define the CNN architecture\n",
+    "class Net_2(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(Net_2, self).__init__()\n",
+    "        \n",
+    "        # Convolutional layers with ReLU activations and MaxPooling\n",
+    "        self.conv1 = nn.Conv2d(3, 16, kernel_size=3, padding=1)  # Output: 16 channels\n",
+    "        self.conv2 = nn.Conv2d(16, 32, kernel_size=3, padding=1)  # Output: 32 channels\n",
+    "        self.conv3 = nn.Conv2d(32, 64, kernel_size=3, padding=1)  # Output: 64 channels\n",
+    "        \n",
+    "        # MaxPool layer\n",
+    "        self.pool = nn.MaxPool2d(2, 2)\n",
+    "        \n",
+    "        # Fully connected layers\n",
+    "        self.fc1 = nn.Linear(64 * 4 * 4, 512)  # Input size based on image dimensions\n",
+    "        self.fc2 = nn.Linear(512, 64)\n",
+    "        self.fc3 = nn.Linear(64, 10)  # Assuming 10 classes for the output\n",
+    "        \n",
+    "        # Dropout layers\n",
+    "        self.dropout = nn.Dropout(0.5)  # Dropout with probability of 0.5\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        # Pass through convolutional layers with ReLU activations and MaxPooling\n",
+    "        x = self.pool(F.relu(self.conv1(x)))  # After conv1: 16 channels\n",
+    "        x = self.pool(F.relu(self.conv2(x)))  # After conv2: 32 channels\n",
+    "        x = self.pool(F.relu(self.conv3(x)))  # After conv3: 64 channels\n",
+    "        \n",
+    "        # Flatten the output of the last convolutional layer\n",
+    "        x = x.view(-1, 64 * 4 * 4)  \n",
+    "        \n",
+    "        # Fully connected layers with ReLU and Dropout\n",
+    "        x = F.relu(self.fc1(x))\n",
+    "        x = self.dropout(x)  # Apply dropout after first fully connected layer\n",
+    "        x = F.relu(self.fc2(x))\n",
+    "        x = self.dropout(x)  # Apply dropout after second fully connected layer\n",
+    "        \n",
+    "        # Final output layer\n",
+    "        x = self.fc3(x)\n",
+    "        \n",
+    "        return x\n",
+    "\n",
+    "\n",
+    "# Create the model\n",
+    "model_2 = Net_2()\n",
+    "print(model_2)\n",
+    "\n",
+    "# Move model to GPU if available\n",
+    "train_on_gpu = torch.cuda.is_available()\n",
+    "if train_on_gpu:\n",
+    "    model.cuda()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "267479fb",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch: 0 \tTraining Loss: 45.389846 \tValidation Loss: 41.777527\n",
+      "Validation loss decreased (inf --> 41.777527).  Saving model ...\n",
+      "Epoch: 1 \tTraining Loss: 39.424652 \tValidation Loss: 35.060819\n",
+      "Validation loss decreased (41.777527 --> 35.060819).  Saving model ...\n",
+      "Epoch: 2 \tTraining Loss: 35.046248 \tValidation Loss: 32.135539\n",
+      "Validation loss decreased (35.060819 --> 32.135539).  Saving model ...\n",
+      "Epoch: 3 \tTraining Loss: 32.571120 \tValidation Loss: 29.923746\n",
+      "Validation loss decreased (32.135539 --> 29.923746).  Saving model ...\n",
+      "Epoch: 4 \tTraining Loss: 30.437492 \tValidation Loss: 27.588401\n",
+      "Validation loss decreased (29.923746 --> 27.588401).  Saving model ...\n",
+      "Epoch: 5 \tTraining Loss: 28.696167 \tValidation Loss: 26.766404\n",
+      "Validation loss decreased (27.588401 --> 26.766404).  Saving model ...\n",
+      "Epoch: 6 \tTraining Loss: 27.121808 \tValidation Loss: 24.613978\n",
+      "Validation loss decreased (26.766404 --> 24.613978).  Saving model ...\n",
+      "Epoch: 7 \tTraining Loss: 25.725125 \tValidation Loss: 23.538336\n",
+      "Validation loss decreased (24.613978 --> 23.538336).  Saving model ...\n",
+      "Epoch: 8 \tTraining Loss: 24.334904 \tValidation Loss: 21.935171\n",
+      "Validation loss decreased (23.538336 --> 21.935171).  Saving model ...\n",
+      "Epoch: 9 \tTraining Loss: 23.203895 \tValidation Loss: 22.022023\n",
+      "Epoch: 10 \tTraining Loss: 22.118146 \tValidation Loss: 19.978609\n",
+      "Validation loss decreased (21.935171 --> 19.978609).  Saving model ...\n",
+      "Epoch: 11 \tTraining Loss: 21.068114 \tValidation Loss: 19.735263\n",
+      "Validation loss decreased (19.978609 --> 19.735263).  Saving model ...\n",
+      "Epoch: 12 \tTraining Loss: 20.225011 \tValidation Loss: 19.091033\n",
+      "Validation loss decreased (19.735263 --> 19.091033).  Saving model ...\n",
+      "Epoch: 13 \tTraining Loss: 19.421816 \tValidation Loss: 18.326990\n",
+      "Validation loss decreased (19.091033 --> 18.326990).  Saving model ...\n",
+      "Epoch: 14 \tTraining Loss: 18.541730 \tValidation Loss: 17.414942\n",
+      "Validation loss decreased (18.326990 --> 17.414942).  Saving model ...\n",
+      "Epoch: 15 \tTraining Loss: 17.814699 \tValidation Loss: 17.238110\n",
+      "Validation loss decreased (17.414942 --> 17.238110).  Saving model ...\n",
+      "Epoch: 16 \tTraining Loss: 16.933247 \tValidation Loss: 16.829644\n",
+      "Validation loss decreased (17.238110 --> 16.829644).  Saving model ...\n",
+      "Epoch: 17 \tTraining Loss: 16.389078 \tValidation Loss: 16.914702\n",
+      "Epoch: 18 \tTraining Loss: 15.726570 \tValidation Loss: 16.755409\n",
+      "Validation loss decreased (16.829644 --> 16.755409).  Saving model ...\n",
+      "Epoch: 19 \tTraining Loss: 15.119167 \tValidation Loss: 16.418999\n",
+      "Validation loss decreased (16.755409 --> 16.418999).  Saving model ...\n",
+      "Epoch: 20 \tTraining Loss: 14.478328 \tValidation Loss: 15.640075\n",
+      "Validation loss decreased (16.418999 --> 15.640075).  Saving model ...\n",
+      "Epoch: 21 \tTraining Loss: 13.877445 \tValidation Loss: 16.125324\n",
+      "Epoch: 22 \tTraining Loss: 13.347822 \tValidation Loss: 16.349312\n",
+      "Epoch: 23 \tTraining Loss: 12.772845 \tValidation Loss: 16.131425\n",
+      "Epoch: 24 \tTraining Loss: 12.325509 \tValidation Loss: 15.288487\n",
+      "Validation loss decreased (15.640075 --> 15.288487).  Saving model ...\n",
+      "Epoch: 25 \tTraining Loss: 11.783999 \tValidation Loss: 15.305513\n",
+      "Epoch: 26 \tTraining Loss: 11.342386 \tValidation Loss: 15.720134\n",
+      "Epoch: 27 \tTraining Loss: 10.812438 \tValidation Loss: 17.583329\n",
+      "Epoch: 28 \tTraining Loss: 10.439049 \tValidation Loss: 16.388209\n",
+      "Epoch: 29 \tTraining Loss: 9.974275 \tValidation Loss: 16.448369\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch.optim as optim\n",
+    "\n",
+    "criterion = nn.CrossEntropyLoss()  # specify loss function\n",
+    "optimizer = optim.SGD(model_2.parameters(), lr=0.01)  # specify optimizer\n",
+    "\n",
+    "n_epochs_2 = 30  # number of epochs to train the model\n",
+    "train_loss_list_2 = []  # list to store loss to visualize\n",
+    "valid_loss_min_2 = np.Inf  # track change in validation loss\n",
+    "\n",
+    "for epoch in range(n_epochs_2):\n",
+    "    # Keep track of training and validation loss\n",
+    "    train_loss = 0.0\n",
+    "    valid_loss = 0.0\n",
+    "\n",
+    "    # Train the model\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",
+    "            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 = 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",
+    "        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",
+    "    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_2(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_2.append(train_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_2:\n",
+    "        print(\n",
+    "            \"Validation loss decreased ({:.6f} --> {:.6f}).  Saving model ...\".format(\n",
+    "                valid_loss_min_2, valid_loss\n",
+    "            )\n",
+    "        )\n",
+    "        torch.save(model_2.state_dict(), \"model_cifar_2.pt\")\n",
+    "        valid_loss_min_2 = valid_loss"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bca17d68",
+   "metadata": {},
+   "source": [
+    "- Model 2 starts with relatively high validation losses but steadily decreases, achieving better performance in terms of validation loss. The best validation loss of 15.28 is obtained at epoch 24, but as with Model 1, validation loss becomes more unstable from epoch 24 onwards. Training loss continues to decrease with each epoch.\n",
+    "- Model 2 showed a stable decrease in validation loss, achieving better performance than Model 1 in the early epochs (at least up to epoch 24). However, from epoch 24 onwards, validation loss also became more volatile, which could be a sign of long-term overfitting.\n",
+    "- Model 2 seems to work better for the first 24 epochs, with a lower and more stable loss of validation than the Model 1."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "18dcef12",
+   "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(n_epochs_2), train_loss_list_2)\n",
+    "plt.xlabel(\"Epoch\")\n",
+    "plt.ylabel(\"Loss\")\n",
+    "plt.title(\"Performance of Model 2\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "489f9382",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Test Loss: 15.510981\n",
+      "\n",
+      "Test Accuracy of airplane: 82% (820/1000)\n",
+      "Test Accuracy of automobile: 80% (803/1000)\n",
+      "Test Accuracy of  bird: 64% (641/1000)\n",
+      "Test Accuracy of   cat: 48% (480/1000)\n",
+      "Test Accuracy of  deer: 70% (701/1000)\n",
+      "Test Accuracy of   dog: 66% (667/1000)\n",
+      "Test Accuracy of  frog: 77% (776/1000)\n",
+      "Test Accuracy of horse: 80% (804/1000)\n",
+      "Test Accuracy of  ship: 86% (860/1000)\n",
+      "Test Accuracy of truck: 80% (808/1000)\n",
+      "\n",
+      "Test Accuracy (Overall): 73% (7360/10000)\n"
+     ]
+    }
+   ],
+   "source": [
+    "model_2.load_state_dict(torch.load(\"./model_cifar_2.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_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_2(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_correct[label] += correct[i].item()\n",
+    "        class_total[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_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",
+    "    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_correct) / np.sum(class_total),\n",
+    "        np.sum(class_correct),\n",
+    "        np.sum(class_total),\n",
+    "    )\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d4b037a0",
+   "metadata": {},
+   "source": [
+    "- Test loss (Loss):\n",
+    "\n",
+    "Model 2 has a significantly lower test loss (15.51) compared with Model 1 (21.15). This suggests that Model 2 is better at generalizing to test data.\n",
+    "\n",
+    "- Overall accuracy:\n",
+    "\n",
+    "Model 2 has a better overall accuracy of 73% versus 64% for Model 1. This shows that Model 2 is better at classifying the test data.\n",
+    "\n",
+    "Model 2 excels particularly in classes such as Airplane (82%) , Ship (86%), Horse (80%), and Truck (80%). It also has better accuracy than the Model 1 in all classes. \n",
+    "\n",
+    "- Conclusion : \n",
+    "\n",
+    "Model 2 outperforms Model 1 in terms of overall accuracy and test loss. It is better at classifying a wider range of classes, and has better generalization capability on test data."
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "bc381cf4",
@@ -1179,7 +1503,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3.11.3 64-bit",
+   "display_name": "Python 3.11.1 64-bit",
    "language": "python",
    "name": "python3"
   },
@@ -1193,11 +1517,11 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.3"
+   "version": "3.11.1"
   },
   "vscode": {
    "interpreter": {
-    "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
+    "hash": "20e40d8fc09a6690434ad602c7eb2d8de15d36ec466bfbfb0de97c7c540d7363"
    }
   }
  },