 A_Quick_PyTorch2.0_Tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "3d0724dd-27ef-4b63-a3df-49ae270b433f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Notebook last updated: 2024-03-25 15:49:45.491638\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "print(f\"Notebook last updated: {datetime.datetime.now()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "367b0ba0-106c-4c46-a899-fd1b2aa17f2c",
   "metadata": {},
   "source": [
    "Before pytorch 2.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f8c7d328-5d7b-4eb5-9817-0e993984e675",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torchvision\n",
    "\n",
    "model = torchvision.models.resnet50() # note: this could be any model\n",
    "\n",
    "### Train model ###\n",
    "\n",
    "### Test model ###"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e5a2646-6d54-42ef-a580-715093acad71",
   "metadata": {},
   "source": [
    "After pytorch 2.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "877a66f1-dc8b-41b9-b122-1a7b1733c569",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torchvision\n",
    "\n",
    "model = torchvision.models.resnet50() # note: this could be any model\n",
    "compiled_model = torch.compile(model) # <- magic happens!\n",
    "\n",
    "### Train model ### <- faster!\n",
    "\n",
    "### Test model ### <- faster!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "6a259d5e-2691-48b3-886f-ba5310f51477",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] Current PyTorch version: 2.1.0+cu118 (should be 2.x+)\n",
      "[INFO] PyTorch 2.x installed, you'll be able to use the new features.\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "\n",
    "# Check PyTorch version\n",
    "pt_version = torch.__version__\n",
    "print(f\"[INFO] Current PyTorch version: {pt_version} (should be 2.x+)\")\n",
    "\n",
    "# Install PyTorch 2.0 if necessary\n",
    "if pt_version.split(\".\")[0] == \"1\": # Check if PyTorch version begins with 1 \n",
    "    !pip3 install -U torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118\n",
    "    print(\"[INFO] PyTorch 2.x installed, if you're on Google Colab, you may need to restart your runtime.\\\n",
    "          Though as of April 2023, Google Colab comes with PyTorch 2.0 pre-installed.\")\n",
    "    import torch\n",
    "    pt_version = torch.__version__\n",
    "    print(f\"[INFO] Current PyTorch version: {pt_version} (should be 2.x+)\")\n",
    "else:\n",
    "    print(\"[INFO] PyTorch 2.x installed, you'll be able to use the new features.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "da9c9369-86f4-4042-82fe-435bf827b33c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GPU name: NVIDIA_GeForce_RTX_4090\n",
      "GPU capability score: (8, 9)\n",
      "GPU score higher than or equal to (8, 0), PyTorch 2.x speedup features available.\n",
      "GPU information:\n",
      "Mon Mar 25 17:48:30 2024       \n",
      "+---------------------------------------------------------------------------------------+\n",
      "| NVIDIA-SMI 545.23.08              Driver Version: 545.23.08    CUDA Version: 12.3     |\n",
      "|-----------------------------------------+----------------------+----------------------+\n",
      "| GPU  Name                 Persistence-M | Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
      "| Fan  Temp   Perf          Pwr:Usage/Cap |         Memory-Usage | GPU-Util  Compute M. |\n",
      "|                                         |                      |               MIG M. |\n",
      "|=========================================+======================+======================|\n",
      "|   0  NVIDIA GeForce RTX 4090        On  | 00000000:01:00.0  On |                  Off |\n",
      "|  0%   44C    P8              10W / 450W |   2365MiB / 24564MiB |      1%      Default |\n",
      "|                                         |                      |                  N/A |\n",
      "+-----------------------------------------+----------------------+----------------------+\n",
      "                                                                                         \n",
      "+---------------------------------------------------------------------------------------+\n",
      "| Processes:                                                                            |\n",
      "|  GPU   GI   CI        PID   Type   Process name                            GPU Memory |\n",
      "|        ID   ID                                                             Usage      |\n",
      "|=======================================================================================|\n",
      "|    0   N/A  N/A      1404      G   /usr/lib/xorg/Xorg                          215MiB |\n",
      "|    0   N/A  N/A      1886    C+G   ...libexec/gnome-remote-desktop-daemon      390MiB |\n",
      "|    0   N/A  N/A      1923      G   /usr/bin/gnome-shell                         40MiB |\n",
      "|    0   N/A  N/A      3388      G   ...74,262144 --variations-seed-version      235MiB |\n",
      "|    0   N/A  N/A     26943      C   ...i/miniconda/envs/pytorch/bin/python     1450MiB |\n",
      "+---------------------------------------------------------------------------------------+\n"
     ]
    }
   ],
   "source": [
    "# Make sure we're using a NVIDIA GPU\n",
    "if torch.cuda.is_available():\n",
    "  gpu_info = !nvidia-smi\n",
    "  gpu_info = '\\n'.join(gpu_info)\n",
    "  if gpu_info.find(\"failed\") >= 0:\n",
    "    print(\"Not connected to a GPU, to leverage the best of PyTorch 2.0, you should connect to a GPU.\")\n",
    "\n",
    "  # Get GPU name\n",
    "  gpu_name = !nvidia-smi --query-gpu=gpu_name --format=csv\n",
    "  gpu_name = gpu_name[1]\n",
    "  GPU_NAME = gpu_name.replace(\" \", \"_\") # remove underscores for easier saving\n",
    "  print(f'GPU name: {GPU_NAME}')\n",
    "\n",
    "  # Get GPU capability score\n",
    "  GPU_SCORE = torch.cuda.get_device_capability()\n",
    "  print(f\"GPU capability score: {GPU_SCORE}\")\n",
    "  if GPU_SCORE >= (8, 0):\n",
    "    print(f\"GPU score higher than or equal to (8, 0), PyTorch 2.x speedup features available.\")\n",
    "  else:\n",
    "    print(f\"GPU score lower than (8, 0), PyTorch 2.x speedup features will be limited (PyTorch 2.x speedups happen most on newer GPUs).\")\n",
    "  \n",
    "  # Print GPU info\n",
    "  print(f\"GPU information:\\n{gpu_info}\")\n",
    "\n",
    "else:\n",
    "  print(\"PyTorch couldn't find a GPU, to leverage the best of PyTorch 2.0, you should connect to a GPU.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "e689a219-1ffa-4082-a317-6dc3be617f57",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Layer weights are on device: cuda:0\n",
      "Layer creating data on device: cuda:0\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "\n",
    "# Set the device\n",
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "\n",
    "# Set the device with context manager (requires PyTorch 2.x+)\n",
    "with torch.device(device):\n",
    "    # All tensors created in this block will be on device\n",
    "    layer = torch.nn.Linear(20, 30)\n",
    "    print(f\"Layer weights are on device: {layer.weight.device}\")\n",
    "    print(f\"Layer creating data on device: {layer(torch.randn(128, 20)).device}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d1426385-dd10-4c05-8ce8-a8b0cc0e4412",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Layer weights are on device: cuda:0\n",
      "Layer creating data on device: cuda:0\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "\n",
    "# Set the device\n",
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "\n",
    "# Set the device globally\n",
    "torch.set_default_device(device)\n",
    "\n",
    "# All tensors created will be on the global device by default\n",
    "layer = torch.nn.Linear(20, 30)\n",
    "print(f\"Layer weights are on device: {layer.weight.device}\")\n",
    "print(f\"Layer creating data on device: {layer(torch.randn(128, 20)).device}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "80e90376-a37a-4713-bfaf-20e9b36f0de5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Layer weights are on device: cpu\n",
      "Layer creating data on device: cpu\n"
     ]
    }
   ],
   "source": [
    "import torch \n",
    "\n",
    "# Set the device globally\n",
    "torch.set_default_device(\"cpu\")\n",
    "\n",
    "# All tensors created will be on \"cpu\"\n",
    "layer = torch.nn.Linear(20, 30)\n",
    "print(f\"Layer weights are on device: {layer.weight.device}\")\n",
    "print(f\"Layer creating data on device: {layer(torch.randn(128, 20)).device}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "1e3ba636-3075-474a-9cef-986cb57b242a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PyTorch version: 2.1.0+cu118\n",
      "TorchVision version: 0.16.0+cu118\n",
      "Using device: cuda\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torchvision\n",
    "\n",
    "print(f\"PyTorch version: {torch.__version__}\")\n",
    "print(f\"TorchVision version: {torchvision.__version__}\")\n",
    "\n",
    "# Set the target device\n",
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "\n",
    "print(f\"Using device: {device}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "631620b8-62ee-4447-9e45-2abc71fc7e2d",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Downloading: \"https://download.pytorch.org/models/resnet50-11ad3fa6.pth\" to /home/qm/.cache/torch/hub/checkpoints/resnet50-11ad3fa6.pth\n",
      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 97.8M/97.8M [01:16<00:00, 1.34MB/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total parameters of model: 25557032 (the more parameters, the more GPU memory the model will use, the more *relative* of a speedup you'll get)\n",
      "Model transforms:\n",
      "ImageClassification(\n",
      "    crop_size=[224]\n",
      "    resize_size=[232]\n",
      "    mean=[0.485, 0.456, 0.406]\n",
      "    std=[0.229, 0.224, 0.225]\n",
      "    interpolation=InterpolationMode.BILINEAR\n",
      ")\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# Create model weights and transforms\n",
    "model_weights = torchvision.models.ResNet50_Weights.IMAGENET1K_V2 # <- use the latest weights (could also use .DEFAULT)\n",
    "transforms = model_weights.transforms()\n",
    "\n",
    "# Setup model\n",
    "model = torchvision.models.resnet50(weights=model_weights)\n",
    "\n",
    "# Count the number of parameters in the model \n",
    "total_params = sum(\n",
    "    param.numel() for param in model.parameters() # <- all params\n",
    "\t# param.numel() for param in model.parameters() if param.requires_grad # <- only trainable params\n",
    ")\n",
    "\n",
    "print(f\"Total parameters of model: {total_params} (the more parameters, the more GPU memory the model will use, the more *relative* of a speedup you'll get)\")\n",
    "print(f\"Model transforms:\\n{transforms}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "0021c7fa-3898-4e73-a304-250c9531cee5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_model(num_classes=10):\n",
    "  \"\"\"\n",
    "  Creates a ResNet50 model with the latest weights and transforms via torchvision.\n",
    "  \"\"\"\n",
    "  model_weights = torchvision.models.ResNet50_Weights.IMAGENET1K_V2\n",
    "  transforms = model_weights.transforms()\n",
    "  model = torchvision.models.resnet50(weights=model_weights)\n",
    "  \n",
    "  # Adjust the number of output features in model to match the number of classes in the dataset\n",
    "  model.fc = torch.nn.Linear(in_features=2048, \n",
    "                             out_features=num_classes)\n",
    "  return model, transforms\n",
    "\n",
    "model, transforms = create_model()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "e18edde0-f16e-4b9b-a5f5-df3d47f34b69",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total free GPU memory: 22.507 GB\n",
      "Total GPU memory: 25.391 GB\n"
     ]
    }
   ],
   "source": [
    "# Check available GPU memory and total GPU memory \n",
    "total_free_gpu_memory, total_gpu_memory = torch.cuda.mem_get_info()\n",
    "print(f\"Total free GPU memory: {round(total_free_gpu_memory * 1e-9, 3)} GB\")\n",
    "print(f\"Total GPU memory: {round(total_gpu_memory * 1e-9, 3)} GB\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "fd68fefc-ace1-442f-867f-58fa684431ab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GPU memory available is 22.507 GB, using batch size of 128 and image size 224\n"
     ]
    }
   ],
   "source": [
    "# Set batch size depending on amount of GPU memory\n",
    "total_free_gpu_memory_gb = round(total_free_gpu_memory * 1e-9, 3)\n",
    "if total_free_gpu_memory_gb >= 16:\n",
    "  BATCH_SIZE = 128 # Note: you could experiment with higher values here if you like.\n",
    "  IMAGE_SIZE = 224\n",
    "  print(f\"GPU memory available is {total_free_gpu_memory_gb} GB, using batch size of {BATCH_SIZE} and image size {IMAGE_SIZE}\")\n",
    "else:\n",
    "  BATCH_SIZE = 32\n",
    "  IMAGE_SIZE = 128\n",
    "  print(f\"GPU memory available is {total_free_gpu_memory_gb} GB, using batch size of {BATCH_SIZE} and image size {IMAGE_SIZE}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "6a736c18-a9ad-40c9-a89a-8c1e7a71326e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Updated data transforms:\n",
      "ImageClassification(\n",
      "    crop_size=224\n",
      "    resize_size=224\n",
      "    mean=[0.485, 0.456, 0.406]\n",
      "    std=[0.229, 0.224, 0.225]\n",
      "    interpolation=InterpolationMode.BILINEAR\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "transforms.crop_size = IMAGE_SIZE\n",
    "transforms.resize_size = IMAGE_SIZE \n",
    "print(f\"Updated data transforms:\\n{transforms}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "0ddd3cdf-2585-4482-ac42-a196d4883928",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] Using GPU with score: (8, 9), enabling TensorFloat32 (TF32) computing (faster on new GPUs)\n"
     ]
    }
   ],
   "source": [
    "if GPU_SCORE >= (8, 0):\n",
    "  print(f\"[INFO] Using GPU with score: {GPU_SCORE}, enabling TensorFloat32 (TF32) computing (faster on new GPUs)\")\n",
    "  torch.backends.cuda.matmul.allow_tf32 = True\n",
    "else:\n",
    "  print(f\"[INFO] Using GPU with score: {GPU_SCORE}, TensorFloat32 (TF32) not available, to use it you need a GPU with score >= (8, 0)\")\n",
    "  torch.backends.cuda.matmul.allow_tf32 = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "14833afe-cab4-4df5-88bf-ca587f4f198f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./cifar-10-python.tar.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 170498071/170498071 [01:50<00:00, 1545991.56it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting ./cifar-10-python.tar.gz to .\n",
      "Files already downloaded and verified\n",
      "[INFO] Train dataset length: 50000\n",
      "[INFO] Test dataset length: 10000\n"
     ]
    }
   ],
   "source": [
    "# Create train and test datasets\n",
    "train_dataset = torchvision.datasets.CIFAR10(root='.', \n",
    "                                             train=True, \n",
    "                                             download=True, \n",
    "                                             transform=transforms)\n",
    "\n",
    "test_dataset = torchvision.datasets.CIFAR10(root='.', \n",
    "                                            train=False, # want the test split\n",
    "                                            download=True, \n",
    "                                            transform=transforms)\n",
    "\n",
    "# Get the lengths of the datasets\n",
    "train_len = len(train_dataset)\n",
    "test_len = len(test_dataset)\n",
    "\n",
    "print(f\"[INFO] Train dataset length: {train_len}\")\n",
    "print(f\"[INFO] Test dataset length: {test_len}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "73af44a3-457b-4dff-aa9a-084f56f3901e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train dataloader length: 391 batches of size 128\n",
      "Test dataloader length: 79 batches of size 128\n",
      "Using number of workers: 32 (generally more workers means faster dataloading from CPU to GPU)\n"
     ]
    }
   ],
   "source": [
    "from torch.utils.data import DataLoader\n",
    "\n",
    "# Create DataLoaders\n",
    "import os\n",
    "NUM_WORKERS = os.cpu_count() # <- use all available CPU cores (this number can be tweaked through experimentation but generally more workers means faster dataloading from CPU to GPU)\n",
    "\n",
    "train_dataloader = DataLoader(dataset=train_dataset,\n",
    "                              batch_size=BATCH_SIZE,\n",
    "                              shuffle=True,\n",
    "                              num_workers=NUM_WORKERS)\n",
    "\n",
    "test_dataloader = DataLoader(dataset=test_dataset,\n",
    "                              batch_size=BATCH_SIZE,\n",
    "                              shuffle=False,\n",
    "                              num_workers=NUM_WORKERS)\n",
    "\n",
    "# Print details\n",
    "print(f\"Train dataloader length: {len(train_dataloader)} batches of size {BATCH_SIZE}\")\n",
    "print(f\"Test dataloader length: {len(test_dataloader)} batches of size {BATCH_SIZE}\")\n",
    "print(f\"Using number of workers: {NUM_WORKERS} (generally more workers means faster dataloading from CPU to GPU)\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "5ffd0852-754f-4907-b772-fea1333285e7",
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "from typing import Dict, List, Tuple\n",
    "\n",
    "def train_step(epoch: int,\n",
    "               model: torch.nn.Module, \n",
    "               dataloader: torch.utils.data.DataLoader, \n",
    "               loss_fn: torch.nn.Module, \n",
    "               optimizer: torch.optim.Optimizer,\n",
    "               device: torch.device,\n",
    "               disable_progress_bar: bool = False) -> Tuple[float, float]:\n",
    "  \"\"\"Trains a PyTorch model for a single epoch.\n",
    "\n",
    "  Turns a target PyTorch model to training mode and then\n",
    "  runs through all of the required training steps (forward\n",
    "  pass, loss calculation, optimizer step).\n",
    "\n",
    "  Args:\n",
    "    model: A PyTorch model to be trained.\n",
    "    dataloader: A DataLoader instance for the model to be trained on.\n",
    "    loss_fn: A PyTorch loss function to minimize.\n",
    "    optimizer: A PyTorch optimizer to help minimize the loss function.\n",
    "    device: A target device to compute on (e.g. \"cuda\" or \"cpu\").\n",
    "\n",
    "  Returns:\n",
    "    A tuple of training loss and training accuracy metrics.\n",
    "    In the form (train_loss, train_accuracy). For example:\n",
    "\n",
    "    (0.1112, 0.8743)\n",
    "  \"\"\"\n",
    "  # Put model in train mode\n",
    "  model.train()\n",
    "\n",
    "  # Setup train loss and train accuracy values\n",
    "  train_loss, train_acc = 0, 0\n",
    "\n",
    "  # Loop through data loader data batches\n",
    "  progress_bar = tqdm(\n",
    "        enumerate(dataloader), \n",
    "        desc=f\"Training Epoch {epoch}\", \n",
    "        total=len(dataloader),\n",
    "        disable=disable_progress_bar\n",
    "    )\n",
    "\n",
    "  for batch, (X, y) in progress_bar:\n",
    "      # Send data to target device\n",
    "      X, y = X.to(device), y.to(device)\n",
    "\n",
    "      # 1. Forward pass\n",
    "      y_pred = model(X)\n",
    "\n",
    "      # 2. Calculate  and accumulate loss\n",
    "      loss = loss_fn(y_pred, y)\n",
    "      train_loss += loss.item() \n",
    "\n",
    "      # 3. Optimizer zero grad\n",
    "      optimizer.zero_grad()\n",
    "\n",
    "      # 4. Loss backward\n",
    "      loss.backward()\n",
    "\n",
    "      # 5. Optimizer step\n",
    "      optimizer.step()\n",
    "\n",
    "      # Calculate and accumulate accuracy metric across all batches\n",
    "      y_pred_class = torch.argmax(torch.softmax(y_pred, dim=1), dim=1)\n",
    "      train_acc += (y_pred_class == y).sum().item()/len(y_pred)\n",
    "\n",
    "      # Update progress bar\n",
    "      progress_bar.set_postfix(\n",
    "            {\n",
    "                \"train_loss\": train_loss / (batch + 1),\n",
    "                \"train_acc\": train_acc / (batch + 1),\n",
    "            }\n",
    "        )\n",
    "\n",
    "\n",
    "  # Adjust metrics to get average loss and accuracy per batch \n",
    "  train_loss = train_loss / len(dataloader)\n",
    "  train_acc = train_acc / len(dataloader)\n",
    "  return train_loss, train_acc\n",
    "\n",
    "def test_step(epoch: int,\n",
    "              model: torch.nn.Module, \n",
    "              dataloader: torch.utils.data.DataLoader, \n",
    "              loss_fn: torch.nn.Module,\n",
    "              device: torch.device,\n",
    "              disable_progress_bar: bool = False) -> Tuple[float, float]:\n",
    "  \"\"\"Tests a PyTorch model for a single epoch.\n",
    "\n",
    "  Turns a target PyTorch model to \"eval\" mode and then performs\n",
    "  a forward pass on a testing dataset.\n",
    "\n",
    "  Args:\n",
    "    model: A PyTorch model to be tested.\n",
    "    dataloader: A DataLoader instance for the model to be tested on.\n",
    "    loss_fn: A PyTorch loss function to calculate loss on the test data.\n",
    "    device: A target device to compute on (e.g. \"cuda\" or \"cpu\").\n",
    "\n",
    "  Returns:\n",
    "    A tuple of testing loss and testing accuracy metrics.\n",
    "    In the form (test_loss, test_accuracy). For example:\n",
    "\n",
    "    (0.0223, 0.8985)\n",
    "  \"\"\"\n",
    "  # Put model in eval mode\n",
    "  model.eval() \n",
    "\n",
    "  # Setup test loss and test accuracy values\n",
    "  test_loss, test_acc = 0, 0\n",
    "\n",
    "  # Loop through data loader data batches\n",
    "  progress_bar = tqdm(\n",
    "      enumerate(dataloader), \n",
    "      desc=f\"Testing Epoch {epoch}\", \n",
    "      total=len(dataloader),\n",
    "      disable=disable_progress_bar\n",
    "  )\n",
    "\n",
    "  # Turn on inference context manager\n",
    "  with torch.no_grad(): # no_grad() required for PyTorch 2.0, I found some errors with `torch.inference_mode()`, please let me know if this is not the case\n",
    "      # Loop through DataLoader batches\n",
    "      for batch, (X, y) in progress_bar:\n",
    "          # Send data to target device\n",
    "          X, y = X.to(device), y.to(device)\n",
    "\n",
    "          # 1. Forward pass\n",
    "          test_pred_logits = model(X)\n",
    "\n",
    "          # 2. Calculate and accumulate loss\n",
    "          loss = loss_fn(test_pred_logits, y)\n",
    "          test_loss += loss.item()\n",
    "\n",
    "          # Calculate and accumulate accuracy\n",
    "          test_pred_labels = test_pred_logits.argmax(dim=1)\n",
    "          test_acc += ((test_pred_labels == y).sum().item()/len(test_pred_labels))\n",
    "\n",
    "          # Update progress bar\n",
    "          progress_bar.set_postfix(\n",
    "              {\n",
    "                  \"test_loss\": test_loss / (batch + 1),\n",
    "                  \"test_acc\": test_acc / (batch + 1),\n",
    "              }\n",
    "          )\n",
    "\n",
    "  # Adjust metrics to get average loss and accuracy per batch \n",
    "  test_loss = test_loss / len(dataloader)\n",
    "  test_acc = test_acc / len(dataloader)\n",
    "  return test_loss, test_acc\n",
    "\n",
    "def train(model: torch.nn.Module, \n",
    "          train_dataloader: torch.utils.data.DataLoader, \n",
    "          test_dataloader: torch.utils.data.DataLoader, \n",
    "          optimizer: torch.optim.Optimizer,\n",
    "          loss_fn: torch.nn.Module,\n",
    "          epochs: int,\n",
    "          device: torch.device,\n",
    "          disable_progress_bar: bool = False) -> Dict[str, List]:\n",
    "  \"\"\"Trains and tests a PyTorch model.\n",
    "\n",
    "  Passes a target PyTorch models through train_step() and test_step()\n",
    "  functions for a number of epochs, training and testing the model\n",
    "  in the same epoch loop.\n",
    "\n",
    "  Calculates, prints and stores evaluation metrics throughout.\n",
    "\n",
    "  Args:\n",
    "    model: A PyTorch model to be trained and tested.\n",
    "    train_dataloader: A DataLoader instance for the model to be trained on.\n",
    "    test_dataloader: A DataLoader instance for the model to be tested on.\n",
    "    optimizer: A PyTorch optimizer to help minimize the loss function.\n",
    "    loss_fn: A PyTorch loss function to calculate loss on both datasets.\n",
    "    epochs: An integer indicating how many epochs to train for.\n",
    "    device: A target device to compute on (e.g. \"cuda\" or \"cpu\").\n",
    "\n",
    "  Returns:\n",
    "    A dictionary of training and testing loss as well as training and\n",
    "    testing accuracy metrics. Each metric has a value in a list for \n",
    "    each epoch.\n",
    "    In the form: {train_loss: [...],\n",
    "                  train_acc: [...],\n",
    "                  test_loss: [...],\n",
    "                  test_acc: [...]} \n",
    "    For example if training for epochs=2: \n",
    "                 {train_loss: [2.0616, 1.0537],\n",
    "                  train_acc: [0.3945, 0.3945],\n",
    "                  test_loss: [1.2641, 1.5706],\n",
    "                  test_acc: [0.3400, 0.2973]} \n",
    "  \"\"\"\n",
    "  # Create empty results dictionary\n",
    "  results = {\"train_loss\": [],\n",
    "      \"train_acc\": [],\n",
    "      \"test_loss\": [],\n",
    "      \"test_acc\": [],\n",
    "      \"train_epoch_time\": [],\n",
    "      \"test_epoch_time\": []\n",
    "  }\n",
    "\n",
    "  # Loop through training and testing steps for a number of epochs\n",
    "  for epoch in tqdm(range(epochs), disable=disable_progress_bar):\n",
    "\n",
    "      # Perform training step and time it\n",
    "      train_epoch_start_time = time.time()\n",
    "      train_loss, train_acc = train_step(epoch=epoch, \n",
    "                                        model=model,\n",
    "                                        dataloader=train_dataloader,\n",
    "                                        loss_fn=loss_fn,\n",
    "                                        optimizer=optimizer,\n",
    "                                        device=device,\n",
    "                                        disable_progress_bar=disable_progress_bar)\n",
    "      train_epoch_end_time = time.time()\n",
    "      train_epoch_time = train_epoch_end_time - train_epoch_start_time\n",
    "      \n",
    "      # Perform testing step and time it\n",
    "      test_epoch_start_time = time.time()\n",
    "      test_loss, test_acc = test_step(epoch=epoch,\n",
    "                                      model=model,\n",
    "                                      dataloader=test_dataloader,\n",
    "                                      loss_fn=loss_fn,\n",
    "                                      device=device,\n",
    "                                      disable_progress_bar=disable_progress_bar)\n",
    "      test_epoch_end_time = time.time()\n",
    "      test_epoch_time = test_epoch_end_time - test_epoch_start_time\n",
    "\n",
    "      # Print out what's happening\n",
    "      print(\n",
    "          f\"Epoch: {epoch+1} | \"\n",
    "          f\"train_loss: {train_loss:.4f} | \"\n",
    "          f\"train_acc: {train_acc:.4f} | \"\n",
    "          f\"test_loss: {test_loss:.4f} | \"\n",
    "          f\"test_acc: {test_acc:.4f} | \"\n",
    "          f\"train_epoch_time: {train_epoch_time:.4f} | \"\n",
    "          f\"test_epoch_time: {test_epoch_time:.4f}\"\n",
    "      )\n",
    "\n",
    "      # Update results dictionary\n",
    "      results[\"train_loss\"].append(train_loss)\n",
    "      results[\"train_acc\"].append(train_acc)\n",
    "      results[\"test_loss\"].append(test_loss)\n",
    "      results[\"test_acc\"].append(test_acc)\n",
    "      results[\"train_epoch_time\"].append(train_epoch_time)\n",
    "      results[\"test_epoch_time\"].append(test_epoch_time)\n",
    "\n",
    "  # Return the filled results at the end of the epochs\n",
    "  return results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "560bb9ac-a8b1-408a-b69f-a0b4e5f2e4b9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set the number of epochs as a constant\n",
    "NUM_EPOCHS = 5\n",
    "\n",
    "# Set the learning rate as a constant (this can be changed to get better results but for now we're just focused on time)\n",
    "LEARNING_RATE = 0.003"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "ddb800db-7c63-4f98-9603-985dfecdd15b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0a6c799ffc47462b851f128339ac12c2",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2d1932d23f66489fad34749db7fd8ed2",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training Epoch 0:   0%|          | 0/391 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "70df82ab24c74bbf8f8220d266a3fff3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing Epoch 0:   0%|          | 0/79 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 1 | train_loss: 0.8051 | train_acc: 0.7193 | test_loss: 0.6125 | test_acc: 0.7900 | train_epoch_time: 76.2773 | test_epoch_time: 6.2542\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "52796764a0e2443190cf65b78f3c736e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training Epoch 1:   0%|          | 0/391 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "950e5373891e4167a11ba591cd4b6576",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing Epoch 1:   0%|          | 0/79 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 2 | train_loss: 0.4461 | train_acc: 0.8450 | test_loss: 0.5873 | test_acc: 0.8076 | train_epoch_time: 76.7363 | test_epoch_time: 5.9911\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c59aef22e0b0401cabf8f4f1d84cbe8c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training Epoch 2:   0%|          | 0/391 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d48684246b454abdb2863e31cf7da5ed",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing Epoch 2:   0%|          | 0/79 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 3 | train_loss: 0.3230 | train_acc: 0.8896 | test_loss: 0.6524 | test_acc: 0.7948 | train_epoch_time: 75.2007 | test_epoch_time: 6.0398\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8ca16e2bd0b049469553094c48ff759b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training Epoch 3:   0%|          | 0/391 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "625dae6109e04d3aa2a688eff6349380",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing Epoch 3:   0%|          | 0/79 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 4 | train_loss: 0.2427 | train_acc: 0.9159 | test_loss: 0.4501 | test_acc: 0.8530 | train_epoch_time: 75.3232 | test_epoch_time: 6.0658\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7dfc2db4762241a0945bc3e6f13a66a6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training Epoch 4:   0%|          | 0/391 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8dc75d5199074627b9e7eb992b5302e5",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing Epoch 4:   0%|          | 0/79 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 5 | train_loss: 0.1829 | train_acc: 0.9357 | test_loss: 0.3943 | test_acc: 0.8736 | train_epoch_time: 75.1977 | test_epoch_time: 6.0311\n"
     ]
    }
   ],
   "source": [
    "# Create model\n",
    "model, transforms = create_model()\n",
    "model.to(device)\n",
    "\n",
    "# Create loss function and optimizer\n",
    "loss_fn = torch.nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.Adam(model.parameters(),\n",
    "                             lr=LEARNING_RATE)\n",
    "\n",
    "# Train model and track results\n",
    "single_run_no_compile_results = train(model=model,\n",
    "                                      train_dataloader=train_dataloader,\n",
    "                                      test_dataloader=test_dataloader,\n",
    "                                      loss_fn=loss_fn,\n",
    "                                      optimizer=optimizer,\n",
    "                                      epochs=NUM_EPOCHS,\n",
    "                                      device=device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "833f7e7a-c86a-4402-80c6-c9a52381351a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time to compile: 0.00020647048950195312 | Note: The first time you compile your model, the first few epochs will be slower than subsequent runs.\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "11a43cacf2824b1889d3c9fab157ee6f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4681ed31e5f342ff94b4907047086184",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training Epoch 0:   0%|          | 0/391 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "17b31c32c13b4bf88d075376b86e484d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing Epoch 0:   0%|          | 0/79 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 1 | train_loss: 0.8017 | train_acc: 0.7216 | test_loss: 0.7921 | test_acc: 0.7348 | train_epoch_time: 93.5567 | test_epoch_time: 12.3123\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3a31290280864428b06a5eceac501937",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training Epoch 1:   0%|          | 0/391 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d879fed050674023ae81a4dfa6279514",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing Epoch 1:   0%|          | 0/79 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 2 | train_loss: 0.4438 | train_acc: 0.8454 | test_loss: 0.6186 | test_acc: 0.7947 | train_epoch_time: 66.9472 | test_epoch_time: 4.8468\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "74d9f1e488b44fcda28e26ec393b5cf9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training Epoch 2:   0%|          | 0/391 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d698e49e8757415b8e9018103ef2b9a0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing Epoch 2:   0%|          | 0/79 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 3 | train_loss: 0.3169 | train_acc: 0.8896 | test_loss: 0.4573 | test_acc: 0.8508 | train_epoch_time: 66.8881 | test_epoch_time: 4.8239\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "204aaa8481be47d39cf31634071a15f8",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training Epoch 3:   0%|          | 0/391 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8dffaa79a0cc47cdbeda0a395f78164f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing Epoch 3:   0%|          | 0/79 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 4 | train_loss: 0.2369 | train_acc: 0.9177 | test_loss: 0.4532 | test_acc: 0.8494 | train_epoch_time: 66.6485 | test_epoch_time: 4.8231\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ef361c47501f49de80073c8ab1529cf9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training Epoch 4:   0%|          | 0/391 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e2d42f3b571a430b9a4befc3ec9df699",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing Epoch 4:   0%|          | 0/79 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 5 | train_loss: 0.1756 | train_acc: 0.9388 | test_loss: 0.3955 | test_acc: 0.8765 | train_epoch_time: 66.6450 | test_epoch_time: 4.8355\n"
     ]
    }
   ],
   "source": [
    "# Create model and transforms\n",
    "model, transforms = create_model()\n",
    "model.to(device)\n",
    "\n",
    "# Create loss function and optimizer\n",
    "loss_fn = torch.nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.Adam(model.parameters(),\n",
    "                             lr=LEARNING_RATE)\n",
    "\n",
    "# Compile the model and time how long it takes\n",
    "compile_start_time = time.time()\n",
    "\n",
    "### New in PyTorch 2.x ###\n",
    "compiled_model = torch.compile(model)\n",
    "##########################\n",
    "\n",
    "compile_end_time = time.time()\n",
    "compile_time = compile_end_time - compile_start_time\n",
    "print(f\"Time to compile: {compile_time} | Note: The first time you compile your model, the first few epochs will be slower than subsequent runs.\")\n",
    "\n",
    "# Train the compiled model\n",
    "single_run_compile_results = train(model=compiled_model,\n",
    "                                   train_dataloader=train_dataloader,\n",
    "                                   test_dataloader=test_dataloader,\n",
    "                                   loss_fn=loss_fn,\n",
    "                                   optimizer=optimizer,\n",
    "                                   epochs=NUM_EPOCHS,\n",
    "                                   device=device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "67381172-d1b9-4bcf-b527-c284660c2319",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Turn experiment results into dataframes\n",
    "import pandas as pd\n",
    "single_run_no_compile_results_df = pd.DataFrame(single_run_no_compile_results)\n",
    "single_run_compile_results_df = pd.DataFrame(single_run_compile_results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "d1d8cba1-2487-4b68-bcc9-c7fad0f82bd5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>train_loss</th>\n",
       "      <th>train_acc</th>\n",
       "      <th>test_loss</th>\n",
       "      <th>test_acc</th>\n",
       "      <th>train_epoch_time</th>\n",
       "      <th>test_epoch_time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.805095</td>\n",
       "      <td>0.719345</td>\n",
       "      <td>0.612466</td>\n",
       "      <td>0.789953</td>\n",
       "      <td>76.277267</td>\n",
       "      <td>6.254151</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.446058</td>\n",
       "      <td>0.844985</td>\n",
       "      <td>0.587267</td>\n",
       "      <td>0.807555</td>\n",
       "      <td>76.736292</td>\n",
       "      <td>5.991078</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.322996</td>\n",
       "      <td>0.889622</td>\n",
       "      <td>0.652437</td>\n",
       "      <td>0.794798</td>\n",
       "      <td>75.200715</td>\n",
       "      <td>6.039832</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.242719</td>\n",
       "      <td>0.915905</td>\n",
       "      <td>0.450083</td>\n",
       "      <td>0.853046</td>\n",
       "      <td>75.323152</td>\n",
       "      <td>6.065755</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.182857</td>\n",
       "      <td>0.935698</td>\n",
       "      <td>0.394311</td>\n",
       "      <td>0.873616</td>\n",
       "      <td>75.197695</td>\n",
       "      <td>6.031086</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   train_loss  train_acc  test_loss  test_acc  train_epoch_time  \\\n",
       "0    0.805095   0.719345   0.612466  0.789953         76.277267   \n",
       "1    0.446058   0.844985   0.587267  0.807555         76.736292   \n",
       "2    0.322996   0.889622   0.652437  0.794798         75.200715   \n",
       "3    0.242719   0.915905   0.450083  0.853046         75.323152   \n",
       "4    0.182857   0.935698   0.394311  0.873616         75.197695   \n",
       "\n",
       "   test_epoch_time  \n",
       "0         6.254151  \n",
       "1         5.991078  \n",
       "2         6.039832  \n",
       "3         6.065755  \n",
       "4         6.031086  "
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check out the head of one of the results dataframes\n",
    "single_run_no_compile_results_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "593de600-7ee4-4a39-9e0f-0aeccb4995ad",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>train_loss</th>\n",
       "      <th>train_acc</th>\n",
       "      <th>test_loss</th>\n",
       "      <th>test_acc</th>\n",
       "      <th>train_epoch_time</th>\n",
       "      <th>test_epoch_time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.801652</td>\n",
       "      <td>0.721567</td>\n",
       "      <td>0.792075</td>\n",
       "      <td>0.734771</td>\n",
       "      <td>93.556742</td>\n",
       "      <td>12.312318</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.443800</td>\n",
       "      <td>0.845444</td>\n",
       "      <td>0.618584</td>\n",
       "      <td>0.794699</td>\n",
       "      <td>66.947198</td>\n",
       "      <td>4.846824</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.316878</td>\n",
       "      <td>0.889586</td>\n",
       "      <td>0.457318</td>\n",
       "      <td>0.850771</td>\n",
       "      <td>66.888077</td>\n",
       "      <td>4.823914</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.236868</td>\n",
       "      <td>0.917703</td>\n",
       "      <td>0.453184</td>\n",
       "      <td>0.849387</td>\n",
       "      <td>66.648502</td>\n",
       "      <td>4.823147</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.175631</td>\n",
       "      <td>0.938799</td>\n",
       "      <td>0.395486</td>\n",
       "      <td>0.876483</td>\n",
       "      <td>66.645042</td>\n",
       "      <td>4.835504</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   train_loss  train_acc  test_loss  test_acc  train_epoch_time  \\\n",
       "0    0.801652   0.721567   0.792075  0.734771         93.556742   \n",
       "1    0.443800   0.845444   0.618584  0.794699         66.947198   \n",
       "2    0.316878   0.889586   0.457318  0.850771         66.888077   \n",
       "3    0.236868   0.917703   0.453184  0.849387         66.648502   \n",
       "4    0.175631   0.938799   0.395486  0.876483         66.645042   \n",
       "\n",
       "   test_epoch_time  \n",
       "0        12.312318  \n",
       "1         4.846824  \n",
       "2         4.823914  \n",
       "3         4.823147  \n",
       "4         4.835504  "
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "single_run_compile_results_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "98f88f29-a254-4282-bb40-6b4c21d1ab4b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create filename to save the results\n",
    "DATASET_NAME = \"CIFAR10\"\n",
    "MODEL_NAME = \"ResNet50\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "b58380df-3a2c-457d-a863-825b1934224a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "def plot_mean_epoch_times(non_compiled_results: pd.DataFrame, \n",
    "                          compiled_results: pd.DataFrame, \n",
    "                          multi_runs: bool=False, \n",
    "                          num_runs: int=0, \n",
    "                          save: bool=False, \n",
    "                          save_path: str=\"\",\n",
    "                          dataset_name: str=DATASET_NAME,\n",
    "                          model_name: str=MODEL_NAME,\n",
    "                          num_epochs: int=NUM_EPOCHS,\n",
    "                          image_size: int=IMAGE_SIZE,\n",
    "                          batch_size: int=BATCH_SIZE) -> plt.figure:\n",
    "    \n",
    "    # Get the mean epoch times from the non-compiled models\n",
    "    mean_train_epoch_time = non_compiled_results.train_epoch_time.mean()\n",
    "    mean_test_epoch_time = non_compiled_results.test_epoch_time.mean()\n",
    "    mean_results = [mean_train_epoch_time, mean_test_epoch_time]\n",
    "\n",
    "    # Get the mean epoch times from the compiled models\n",
    "    mean_compile_train_epoch_time = compiled_results.train_epoch_time.mean()\n",
    "    mean_compile_test_epoch_time = compiled_results.test_epoch_time.mean()\n",
    "    mean_compile_results = [mean_compile_train_epoch_time, mean_compile_test_epoch_time]\n",
    "\n",
    "    # Calculate the percentage difference between the mean compile and non-compile train epoch times\n",
    "    train_epoch_time_diff = mean_compile_train_epoch_time - mean_train_epoch_time\n",
    "    train_epoch_time_diff_percent = (train_epoch_time_diff / mean_train_epoch_time) * 100\n",
    "\n",
    "    # Calculate the percentage difference between the mean compile and non-compile test epoch times\n",
    "    test_epoch_time_diff = mean_compile_test_epoch_time - mean_test_epoch_time\n",
    "    test_epoch_time_diff_percent = (test_epoch_time_diff / mean_test_epoch_time) * 100\n",
    "\n",
    "    # Print the mean difference percentages\n",
    "    print(f\"Mean train epoch time difference: {round(train_epoch_time_diff_percent, 3)}% (negative means faster)\")\n",
    "    print(f\"Mean test epoch time difference: {round(test_epoch_time_diff_percent, 3)}% (negative means faster)\")\n",
    "\n",
    "    # Create a bar plot of the mean train and test epoch time for both compiled and non-compiled models\n",
    "    plt.figure(figsize=(10, 7))\n",
    "    width = 0.3\n",
    "    x_indicies = np.arange(len(mean_results))\n",
    "\n",
    "    plt.bar(x=x_indicies, height=mean_results, width=width, label=\"non_compiled_results\")\n",
    "    plt.bar(x=x_indicies + width, height=mean_compile_results, width=width, label=\"compiled_results\")\n",
    "    plt.xticks(x_indicies + width / 2, (\"Train Epoch\", \"Test Epoch\"))\n",
    "    plt.ylabel(\"Mean epoch time (seconds, lower is better)\")\n",
    "\n",
    "    # Create the title based on the parameters passed to the function\n",
    "    if multi_runs:\n",
    "        plt.suptitle(\"Multiple run results\")\n",
    "        plt.title(f\"GPU: {gpu_name} | Epochs: {num_epochs} ({num_runs} runs) | Data: {dataset_name} | Model: {model_name} | Image size: {image_size} | Batch size: {batch_size}\")\n",
    "    else:\n",
    "        plt.suptitle(\"Single run results\")\n",
    "        plt.title(f\"GPU: {gpu_name} | Epochs: {num_epochs} | Data: {dataset_name} | Model: {model_name} | Image size: {image_size} | Batch size: {batch_size}\")\n",
    "    plt.legend();\n",
    "\n",
    "    # Save the figure\n",
    "    if save:\n",
    "        assert save_path != \"\", \"Please specify a save path to save the model figure to via the save_path parameter.\"\n",
    "        plt.savefig(save_path)\n",
    "        print(f\"[INFO] Plot saved to {save_path}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "fec12e41-6874-4fc8-a8f9-592eb03fb3a1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] Save path for single run results: pytorch_2_results/figures/single_run_NVIDIA_GeForce_RTX_4090_ResNet50_CIFAR10_224_train_epoch_time.png\n",
      "Mean train epoch time difference: -4.766% (negative means faster)\n",
      "Mean test epoch time difference: 4.147% (negative means faster)\n",
      "[INFO] Plot saved to pytorch_2_results/figures/single_run_NVIDIA_GeForce_RTX_4090_ResNet50_CIFAR10_224_train_epoch_time.png\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x700 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create directory for saving figures\n",
    "import os\n",
    "dir_to_save_figures_in = \"pytorch_2_results/figures/\" \n",
    "os.makedirs(dir_to_save_figures_in, exist_ok=True)\n",
    "\n",
    "# Create a save path for the single run results\n",
    "save_path_multi_run = f\"{dir_to_save_figures_in}single_run_{GPU_NAME}_{MODEL_NAME}_{DATASET_NAME}_{IMAGE_SIZE}_train_epoch_time.png\"\n",
    "print(f\"[INFO] Save path for single run results: {save_path_multi_run}\")\n",
    "\n",
    "# Plot the results and save the figures\n",
    "plot_mean_epoch_times(non_compiled_results=single_run_no_compile_results_df, \n",
    "                      compiled_results=single_run_compile_results_df, \n",
    "                      multi_runs=False, \n",
    "                      save_path=save_path_multi_run, \n",
    "                      save=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "e45feb78-eccf-4861-9740-ad67db5e9214",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] Saving non-compiled experiment 1 results to: pytorch_2_results/single_run_results/single_run_non_compiled_results_CIFAR10_ResNet50_NVIDIA_GeForce_RTX_4090.csv\n",
      "[INFO] Saving compiled experiment 2 results to: pytorch_2_results/single_run_results/single_run_compiled_results_CIFAR10_ResNet50_NVIDIA_GeForce_RTX_4090.csv\n"
     ]
    }
   ],
   "source": [
    "# Make a directory for single_run results\n",
    "import os\n",
    "pytorch_2_results_dir = \"pytorch_2_results\"\n",
    "pytorch_2_single_run_results_dir = f\"{pytorch_2_results_dir}/single_run_results\"\n",
    "os.makedirs(pytorch_2_single_run_results_dir, exist_ok=True)\n",
    "\n",
    "# Create filenames for each of the dataframes\n",
    "save_name_for_non_compiled_results = f\"single_run_non_compiled_results_{DATASET_NAME}_{MODEL_NAME}_{GPU_NAME}.csv\"\n",
    "save_name_for_compiled_results = f\"single_run_compiled_results_{DATASET_NAME}_{MODEL_NAME}_{GPU_NAME}.csv\"\n",
    "\n",
    "# Create filepaths to save the results to\n",
    "single_run_no_compile_save_path = f\"{pytorch_2_single_run_results_dir}/{save_name_for_non_compiled_results}\"\n",
    "single_run_compile_save_path = f\"{pytorch_2_single_run_results_dir}/{save_name_for_compiled_results}\"\n",
    "print(f\"[INFO] Saving non-compiled experiment 1 results to: {single_run_no_compile_save_path}\")\n",
    "print(f\"[INFO] Saving compiled experiment 2 results to: {single_run_compile_save_path}\")\n",
    "\n",
    "# Save the results\n",
    "single_run_no_compile_results_df.to_csv(single_run_no_compile_save_path)\n",
    "single_run_compile_results_df.to_csv(single_run_compile_save_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "e2c95985-a0bf-4a7d-b89f-30569781de13",
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_and_train_non_compiled_model(epochs=NUM_EPOCHS, \n",
    "                                        learning_rate=LEARNING_RATE, \n",
    "                                        disable_progress_bar=False):\n",
    "    \"\"\"\n",
    "    Create and train a non-compiled PyTorch model.\n",
    "    \"\"\"\n",
    "    model, _ = create_model()\n",
    "    model.to(device)\n",
    "\n",
    "    loss_fn = torch.nn.CrossEntropyLoss()\n",
    "    optimizer = torch.optim.Adam(model.parameters(),\n",
    "                                 lr=learning_rate)\n",
    "\n",
    "    results = train(model=model,\n",
    "                    train_dataloader=train_dataloader,\n",
    "                    test_dataloader=test_dataloader,\n",
    "                    loss_fn=loss_fn,\n",
    "                    optimizer=optimizer,\n",
    "                    epochs=epochs,\n",
    "                    device=device,\n",
    "                    disable_progress_bar=disable_progress_bar)\n",
    "    return results\n",
    "\n",
    "def create_compiled_model():\n",
    "    \"\"\"\n",
    "    Create a compiled PyTorch model and return it.\n",
    "    \"\"\"\n",
    "    model, _ = create_model()\n",
    "    model.to(device)\n",
    "    \n",
    "    compile_start_time = time.time()\n",
    "    ### New in PyTorch 2.x ###\n",
    "    compiled_model = torch.compile(model)\n",
    "    ##########################\n",
    "    compile_end_time = time.time()\n",
    "\n",
    "    compile_time = compile_end_time - compile_start_time\n",
    "\n",
    "    print(f\"Time to compile: {compile_time} | Note: The first time you compile your model, the first few epochs will be slower than subsequent runs.\")\n",
    "    return compiled_model\n",
    "\n",
    "def train_compiled_model(model=compiled_model, \n",
    "                         epochs=NUM_EPOCHS, \n",
    "                         learning_rate=LEARNING_RATE,\n",
    "                         disable_progress_bar=False):\n",
    "    \"\"\"\n",
    "    Train a compiled model and return the results.\n",
    "    \"\"\"\n",
    "    loss_fn = torch.nn.CrossEntropyLoss()\n",
    "    optimizer = torch.optim.Adam(compiled_model.parameters(),\n",
    "                                 lr=learning_rate)\n",
    "    \n",
    "    compile_results = train(model=model,\n",
    "                            train_dataloader=train_dataloader,\n",
    "                            test_dataloader=test_dataloader,\n",
    "                            loss_fn=loss_fn,\n",
    "                            optimizer=optimizer,\n",
    "                            epochs=epochs,\n",
    "                            device=device,\n",
    "                            disable_progress_bar=disable_progress_bar)\n",
    "    \n",
    "    return compile_results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "aeb3445a-8f33-4f87-92e9-0c901afc05af",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ac5a8a00d54441899ea3f415702d4bfc",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/3 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] Run 1 of 3 for non-compiled model\n",
      "Epoch: 1 | train_loss: 0.7868 | train_acc: 0.7292 | test_loss: 0.6733 | test_acc: 0.7662 | train_epoch_time: 76.4905 | test_epoch_time: 6.2236\n",
      "Epoch: 2 | train_loss: 0.4339 | train_acc: 0.8500 | test_loss: 0.5578 | test_acc: 0.8079 | train_epoch_time: 76.9883 | test_epoch_time: 6.1521\n",
      "Epoch: 3 | train_loss: 0.3188 | train_acc: 0.8887 | test_loss: 0.4318 | test_acc: 0.8506 | train_epoch_time: 75.5807 | test_epoch_time: 6.0864\n",
      "Epoch: 4 | train_loss: 0.2285 | train_acc: 0.9209 | test_loss: 0.3784 | test_acc: 0.8751 | train_epoch_time: 75.2958 | test_epoch_time: 6.0950\n",
      "Epoch: 5 | train_loss: 0.1706 | train_acc: 0.9405 | test_loss: 0.3883 | test_acc: 0.8741 | train_epoch_time: 75.2721 | test_epoch_time: 6.0560\n",
      "[INFO] Run 2 of 3 for non-compiled model\n",
      "Epoch: 1 | train_loss: 0.7849 | train_acc: 0.7277 | test_loss: 0.8263 | test_acc: 0.7251 | train_epoch_time: 75.1225 | test_epoch_time: 6.0376\n",
      "Epoch: 2 | train_loss: 0.4406 | train_acc: 0.8488 | test_loss: 0.4966 | test_acc: 0.8348 | train_epoch_time: 75.3060 | test_epoch_time: 6.0407\n",
      "Epoch: 3 | train_loss: 0.3121 | train_acc: 0.8921 | test_loss: 0.5001 | test_acc: 0.8412 | train_epoch_time: 75.8035 | test_epoch_time: 6.1025\n",
      "Epoch: 4 | train_loss: 0.2353 | train_acc: 0.9180 | test_loss: 0.3866 | test_acc: 0.8721 | train_epoch_time: 75.9459 | test_epoch_time: 6.1986\n",
      "Epoch: 5 | train_loss: 0.1737 | train_acc: 0.9388 | test_loss: 0.4286 | test_acc: 0.8684 | train_epoch_time: 76.0287 | test_epoch_time: 6.1135\n",
      "[INFO] Run 3 of 3 for non-compiled model\n",
      "Epoch: 1 | train_loss: 0.7778 | train_acc: 0.7317 | test_loss: 0.7263 | test_acc: 0.7472 | train_epoch_time: 75.5365 | test_epoch_time: 6.0892\n",
      "Epoch: 2 | train_loss: 0.4334 | train_acc: 0.8513 | test_loss: 0.5162 | test_acc: 0.8340 | train_epoch_time: 75.6572 | test_epoch_time: 6.1209\n",
      "Epoch: 3 | train_loss: 0.3139 | train_acc: 0.8916 | test_loss: 0.4366 | test_acc: 0.8491 | train_epoch_time: 76.5215 | test_epoch_time: 6.1641\n",
      "Epoch: 4 | train_loss: 0.2331 | train_acc: 0.9189 | test_loss: 0.3941 | test_acc: 0.8665 | train_epoch_time: 77.3750 | test_epoch_time: 6.0458\n",
      "Epoch: 5 | train_loss: 0.1702 | train_acc: 0.9408 | test_loss: 0.3613 | test_acc: 0.8771 | train_epoch_time: 75.6079 | test_epoch_time: 6.1451\n"
     ]
    }
   ],
   "source": [
    "# Run non-compiled model for multiple runs\n",
    "NUM_RUNS = 3\n",
    "NUM_EPOCHS = 5\n",
    "\n",
    "# Create an empty list to store multiple run results\n",
    "non_compile_results_multiple_runs = []\n",
    "\n",
    "# Run non-compiled model for multiple runs\n",
    "for i in tqdm(range(NUM_RUNS)):\n",
    "    print(f\"[INFO] Run {i+1} of {NUM_RUNS} for non-compiled model\")\n",
    "    results = create_and_train_non_compiled_model(epochs=NUM_EPOCHS, disable_progress_bar=True)\n",
    "    non_compile_results_multiple_runs.append(results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "b2c11aff-c7bc-4edf-9e4a-52e4a903f719",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>train_loss</th>\n",
       "      <th>train_acc</th>\n",
       "      <th>test_loss</th>\n",
       "      <th>test_acc</th>\n",
       "      <th>train_epoch_time</th>\n",
       "      <th>test_epoch_time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.786795</td>\n",
       "      <td>0.729188</td>\n",
       "      <td>0.673341</td>\n",
       "      <td>0.766218</td>\n",
       "      <td>76.490460</td>\n",
       "      <td>6.223612</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.433911</td>\n",
       "      <td>0.849996</td>\n",
       "      <td>0.557825</td>\n",
       "      <td>0.807852</td>\n",
       "      <td>76.988336</td>\n",
       "      <td>6.152137</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.318805</td>\n",
       "      <td>0.888743</td>\n",
       "      <td>0.431848</td>\n",
       "      <td>0.850574</td>\n",
       "      <td>75.580699</td>\n",
       "      <td>6.086446</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.228476</td>\n",
       "      <td>0.920864</td>\n",
       "      <td>0.378354</td>\n",
       "      <td>0.875099</td>\n",
       "      <td>75.295840</td>\n",
       "      <td>6.095031</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.170631</td>\n",
       "      <td>0.940509</td>\n",
       "      <td>0.388311</td>\n",
       "      <td>0.874110</td>\n",
       "      <td>75.272077</td>\n",
       "      <td>6.055991</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.784903</td>\n",
       "      <td>0.727693</td>\n",
       "      <td>0.826308</td>\n",
       "      <td>0.725079</td>\n",
       "      <td>75.122478</td>\n",
       "      <td>6.037605</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.440597</td>\n",
       "      <td>0.848849</td>\n",
       "      <td>0.496616</td>\n",
       "      <td>0.834751</td>\n",
       "      <td>75.305992</td>\n",
       "      <td>6.040748</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.312059</td>\n",
       "      <td>0.892108</td>\n",
       "      <td>0.500058</td>\n",
       "      <td>0.841179</td>\n",
       "      <td>75.803494</td>\n",
       "      <td>6.102520</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.235292</td>\n",
       "      <td>0.918043</td>\n",
       "      <td>0.386566</td>\n",
       "      <td>0.872132</td>\n",
       "      <td>75.945858</td>\n",
       "      <td>6.198591</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.173718</td>\n",
       "      <td>0.938791</td>\n",
       "      <td>0.428564</td>\n",
       "      <td>0.868374</td>\n",
       "      <td>76.028689</td>\n",
       "      <td>6.113453</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.777808</td>\n",
       "      <td>0.731726</td>\n",
       "      <td>0.726269</td>\n",
       "      <td>0.747231</td>\n",
       "      <td>75.536450</td>\n",
       "      <td>6.089193</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.433393</td>\n",
       "      <td>0.851259</td>\n",
       "      <td>0.516232</td>\n",
       "      <td>0.833960</td>\n",
       "      <td>75.657224</td>\n",
       "      <td>6.120879</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.313922</td>\n",
       "      <td>0.891552</td>\n",
       "      <td>0.436574</td>\n",
       "      <td>0.849090</td>\n",
       "      <td>76.521455</td>\n",
       "      <td>6.164129</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.233130</td>\n",
       "      <td>0.918890</td>\n",
       "      <td>0.394114</td>\n",
       "      <td>0.866495</td>\n",
       "      <td>77.375006</td>\n",
       "      <td>6.045778</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.170213</td>\n",
       "      <td>0.940837</td>\n",
       "      <td>0.361331</td>\n",
       "      <td>0.877077</td>\n",
       "      <td>75.607877</td>\n",
       "      <td>6.145055</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   train_loss  train_acc  test_loss  test_acc  train_epoch_time  \\\n",
       "0    0.786795   0.729188   0.673341  0.766218         76.490460   \n",
       "1    0.433911   0.849996   0.557825  0.807852         76.988336   \n",
       "2    0.318805   0.888743   0.431848  0.850574         75.580699   \n",
       "3    0.228476   0.920864   0.378354  0.875099         75.295840   \n",
       "4    0.170631   0.940509   0.388311  0.874110         75.272077   \n",
       "0    0.784903   0.727693   0.826308  0.725079         75.122478   \n",
       "1    0.440597   0.848849   0.496616  0.834751         75.305992   \n",
       "2    0.312059   0.892108   0.500058  0.841179         75.803494   \n",
       "3    0.235292   0.918043   0.386566  0.872132         75.945858   \n",
       "4    0.173718   0.938791   0.428564  0.868374         76.028689   \n",
       "0    0.777808   0.731726   0.726269  0.747231         75.536450   \n",
       "1    0.433393   0.851259   0.516232  0.833960         75.657224   \n",
       "2    0.313922   0.891552   0.436574  0.849090         76.521455   \n",
       "3    0.233130   0.918890   0.394114  0.866495         77.375006   \n",
       "4    0.170213   0.940837   0.361331  0.877077         75.607877   \n",
       "\n",
       "   test_epoch_time  \n",
       "0         6.223612  \n",
       "1         6.152137  \n",
       "2         6.086446  \n",
       "3         6.095031  \n",
       "4         6.055991  \n",
       "0         6.037605  \n",
       "1         6.040748  \n",
       "2         6.102520  \n",
       "3         6.198591  \n",
       "4         6.113453  \n",
       "0         6.089193  \n",
       "1         6.120879  \n",
       "2         6.164129  \n",
       "3         6.045778  \n",
       "4         6.145055  "
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Go through non_compile_results_multiple_runs and create a dataframe for each run then concatenate them together\n",
    "non_compile_results_dfs = []\n",
    "for result in non_compile_results_multiple_runs:\n",
    "    result_df = pd.DataFrame(result)\n",
    "    non_compile_results_dfs.append(result_df)\n",
    "non_compile_results_multiple_runs_df = pd.concat(non_compile_results_dfs)\n",
    "non_compile_results_multiple_runs_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "1e32d6b8-74d5-4fe5-9bac-7858087a7862",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>train_loss</th>\n",
       "      <th>train_acc</th>\n",
       "      <th>test_loss</th>\n",
       "      <th>test_acc</th>\n",
       "      <th>train_epoch_time</th>\n",
       "      <th>test_epoch_time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.783169</td>\n",
       "      <td>0.729536</td>\n",
       "      <td>0.741973</td>\n",
       "      <td>0.746176</td>\n",
       "      <td>75.716463</td>\n",
       "      <td>6.116803</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.435967</td>\n",
       "      <td>0.850035</td>\n",
       "      <td>0.523557</td>\n",
       "      <td>0.825521</td>\n",
       "      <td>75.983851</td>\n",
       "      <td>6.104588</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.314928</td>\n",
       "      <td>0.890801</td>\n",
       "      <td>0.456160</td>\n",
       "      <td>0.846948</td>\n",
       "      <td>75.968549</td>\n",
       "      <td>6.117698</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.232299</td>\n",
       "      <td>0.919266</td>\n",
       "      <td>0.386345</td>\n",
       "      <td>0.871242</td>\n",
       "      <td>76.205568</td>\n",
       "      <td>6.113133</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.171521</td>\n",
       "      <td>0.940046</td>\n",
       "      <td>0.392735</td>\n",
       "      <td>0.873187</td>\n",
       "      <td>75.636214</td>\n",
       "      <td>6.104833</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   train_loss  train_acc  test_loss  test_acc  train_epoch_time  \\\n",
       "0    0.783169   0.729536   0.741973  0.746176         75.716463   \n",
       "1    0.435967   0.850035   0.523557  0.825521         75.983851   \n",
       "2    0.314928   0.890801   0.456160  0.846948         75.968549   \n",
       "3    0.232299   0.919266   0.386345  0.871242         76.205568   \n",
       "4    0.171521   0.940046   0.392735  0.873187         75.636214   \n",
       "\n",
       "   test_epoch_time  \n",
       "0         6.116803  \n",
       "1         6.104588  \n",
       "2         6.117698  \n",
       "3         6.113133  \n",
       "4         6.104833  "
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get the averages across the multiple runs\n",
    "non_compile_results_multiple_runs_df = non_compile_results_multiple_runs_df.groupby(non_compile_results_multiple_runs_df.index).mean()\n",
    "non_compile_results_multiple_runs_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "03ec2d5f-f3ab-4cfa-b8cb-0f18e9091f8e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time to compile: 0.0003705024719238281 | Note: The first time you compile your model, the first few epochs will be slower than subsequent runs.\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "54e62af225f2455a8fa238b7471d08e6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/3 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] Run 1 of 3 for compiled model\n",
      "Epoch: 1 | train_loss: 0.7878 | train_acc: 0.7269 | test_loss: 0.6773 | test_acc: 0.7683 | train_epoch_time: 85.6216 | test_epoch_time: 9.8007\n",
      "Epoch: 2 | train_loss: 0.4309 | train_acc: 0.8519 | test_loss: 0.5041 | test_acc: 0.8306 | train_epoch_time: 66.0778 | test_epoch_time: 4.6948\n",
      "Epoch: 3 | train_loss: 0.3128 | train_acc: 0.8908 | test_loss: 0.4046 | test_acc: 0.8665 | train_epoch_time: 66.5025 | test_epoch_time: 4.7814\n",
      "Epoch: 4 | train_loss: 0.2349 | train_acc: 0.9186 | test_loss: 0.4996 | test_acc: 0.8365 | train_epoch_time: 67.1311 | test_epoch_time: 4.8166\n",
      "Epoch: 5 | train_loss: 0.1817 | train_acc: 0.9362 | test_loss: 0.3733 | test_acc: 0.8798 | train_epoch_time: 66.6246 | test_epoch_time: 4.7042\n",
      "[INFO] Run 2 of 3 for compiled model\n",
      "Epoch: 1 | train_loss: 0.1946 | train_acc: 0.9320 | test_loss: 0.3654 | test_acc: 0.8866 | train_epoch_time: 66.9027 | test_epoch_time: 4.9273\n",
      "Epoch: 2 | train_loss: 0.1263 | train_acc: 0.9563 | test_loss: 0.3591 | test_acc: 0.8890 | train_epoch_time: 67.2379 | test_epoch_time: 4.8269\n",
      "Epoch: 3 | train_loss: 0.0953 | train_acc: 0.9675 | test_loss: 0.4128 | test_acc: 0.8754 | train_epoch_time: 66.5721 | test_epoch_time: 4.8402\n",
      "Epoch: 4 | train_loss: 0.0731 | train_acc: 0.9747 | test_loss: 0.4222 | test_acc: 0.8899 | train_epoch_time: 67.2221 | test_epoch_time: 4.7752\n",
      "Epoch: 5 | train_loss: 0.0675 | train_acc: 0.9772 | test_loss: 0.4411 | test_acc: 0.8801 | train_epoch_time: 66.0375 | test_epoch_time: 4.7081\n",
      "[INFO] Run 3 of 3 for compiled model\n",
      "Epoch: 1 | train_loss: 0.0705 | train_acc: 0.9757 | test_loss: 0.4413 | test_acc: 0.8829 | train_epoch_time: 66.0006 | test_epoch_time: 4.7547\n",
      "Epoch: 2 | train_loss: 0.0616 | train_acc: 0.9784 | test_loss: 0.5542 | test_acc: 0.8535 | train_epoch_time: 65.6224 | test_epoch_time: 4.7328\n",
      "Epoch: 3 | train_loss: 0.0574 | train_acc: 0.9808 | test_loss: 0.4316 | test_acc: 0.8953 | train_epoch_time: 65.5858 | test_epoch_time: 4.7506\n",
      "Epoch: 4 | train_loss: 0.0291 | train_acc: 0.9898 | test_loss: 0.4482 | test_acc: 0.8972 | train_epoch_time: 65.5331 | test_epoch_time: 4.7688\n",
      "Epoch: 5 | train_loss: 0.0363 | train_acc: 0.9878 | test_loss: 0.4421 | test_acc: 0.8918 | train_epoch_time: 65.8635 | test_epoch_time: 4.7198\n"
     ]
    }
   ],
   "source": [
    "# Create compiled model\n",
    "compiled_model = create_compiled_model()\n",
    "\n",
    "# Create an empty list to store compiled model results\n",
    "compiled_results_multiple_runs = []\n",
    "\n",
    "# Run compiled model for multiple runs\n",
    "for i in tqdm(range(NUM_RUNS)):\n",
    "    print(f\"[INFO] Run {i+1} of {NUM_RUNS} for compiled model\")\n",
    "    # Train the compiled model (note: the model will only be compiled once and then re-used for subsequent runs)\n",
    "    results = train_compiled_model(model=compiled_model, epochs=NUM_EPOCHS, disable_progress_bar=True)\n",
    "    compiled_results_multiple_runs.append(results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "23843e87-32e2-4ff7-b5ca-c458860d005e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>train_loss</th>\n",
       "      <th>train_acc</th>\n",
       "      <th>test_loss</th>\n",
       "      <th>test_acc</th>\n",
       "      <th>train_epoch_time</th>\n",
       "      <th>test_epoch_time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.787800</td>\n",
       "      <td>0.726926</td>\n",
       "      <td>0.677275</td>\n",
       "      <td>0.768295</td>\n",
       "      <td>85.621562</td>\n",
       "      <td>9.800743</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.430861</td>\n",
       "      <td>0.851854</td>\n",
       "      <td>0.504077</td>\n",
       "      <td>0.830597</td>\n",
       "      <td>66.077762</td>\n",
       "      <td>4.694848</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.312821</td>\n",
       "      <td>0.890793</td>\n",
       "      <td>0.404571</td>\n",
       "      <td>0.866495</td>\n",
       "      <td>66.502523</td>\n",
       "      <td>4.781373</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.234913</td>\n",
       "      <td>0.918626</td>\n",
       "      <td>0.499595</td>\n",
       "      <td>0.836531</td>\n",
       "      <td>67.131138</td>\n",
       "      <td>4.816620</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.181731</td>\n",
       "      <td>0.936189</td>\n",
       "      <td>0.373278</td>\n",
       "      <td>0.879846</td>\n",
       "      <td>66.624619</td>\n",
       "      <td>4.704153</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.194568</td>\n",
       "      <td>0.931997</td>\n",
       "      <td>0.365353</td>\n",
       "      <td>0.886570</td>\n",
       "      <td>66.902652</td>\n",
       "      <td>4.927339</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.126297</td>\n",
       "      <td>0.956330</td>\n",
       "      <td>0.359148</td>\n",
       "      <td>0.889043</td>\n",
       "      <td>67.237862</td>\n",
       "      <td>4.826863</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.095301</td>\n",
       "      <td>0.967543</td>\n",
       "      <td>0.412823</td>\n",
       "      <td>0.875396</td>\n",
       "      <td>66.572143</td>\n",
       "      <td>4.840187</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.073089</td>\n",
       "      <td>0.974700</td>\n",
       "      <td>0.422213</td>\n",
       "      <td>0.889933</td>\n",
       "      <td>67.222106</td>\n",
       "      <td>4.775151</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.067497</td>\n",
       "      <td>0.977210</td>\n",
       "      <td>0.441127</td>\n",
       "      <td>0.880142</td>\n",
       "      <td>66.037504</td>\n",
       "      <td>4.708092</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.070495</td>\n",
       "      <td>0.975659</td>\n",
       "      <td>0.441296</td>\n",
       "      <td>0.882911</td>\n",
       "      <td>66.000640</td>\n",
       "      <td>4.754683</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.061555</td>\n",
       "      <td>0.978369</td>\n",
       "      <td>0.554178</td>\n",
       "      <td>0.853540</td>\n",
       "      <td>65.622355</td>\n",
       "      <td>4.732759</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.057406</td>\n",
       "      <td>0.980786</td>\n",
       "      <td>0.431582</td>\n",
       "      <td>0.895273</td>\n",
       "      <td>65.585803</td>\n",
       "      <td>4.750594</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.029078</td>\n",
       "      <td>0.989826</td>\n",
       "      <td>0.448227</td>\n",
       "      <td>0.897152</td>\n",
       "      <td>65.533080</td>\n",
       "      <td>4.768819</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.036322</td>\n",
       "      <td>0.987840</td>\n",
       "      <td>0.442069</td>\n",
       "      <td>0.891812</td>\n",
       "      <td>65.863534</td>\n",
       "      <td>4.719811</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   train_loss  train_acc  test_loss  test_acc  train_epoch_time  \\\n",
       "0    0.787800   0.726926   0.677275  0.768295         85.621562   \n",
       "1    0.430861   0.851854   0.504077  0.830597         66.077762   \n",
       "2    0.312821   0.890793   0.404571  0.866495         66.502523   \n",
       "3    0.234913   0.918626   0.499595  0.836531         67.131138   \n",
       "4    0.181731   0.936189   0.373278  0.879846         66.624619   \n",
       "0    0.194568   0.931997   0.365353  0.886570         66.902652   \n",
       "1    0.126297   0.956330   0.359148  0.889043         67.237862   \n",
       "2    0.095301   0.967543   0.412823  0.875396         66.572143   \n",
       "3    0.073089   0.974700   0.422213  0.889933         67.222106   \n",
       "4    0.067497   0.977210   0.441127  0.880142         66.037504   \n",
       "0    0.070495   0.975659   0.441296  0.882911         66.000640   \n",
       "1    0.061555   0.978369   0.554178  0.853540         65.622355   \n",
       "2    0.057406   0.980786   0.431582  0.895273         65.585803   \n",
       "3    0.029078   0.989826   0.448227  0.897152         65.533080   \n",
       "4    0.036322   0.987840   0.442069  0.891812         65.863534   \n",
       "\n",
       "   test_epoch_time  \n",
       "0         9.800743  \n",
       "1         4.694848  \n",
       "2         4.781373  \n",
       "3         4.816620  \n",
       "4         4.704153  \n",
       "0         4.927339  \n",
       "1         4.826863  \n",
       "2         4.840187  \n",
       "3         4.775151  \n",
       "4         4.708092  \n",
       "0         4.754683  \n",
       "1         4.732759  \n",
       "2         4.750594  \n",
       "3         4.768819  \n",
       "4         4.719811  "
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Go through compile_results_multiple_runs and create a dataframe for each run then concatenate them together\n",
    "compile_results_dfs = []\n",
    "for result in compiled_results_multiple_runs:\n",
    "    result_df = pd.DataFrame(result)\n",
    "    compile_results_dfs.append(result_df)\n",
    "compile_results_multiple_runs_df = pd.concat(compile_results_dfs)\n",
    "compile_results_multiple_runs_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "4a6dde60-c895-4bea-bda6-9c41ffc51551",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>train_loss</th>\n",
       "      <th>train_acc</th>\n",
       "      <th>test_loss</th>\n",
       "      <th>test_acc</th>\n",
       "      <th>train_epoch_time</th>\n",
       "      <th>test_epoch_time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.350954</td>\n",
       "      <td>0.878194</td>\n",
       "      <td>0.494641</td>\n",
       "      <td>0.845926</td>\n",
       "      <td>72.841618</td>\n",
       "      <td>6.494255</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.206237</td>\n",
       "      <td>0.928851</td>\n",
       "      <td>0.472468</td>\n",
       "      <td>0.857727</td>\n",
       "      <td>66.312660</td>\n",
       "      <td>4.751490</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.155176</td>\n",
       "      <td>0.946374</td>\n",
       "      <td>0.416325</td>\n",
       "      <td>0.879055</td>\n",
       "      <td>66.220156</td>\n",
       "      <td>4.790718</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.112360</td>\n",
       "      <td>0.961051</td>\n",
       "      <td>0.456679</td>\n",
       "      <td>0.874539</td>\n",
       "      <td>66.628774</td>\n",
       "      <td>4.786863</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.095183</td>\n",
       "      <td>0.967080</td>\n",
       "      <td>0.418824</td>\n",
       "      <td>0.883933</td>\n",
       "      <td>66.175219</td>\n",
       "      <td>4.710686</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   train_loss  train_acc  test_loss  test_acc  train_epoch_time  \\\n",
       "0    0.350954   0.878194   0.494641  0.845926         72.841618   \n",
       "1    0.206237   0.928851   0.472468  0.857727         66.312660   \n",
       "2    0.155176   0.946374   0.416325  0.879055         66.220156   \n",
       "3    0.112360   0.961051   0.456679  0.874539         66.628774   \n",
       "4    0.095183   0.967080   0.418824  0.883933         66.175219   \n",
       "\n",
       "   test_epoch_time  \n",
       "0         6.494255  \n",
       "1         4.751490  \n",
       "2         4.790718  \n",
       "3         4.786863  \n",
       "4         4.710686  "
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get the averages across the multiple runs\n",
    "compile_results_multiple_runs_df = compile_results_multiple_runs_df.groupby(compile_results_multiple_runs_df.index).mean() # .index = groupby the epoch number\n",
    "compile_results_multiple_runs_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "4481c6a9-d620-4649-949b-1ccb6bba8f7f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean train epoch time difference: -10.891% (negative means faster)\n",
      "Mean test epoch time difference: -16.438% (negative means faster)\n",
      "[INFO] Plot saved to pytorch_2_results/figures/multi_run_NVIDIA_GeForce_RTX_4090_ResNet50_CIFAR10_224_train_epoch_time.png\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x700 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create a directory to save the multi-run figure to \n",
    "os.makedirs(\"pytorch_2_results/figures\", exist_ok=True)\n",
    "\n",
    "# Create a path to save the figure for multiple runs\n",
    "save_path_multi_run = f\"pytorch_2_results/figures/multi_run_{GPU_NAME}_{MODEL_NAME}_{DATASET_NAME}_{IMAGE_SIZE}_train_epoch_time.png\"\n",
    "\n",
    "# Plot the mean epoch times for experiment 3 and 4\n",
    "plot_mean_epoch_times(non_compiled_results=non_compile_results_multiple_runs_df, \n",
    "                      compiled_results=compile_results_multiple_runs_df, \n",
    "                      multi_runs=True, \n",
    "                      num_runs=NUM_RUNS, \n",
    "                      save_path=save_path_multi_run, \n",
    "                      save=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "018cbce4-fab4-489b-b6e1-1acb89466f95",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] Saving experiment 3 non-compiled results to: pytorch_2_results/multi_run_results/single_run_non_compiled_results_CIFAR10_ResNet50_NVIDIA_GeForce_RTX_4090.csv\n",
      "[INFO] Saving experiment 4 compiled results to: pytorch_2_results/multi_run_results/single_run_compiled_results_CIFAR10_ResNet50_NVIDIA_GeForce_RTX_4090.csv\n"
     ]
    }
   ],
   "source": [
    "# Make a directory for multi_run results\n",
    "import os\n",
    "pytorch_2_results_dir = \"pytorch_2_results\"\n",
    "pytorch_2_multi_run_results_dir = f\"{pytorch_2_results_dir}/multi_run_results\"\n",
    "os.makedirs(pytorch_2_multi_run_results_dir, exist_ok=True)\n",
    "\n",
    "# Create filenames for each of the dataframes\n",
    "save_name_for_multi_run_non_compiled_results = f\"multi_run_non_compiled_results_{NUM_RUNS}_runs_{DATASET_NAME}_{MODEL_NAME}_{GPU_NAME}.csv\"\n",
    "save_name_for_multi_run_compiled_results = f\"multi_run_compiled_results_{NUM_RUNS}_runs_{DATASET_NAME}_{MODEL_NAME}_{GPU_NAME}.csv\"\n",
    "\n",
    "# Create filepaths to save the results to\n",
    "multi_run_no_compile_save_path = f\"{pytorch_2_multi_run_results_dir}/{save_name_for_non_compiled_results}\"\n",
    "multi_run_compile_save_path = f\"{pytorch_2_multi_run_results_dir}/{save_name_for_compiled_results}\"\n",
    "print(f\"[INFO] Saving experiment 3 non-compiled results to: {multi_run_no_compile_save_path}\")\n",
    "print(f\"[INFO] Saving experiment 4 compiled results to: {multi_run_compile_save_path}\")\n",
    "\n",
    "# Save the results\n",
    "non_compile_results_multiple_runs_df.to_csv(multi_run_no_compile_save_path)\n",
    "compile_results_multiple_runs_df.to_csv(multi_run_compile_save_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "68c05851-1b4e-439a-a40b-ecc1b473d574",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}