03_train_test.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Dict, List, Tuple\n",
    "import torch\n",
    "from torch.utils.data import DataLoader\n",
    "from torch import nn\n",
    "from torch.utils.tensorboard import SummaryWriter\n",
    "from tqdm.auto import tqdm\n",
    "from datetime import datetime\n",
    "from utils.engine import train_func, test_func\n",
    "from utils.engine import set_seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from utils.data_load import load_data\n",
    "\n",
    "train_dataloader, test_dataloader = load_data(\"output/\", 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'cuda'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_func_profiler(model: nn.Module, data: DataLoader, loss_fn:nn.Module,\n",
    "               optimizer: torch.optim.Optimizer, device: torch.device\n",
    "               , log_dir: str) -> Tuple[float, float]:\n",
    "    \"\"\"\n",
    "    Trains a model for a single epoch\n",
    "\n",
    "    Args\n",
    "    ----\n",
    "        model: A Pytorch model\n",
    "        data: a DataLoader object with the train data\n",
    "        loss_fn: loss function to minimized\n",
    "        optimizer: A Pytorch optimizer\n",
    "        device: A target device to perform the operations (\"cuda\" or \"cpu\")\n",
    "\n",
    "    Returns\n",
    "    ------\n",
    "        A tuple with the loss and accuracy of the training epoch like\n",
    "        (train_loss, train_acc)\n",
    "    \"\"\"\n",
    "    def trace_handler(prof):\n",
    "        print(prof.key_averages().table(sort_by=\"self_cuda_time_total\", row_limit=-1))\n",
    "\n",
    "    model.train()\n",
    "    train_loss, train_acc = 0, 0\n",
    "    with torch.profiler.profile(\n",
    "        schedule=torch.profiler.schedule(\n",
    "            wait=1,\n",
    "            warmup=1,\n",
    "            active=1,\n",
    "            repeat=1),\n",
    "        #on_trace_ready=trace_handler,\n",
    "        on_trace_ready=torch.profiler.tensorboard_trace_handler(\"./log\"),\n",
    "        with_stack=True\n",
    "    ) as profiler:\n",
    "        for _ , (x, y) in enumerate(data):\n",
    "            x, y = x.to(device), y.to(device)\n",
    "            y_logit = model(x)\n",
    "            loss = loss_fn(y_logit, y)\n",
    "            train_loss += loss.item()\n",
    "            optimizer.zero_grad()\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "            profiler.step()\n",
    "            y_pred = torch.softmax(y_logit, 1).argmax(1)\n",
    "            train_acc += (y_pred == y).sum().item() / len (y_pred)\n",
    "            #We can use another function if we want\n",
    "    train_loss = train_loss / len(data)\n",
    "    train_acc = train_acc / len(data)\n",
    "    return train_loss, train_acc                            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(model: nn.Module, test_data: DataLoader, train_data: DataLoader, loss_fn:nn.Module,\n",
    "        optimizer: torch.optim.Optimizer, device: torch.device, epochs: int\n",
    "        , writer: SummaryWriter) -> Dict[str, List]:\n",
    "    \"\"\"\n",
    "    Trains and test a Pytorch model\n",
    "\n",
    "    Args:\n",
    "    -----\n",
    "        model: A Pytorch model\n",
    "        train_data: a DataLoader object with the train data\n",
    "        test_data: a DataLoader object with the train data\n",
    "        loss_fn: loss function to minimized\n",
    "        optimizer: A Pytorch optimizer\n",
    "        device: A target device to perform the operations (\"cuda\" or \"cpu\")\n",
    "        epochs: A integre with the number of epochs that the model will be train\n",
    "    Returns:\n",
    "    --------\n",
    "        A dictionary with the train and test loss and accuracy for every epoch\n",
    "        in the form of \n",
    "        {\"train_loss\": [...],\n",
    "        \"train_acc\": [...],\n",
    "        \"test_loss\": [...],\n",
    "        \"test_acc\": [...]}\n",
    "    \"\"\"\n",
    "    results = {\n",
    "        \"train_loss\": [],\n",
    "        \"train_acc\": [],\n",
    "        \"test_loss\": [],\n",
    "        \"test_acc\": []\n",
    "    }\n",
    "    for epoch in tqdm(range(epochs)):\n",
    "        train_loss, train_acc = train_func(\n",
    "            model,train_data,loss_fn,optimizer, device)\n",
    "        test_loss, test_acc = test_func(\n",
    "            model, test_data, loss_fn, device)\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",
    "        )\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",
    "\n",
    "        ##Add of the writer\n",
    "        if writer:\n",
    "            writer.add_scalars(main_tag=\"Loss\", \n",
    "            tag_scalar_dict={\"train_loss\": train_loss, \"tests_loss\": test_loss},\n",
    "            global_step=epoch\n",
    "            )\n",
    "\n",
    "            writer.add_scalars(main_tag=\"Accuracy\", \n",
    "            tag_scalar_dict={\"train_acc\": train_acc, \"tests_acc\": test_acc},\n",
    "            global_step=epoch\n",
    "            )\n",
    "\n",
    "            writer.close()\n",
    "    return results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TinyVGG(nn.Module):\n",
    "    \"\"\"\n",
    "    Model architecture copying TinyVGG from: \n",
    "    https://poloclub.github.io/cnn-explainer/\n",
    "    \"\"\"\n",
    "    def __init__(self, input_shape: int, hidden_units: int, output_shape: int) -> None:\n",
    "        super().__init__()\n",
    "        self.conv_block_1 = nn.Sequential(\n",
    "            nn.Conv3d(in_channels=input_shape, \n",
    "                      out_channels=hidden_units, \n",
    "                      kernel_size=3, # how big is the square that's going over the image?\n",
    "                      stride=1, # default\n",
    "                      padding=1), # options = \"valid\" (no padding) or \"same\" (output has same shape as input) or int for specific number \n",
    "            nn.ReLU(),\n",
    "            nn.Conv3d(in_channels=hidden_units, \n",
    "                      out_channels=hidden_units,\n",
    "                      kernel_size=3,\n",
    "                      stride=1,\n",
    "                      padding=1),\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool3d(kernel_size=2,\n",
    "                         stride=2) # default stride value is same as kernel_size\n",
    "        )\n",
    "        self.conv_block_2 = nn.Sequential(\n",
    "            nn.Conv3d(hidden_units, hidden_units, kernel_size=3, padding=1),\n",
    "            nn.ReLU(),\n",
    "            nn.Conv3d(hidden_units, hidden_units, kernel_size=3, padding=1),\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool3d(2)\n",
    "        )\n",
    "        self.classifier = nn.Sequential(\n",
    "            nn.Flatten(),\n",
    "            # Where did this in_features shape come from? \n",
    "            # It's because each layer of our network compresses and changes the shape of our inputs data.\n",
    "            nn.LayerNorm((836352,), elementwise_affine=False, eps=1e-5),\n",
    "            nn.Linear(in_features= 836352,\n",
    "                      out_features=output_shape)\n",
    "        )\n",
    "    \n",
    "    def forward(self, x: torch.Tensor):\n",
    "        x = self.conv_block_1(x)\n",
    "        # print(x.shape)\n",
    "        x = self.conv_block_2(x)\n",
    "        x = self.classifier(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_write(name: str, model: str, extra: str=None) -> SummaryWriter():\n",
    "    from datetime import datetime\n",
    "    import os\n",
    "\n",
    "    timestamp = datetime.now().strftime(\"%Y-%m-%d\")\n",
    "    if extra:\n",
    "        log_dir = os.path.join(\"runs\", timestamp, name, model, extra)\n",
    "    else:\n",
    "        log_dir = os.path.join(\"runs\", timestamp, name, model)\n",
    "    print(f\"[INFO] create summary writer, saving to: {log_dir}\")\n",
    "    return SummaryWriter(log_dir=log_dir)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_epochs = [2, 5, 10]\n",
    "optimizers = [\"Adam\", \"SGD\", \"Adamw\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def select_optimizer(model: nn.Module, optimizer: str):\n",
    "    if optimizer == \"Adam\":\n",
    "        return torch.optim.Adam(model.parameters(), lr=0.001)\n",
    "    elif optimizer == \"SGD\": \n",
    "        return torch.optim.SGD(model.parameters(), lr=0.001)\n",
    "    elif optimizer == \"Adamw\":\n",
    "        return torch.optim.AdamW(model.parameters(), lr=0.001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] Experiment number: 1\n",
      "[INFO] model: TinyVGG\n",
      "[INFO] Optimizer: Adam\n",
      "[INFO] Epochs: 2\n",
      "[INFO] create summary writer, saving to: runs/2024-11-21/Adam/TinyVGG/2\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "928050ce50d5453ca9493182f14a7178",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/2 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 |train_loss : 0.5387 |train_acc : 0.6667 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 2 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "--------------------------------------------------\n",
      "\n",
      "[INFO] Experiment number: 2\n",
      "[INFO] model: TinyVGG\n",
      "[INFO] Optimizer: SGD\n",
      "[INFO] Epochs: 2\n",
      "[INFO] create summary writer, saving to: runs/2024-11-21/SGD/TinyVGG/2\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "62d95364c6f94841a04d401ee48d297a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/2 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 |train_loss : 0.4216 |train_acc : 0.6667 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 2 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "--------------------------------------------------\n",
      "\n",
      "[INFO] Experiment number: 3\n",
      "[INFO] model: TinyVGG\n",
      "[INFO] Optimizer: Adamw\n",
      "[INFO] Epochs: 2\n",
      "[INFO] create summary writer, saving to: runs/2024-11-21/Adamw/TinyVGG/2\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4cefead976c74e1fbdb3d78b43b53d64",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/2 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 |train_loss : 0.4064 |train_acc : 0.6667 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 2 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "--------------------------------------------------\n",
      "\n",
      "[INFO] Experiment number: 4\n",
      "[INFO] model: TinyVGG\n",
      "[INFO] Optimizer: Adam\n",
      "[INFO] Epochs: 5\n",
      "[INFO] create summary writer, saving to: runs/2024-11-21/Adam/TinyVGG/5\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e5419be5963c420d833c264707de3d2f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 |train_loss : 0.2911 |train_acc : 0.8333 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 2 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 3 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 4 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 5 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "--------------------------------------------------\n",
      "\n",
      "[INFO] Experiment number: 5\n",
      "[INFO] model: TinyVGG\n",
      "[INFO] Optimizer: SGD\n",
      "[INFO] Epochs: 5\n",
      "[INFO] create summary writer, saving to: runs/2024-11-21/SGD/TinyVGG/5\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c5e1c4fc870d48a59e28ea194f930081",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 |train_loss : 0.3085 |train_acc : 0.6667 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 2 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 3 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 4 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 5 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "--------------------------------------------------\n",
      "\n",
      "[INFO] Experiment number: 6\n",
      "[INFO] model: TinyVGG\n",
      "[INFO] Optimizer: Adamw\n",
      "[INFO] Epochs: 5\n",
      "[INFO] create summary writer, saving to: runs/2024-11-21/Adamw/TinyVGG/5\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "bc7fac7365a34a209f38f78bcd3a5f26",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 |train_loss : 0.2244 |train_acc : 0.8333 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 2 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 3 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 4 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 5 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "--------------------------------------------------\n",
      "\n",
      "[INFO] Experiment number: 7\n",
      "[INFO] model: TinyVGG\n",
      "[INFO] Optimizer: Adam\n",
      "[INFO] Epochs: 10\n",
      "[INFO] create summary writer, saving to: runs/2024-11-21/Adam/TinyVGG/10\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ef71213a892142efb756906ddbf2b6ed",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 |train_loss : 0.2883 |train_acc : 0.6667 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 2 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 3 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 4 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 5 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 6 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 7 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 8 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 9 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 10 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "--------------------------------------------------\n",
      "\n",
      "[INFO] Experiment number: 8\n",
      "[INFO] model: TinyVGG\n",
      "[INFO] Optimizer: SGD\n",
      "[INFO] Epochs: 10\n",
      "[INFO] create summary writer, saving to: runs/2024-11-21/SGD/TinyVGG/10\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "deb328297d24499abaeebc3d895c9f7a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 |train_loss : 0.1136 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 2 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 3 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 4 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 5 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 6 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 7 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 8 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 9 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 10 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "--------------------------------------------------\n",
      "\n",
      "[INFO] Experiment number: 9\n",
      "[INFO] model: TinyVGG\n",
      "[INFO] Optimizer: Adamw\n",
      "[INFO] Epochs: 10\n",
      "[INFO] create summary writer, saving to: runs/2024-11-21/Adamw/TinyVGG/10\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f41c08c52dfc45d18dee6c7f68cc74e7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 |train_loss : 0.2061 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 2 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 3 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 4 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 5 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 6 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 7 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 8 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 9 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "Epoch 10 |train_loss : 0.0000 |train_acc : 1.0000 |test_loss : 0.0000 |test_acc : 1.0000 \n",
      "--------------------------------------------------\n",
      "\n"
     ]
    }
   ],
   "source": [
    "set_seed()\n",
    "\n",
    "experiment_number = 0\n",
    "model_num = 0\n",
    "loss_fn = nn.CrossEntropyLoss().to(device)\n",
    "timestamp = datetime.now().strftime(\"%Y-%m-%d\")\n",
    "\n",
    "for epochs in num_epochs:\n",
    "    for optimizer_name in optimizers:\n",
    "        experiment_number += 1\n",
    "        model_name = \"TinyVGG\"\n",
    "        print(f\"[INFO] Experiment number: {experiment_number}\")\n",
    "        print(f\"[INFO] model: {model_name}\")\n",
    "        print(f\"[INFO] Optimizer: {optimizer_name}\")\n",
    "        print(f\"[INFO] Epochs: {epochs}\")\n",
    "        model = TinyVGG(input_shape=1, hidden_units=64, output_shape=2).to(device)\n",
    "        writer = create_write(name=optimizer_name, \n",
    "        model=model_name, extra=str(epochs))\n",
    "        #log_dir = os.path.join(\"log\", timestamp + optimizer + name + str(epochs))\n",
    "        optimizer = select_optimizer(model, optimizer_name)\n",
    "        results = train(model, test_dataloader, train_dataloader, loss_fn, optimizer, device,\n",
    "        epochs, writer)\n",
    "        print(\"-\" * 50 + \"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.cuda.empty_cache()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from utils.summary_utils import plot_roc_curve\n",
    "from sklearn.metrics import roc_curve, auc\n",
    "\n",
    "train_labels, train_preds = [0, 1, 0, 1], [1, 0, 1, 1]\n",
    "\n",
    "fprr, tprr, _ = roc_curve(train_labels, train_preds)\n",
    "roc_auc = auc(fprr, tprr)\n",
    "roc_fig = plot_roc_curve(fprr, tprr, roc_auc)\n",
    "\n",
    "roc_fig\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pytorch",
   "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.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}