testing_model.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import cv2\n",
    "import time\n",
    "import torch\n",
    "from tqdm import tqdm\n",
    "import torch.nn as nn\n",
    "from PIL import Image\n",
    "import torch.optim as optim\n",
    "import xml.etree.ElementTree as ET\n",
    "from torch.optim import lr_scheduler\n",
    "from torch.utils.data import random_split\n",
    "from utils.image_utils import extract_bndbox_values\n",
    "from torchvision import datasets, models, transforms\n",
    "\n",
    "device = \"cuda\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'spot0': {'xmin': 3292.0, 'ymin': 1850.0, 'xmax': 3528.0, 'ymax': 2008.0},\n",
       " 'spot1': {'xmin': 2981.0, 'ymin': 1912.0, 'xmax': 3217.0, 'ymax': 2070.0},\n",
       " 'spot2': {'xmin': 2656.0, 'ymin': 1955.0, 'xmax': 2892.0, 'ymax': 2113.0},\n",
       " 'spot3': {'xmin': 2223.0, 'ymin': 1990.0, 'xmax': 2459.0, 'ymax': 2148.0},\n",
       " 'spot4': {'xmin': 1847.0, 'ymin': 2025.0, 'xmax': 2083.0, 'ymax': 2183.0},\n",
       " 'spot5': {'xmin': 1452.0, 'ymin': 2033.0, 'xmax': 1688.0, 'ymax': 2191.0},\n",
       " 'spot6': {'xmin': 1050.0, 'ymin': 2051.0, 'xmax': 1286.0, 'ymax': 2209.0},\n",
       " 'spot7': {'xmin': 601.0, 'ymin': 2081.0, 'xmax': 837.0, 'ymax': 2239.0},\n",
       " 'spot8': {'xmin': 166.0, 'ymin': 2068.0, 'xmax': 402.0, 'ymax': 2226.0}}"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check if annotations are parsed right \n",
    "tree = ET.parse(\"inference-label-studio/Annotations/7c738c45-20230609_155230.xml\")\n",
    "root = tree.getroot()\n",
    "bndbox_values = {}\n",
    "\n",
    "for i, obj in enumerate(root.findall('object')):\n",
    "    bndbox = obj.find('bndbox')\n",
    "    name = obj.find('name').text\n",
    "\n",
    "    xmin = float(bndbox.find('xmin').text)\n",
    "    ymin = float(bndbox.find('ymin').text)\n",
    "    xmax = float(bndbox.find('xmax').text)\n",
    "    ymax = float(bndbox.find('ymax').text)\n",
    "    bndbox_values[name + str(i)] = {'xmin': xmin, 'ymin': ymin, 'xmax': xmax, 'ymax': ymax}\n",
    "\n",
    "bndbox_values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Path:  inference-label-studio/images\\253e1d5b-20230609_160143.jpg\n",
      "Path:  inference-label-studio/images\\44146dba-9b1e7b8b-20230608_110037.jpg\n",
      "Path:  inference-label-studio/images\\55d78e5f-20230608_105630.jpg\n",
      "Path:  inference-label-studio/images\\7219e6a2-pk_lot.jpg\n",
      "Path:  inference-label-studio/images\\7c738c45-20230609_155230.jpg\n",
      "Path:  inference-label-studio/images\\830075f3-20230609_160427.jpg\n",
      "Path:  inference-label-studio/images\\8899e45e-20230610_084906.jpg\n",
      "Path:  inference-label-studio/images\\8c52cc71-20230608_110040.jpg\n",
      "Path:  inference-label-studio/images\\92fc6ed0-692159c7-Screenshot_2023-12-14_211832.png\n",
      "Path:  inference-label-studio/images\\9c6ba07f-20230608_105636.jpg\n",
      "Path:  inference-label-studio/images\\a8ee32be-20230609_160422.jpg\n",
      "Path:  inference-label-studio/images\\abfaec3a-20230608_110054.jpg\n",
      "Path:  inference-label-studio/images\\b8759a9e-20230608_110048.jpg\n",
      "Path:  inference-label-studio/images\\ca8c8b20-parking.jpg\n",
      "Path:  inference-label-studio/images\\cf810670-20230608_110037.jpg\n",
      "Path:  inference-label-studio/images\\d6f65c2a-20230609_155226.jpg\n",
      "Path:  inference-label-studio/images\\daf303f4-20230609_160404.jpg\n",
      "Path:  inference-label-studio/images\\e0425f6b-20230609_155151.jpg\n",
      "Path:  inference-label-studio/images\\ebde7602-pg_survailance.jpg\n"
     ]
    }
   ],
   "source": [
    "# Check if images can be loaded \n",
    "image_folder = \"inference-label-studio/images\"\n",
    "annotation_folder = \"inference-label-studio/Annotations\"\n",
    "\n",
    "# Loop over images\n",
    "for image_filename in os.listdir(image_folder):\n",
    "    image_path = os.path.join(image_folder, image_filename)\n",
    "\n",
    "    image_to_draw = cv2.imread(image_path)\n",
    "    full_image = Image.open(image_path)\n",
    "    \n",
    "    print(\"Path: \", image_path)\n",
    "    \n",
    "    if image_filename.endswith(\".jpg\") or image_filename.endswith(\".png\"):\n",
    "        annotation_filename = os.path.join(\n",
    "            annotation_folder,\n",
    "            image_filename.replace(\".jpg\", \".xml\").replace(\".png\", \".xml\"),\n",
    "        )\n",
    "\n",
    "    # Check if the annotation file exists\n",
    "    if os.path.isfile(annotation_filename):\n",
    "        bndbox_values = extract_bndbox_values(annotation_filename)\n",
    "\n",
    "    # crop patches\n",
    "    for key in bndbox_values:\n",
    "            values = bndbox_values[key]\n",
    "            # Extract coordinates from the bounding box\n",
    "            xmin = int(values[\"xmin\"])\n",
    "            ymin = int(values[\"ymin\"])\n",
    "            xmax = int(values[\"xmax\"])\n",
    "            ymax = int(values[\"ymax\"])\n",
    "            # Crop patch for the image\n",
    "            patch = full_image.crop((xmin, ymin, xmax, ymax))\n",
    "            #print(patch)\n",
    "            #img = Image.open(image_path)\n",
    "            #display(patch)\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# define datasets transformers\n",
    "\n",
    "data_transforms = {\n",
    "        \"train\": transforms.Compose(\n",
    "            [\n",
    "                transforms.RandomResizedCrop(224),\n",
    "                transforms.RandomHorizontalFlip(),\n",
    "                transforms.ToTensor(),\n",
    "                transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n",
    "            ]\n",
    "        ),\n",
    "        \"val\": transforms.Compose(\n",
    "            [\n",
    "                transforms.Resize(256),\n",
    "                transforms.CenterCrop(224),\n",
    "                transforms.ToTensor(),\n",
    "                transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n",
    "            ]\n",
    "        ),\n",
    "    }\n",
    "\n",
    "\n",
    "pk_lot_dir  = \"pk_lot_data\"\n",
    "cnr_parking_dir  = \"cnr_parking_data\"\n",
    "\n",
    "# load datasets\n",
    "image_datasets_pk_lot = {\n",
    "    x: datasets.ImageFolder(os.path.join(pk_lot_dir, y), data_transforms[y])\n",
    "    for x,y  in zip([\"train\", \"val\"], [\"train\", \"val\"])\n",
    "}\n",
    "image_datasets_cnr_park = {\n",
    "    x: datasets.ImageFolder(os.path.join(cnr_parking_dir, y), data_transforms[y])\n",
    "    for x,y  in zip([\"train\", \"val\"], [\"train\", \"val\"])\n",
    "}\n",
    "\n",
    "# Make the validation sets 2 times smaller \n",
    "dataset_size_cnr_val = len(image_datasets_cnr_park[\"val\"])\n",
    "split_point = dataset_size_cnr_val // 2\n",
    "image_datasets_cnr_park[\"val\"], dataset_part2 = random_split(image_datasets_cnr_park[\"val\"], [split_point, dataset_size_cnr_val - split_point])\n",
    "\n",
    "\n",
    "dataset_size_pk_lot_val = len(image_datasets_pk_lot[\"val\"])\n",
    "split_point = dataset_size_pk_lot_val // 4\n",
    "image_datasets_pk_lot[\"val\"], dataset_part2 = random_split(image_datasets_pk_lot[\"val\"], [split_point, dataset_size_pk_lot_val - split_point])\n",
    "\n",
    "# Combine train and validation datasets to be from the 2 datasets\n",
    "train_dataset = torch.utils.data.ConcatDataset([image_datasets_pk_lot[\"train\"], image_datasets_cnr_park[\"train\"]])\n",
    "val_dataset = torch.utils.data.ConcatDataset([image_datasets_pk_lot[\"val\"], image_datasets_cnr_park[\"val\"]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Size of train and test:  {'train': 618925, 'val': 34913}\n"
     ]
    }
   ],
   "source": [
    "# make data loaders\n",
    "dataloaders_cnr_park= {\n",
    "    \"train\": torch.utils.data.DataLoader(\n",
    "        image_datasets_cnr_park[\"train\"],\n",
    "        batch_size=64,\n",
    "        shuffle=True,\n",
    "        num_workers=0,\n",
    "    ),\n",
    "    \"val\": torch.utils.data.DataLoader(\n",
    "        image_datasets_cnr_park[\"val\"],\n",
    "        batch_size=64,\n",
    "        shuffle=True,\n",
    "        num_workers=0,\n",
    "    )\n",
    "    \n",
    "}\n",
    "\n",
    "dataloaders_pk_lot= {\n",
    "    \"train\": torch.utils.data.DataLoader(\n",
    "        image_datasets_pk_lot[\"train\"],\n",
    "        batch_size=64,\n",
    "        shuffle=True,\n",
    "        num_workers=0,\n",
    "    ),\n",
    "    \"val\": torch.utils.data.DataLoader(\n",
    "        image_datasets_pk_lot[\"val\"],\n",
    "        batch_size=64,\n",
    "        shuffle=True,\n",
    "        num_workers=0,\n",
    "    )\n",
    "    \n",
    "}\n",
    "\n",
    "\n",
    "dataloaders = {\n",
    "    \"train\": torch.utils.data.DataLoader(\n",
    "        train_dataset,\n",
    "        batch_size=32,\n",
    "        shuffle=True,\n",
    "        num_workers=0,\n",
    "    ),\n",
    "    \"val\": torch.utils.data.DataLoader(\n",
    "        val_dataset,\n",
    "        batch_size=32,\n",
    "        shuffle=True,\n",
    "        num_workers=0,\n",
    "    )\n",
    "    \n",
    "}\n",
    "dataset_sizes = {\"train\": len(train_dataset) , \"val\": len(val_dataset)}\n",
    "print(\"Size of train and test: \", dataset_sizes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model parameters:  4862273\n",
      "Model parameters:  32331\n"
     ]
    }
   ],
   "source": [
    "from utils.image_utils import mAlexNet\n",
    "\n",
    "model_type = \"m_alex\"\n",
    "\n",
    "# if model_type == \"m_alex\":\n",
    "alex_model = mAlexNet()\n",
    "alex_model.to(device)\n",
    "alex_model.load_state_dict(torch.load(\"./models/final_m_alex_net_both.pth\", weights_only = True)) \n",
    "# elif model_type == \"alex\":\n",
    "model = models.alexnet(weights=\"IMAGENET1K_V1\")\n",
    "model.classifier = nn.Sequential(\n",
    "    nn.Dropout(p=0.5, inplace=False),\n",
    "    nn.Linear(in_features=9216, out_features=256, bias=True),\n",
    "    nn.ReLU(inplace=True),\n",
    "    nn.Dropout(p=0.5, inplace=False),\n",
    "    nn.Linear(in_features=256, out_features=128, bias=True),\n",
    "    nn.ReLU(inplace=True),\n",
    "    nn.Linear(in_features=128, out_features=1, bias=True),\n",
    ")\n",
    "model.load_state_dict(torch.load(\"./models/final_alex_net_both.pth\", weights_only = True))\n",
    "model.to(device)\n",
    "\n",
    "print(\"Model parameters: \", sum(p.numel() for p in model.parameters() if p.requires_grad) )\n",
    "print(\"Alex model parameters: \", sum(p.numel() for p in alex_model.parameters() if p.requires_grad) )\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model parameters:  4862273\n"
     ]
    }
   ],
   "source": [
    "def load_model(filename, model_type):\n",
    "    if model_type == \"m_alex\":\n",
    "        model = mAlexNet()\n",
    "        model.to(device)\n",
    "        model.load_state_dict(torch.load(f\"./models/{filename}\", weights_only = True)) \n",
    "    elif model_type == \"alex\":\n",
    "        model = models.alexnet(weights=\"IMAGENET1K_V1\")\n",
    "        model.classifier = nn.Sequential(\n",
    "            nn.Dropout(p=0.5, inplace=False),\n",
    "            nn.Linear(in_features=9216, out_features=256, bias=True),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Dropout(p=0.5, inplace=False),\n",
    "            nn.Linear(in_features=256, out_features=128, bias=True),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Linear(in_features=128, out_features=1, bias=True),\n",
    "        )\n",
    "        model.load_state_dict(torch.load(\"./models/final_alex_net_both.pth\", weights_only = True))\n",
    "        model.to(device)\n",
    "\n",
    "    print(\"Model parameters: \", sum(p.numel() for p in model.parameters() if p.requires_grad) )\n",
    "    return model\n",
    "\n",
    "alex_model = load_model(filename=\"final_alex_net_cnr.pth\",model_type=\"alex\")\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([  9.3994,  11.1687,  -3.0027,  -7.4812,  -9.2655,  18.6632,  -3.1986,\n",
      "          2.6856,  10.6401,  -6.9936,  -0.6863, -10.9461,  -4.1949,  -6.0942,\n",
      "         -8.9680,  -3.8564,  -5.8303,  -5.7496,  -8.0030,  10.5291,  32.6932,\n",
      "         11.7911,   8.6380,  10.6126,   7.7609,  19.4778,  11.1222,  -2.7234,\n",
      "         -5.5657,  21.6302,   7.5554,   4.9666], device='cuda:0',\n",
      "       grad_fn=<SqueezeBackward1>)\n",
      "tensor([1, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,\n",
      "        1, 1, 1, 0, 0, 1, 0, 1], device='cuda:0')\n",
      "10.925135612487793\n",
      "tensor(30, device='cuda:0')\n"
     ]
    }
   ],
   "source": [
    "# Testing model trainng loop\n",
    "inputs, labels  = next(iter(dataloaders[\"val\"]))\n",
    "criterion = nn.BCEWithLogitsLoss()\n",
    "#criterion = nn.CrossEntropyLoss()\n",
    "\n",
    "# Define optimizer for nn\n",
    "optimizer = optim.AdamW(model.parameters(),lr=0.001, fused=True)\n",
    "scheduler = lr_scheduler.StepLR(optimizer, step_size=7, gamma=0.1)\n",
    "\n",
    "inputs = inputs.to(device)\n",
    "labels = labels.to(device)\n",
    "\n",
    "running_corrects=0\n",
    "running_loss =0\n",
    "\n",
    "# zero the parameter gradients\n",
    "optimizer.zero_grad()\n",
    "\n",
    "# forward\n",
    "# track history if only in train\n",
    "with torch.set_grad_enabled(True):\n",
    "        outputs = model(inputs).squeeze(dim=1)\n",
    "        print(outputs)\n",
    "        print(labels)\n",
    "        #_, preds = torch.max(outputs, 1)\n",
    "        #preds = np.where(outputs > 0, 1, 0)\n",
    "        preds = (torch.sigmoid(outputs) > 0.5).float()\n",
    "\n",
    "        loss = criterion(outputs, labels.float())\n",
    "\n",
    "        # backward + optimize only if in training phase\n",
    "        \n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        \n",
    "# statistics\n",
    "running_loss += loss.item() * inputs.size(0)\n",
    "running_corrects += torch.sum(preds == labels.data)\n",
    "\n",
    "scheduler.step()\n",
    "print(running_loss) \n",
    "print(running_corrects) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "60504"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(val_dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 292/292 [01:01<00:00,  4.72it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model accuracy: 96.214%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# Testing model accuracy\n",
    "all = len(image_datasets_cnr_park[\"val\"])\n",
    "corrects =0 \n",
    "for (inputs, labels) in tqdm(dataloaders_cnr_park[\"val\"]):\n",
    "    inputs, labels = inputs.to(device), labels.to(device)\n",
    "    with torch.no_grad():\n",
    "            outputs = model(inputs)\n",
    "            preds = (torch.sigmoid(outputs) > 0.5).float()\n",
    "            preds = preds.squeeze().int()  # Remove dimensions of size 1\n",
    "            corrects += torch.sum(preds == labels).item()\n",
    "\n",
    "print(f\"Model accuracy: {round(corrects/all,5)*100}%\")\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_accuracy(model, dataset, dataloader):\n",
    "    all = len(dataset)\n",
    "    corrects =0 \n",
    "    for (inputs, labels) in tqdm(dataloader):\n",
    "        inputs, labels = inputs.to(device), labels.to(device)\n",
    "        with torch.no_grad():\n",
    "                outputs = model(inputs)\n",
    "                preds = (torch.sigmoid(outputs) > 0.5).float()\n",
    "                preds = preds.squeeze().int()  # Remove dimensions of size 1\n",
    "                corrects += torch.sum(preds == labels).item()\n",
    "\n",
    "    return round(corrects/all,5)*100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 146/146 [00:52<00:00,  2.80it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy is 94.337%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "accuracy = get_accuracy(model, image_datasets_cnr_park[\"val\"], dataloaders_cnr_park[\"val\"])\n",
    "print(f\"Accuracy is {accuracy}%\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "m_alex_files = [\"final_m_alex_net_both.pth\",\n",
    "    \"final_m_alex_net_cnr.pth\",\n",
    "    \"final_m_alex_net_pk.pth\",\n",
    "    \"m_alex_net_both_best_acc.pth\",\n",
    "    \"m_alex_net_cnr_best_acc.pth\",\n",
    "    \"m_alex_net_combined.pth\",\n",
    "    \"m_alex_net_pk_best_acc.pth\"]\n",
    "\n",
    "alex_files = [\n",
    "    \"alex_net_both_best_acc.pth\",\n",
    "    \"alex_net_cnr_best_acc.pth\",\n",
    "    \"final_alex_net_both.pth\",\n",
    "    \"final_alex_net_cnr.pth\",\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_model(filename, model_type):\n",
    "    if model_type == \"m_alex\":\n",
    "        model = mAlexNet()\n",
    "        model.to(device)\n",
    "        model.load_state_dict(torch.load(f\"./models/{filename}\", weights_only = True)) \n",
    "    elif model_type == \"alex\":\n",
    "        model = models.alexnet(weights=\"IMAGENET1K_V1\")\n",
    "        model.classifier = nn.Sequential(\n",
    "            nn.Dropout(p=0.5, inplace=False),\n",
    "            nn.Linear(in_features=9216, out_features=256, bias=True),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Dropout(p=0.5, inplace=False),\n",
    "            nn.Linear(in_features=256, out_features=128, bias=True),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Linear(in_features=128, out_features=1, bias=True),\n",
    "        )\n",
    "        model.load_state_dict(torch.load(\"./models/final_alex_net_both.pth\", weights_only = True))\n",
    "        model.to(device)\n",
    "\n",
    "    print(\"Model parameters: \", sum(p.numel() for p in model.parameters() if p.requires_grad) )\n",
    "    \n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model parameters:  32331\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 400/400 [06:59<00:00,  1.05s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of final_m_alex_net_both is 98.707%\n",
      "Model parameters:  32331\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 400/400 [02:04<00:00,  3.21it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of final_m_alex_net_cnr is 59.211000000000006%\n",
      "Model parameters:  32331\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 400/400 [02:50<00:00,  2.34it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of final_m_alex_net_pk is 98.726%\n",
      "Model parameters:  32331\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 400/400 [02:36<00:00,  2.55it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of m_alex_net_both_best_acc is 98.707%\n",
      "Model parameters:  32331\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 400/400 [01:39<00:00,  4.02it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of m_alex_net_cnr_best_acc is 69.18299999999999%\n",
      "Model parameters:  32331\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 400/400 [02:10<00:00,  3.07it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of m_alex_net_combined is 98.941%\n",
      "Model parameters:  32331\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 400/400 [01:33<00:00,  4.26it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of m_alex_net_pk_best_acc is 99.187%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "m_alex_accuracies = {}\n",
    "\n",
    "for model_file in m_alex_files:\n",
    "    m_alex_model = load_model(filename=model_file, model_type=\"m_alex\") # type: ignore\n",
    "    accuracy = get_accuracy(m_alex_model, image_datasets_pk_lot[\"val\"], dataloaders_pk_lot[\"val\"])\n",
    "    print(f\"Accuracy of {model_file.split('.')[0]} is {accuracy}%\")\n",
    "    m_alex_accuracies[model_file.split(\".\")[0]] = accuracy\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model parameters:  4862273\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 146/146 [00:46<00:00,  3.15it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of alex_net_both_best_acc is 93.961%\n",
      "Model parameters:  4862273\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 146/146 [00:46<00:00,  3.15it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of alex_net_cnr_best_acc is 94.144%\n",
      "Model parameters:  4862273\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 146/146 [00:39<00:00,  3.74it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of final_alex_net_both is 94.05799999999999%\n",
      "Model parameters:  4862273\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 146/146 [00:38<00:00,  3.75it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of final_alex_net_cnr is 94.272%\n"
     ]
    }
   ],
   "source": [
    "alex_accuracies = {}\n",
    "\n",
    "for model_file in alex_files:\n",
    "    alex_model = load_model(filename=model_file, model_type=\"alex\") # type: ignore\n",
    "    accuracy = get_accuracy(alex_model, image_datasets_cnr_park[\"val\"], dataloaders_cnr_park[\"val\"])\n",
    "    print(f\"Accuracy of {model_file.split('.')[0]} is {accuracy}%\")\n",
    "    alex_accuracies[model_file.split(\".\")[0]] = accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'alex_net_both_best_acc': 93.961,\n",
       " 'alex_net_cnr_best_acc': 94.144,\n",
       " 'final_alex_net_both': 94.05799999999999,\n",
       " 'final_alex_net_cnr': 94.272}"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "alex_accuracies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "# Extracting file names and accuracies from the dictionary\n",
    "# Extracting file names and accuracies from the dictionary\n",
    "file_names = list(alex_accuracies.keys())\n",
    "accuracy_values = list(alex_accuracies.values())\n",
    "accuracy_values = [round(value, 2) for value in accuracy_values]\n",
    "\n",
    "\n",
    "# Plotting the horizontal bar graph with slimmer bars and pale blue color\n",
    "plt.figure(figsize=(8, 5))  # Adjust the figure size as needed\n",
    "bars = plt.barh(file_names, accuracy_values, color='lightblue', height=0.6)  # Adjust height for slimmer bars\n",
    "\n",
    "# Adding labels and title\n",
    "plt.xlabel('Accuracy (%)')\n",
    "plt.ylabel('File Names (Models)')\n",
    "plt.title('Accuracies for the Alex Net Model')\n",
    "\n",
    "# Adjust the x-axis limits to start from 80%\n",
    "plt.xlim(80, 100)\n",
    "\n",
    "# Displaying the numerical values on the bars\n",
    "for bar, value in zip(bars, accuracy_values):\n",
    "    plt.text(bar.get_width() + 0.5, bar.get_y() + bar.get_height()/2, f'{value}%', va='center', fontsize=10)\n",
    "\n",
    "# Display the plot\n",
    "plt.tight_layout()  # Adjust layout for better spacing\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "# Extracting file names and accuracies from the dictionary\n",
    "# Extracting file names and accuracies from the dictionary\n",
    "file_names = list(m_alex_accuracies.keys())\n",
    "accuracy_values = list(m_alex_accuracies.values())\n",
    "accuracy_values = [round(value, 2) for value in accuracy_values]\n",
    "\n",
    "\n",
    "# Plotting the horizontal bar graph with slimmer bars and pale blue color\n",
    "plt.figure(figsize=(8, 5))  # Adjust the figure size as needed\n",
    "bars = plt.barh(file_names, accuracy_values, color='lightblue', height=0.6)  # Adjust height for slimmer bars\n",
    "\n",
    "# Adding labels and title\n",
    "plt.xlabel('Accuracy (%)')\n",
    "plt.ylabel('File Names (Models)')\n",
    "plt.title('Accuracies for the m_Alex Net Model')\n",
    "\n",
    "# Adjust the x-axis limits to start from 80%\n",
    "plt.xlim(50, 100)\n",
    "\n",
    "# Displaying the numerical values on the bars\n",
    "for bar, value in zip(bars, accuracy_values):\n",
    "    plt.text(bar.get_width(), bar.get_y() + bar.get_height()/2, f'{value}%', va='center', fontsize=10)\n",
    "\n",
    "# Display the plot\n",
    "plt.tight_layout()  # Adjust layout for better spacing\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "parking",
   "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}