diff --git a/README.md b/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..ac4ecb45f38e383a70fd30b196e32692f4bf140f
--- /dev/null
+++ b/README.md
@@ -0,0 +1,26 @@
+# Image classification - Zhengfei ZHANG
+
+This project consists of my solution for the image classification assignment.
+
+If you need to run the code, I suggest you doing it first (see [Usage](#usage)), then read the rest of this file for details and explanations while the program is running, as it is rather time consuming.
+
+## Table of Contents
+
+- [Prerequisites](#prerequisites)
+- [Description](#description)
+- [Usage](#usage)
+
+## Prerequisites
+
+All of the work has been performed under Python 3.12.2.
+
+The libraries and the version used are as follows:
+
+- matplotlib 3.9.2
+- numpy 2.0.2
+- PyTorch 2.5.1
+- Torchvision 0.20.1
+
+## Description
+
+The goal of the project is to do image classification on the CIFAR-10 dataset using deep learning methods.
\ No newline at end of file
diff --git a/TD2 Deep Learning.ipynb b/TD2 Deep Learning.ipynb
index 823668092f4cc7a8defc6d243f8ba99e29857cc7..980840a0f506d82c3aafcccd30335372203856d6 100644
--- a/TD2 Deep Learning.ipynb	
+++ b/TD2 Deep Learning.ipynb	
@@ -214,10 +214,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 17,
    "id": "462666a2",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Files already downloaded and verified\n",
+      "Files already downloaded and verified\n"
+     ]
+    }
+   ],
    "source": [
     "import numpy as np\n",
     "from torchvision import datasets, transforms\n",
@@ -286,10 +295,28 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 24,
    "id": "317bf070",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "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",
+       ")"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "import torch.nn as nn\n",
     "import torch.nn.functional as F\n",
@@ -319,10 +346,9 @@
     "\n",
     "# create a complete CNN\n",
     "model = Net()\n",
-    "print(model)\n",
-    "# move tensors to GPU if CUDA is available\n",
-    "if train_on_gpu:\n",
-    "    model.cuda()"
+    "# print(model)\n",
+    "# move tensors to the chosen device\n",
+    "model.to(device)"
    ]
   },
   {
@@ -338,7 +364,57 @@
    "execution_count": null,
    "id": "4b53f229",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch: 0 \tTraining Loss: 44.473933 \tValidation Loss: 39.620629\n",
+      "Validation loss decreased (inf --> 39.620629).  Saving model ...\n",
+      "Epoch: 1 \tTraining Loss: 35.544782 \tValidation Loss: 32.533757\n",
+      "Validation loss decreased (39.620629 --> 32.533757).  Saving model ...\n",
+      "Epoch: 2 \tTraining Loss: 30.859100 \tValidation Loss: 29.284232\n",
+      "Validation loss decreased (32.533757 --> 29.284232).  Saving model ...\n",
+      "Epoch: 3 \tTraining Loss: 28.244149 \tValidation Loss: 28.139195\n",
+      "Validation loss decreased (29.284232 --> 28.139195).  Saving model ...\n",
+      "Epoch: 4 \tTraining Loss: 26.283759 \tValidation Loss: 25.799773\n",
+      "Validation loss decreased (28.139195 --> 25.799773).  Saving model ...\n",
+      "Epoch: 5 \tTraining Loss: 24.848492 \tValidation Loss: 24.929654\n",
+      "Validation loss decreased (25.799773 --> 24.929654).  Saving model ...\n",
+      "Epoch: 6 \tTraining Loss: 23.681632 \tValidation Loss: 23.586609\n",
+      "Validation loss decreased (24.929654 --> 23.586609).  Saving model ...\n",
+      "Epoch: 7 \tTraining Loss: 22.641888 \tValidation Loss: 23.032703\n",
+      "Validation loss decreased (23.586609 --> 23.032703).  Saving model ...\n",
+      "Epoch: 8 \tTraining Loss: 21.752826 \tValidation Loss: 22.664754\n",
+      "Validation loss decreased (23.032703 --> 22.664754).  Saving model ...\n",
+      "Epoch: 9 \tTraining Loss: 20.981409 \tValidation Loss: 22.301936\n",
+      "Validation loss decreased (22.664754 --> 22.301936).  Saving model ...\n",
+      "Epoch: 10 \tTraining Loss: 20.292528 \tValidation Loss: 22.741102\n",
+      "Epoch: 11 \tTraining Loss: 19.607159 \tValidation Loss: 21.533517\n",
+      "Validation loss decreased (22.301936 --> 21.533517).  Saving model ...\n",
+      "Epoch: 12 \tTraining Loss: 18.932060 \tValidation Loss: 21.467511\n",
+      "Validation loss decreased (21.533517 --> 21.467511).  Saving model ...\n",
+      "Epoch: 13 \tTraining Loss: 18.342876 \tValidation Loss: 21.668419\n",
+      "Epoch: 14 \tTraining Loss: 17.725712 \tValidation Loss: 21.420723\n",
+      "Validation loss decreased (21.467511 --> 21.420723).  Saving model ...\n",
+      "Epoch: 15 \tTraining Loss: 17.228202 \tValidation Loss: 21.657052\n",
+      "Epoch: 16 \tTraining Loss: 16.635705 \tValidation Loss: 22.080738\n",
+      "Epoch: 17 \tTraining Loss: 16.082365 \tValidation Loss: 21.646796\n",
+      "Epoch: 18 \tTraining Loss: 15.567858 \tValidation Loss: 22.053860\n",
+      "Epoch: 19 \tTraining Loss: 15.077309 \tValidation Loss: 22.270342\n",
+      "Epoch: 20 \tTraining Loss: 14.603599 \tValidation Loss: 22.214336\n",
+      "Epoch: 21 \tTraining Loss: 14.093810 \tValidation Loss: 22.724239\n",
+      "Epoch: 22 \tTraining Loss: 13.643105 \tValidation Loss: 22.612203\n",
+      "Epoch: 23 \tTraining Loss: 13.193473 \tValidation Loss: 23.833128\n",
+      "Epoch: 24 \tTraining Loss: 12.774464 \tValidation Loss: 24.365881\n",
+      "Epoch: 25 \tTraining Loss: 12.335211 \tValidation Loss: 24.674567\n",
+      "Epoch: 26 \tTraining Loss: 11.861359 \tValidation Loss: 24.542632\n",
+      "Epoch: 27 \tTraining Loss: 11.523480 \tValidation Loss: 25.236285\n",
+      "Epoch: 28 \tTraining Loss: 11.013934 \tValidation Loss: 26.543926\n",
+      "Epoch: 29 \tTraining Loss: 10.694415 \tValidation Loss: 26.362344\n"
+     ]
+    }
+   ],
    "source": [
     "import torch.optim as optim\n",
     "\n",
@@ -347,7 +423,9 @@
     "\n",
     "n_epochs = 30  # number of epochs to train the model\n",
     "train_loss_list = []  # list to store loss to visualize\n",
-    "valid_loss_min = np.Inf  # track change in validation loss\n",
+    "valid_loss_min = np.inf  # track change in validation loss\n",
+    "\n",
+    "patience = 3 # For early stopping\n",
     "\n",
     "for epoch in range(n_epochs):\n",
     "    # Keep track of training and validation loss\n",
@@ -357,9 +435,8 @@
     "    # Train the model\n",
     "    model.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",
+    "        # Move tensors to the chosen device\n",
+    "        data, target = data.to(device), target.to(device)\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",
@@ -377,8 +454,7 @@
     "    model.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",
+    "        data, target = data.to(device), target.to(device)\n",
     "        # Forward pass: compute predicted outputs by passing inputs to the model\n",
     "        output = model(data)\n",
     "        # Calculate the batch loss\n",
@@ -400,13 +476,19 @@
     "\n",
     "    # Save model if validation loss has decreased\n",
     "    if valid_loss <= valid_loss_min:\n",
+    "        counter = 0\n",
     "        print(\n",
     "            \"Validation loss decreased ({:.6f} --> {:.6f}).  Saving model ...\".format(\n",
     "                valid_loss_min, valid_loss\n",
     "            )\n",
     "        )\n",
     "        torch.save(model.state_dict(), \"model_cifar.pt\")\n",
-    "        valid_loss_min = valid_loss"
+    "        valid_loss_min = valid_loss\n",
+    "    else:\n",
+    "        counter += 1\n",
+    "        if counter >= patience:\n",
+    "            print(\"Stopped early\")\n",
+    "            break"
    ]
   },
   {
@@ -417,12 +499,31 @@
     "Does overfit occur? If so, do an early stopping."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "39893a6c",
+   "metadata": {},
+   "source": [
+    "Answer: Overfit did occur. I implemented early stopping in the code above, with patience of 3."
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 28,
    "id": "d39df818",
    "metadata": {},
-   "outputs": [],
+   "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",
@@ -443,12 +544,33 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 31,
    "id": "e93efdfc",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Test Loss: 21.418785\n",
+      "\n",
+      "Test Accuracy of airplane: 67% (677/1000)\n",
+      "Test Accuracy of automobile: 77% (770/1000)\n",
+      "Test Accuracy of  bird: 50% (503/1000)\n",
+      "Test Accuracy of   cat: 35% (354/1000)\n",
+      "Test Accuracy of  deer: 62% (623/1000)\n",
+      "Test Accuracy of   dog: 52% (525/1000)\n",
+      "Test Accuracy of  frog: 69% (696/1000)\n",
+      "Test Accuracy of horse: 68% (686/1000)\n",
+      "Test Accuracy of  ship: 80% (803/1000)\n",
+      "Test Accuracy of truck: 69% (698/1000)\n",
+      "\n",
+      "Test Accuracy (Overall): 63% (6335/10000)\n"
+     ]
+    }
+   ],
    "source": [
-    "model.load_state_dict(torch.load(\"./model_cifar.pt\"))\n",
+    "model.load_state_dict(torch.load(\"./model_cifar.pt\", weights_only=True))\n",
     "\n",
     "# track test loss\n",
     "test_loss = 0.0\n",
@@ -458,9 +580,8 @@
     "model.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",
+    "    # move tensors to the selected device\n",
+    "    data, target = data.to(device), target.to(device)\n",
     "    # forward pass: compute predicted outputs by passing inputs to the model\n",
     "    output = model(data)\n",
     "    # calculate the batch loss\n",
@@ -472,9 +593,9 @@
     "    # 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",
+    "        np.squeeze(correct_tensor.cpu().numpy())  # Move to CPU for NumPy operations\n",
+    "        if device.type != \"cpu\"  # if the device isn't CPU already\n",
+    "        else np.squeeze(correct_tensor.numpy())\n",
     "    )\n",
     "    # calculate test accuracy for each object class\n",
     "    for i in range(batch_size):\n",
@@ -527,6 +648,332 @@
     "Compare the results obtained with this new network to those obtained previously."
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "id": "28da770d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "NewNet(\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.3, inplace=False)\n",
+       ")"
+      ]
+     },
+     "execution_count": 33,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import torch.nn as nn\n",
+    "import torch.nn.functional as F\n",
+    "\n",
+    "class NewNet(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(NewNet, self).__init__()\n",
+    "        # Convolutional layers\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",
+    "        # Max pooling layer\n",
+    "        self.pool = nn.MaxPool2d(kernel_size=2)\n",
+    "\n",
+    "        # Fully connected layers\n",
+    "        self.fc1 = nn.Linear(64 * 4 * 4, 512)  # Assuming input image size is 32x32\n",
+    "        self.fc2 = nn.Linear(512, 64)\n",
+    "        self.fc3 = nn.Linear(64, 10)  # 10 output classes for CIFAR-10\n",
+    "\n",
+    "        # Dropout\n",
+    "        self.dropout = nn.Dropout(0.3) \n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        # Convolutional layers with ReLU and MaxPool\n",
+    "        x = self.pool(F.relu(self.conv1(x)))  # Conv1 -> ReLU -> MaxPool\n",
+    "        x = self.pool(F.relu(self.conv2(x)))  # Conv2 -> ReLU -> MaxPool\n",
+    "        x = self.pool(F.relu(self.conv3(x)))  # Conv3 -> ReLU -> MaxPool\n",
+    "\n",
+    "        # Flatten the tensor for fully connected layers\n",
+    "        x = x.view(-1, 64 * 4 * 4)  # 64 channels, each 4x4 (after 3 pooling layers)\n",
+    "\n",
+    "        # Fully connected layers with ReLU and Dropout\n",
+    "        x = F.relu(self.fc1(x))  # FC1 -> ReLU\n",
+    "        x = self.dropout(x)      # Apply Dropout\n",
+    "        x = F.relu(self.fc2(x))  # FC2 -> ReLU\n",
+    "        x = self.dropout(x)      # Apply Dropout\n",
+    "        x = self.fc3(x)          # FC3 (output layer, no activation)\n",
+    "\n",
+    "        return x\n",
+    "\n",
+    "# Instantiate the model and move it to the chosen device\n",
+    "new_model = NewNet()\n",
+    "new_model.to(device)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "id": "210b2852",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch: 0 \tTraining Loss: 44.427319 \tValidation Loss: 40.379719\n",
+      "Validation loss decreased (inf --> 40.379719).  Saving model ...\n",
+      "Epoch: 1 \tTraining Loss: 38.668627 \tValidation Loss: 35.563413\n",
+      "Validation loss decreased (40.379719 --> 35.563413).  Saving model ...\n",
+      "Epoch: 2 \tTraining Loss: 34.096305 \tValidation Loss: 31.245042\n",
+      "Validation loss decreased (35.563413 --> 31.245042).  Saving model ...\n",
+      "Epoch: 3 \tTraining Loss: 31.116184 \tValidation Loss: 29.127113\n",
+      "Validation loss decreased (31.245042 --> 29.127113).  Saving model ...\n",
+      "Epoch: 4 \tTraining Loss: 28.863355 \tValidation Loss: 27.261098\n",
+      "Validation loss decreased (29.127113 --> 27.261098).  Saving model ...\n",
+      "Epoch: 5 \tTraining Loss: 26.840526 \tValidation Loss: 24.582053\n",
+      "Validation loss decreased (27.261098 --> 24.582053).  Saving model ...\n",
+      "Epoch: 6 \tTraining Loss: 25.091524 \tValidation Loss: 23.448411\n",
+      "Validation loss decreased (24.582053 --> 23.448411).  Saving model ...\n",
+      "Epoch: 7 \tTraining Loss: 23.575481 \tValidation Loss: 22.002271\n",
+      "Validation loss decreased (23.448411 --> 22.002271).  Saving model ...\n",
+      "Epoch: 8 \tTraining Loss: 22.132604 \tValidation Loss: 21.072783\n",
+      "Validation loss decreased (22.002271 --> 21.072783).  Saving model ...\n",
+      "Epoch: 9 \tTraining Loss: 20.872915 \tValidation Loss: 19.869785\n",
+      "Validation loss decreased (21.072783 --> 19.869785).  Saving model ...\n",
+      "Epoch: 10 \tTraining Loss: 19.703448 \tValidation Loss: 18.738881\n",
+      "Validation loss decreased (19.869785 --> 18.738881).  Saving model ...\n",
+      "Epoch: 11 \tTraining Loss: 18.590030 \tValidation Loss: 17.896260\n",
+      "Validation loss decreased (18.738881 --> 17.896260).  Saving model ...\n",
+      "Epoch: 12 \tTraining Loss: 17.555201 \tValidation Loss: 17.599109\n",
+      "Validation loss decreased (17.896260 --> 17.599109).  Saving model ...\n",
+      "Epoch: 13 \tTraining Loss: 16.532635 \tValidation Loss: 17.089988\n",
+      "Validation loss decreased (17.599109 --> 17.089988).  Saving model ...\n",
+      "Epoch: 14 \tTraining Loss: 15.708936 \tValidation Loss: 16.946565\n",
+      "Validation loss decreased (17.089988 --> 16.946565).  Saving model ...\n",
+      "Epoch: 15 \tTraining Loss: 14.713673 \tValidation Loss: 16.396082\n",
+      "Validation loss decreased (16.946565 --> 16.396082).  Saving model ...\n",
+      "Epoch: 16 \tTraining Loss: 13.923363 \tValidation Loss: 16.574588\n",
+      "Epoch: 17 \tTraining Loss: 13.109490 \tValidation Loss: 16.013181\n",
+      "Validation loss decreased (16.396082 --> 16.013181).  Saving model ...\n",
+      "Epoch: 18 \tTraining Loss: 12.363001 \tValidation Loss: 15.954380\n",
+      "Validation loss decreased (16.013181 --> 15.954380).  Saving model ...\n",
+      "Epoch: 19 \tTraining Loss: 11.658812 \tValidation Loss: 16.106396\n",
+      "Epoch: 20 \tTraining Loss: 10.857707 \tValidation Loss: 16.401605\n",
+      "Epoch: 21 \tTraining Loss: 10.176664 \tValidation Loss: 16.437715\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch.optim as optim\n",
+    "\n",
+    "criterion = nn.CrossEntropyLoss()  # specify loss function\n",
+    "optimizer = optim.SGD(new_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",
+    "valid_loss_min = np.inf  # track change in validation loss\n",
+    "\n",
+    "patience = 3 # For early stopping\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",
+    "    new_model.train()\n",
+    "    for data, target in train_loader:\n",
+    "        # Move tensors to the chosen device\n",
+    "        data, target = data.to(device), target.to(device)\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 = new_model(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",
+    "    new_model.eval()\n",
+    "    for data, target in valid_loader:\n",
+    "        # Move tensors to GPU if CUDA is available\n",
+    "        data, target = data.to(device), target.to(device)\n",
+    "        # Forward pass: compute predicted outputs by passing inputs to the model\n",
+    "        output = new_model(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",
+    "\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",
+    "        counter = 0\n",
+    "        print(\n",
+    "            \"Validation loss decreased ({:.6f} --> {:.6f}).  Saving model ...\".format(\n",
+    "                valid_loss_min, valid_loss\n",
+    "            )\n",
+    "        )\n",
+    "        torch.save(new_model.state_dict(), \"new_model_cifar.pt\")\n",
+    "        valid_loss_min = valid_loss\n",
+    "    else:\n",
+    "        counter += 1\n",
+    "        if counter >= patience:\n",
+    "            print(\"Stopped early\")\n",
+    "            break"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "id": "557508e9",
+   "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(train_loss_list)\n",
+    "plt.xlabel(\"Epoch\")\n",
+    "plt.ylabel(\"Loss\")\n",
+    "plt.title(\"Performance of Model 2\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "id": "9f0a4c3f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Test Loss: 16.079455\n",
+      "\n",
+      "Test Accuracy of airplane: 79% (793/1000)\n",
+      "Test Accuracy of automobile: 80% (800/1000)\n",
+      "Test Accuracy of  bird: 60% (601/1000)\n",
+      "Test Accuracy of   cat: 53% (530/1000)\n",
+      "Test Accuracy of  deer: 59% (591/1000)\n",
+      "Test Accuracy of   dog: 61% (619/1000)\n",
+      "Test Accuracy of  frog: 85% (851/1000)\n",
+      "Test Accuracy of horse: 78% (783/1000)\n",
+      "Test Accuracy of  ship: 85% (855/1000)\n",
+      "Test Accuracy of truck: 85% (854/1000)\n",
+      "\n",
+      "Test Accuracy (Overall): 72% (7277/10000)\n"
+     ]
+    }
+   ],
+   "source": [
+    "new_model.load_state_dict(torch.load(\"./new_model_cifar.pt\", weights_only=True))\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",
+    "new_model.eval()\n",
+    "# iterate over test data\n",
+    "for data, target in test_loader:\n",
+    "    # move tensors to the selected device\n",
+    "    data, target = data.to(device), target.to(device)\n",
+    "    # forward pass: compute predicted outputs by passing inputs to the model\n",
+    "    output = new_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",
+    "    # 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.cpu().numpy())  # Move to CPU for NumPy operations\n",
+    "        if device.type != \"cpu\"  # if the device isn't CPU already\n",
+    "        else np.squeeze(correct_tensor.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": "c8c554a3",
+   "metadata": {},
+   "source": [
+    "Both training and validation loss have been lower for the 2nd model.\n",
+    "Test accuracy is 10% higher."
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "bc381cf4",