{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ec056806",
   "metadata": {},
   "source": [
    "# Lesson 31 demo: Optuna hyperparameter optimization\n",
    "\n",
    "This notebook demonstrates how to use [**Optuna**](https://optuna.org) to automatically find the best hyperparameters for a CNN. Optuna is an awesome optimization framework that can be used to optimize just about *anything* and has a few cool features:\n",
    "\n",
    "1. Intelligent parameter search with advanced sampling algorithms\n",
    "2. Built in 'pruning' of non-promising trials (think early stopping...)\n",
    "3. A built in results logging & dashboard\n",
    "4. The ability to stop and then resume optimization experiments\n",
    "5. Built in parallelism over trials\n",
    "\n",
    "We'll optimize 4 hyperparameters to keep things simple:\n",
    "\n",
    "1. **Number of filters in the first convolutional block** (16 - 128)\n",
    "2. **Number of convolutional blocks** (1 - 5)\n",
    "3. **Dropout rate** (0.2 - 0.5)\n",
    "4. **Learning rate** (1e-5 - 1e-2)\n",
    "\n",
    "## Notebook set up\n",
    "\n",
    "### Required packages\n",
    "\n",
    "To run this notebook you need to install my [`image_classification_tools`](https://pypi.org/project/image-classification-tools) package via pip:\n",
    "\n",
    "```\n",
    "pip install image_classification_tools`\n",
    "```\n",
    "\n",
    "If you are not working in one of the course deeplearning containers, you may also need to pip install `optuna` and `optuna-dashboard`.\n",
    "\n",
    "```\n",
    "pip install optuna optuna-dashboard\n",
    "```\n",
    "\n",
    "The Optuna dashboard can be viewed either via the VS Code extension 'Optuna Dashboard', or via the built-in web server, though the built in web server has more features/plots than the extension. Start it with:\n",
    "\n",
    "```\n",
    "optuna-dashboard sqlite:///data/simple_optimization.db --host 0.0.0.0\n",
    "```\n",
    "\n",
    "> **Note**: running this notebook on a GPU requires >12 GB VRAM, if you run into OOM (out-of-memory) errors, try decreasing the maximum number of convolutional blocks, or the maximum number of filters."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7d9f826",
   "metadata": {},
   "source": [
    "### Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "45009458",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Standard library imports\n",
    "from pathlib import Path\n",
    "\n",
    "# Third-party imports\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import optuna\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "from torch.utils.data import DataLoader\n",
    "\n",
    "# Custom package imports\n",
    "from image_classification_tools.pytorch.training import train_model\n",
    "from image_classification_tools.pytorch.evaluation import evaluate_model\n",
    "from image_classification_tools.pytorch.plotting import (\n",
    "    plot_sample_images,\n",
    "    plot_learning_curves,\n",
    "    plot_confusion_matrix\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31bb8f8f",
   "metadata": {},
   "source": [
    "### Fixed hyperparameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "89b18ffa",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fixed hyperparameters (not optimized)\n",
    "batch_size     = 2000\n",
    "fc_units_1     = 512\n",
    "fc_units_2     = 128\n",
    "use_batch_norm = True\n",
    "\n",
    "# Optuna settings\n",
    "n_trials           = 1   # Number of Optuna trials\n",
    "n_epochs_per_trial = 70  # Short training per trial\n",
    "\n",
    "# Final model training settings\n",
    "n_epochs_final = 100 # Longer training for final model"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "192f67c3",
   "metadata": {},
   "source": [
    "### Other configuration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "69cd7d65",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using device: cuda\n"
     ]
    }
   ],
   "source": [
    "# Suppress Optuna info messages (show only warnings and errors)\n",
    "optuna.logging.set_verbosity(optuna.logging.WARNING)\n",
    "\n",
    "# Check device availability\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "print(f'Using device: {device}')\n",
    "\n",
    "# Storage path for Optuna study\n",
    "storage_path = Path('../data/simple_optimization.db')\n",
    "storage_path.parent.mkdir(parents=True, exist_ok=True)\n",
    "storage_url = f'sqlite:///{storage_path.resolve()}'\n",
    "\n",
    "# CIFAR-10 class names\n",
    "class_names = [\n",
    "    'airplane', 'automobile', 'bird', 'cat', 'deer', \n",
    "    'dog', 'frog', 'horse', 'ship', 'truck'\n",
    "]\n",
    "\n",
    "num_classes = len(class_names)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae3add42",
   "metadata": {},
   "source": [
    "## 1. Load and prepare data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "06308407",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n",
      "\n",
      "Training samples: 50000\n",
      "Test samples: 10000\n"
     ]
    }
   ],
   "source": [
    "# Data directory\n",
    "data_dir = Path('../data')\n",
    "data_dir.mkdir(parents=True, exist_ok=True)\n",
    "\n",
    "# Transform: convert to tensor and normalize RGB channels\n",
    "transform = transforms.Compose([\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))\n",
    "])\n",
    "\n",
    "# Use the fast BrainChip mirror for downloading CIFAR-10\n",
    "torchvision.datasets.CIFAR10.url = 'https://data.brainchip.com/dataset-mirror/cifar10/cifar-10-python.tar.gz'\n",
    "\n",
    "# Download and load CIFAR-10\n",
    "train_dataset = torchvision.datasets.CIFAR10(\n",
    "    root=data_dir,\n",
    "    train=True,\n",
    "    download=True,\n",
    "    transform=transform\n",
    ")\n",
    "\n",
    "test_dataset = torchvision.datasets.CIFAR10(\n",
    "    root=data_dir,\n",
    "    train=False,\n",
    "    download=True,\n",
    "    transform=transform\n",
    ")\n",
    "\n",
    "print(f'\\nTraining samples: {len(train_dataset)}')\n",
    "print(f'Test samples: {len(test_dataset)}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "0b7eeee4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_train: torch.Size([40000, 3, 32, 32])\n",
      "X_val: torch.Size([10000, 3, 32, 32])\n",
      "X_test: torch.Size([10000, 3, 32, 32])\n"
     ]
    }
   ],
   "source": [
    "# Preload data to GPU for faster training\n",
    "X_train_full = torch.stack([img for img, _ in train_dataset]).to(device)\n",
    "y_train_full = torch.tensor([label for _, label in train_dataset]).to(device)\n",
    "X_test = torch.stack([img for img, _ in test_dataset]).to(device)\n",
    "y_test = torch.tensor([label for _, label in test_dataset]).to(device)\n",
    "\n",
    "# Split training data into train and validation sets (80/20)\n",
    "n_train = int(0.8 * len(X_train_full))\n",
    "indices = torch.randperm(len(X_train_full))\n",
    "\n",
    "X_train = X_train_full[indices[:n_train]]\n",
    "y_train = y_train_full[indices[:n_train]]\n",
    "X_val = X_train_full[indices[n_train:]]\n",
    "y_val = y_train_full[indices[n_train:]]\n",
    "\n",
    "print(f'X_train: {X_train.shape}')\n",
    "print(f'X_val: {X_val.shape}')\n",
    "print(f'X_test: {X_test.shape}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "dab7fae8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training batches: 20\n",
      "Validation batches: 5\n",
      "Test batches: 5\n"
     ]
    }
   ],
   "source": [
    "# Create DataLoaders\n",
    "train_tensor_dataset = torch.utils.data.TensorDataset(X_train, y_train)\n",
    "val_tensor_dataset = torch.utils.data.TensorDataset(X_val, y_val)\n",
    "test_tensor_dataset = torch.utils.data.TensorDataset(X_test, y_test)\n",
    "\n",
    "train_loader = DataLoader(train_tensor_dataset, batch_size=batch_size, shuffle=True)\n",
    "val_loader = DataLoader(val_tensor_dataset, batch_size=batch_size, shuffle=False)\n",
    "test_loader = DataLoader(test_tensor_dataset, batch_size=batch_size, shuffle=False)\n",
    "\n",
    "print(f'Training batches: {len(train_loader)}')\n",
    "print(f'Validation batches: {len(val_loader)}')\n",
    "print(f'Test batches: {len(test_loader)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18183370",
   "metadata": {},
   "source": [
    "## 2. Define CNN architecture\n",
    "\n",
    "This function creates a CNN with a configurable number of convolutional blocks and dropout rate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "dc2ade26",
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_cnn(n_filters: int,n_conv_blocks: int, dropout_rate: float) -> nn.Sequential:\n",
    "    '''Create a CNN with configurable architecture.\n",
    "    \n",
    "    Args:\n",
    "        n_conv_blocks: Number of convolutional blocks (1-4)\n",
    "        dropout_rate: Dropout probability\n",
    "    \n",
    "    Returns:\n",
    "        nn.Sequential model\n",
    "    '''\n",
    "\n",
    "    layers = []\n",
    "    in_channels = 3  # RGB input\n",
    "    current_size = 32  # Input image size\n",
    "    initial_filters = n_filters\n",
    "    \n",
    "    for block_idx in range(n_conv_blocks):\n",
    "        out_channels = initial_filters * (2 ** block_idx)\n",
    "        \n",
    "        # Conv -> BatchNorm -> ReLU -> Conv -> BatchNorm -> ReLU -> Pool -> Dropout\n",
    "        layers.append(nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1))\n",
    "        layers.append(nn.BatchNorm2d(out_channels))\n",
    "        layers.append(nn.ReLU())\n",
    "        \n",
    "        layers.append(nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1))\n",
    "        layers.append(nn.BatchNorm2d(out_channels))\n",
    "        layers.append(nn.ReLU())\n",
    "        \n",
    "        layers.append(nn.MaxPool2d(2, 2))\n",
    "        layers.append(nn.Dropout(dropout_rate))\n",
    "        \n",
    "        in_channels = out_channels\n",
    "        current_size //= 2\n",
    "    \n",
    "    # Calculate flattened size\n",
    "    final_channels = n_filters * (2 ** (n_conv_blocks - 1))\n",
    "    flattened_size = final_channels * current_size * current_size\n",
    "    \n",
    "    # Classifier (3 fully connected layers)\n",
    "    layers.append(nn.Flatten())\n",
    "    layers.append(nn.Linear(flattened_size, fc_units_1))\n",
    "    layers.append(nn.ReLU())\n",
    "    layers.append(nn.Dropout(dropout_rate))\n",
    "    layers.append(nn.Linear(fc_units_1, fc_units_2))\n",
    "    layers.append(nn.ReLU())\n",
    "    layers.append(nn.Dropout(dropout_rate))\n",
    "    layers.append(nn.Linear(fc_units_2, num_classes))\n",
    "    \n",
    "    return nn.Sequential(*layers)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4080c835",
   "metadata": {},
   "source": [
    "## 3. Optuna hyperparameter optimization\n",
    "\n",
    "We define an objective function that:\n",
    "1. Samples hyperparameters from defined search spaces\n",
    "2. Creates and trains a model with those hyperparameters\n",
    "3. Returns the validation accuracy to maximize\n",
    "\n",
    "### 3.1. Define training function for trials"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "590f3eab",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_trial(\n",
    "    model: nn.Module,\n",
    "    optimizer: optim.Optimizer,\n",
    "    criterion: nn.Module,\n",
    "    train_loader: DataLoader,\n",
    "    val_loader: DataLoader,\n",
    "    n_epochs: int,\n",
    "    trial: optuna.Trial\n",
    ") -> float:\n",
    "    '''Train a model for a single Optuna trial with pruning support.'''\n",
    "    \n",
    "    best_val_accuracy = 0.0\n",
    "    \n",
    "    for epoch in range(n_epochs):\n",
    "\n",
    "        # Training phase\n",
    "        model.train()\n",
    "\n",
    "        for images, labels in train_loader:\n",
    "            optimizer.zero_grad()\n",
    "            outputs = model(images)\n",
    "            loss = criterion(outputs, labels)\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "        \n",
    "        # Validation phase\n",
    "        model.eval()\n",
    "        val_correct = 0\n",
    "        val_total = 0\n",
    "        \n",
    "        with torch.no_grad():\n",
    "            for images, labels in val_loader:\n",
    "\n",
    "                outputs = model(images)\n",
    "                _, predicted = torch.max(outputs.data, 1)\n",
    "                val_total += labels.size(0)\n",
    "                val_correct += (predicted == labels).sum().item()\n",
    "        \n",
    "        val_accuracy = 100 * val_correct / val_total\n",
    "        best_val_accuracy = max(best_val_accuracy, val_accuracy)\n",
    "        \n",
    "        # Report for pruning\n",
    "        trial.report(val_accuracy, epoch)\n",
    "        \n",
    "        if trial.should_prune():\n",
    "            raise optuna.TrialPruned()\n",
    "    \n",
    "    return best_val_accuracy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "497b5bb3",
   "metadata": {},
   "source": [
    "### 3.2. Define objective function\n",
    "\n",
    "The objective function defines one training run and returns the metric we want to optimize. Optuna will call this function repeatedly with different values selected from our hyperparameter ranges."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "86190b9f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def objective(trial: optuna.Trial) -> float:\n",
    "    '''Optuna objective function: optimize filter number, number of convolutional blocks,\n",
    "    dropout rate and learning rate.'''\n",
    "    \n",
    "    # Hyperparameters to optimize\n",
    "    n_filters = trial.suggest_int('n_filters', 16, 128)\n",
    "    n_conv_blocks = trial.suggest_int('n_conv_blocks', 1, 5)\n",
    "    dropout_rate = trial.suggest_float('dropout_rate', 0.2, 0.5)\n",
    "    learning_rate = trial.suggest_float('learning_rate', 1e-5, 1e-2)\n",
    "    \n",
    "    # Create model\n",
    "    model = create_cnn(\n",
    "        n_filters=n_filters,\n",
    "        n_conv_blocks=n_conv_blocks,\n",
    "        dropout_rate=dropout_rate\n",
    "    ).to(device)\n",
    "    \n",
    "    # Create optimizer\n",
    "    optimizer = optim.Adam(model.parameters(), lr=learning_rate)\n",
    "    \n",
    "    # Set loss function\n",
    "    criterion = nn.CrossEntropyLoss()\n",
    "    \n",
    "    # Train and return validation accuracy\n",
    "    try:\n",
    "        return train_trial(\n",
    "            model=model,\n",
    "            optimizer=optimizer,\n",
    "            criterion=criterion,\n",
    "            train_loader=train_loader,\n",
    "            val_loader=val_loader,\n",
    "            n_epochs=n_epochs_per_trial,\n",
    "            trial=trial\n",
    "        )\n",
    "\n",
    "    except torch.cuda.OutOfMemoryError:\n",
    "\n",
    "        torch.cuda.empty_cache()\n",
    "        raise optuna.TrialPruned('CUDA OOM')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a959352",
   "metadata": {},
   "source": [
    "### 3.3. Run optimization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "ebcf6ba0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5dd0fd5e12a941c3894247345dcfdd95",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/1 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Winning validation accuracy: 86.89%\n",
      "\n",
      "Best hyperparameters:\n",
      " n_filters: 46\n",
      " n_conv_blocks: 4\n",
      " dropout_rate: 0.3062549713903302\n",
      " learning_rate: 0.0015130666936698752\n",
      "\n",
      "CPU times: user 14.4 s, sys: 1.92 s, total: 16.3 s\n",
      "Wall time: 16.1 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "    \n",
    "# Create Optuna study (maximize validation accuracy)\n",
    "study = optuna.create_study(\n",
    "    direction='maximize',\n",
    "    study_name='simple_optimization',\n",
    "    storage=storage_url,\n",
    "    load_if_exists=True,\n",
    "    pruner=optuna.pruners.MedianPruner(n_warmup_steps=3)\n",
    ")\n",
    "\n",
    "# Run optimization\n",
    "study.optimize(objective, n_trials=n_trials, show_progress_bar=True)\n",
    "\n",
    "print(f'Winning validation accuracy: {study.best_trial.value:.2f}%')\n",
    "print(f'\\nBest hyperparameters:')\n",
    "\n",
    "for key, value in study.best_trial.params.items():\n",
    "    print(f' {key}: {value}')\n",
    "\n",
    "print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02c4e964",
   "metadata": {},
   "source": [
    "### 3.4. Visualize optimization results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "25f039d0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axes = plt.subplots(1, 2, figsize=(12, 4))\n",
    "\n",
    "# Optimization history\n",
    "axes[0].set_title('Optimization History')\n",
    "\n",
    "trial_numbers = [t.number for t in study.trials if t.value is not None]\n",
    "trial_values = [t.value for t in study.trials if t.value is not None]\n",
    "\n",
    "axes[0].plot(trial_numbers, trial_values, 'ko-', alpha=0.6)\n",
    "axes[0].axhline(y=study.best_value, color='r', linestyle='--', label=f'Best: {study.best_value:.2f}%')\n",
    "axes[0].set_xlabel('Trial')\n",
    "axes[0].set_ylabel('Validation Accuracy (%)')\n",
    "axes[0].legend()\n",
    "\n",
    "# Hyperparameter importance\n",
    "axes[1].set_title('Hyperparameter Importance')\n",
    "completed_trials = [t for t in study.trials if t.state == optuna.trial.TrialState.COMPLETE]\n",
    "\n",
    "if len(completed_trials) >= 5:\n",
    "    importance = optuna.importance.get_param_importances(study)\n",
    "    params = list(importance.keys())\n",
    "    values = list(importance.values())\n",
    "    axes[1].barh(params, values, color='steelblue')\n",
    "    axes[1].set_xlabel('Importance')\n",
    "\n",
    "else:\n",
    "    axes[1].text(\n",
    "        0.5, 0.5,\n",
    "        'Not enough trials\\nfor importance analysis', \n",
    "        ha='center', va='center', transform=axes[1].transAxes\n",
    "    )\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0568375d",
   "metadata": {},
   "source": [
    "## 4. Train final model with best hyperparameters\n",
    "\n",
    "Now we train the winning model configuration for more epochs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "5633d796",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best hyperparameters:\n",
      " - n_filters: 46\n",
      " - n_conv_blocks: 4\n",
      " - dropout_rate: 0.306\n",
      " - learning_rate: 0.00151\n"
     ]
    }
   ],
   "source": [
    "# Get best hyperparameters\n",
    "best_params = study.best_trial.params\n",
    "\n",
    "print('Best hyperparameters:')\n",
    "print(f' - n_filters: {best_params[\"n_filters\"]}')\n",
    "print(f' - n_conv_blocks: {best_params[\"n_conv_blocks\"]}')\n",
    "print(f' - dropout_rate: {best_params[\"dropout_rate\"]:.3f}')\n",
    "print(f' - learning_rate: {best_params[\"learning_rate\"]:.5f}')\n",
    "\n",
    "# Create model with best hyperparameters\n",
    "best_model = create_cnn(\n",
    "    n_filters=best_params['n_filters'],\n",
    "    n_conv_blocks=best_params['n_conv_blocks'],\n",
    "    dropout_rate=best_params['dropout_rate']\n",
    ").to(device)\n",
    "\n",
    "# Create optimizer\n",
    "best_optimizer = optim.Adam(best_model.parameters(), lr=best_params['learning_rate'])\n",
    "\n",
    "# Set loss function\n",
    "criterion = nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "d45b409e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch   1/100 - loss: 2.0833 - acc: 19.39% - val_loss: 2.4462 - val_acc: 18.68%\n",
      "Epoch  10/100 - loss: 0.7981 - acc: 71.92% - val_loss: 0.8968 - val_acc: 68.63%\n",
      "Epoch  20/100 - loss: 0.4444 - acc: 84.73% - val_loss: 0.5398 - val_acc: 81.83%\n",
      "Epoch  30/100 - loss: 0.2815 - acc: 90.28% - val_loss: 0.5577 - val_acc: 83.50%\n",
      "Epoch  40/100 - loss: 0.1815 - acc: 93.61% - val_loss: 0.5760 - val_acc: 85.26%\n",
      "Epoch  50/100 - loss: 0.1230 - acc: 95.82% - val_loss: 0.6085 - val_acc: 85.62%\n",
      "Epoch  60/100 - loss: 0.0919 - acc: 96.91% - val_loss: 0.5841 - val_acc: 86.41%\n",
      "Epoch  70/100 - loss: 0.0764 - acc: 97.48% - val_loss: 0.7218 - val_acc: 85.38%\n",
      "Epoch  80/100 - loss: 0.0623 - acc: 97.95% - val_loss: 0.6653 - val_acc: 86.58%\n",
      "Epoch  90/100 - loss: 0.0465 - acc: 98.42% - val_loss: 0.7240 - val_acc: 86.71%\n",
      "Epoch 100/100 - loss: 0.0480 - acc: 98.47% - val_loss: 0.6616 - val_acc: 86.88%\n",
      "CPU times: user 12min 23s, sys: 499 ms, total: 12min 24s\n",
      "Wall time: 12min 19s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "# Train for more epochs\n",
    "history = train_model(\n",
    "    model=best_model,\n",
    "    train_loader=train_loader,\n",
    "    val_loader=val_loader,\n",
    "    criterion=criterion,\n",
    "    optimizer=best_optimizer,\n",
    "    epochs=n_epochs_final,\n",
    "    print_every=10\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "57e97c64",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot learning curves\n",
    "fig, axes = plot_learning_curves(history)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "893772dd",
   "metadata": {},
   "source": [
    "## 5. Evaluate on test set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "7cab2506",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test accuracy: 85.62%\n"
     ]
    }
   ],
   "source": [
    "test_accuracy, predictions, true_labels = evaluate_model(best_model, test_loader)\n",
    "print(f'Test accuracy: {test_accuracy:.2f}%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "4c1f8d03",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Confusion matrix\n",
    "fig, ax = plot_confusion_matrix(true_labels, predictions, class_names)\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}