vehicle-classification/notebooks/Final-Submission.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "21b10b99",
   "metadata": {},
   "source": [
    "# Task 1: Load Dataset\n",
    "Load images from disk and count per class to verify dataset integrity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d318d1f0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Van: 1111 images\n",
      "Taxi: 748 images\n",
      "Bicycle: 1618 images\n",
      "Bus: 2133 images\n",
      "Car: 6781 images\n",
      "Motorcycle: 2986 images\n",
      "Truck: 2033 images\n",
      "NonVehicles: 8968 images\n",
      "Total Count: 26378 images\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "data_dir = '../data/raw/vehicle_classification'\n",
    "\n",
    "total_count = 0\n",
    "\n",
    "for class_name in os.listdir(data_dir):\n",
    "    class_path = os.path.join(data_dir, class_name)\n",
    "    if os.path.isdir(class_path):\n",
    "        count = len(os.listdir(class_path))\n",
    "        total_count += count\n",
    "        print(f\"{class_name}: {count} images\")\n",
    "\n",
    "print(f\"Total Count: {total_count} images\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64122ad4",
   "metadata": {},
   "source": [
    "Check out sample image from dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "5604ace3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Size: (64, 64)\n",
      "Mode: RGB\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from PIL import Image\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# first image in first folder\n",
    "first_class = os.listdir(data_dir)[0]\n",
    "first_image_path = os.path.join(data_dir, first_class, os.listdir(os.path.join(data_dir, first_class))[0])\n",
    "\n",
    "img = Image.open(first_image_path)\n",
    "print(f\"Size: {img.size}\")\n",
    "print(f\"Mode: {img.mode}\")\n",
    "plt.imshow(img)\n",
    "plt.title(first_class)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c19ec00a",
   "metadata": {},
   "source": [
    "Ensure that all images are RGB, all of same resolution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "3cedd586",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unique sizes: {(64, 64)}\n",
      "Unique modes: {'RGB'}\n"
     ]
    }
   ],
   "source": [
    "sizes = set()\n",
    "modes = set()\n",
    "\n",
    "for class_name in os.listdir(data_dir):\n",
    "    class_path = os.path.join(data_dir, class_name)\n",
    "    if not os.path.isdir(class_path):\n",
    "        continue\n",
    "    for img_name in os.listdir(class_path):\n",
    "        img = Image.open(os.path.join(class_path, img_name))\n",
    "        sizes.add(img.size)\n",
    "        modes.add(img.mode)\n",
    "\n",
    "print(f\"Unique sizes: {sizes}\")\n",
    "print(f\"Unique modes: {modes}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88ac961b",
   "metadata": {},
   "source": [
    "Accelrate torch with GPU or MPS if available (credit: Claude)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "8f556b22",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GPU: NVIDIA GeForce RTX 5080\n",
      "Running on: cuda\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "\n",
    "if torch.cuda.is_available():\n",
    "    DEVICE = torch.device('cuda')\n",
    "    print(f'GPU: {torch.cuda.get_device_name(0)}')\n",
    "elif torch.backends.mps.is_available():\n",
    "    DEVICE = torch.device('mps')\n",
    "    print('Apple Silicon (MPS)')\n",
    "else:\n",
    "    DEVICE = torch.device('cpu')\n",
    "    print('CPU')\n",
    "\n",
    "print(f'Running on: {DEVICE}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ad97919",
   "metadata": {},
   "source": [
    "# Task 2: Split Dataset 80:20 (Train / Test)\n",
    "\n",
    "Augmentation applied to training set only — test set kept clean for fair evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f68c1a25",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train: 21102, Test: 5276\n"
     ]
    }
   ],
   "source": [
    "import math \n",
    "from torchvision import datasets, transforms\n",
    "from torch.utils.data import random_split, DataLoader\n",
    "\n",
    "\n",
    "train_transform = transforms.Compose([\n",
    "    transforms.Resize((64, 64)), # Resize to 64x64 (even though all images are)\n",
    "    transforms.RandomHorizontalFlip(), # randomly mirror image\n",
    "    transforms.RandomRotation(20), # rotate up to 20 degrees\n",
    "    transforms.ColorJitter(brightness=0.3, contrast=0.3), # vary lighting\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) # Normalize tensors as in Pytorch tutorial\n",
    "])\n",
    "\n",
    "test_transform = transforms.Compose([\n",
    "    transforms.Resize((64,64)), # Resize to 64x64 (even though all images are)\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])  # Normalize tensors as in Pytorch tutorial\n",
    "])\n",
    "\n",
    "train_full = datasets.ImageFolder(root=data_dir, transform=train_transform) #Load full dataset with train transform\n",
    "test_full = datasets.ImageFolder(root=data_dir, transform=test_transform) # Load full dataset with test transform\n",
    "\n",
    "train_size = math.floor(len(train_full) * 0.8) #80% split for training\n",
    "test_size = len(train_full) - train_size # Remaining 20% used for testing\n",
    "\n",
    "torch.manual_seed(42) # Fixes the RNG to the same starting point...42 is convention according to GeeksForGeeks\n",
    "indices = torch.randperm(len(train_full)).tolist() #randomly shuffle the indices\n",
    "\n",
    "train_indices = indices[:train_size] # First 80% of indices\n",
    "test_indices = indices[train_size:] # remaining 20% of indices\n",
    "\n",
    "train_dataset = torch.utils.data.Subset(train_full, train_indices) #Create final datasets\n",
    "test_dataset = torch.utils.data.Subset(test_full, test_indices)\n",
    "\n",
    "print(f\"Train: {len(train_dataset)}, Test: {len(test_dataset)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2eede814",
   "metadata": {},
   "source": [
    "Credit: Claude: load dataset into batches (64 is standard), and dedicate n threads to the process (min 1, preferrably 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "e1539eaa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "['Bicycle', 'Bus', 'Car', 'Motorcycle', 'NonVehicles', 'Taxi', 'Truck', 'Van']\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "NUM_WORKERS = min(4, os.cpu_count() or 1)\n",
    "PIN_MEMORY  = (DEVICE.type == 'cuda') #  Pin memory if GPU available for CUDA\n",
    "\n",
    "print(NUM_WORKERS)\n",
    "\n",
    "train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True,\n",
    "                          num_workers=NUM_WORKERS, pin_memory=PIN_MEMORY)\n",
    "test_loader  = DataLoader(test_dataset,  batch_size=64, shuffle=False,\n",
    "                          num_workers=NUM_WORKERS, pin_memory=PIN_MEMORY)\n",
    "classes = train_full.classes \n",
    "print(classes)\n",
    "print(len(classes))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7255041",
   "metadata": {},
   "source": [
    "# Task 3: CNN Architecture\n",
    "Model takes a batch of (3, 64, 64) images and outputs 8 class scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d1b7d9ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Net(\n",
      "  (features): Sequential(\n",
      "    (0): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    (2): ReLU()\n",
      "    (3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "    (4): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (5): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    (6): ReLU()\n",
      "    (7): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "    (8): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (9): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    (10): ReLU()\n",
      "    (11): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "  )\n",
      "  (classifier): Sequential(\n",
      "    (0): Flatten(start_dim=1, end_dim=-1)\n",
      "    (1): Linear(in_features=8192, out_features=512, bias=True)\n",
      "    (2): ReLU()\n",
      "    (3): Dropout(p=0.5, inplace=False)\n",
      "    (4): Linear(in_features=512, out_features=8, bias=True)\n",
      "  )\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "import torch.nn as nn\n",
    "\n",
    "class Net(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Net, self).__init__()\n",
    "\n",
    "        self.features = nn.Sequential(\n",
    "            # go from 64x64 to 32x32\n",
    "\n",
    "            # kernel size = 3x3 filter patch\n",
    "            #padding = 1, so 64x64 stays 64x64 after conv\n",
    "            nn.Conv2d(3, 32, kernel_size=3, padding=1), # 3 channel RRGB, 32 filters (recommended), and adding 1 pixel of zeros so keep output at same size\n",
    "\n",
    "            nn.BatchNorm2d(32), # mirrors conv2d output\n",
    "            nn.ReLU(), #Activation fn\n",
    "            nn.MaxPool2d(2,2), # 2x2 window, stride = 2: so halved --> 32x32\n",
    "\n",
    "            #Go from 32x32 --> 16x16 in the same manner\n",
    "\n",
    "            nn.Conv2d(32, 64, kernel_size=3, padding=1), # Double filters --> more complex features detected\n",
    "            nn.BatchNorm2d(64),\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool2d(2,2), \n",
    "            \n",
    "            # Go from 16x 16 0 -->  8x8 in the same manner\n",
    "\n",
    "            nn.Conv2d(64, 128, kernel_size=3, padding=1), # Double filters again --> even more complex rfeatures detected\n",
    "            nn.BatchNorm2d(128),\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool2d(2,2), \n",
    "\n",
    "        )\n",
    "\n",
    "        self.classifier = nn.Sequential(\n",
    "            nn.Flatten(),\n",
    "            nn.Linear (128 * 8 *8, 512), # flattened size of 8x8 * 128, 512 is arbitrary number of hidden neurons (recommended by GeeksForGeeks)....tunned to learn details without overfitting\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout(0.5),#Randomly zero 50% of neurons --> prevent memorization and overfitting\n",
    "            nn.Linear(512, len(classes)) # one score per vehicle class\n",
    "        )\n",
    "\n",
    "    def forward(self, x): \n",
    "        x = self.features(x) # extract spatial features via conv blocks\n",
    "        x = self.classifier(x) # flatten to 8 vehicle clases\n",
    "        return x\n",
    "\n",
    "model = Net().to(DEVICE)\n",
    "device = DEVICE\n",
    "\n",
    "print(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22e71032",
   "metadata": {},
   "source": [
    "Loss fn and optimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "54d11a04",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.optim as optim\n",
    "\n",
    "criterion = nn.CrossEntropyLoss() # Applied softmax to convert scores --> probabilities --> penalizes model \n",
    "\n",
    "# Changed to adam optimizer (internal momentumn calculation)\n",
    "optimizer = optim.Adam(model.parameters(), lr=0.001)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "572d80e3",
   "metadata": {},
   "source": [
    "# Task 4: Train Model\n",
    "\n",
    "Track loss and accuracy per epoch — stored in lists for plotting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "374d0590",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1: Loss=1.137, Accuracy=62.59%\n",
      "Epoch 2: Loss=0.866, Accuracy=69.80%\n",
      "Epoch 3: Loss=0.796, Accuracy=71.93%\n",
      "Epoch 4: Loss=0.752, Accuracy=74.03%\n",
      "Epoch 5: Loss=0.712, Accuracy=74.89%\n",
      "Epoch 6: Loss=0.683, Accuracy=76.17%\n",
      "Epoch 7: Loss=0.659, Accuracy=76.99%\n",
      "Epoch 8: Loss=0.635, Accuracy=77.73%\n",
      "Epoch 9: Loss=0.615, Accuracy=78.54%\n",
      "Epoch 10: Loss=0.597, Accuracy=78.92%\n",
      "Epoch 11: Loss=0.575, Accuracy=79.91%\n",
      "Epoch 12: Loss=0.567, Accuracy=80.05%\n",
      "Epoch 13: Loss=0.554, Accuracy=80.72%\n",
      "Epoch 14: Loss=0.542, Accuracy=81.12%\n",
      "Epoch 15: Loss=0.532, Accuracy=81.31%\n",
      "Epoch 16: Loss=0.522, Accuracy=81.75%\n",
      "Epoch 17: Loss=0.505, Accuracy=82.06%\n",
      "Epoch 18: Loss=0.489, Accuracy=82.72%\n",
      "Epoch 19: Loss=0.487, Accuracy=82.87%\n",
      "Epoch 20: Loss=0.488, Accuracy=82.76%\n",
      "Epoch 21: Loss=0.471, Accuracy=83.04%\n",
      "Epoch 22: Loss=0.455, Accuracy=83.86%\n",
      "Epoch 23: Loss=0.449, Accuracy=83.77%\n",
      "Epoch 24: Loss=0.444, Accuracy=84.12%\n",
      "Epoch 25: Loss=0.448, Accuracy=84.23%\n",
      "Epoch 26: Loss=0.431, Accuracy=84.57%\n",
      "Epoch 27: Loss=0.425, Accuracy=85.00%\n",
      "Epoch 28: Loss=0.414, Accuracy=84.98%\n",
      "Epoch 29: Loss=0.412, Accuracy=85.57%\n",
      "Epoch 30: Loss=0.399, Accuracy=85.84%\n",
      "Finished Training\n"
     ]
    }
   ],
   "source": [
    "train_losses, train_accs = [], [] #To store accs for visualization\n",
    "\n",
    "for epoch in range(30): # 30 epochs\n",
    "    running_loss = 0.0 # keep track of running loss\n",
    "    correct = 0\n",
    "    total = 0\n",
    "\n",
    "    for i, data in enumerate(train_loader, 0):\n",
    "        inputs, labels = data\n",
    "        inputs, labels = inputs.to(device), labels.to(device)\n",
    "        optimizer.zero_grad() # clear prior gradients\n",
    "        outputs = model(inputs) # forward pass \n",
    "        loss = criterion(outputs, labels) # compare to GT\n",
    "        loss.backward() # Backprop...compute gradient of loss\n",
    "        optimizer.step() #Use adam optimizer to update weights using gradients\n",
    "\n",
    "        running_loss += loss.item() #Extract scalar loss value \n",
    "        _, predicted = torch.max(outputs, 1) # Take index of highest score as predicted class\n",
    "        total += labels.size(0)\n",
    "        correct += (predicted == labels).sum().item()  #update correct tally\n",
    "\n",
    "    epoch_loss = running_loss / len(train_loader) #Compute avg loss\n",
    "    epoch_acc  = 100 * correct / total #Avg acc accross epoch\n",
    "\n",
    "\n",
    "    #Adding epochs to list\n",
    "    train_losses.append(epoch_loss)\n",
    "    train_accs.append(epoch_acc) \n",
    "\n",
    "    print(f'Epoch {epoch+1}: Loss={epoch_loss:.3f}, Accuracy={epoch_acc:.2f}%')\n",
    "\n",
    "print('Finished Training')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26ab705a",
   "metadata": {},
   "source": [
    "# Task 6 (Bonus): Plot Loss & Accuracy Curves\n",
    "\n",
    "Visualises how loss decreased and accuracy improved across 30 epochs [credit: Claude]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "c71ee0ff",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))\n",
    "\n",
    "\n",
    "# Plot 1: Training loss vs epoch \n",
    "ax1.plot(train_losses, color='steelblue', linewidth=2)\n",
    "ax1.set_title('Training Loss')\n",
    "ax1.set_xlabel('Epoch')\n",
    "ax1.set_ylabel('Loss')\n",
    "ax1.grid(True, alpha=0.3)\n",
    "\n",
    "#Plot 2: training acc. vs epoch\n",
    "ax2.plot(train_accs, color='darkorange', linewidth=2)\n",
    "ax2.set_title('Training Accuracy')\n",
    "ax2.set_xlabel('Epoch')\n",
    "ax2.set_ylabel('Accuracy (%)')\n",
    "ax2.grid(True, alpha=0.3)\n",
    "\n",
    "#Concat two plots, save, and show\n",
    "plt.suptitle('Training Curves', fontsize=14, fontweight='bold')\n",
    "plt.tight_layout()\n",
    "os.makedirs('../results', exist_ok=True)\n",
    "plt.savefig('../results/training_curves.png', dpi=150, bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3bfda75",
   "metadata": {},
   "source": [
    "Save Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "2bf2b9a2",
   "metadata": {},
   "outputs": [],
   "source": [
    "os.makedirs('../models', exist_ok=True)\n",
    "PATH = '../models/final-classifier.pth'\n",
    "torch.save(model.state_dict(), PATH)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "057d5d72",
   "metadata": {},
   "source": [
    "# Task 5: Final Accuracy\n",
    "Evaluate on both train and test sets with Dropout disabled (model.eval())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "9e54f566",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Final Train Accuracy : 86.68%\n",
      "Final Test  Accuracy : 84.67%\n"
     ]
    }
   ],
   "source": [
    "model.eval() # Switch to eval mode (disabled droupout --> higher acc) (credit: Claude)\n",
    "train_correct, train_total = 0, 0\n",
    "with torch.no_grad(): #Gradient computation not needed for inference\n",
    "    for images, labels in train_loader:\n",
    "        images, labels = images.to(device), labels.to(device)\n",
    "        outputs = model(images) #Fwd pass only\n",
    "        _, predicted = torch.max(outputs, 1) #highest score = predicted class\n",
    "        train_total += labels.size(0) #Count total \n",
    "        train_correct += (predicted == labels).sum().item() # Count correct\n",
    "\n",
    "# Test accuracy - repeat with test set\n",
    "test_correct, test_total = 0, 0\n",
    "with torch.no_grad():\n",
    "    for images, labels in test_loader:\n",
    "        images, labels = images.to(device), labels.to(device)\n",
    "        outputs = model(images)\n",
    "        _, predicted = torch.max(outputs, 1)\n",
    "        test_total += labels.size(0)\n",
    "        test_correct += (predicted == labels).sum().item()\n",
    "\n",
    "print(f'Final Train Accuracy : {100 * train_correct / train_total:.2f}%')\n",
    "print(f'Final Test  Accuracy : {100 * test_correct  / test_total:.2f}%')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60666242",
   "metadata": {},
   "source": [
    "Credit Claude: Testing accuracy per class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "8cc7ed40",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy for class: Bicycle    is 81.3%\n",
      "Accuracy for class: Bus        is 87.0%\n",
      "Accuracy for class: Car        is 86.1%\n",
      "Accuracy for class: Motorcycle is 89.9%\n",
      "Accuracy for class: NonVehicles is 99.8%\n",
      "Accuracy for class: Taxi       is 50.0%\n",
      "Accuracy for class: Truck      is 46.4%\n",
      "Accuracy for class: Van        is 36.7%\n"
     ]
    }
   ],
   "source": [
    "correct_pred = {classname: 0 for classname in classes} # Correct predicitions per class\n",
    "total_pred = {classname: 0 for classname in classes} # total images seen per class\n",
    "\n",
    "model.eval()\n",
    "with torch.no_grad():\n",
    "    for data in test_loader:\n",
    "        images, labels = data\n",
    "        images, labels = images.to(device), labels.to(device)\n",
    "        outputs = model(images)\n",
    "        _, predictions = torch.max(outputs, 1) #predicted class index per class\n",
    "        for label, prediction in zip(labels, predictions):\n",
    "            if label == prediction:\n",
    "                correct_pred[classes[label]] += 1\n",
    "            total_pred[classes[label]] += 1\n",
    "\n",
    "for classname, correct_count in correct_pred.items():\n",
    "    accuracy = 100 * float(correct_count) / total_pred[classname]\n",
    "    print(f'Accuracy for class: {classname:10s} is {accuracy:.1f}%')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}