Step_3_Hyperparameters_tuning_2.ipynb

{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"provenance":[],"toc_visible":true,"gpuType":"T4"},"kernelspec":{"name":"python3","display_name":"Python 3"},"language_info":{"name":"python"},"accelerator":"GPU"},"cells":[{"cell_type":"markdown","source":["## Imports"],"metadata":{"id":"8XCwIZxBEpte"}},{"cell_type":"code","execution_count":1,"metadata":{"id":"q_ubBRyrDsCj","executionInfo":{"status":"ok","timestamp":1734435038446,"user_tz":-60,"elapsed":12391,"user":{"displayName":"ombrali","userId":"07436965216173521894"}}},"outputs":[],"source":["from google.colab import drive\n","import zipfile\n","import os\n","\n","import torch\n","import random\n","from torchvision import datasets, transforms, models\n","from torch.utils.data import DataLoader, Dataset, WeightedRandomSampler\n","from PIL import Image\n","import matplotlib.pyplot as plt\n","import numpy as np\n","import torch.nn as nn\n","import torch.optim as optim\n","from sklearn.metrics import f1_score\n","from torchvision.models import googlenet\n","from torch.optim.lr_scheduler import CosineAnnealingLR, ReduceLROnPlateau"]},{"cell_type":"code","source":["# Use drive.mount with force_remount=True\n","drive.mount('/content/drive')"],"metadata":{"id":"ARL9ngsdETr2","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1734435057123,"user_tz":-60,"elapsed":18685,"user":{"displayName":"ombrali","userId":"07436965216173521894"}},"outputId":"f50749e3-3e32-4f17-9605-a4b5684292cd"},"execution_count":2,"outputs":[{"output_type":"stream","name":"stdout","text":["Mounted at /content/drive\n"]}]},{"cell_type":"code","source":["# Path to your ZIP file in Google Drive\n","zip_path = '/content/drive/MyDrive/ML Project 2 :)/data (2).zip'\n","\n","# Extract to a working directory\n","extract_path = '/content/dataset'\n","with zipfile.ZipFile(zip_path, 'r') as zip_ref:\n","    zip_ref.extractall(extract_path)"],"metadata":{"id":"uq06GqLzEVH-","executionInfo":{"status":"ok","timestamp":1734435090024,"user_tz":-60,"elapsed":32908,"user":{"displayName":"ombrali","userId":"07436965216173521894"}}},"execution_count":3,"outputs":[]},{"cell_type":"markdown","source":["## Utility functions"],"metadata":{"id":"d_pM83StEXb7"}},{"cell_type":"markdown","source":["### Data augmentation"],"metadata":{"id":"WFdGjDXqEvJ2"}},{"cell_type":"code","source":["class AugmentedDataset(torch.utils.data.Dataset):\n","    def __init__(self, dataset, clean_percentage=0.0, cracked_percentage=0.0,\n","                 clean_lighting_percentage=0.0, cracked_lighting_percentage=0.0,\n","                 seed=None, device='cpu'):\n","        \"\"\"\n","        Custom dataset to apply random transformations selectively and augment dataset size.\n","\n","        Args:\n","            dataset: Original dataset (e.g., datasets.ImageFolder).\n","            clean_percentage (float): Percentage of 'clean' (label 0) to apply transformations.\n","            cracked_percentage (float): Percentage of 'cracked' (label 1) to apply transformations.\n","            clean_lighting_percentage (float): Percentage of 'clean' (label 0) to apply random lighting shifts.\n","            cracked_lighting_percentage (float): Percentage of 'cracked' (label 1) to apply random lighting shifts.\n","            seed (int, optional): Random seed for reproducibility.\n","            device (str): Device to use ('cpu' or 'cuda').\n","        \"\"\"\n","        self.dataset = dataset\n","        self.clean_percentage = clean_percentage\n","        self.cracked_percentage = cracked_percentage\n","        self.clean_lighting_percentage = clean_lighting_percentage\n","        self.cracked_lighting_percentage = cracked_lighting_percentage\n","        self.device = device\n","\n","        if seed is not None:\n","            random.seed(seed)\n","            np.random.seed(seed)\n","\n","        # Separate indices by labels\n","        self.clean_indices = [i for i, (_, label) in enumerate(dataset) if label == 0]\n","        self.cracked_indices = [i for i, (_, label) in enumerate(dataset) if label == 1]\n","\n","        # Precompute augmented data indices\n","        self.rotation_indices = set(\n","            random.sample(self.clean_indices, int(len(self.clean_indices) * clean_percentage)) +\n","            random.sample(self.cracked_indices, int(len(self.cracked_indices) * cracked_percentage))\n","        )\n","        self.lighting_indices = set(\n","            random.sample(self.clean_indices, int(len(self.clean_indices) * clean_lighting_percentage)) +\n","            random.sample(self.cracked_indices, int(len(self.cracked_indices) * cracked_lighting_percentage))\n","        )\n","\n","        self.rotation_transforms = self.get_rotation_transforms()\n","\n","    def get_rotation_transforms(self):\n","        \"\"\"\n","        Predefine transformations for random rotations and flips.\n","        \"\"\"\n","        return [\n","            lambda x: x.transpose(-1, -2),   # 90 degrees rotation\n","            lambda x: torch.flip(x, dims=(-1, -2)),  # 180 degrees rotation\n","            lambda x: torch.rot90(x, k=3, dims=(-1, -2)),  # 270 degrees rotation\n","            lambda x: torch.flip(x, dims=(-1,)),  # Horizontal (N-S) flip\n","            lambda x: torch.flip(x, dims=(-2,))   # Vertical (E-W) flip\n","        ]\n","\n","    def __len__(self):\n","        return len(self.dataset) + len(self.rotation_indices) + len(self.lighting_indices)\n","\n","    def __getitem__(self, idx):\n","        if idx < len(self.dataset):\n","            # For original dataset items, just return the image and label\n","            img, label = self.dataset[idx]\n","            return img.to(self.device), label\n","\n","        # Handle augmented data (rotations and flips)\n","        idx -= len(self.dataset)\n","        if idx < len(self.rotation_indices):\n","            aug_idx = list(self.rotation_indices)[idx]\n","            img, label = self.dataset[aug_idx]\n","            return self.apply_random_transformation(img.to(self.device)), label\n","\n","        # Handle lighting shift augmentation\n","        idx -= len(self.rotation_indices)\n","        aug_idx = list(self.lighting_indices)[idx]\n","        img, label = self.dataset[aug_idx]\n","        return self.apply_lighting_shift(img.to(self.device)), label\n","\n","    def apply_random_transformation(self, img_tensor):\n","        \"\"\"\n","        Apply a random transformation (rotation or flip).\n","        \"\"\"\n","        transform = random.choice(self.rotation_transforms)\n","        return transform(img_tensor)\n","\n","    def apply_lighting_shift(self, img_tensor):\n","        \"\"\"\n","        Apply a random lighting shift to the tensor image.\n","        \"\"\"\n","        brightness_factor = torch.FloatTensor(1).uniform_(0.8, 1.2).item()\n","        return img_tensor * brightness_factor"],"metadata":{"id":"Y7R4PmLNEYOu","executionInfo":{"status":"ok","timestamp":1734435090026,"user_tz":-60,"elapsed":15,"user":{"displayName":"ombrali","userId":"07436965216173521894"}}},"execution_count":4,"outputs":[]},{"cell_type":"markdown","source":["### ROC curves and AUC"],"metadata":{"id":"BVhg8XhHEzpP"}},{"cell_type":"code","source":["from sklearn.metrics import roc_curve, auc\n","\n","def plot_average_roc(models, val_loader, device, labels):\n","    \"\"\"\n","    Plots the ROC curve for multiple models and their average.\n","\n","    Args:\n","        models (list of torch.nn.Module): List of trained models.\n","        val_loader (DataLoader): DataLoader for the validation set.\n","        device (torch.device): Device to use (CPU or GPU).\n","        labels (list of str): Names of the models for legend labeling.\n","    \"\"\"\n","    all_fpr = np.linspace(0, 1, 100)  # Common FPR axis for interpolation\n","    tpr_list = []  # Store TPR values for each model's interpolated curve\n","    auc_list = []  # Store AUC values for each model\n","\n","    plt.figure(figsize=(10, 8))\n","\n","    for i, model in enumerate(models):\n","        model.eval()\n","        true_labels = []\n","        pred_probs = []\n","\n","        # Disable gradient computation during evaluation\n","        with torch.no_grad():\n","            for images, labels in val_loader:\n","                images, labels = images.to(device), labels.to(device)\n","\n","                # Forward pass\n","                outputs = model(images)\n","                probabilities = outputs[:, 1]  # Use logits for positive class\n","\n","                # Append true labels and predicted probabilities\n","                true_labels.extend(labels.cpu().numpy())\n","                pred_probs.extend(probabilities.cpu().numpy())\n","\n","        # Calculate ROC curve metrics\n","        fpr, tpr, _ = roc_curve(true_labels, pred_probs)\n","        roc_auc = auc(fpr, tpr)\n","        auc_list.append(roc_auc)\n","\n","        # Interpolate TPR to common FPR axis\n","        interpolated_tpr = np.interp(all_fpr, fpr, tpr)\n","        tpr_list.append(interpolated_tpr)\n","\n","        # Plot individual model's ROC curve in light grey\n","        plt.plot(fpr, tpr, color='lightgrey', lw=1, label=f\"{labels[i]} (AUC = {roc_auc:.2f})\")\n","\n","    # Compute the average TPR\n","    mean_tpr = np.mean(tpr_list, axis=0)\n","    mean_auc = auc(all_fpr, mean_tpr)\n","\n","    # Plot the average ROC curve in blue\n","    plt.plot(all_fpr, mean_tpr, color='blue', lw=2, label=f\"Average (AUC = {mean_auc:.2f})\")\n","\n","    # Add baseline\n","    plt.plot([0, 1], [0, 1], color='red', linestyle='--', label=\"Random Classifier (AUC = 0.5)\")\n","\n","    # Add labels, title, and legend\n","    plt.xlabel(\"False Positive Rate\")\n","    plt.ylabel(\"True Positive Rate\")\n","    plt.title(\"Average ROC Curve Across Models\")\n","    plt.legend(loc=\"lower right\")\n","    plt.grid()\n","    plt.show()"],"metadata":{"id":"fJPSlXaEEeEe","executionInfo":{"status":"ok","timestamp":1734435090027,"user_tz":-60,"elapsed":13,"user":{"displayName":"ombrali","userId":"07436965216173521894"}}},"execution_count":5,"outputs":[]},{"cell_type":"markdown","source":["## Training"],"metadata":{"id":"oDKZp2p-EhQW"}},{"cell_type":"code","source":["transform = transforms.Compose([\n","    transforms.Resize((224, 224)),  # Resize the image to 224x224 for ResNet\n","    transforms.ToTensor(),  # Convert to Tensor\n","    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),  # Normalize with ImageNet stats to use pretrained weights\n","])\n","\n","# Load the datasets again using the final transformation\n","train_dataset = datasets.ImageFolder(os.path.join(extract_path, 'train'), transform=transform)\n","val_dataset = datasets.ImageFolder(os.path.join(extract_path, 'validation'), transform=transform)\n","\n","val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False)"],"metadata":{"id":"n9UsXURaEh6l","executionInfo":{"status":"ok","timestamp":1734435090297,"user_tz":-60,"elapsed":282,"user":{"displayName":"ombrali","userId":"07436965216173521894"}}},"execution_count":6,"outputs":[]},{"cell_type":"markdown","source":["Apply the best augmentation found :"],"metadata":{"id":"EZp4LOrSJFf4"}},{"cell_type":"code","source":["print(len(train_dataset))\n","\n","clean_rotation_percentage=0.5\n","cracked_rotation_percentage=0.5\n","clean_lighting_percentage=0.0\n","cracked_lighting_percentage=0.0\n","seed=42\n","device='cuda' if torch.cuda.is_available() else 'cpu'\n","\n","augmented_dataset1 = AugmentedDataset(\n","        train_dataset, clean_rotation_percentage, cracked_rotation_percentage, clean_lighting_percentage, cracked_lighting_percentage, seed, device)\n","\n","print(len(augmented_dataset1)) #Not actual size: the class ads indices, and when those are accessed during training an augment is applied acc to if\n","                               #they belong to rotation indices or lighting ones\n","\n","train_loader = DataLoader(augmented_dataset1, batch_size=32, shuffle=True)"],"metadata":{"id":"lzAXmk3VIwgh","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1734435299802,"user_tz":-60,"elapsed":209514,"user":{"displayName":"ombrali","userId":"07436965216173521894"}},"outputId":"9cb439df-8f27-48cb-b15b-df7142344436"},"execution_count":7,"outputs":[{"output_type":"stream","name":"stdout","text":["52193\n","78289\n"]}]},{"cell_type":"markdown","source":["Start with a lower learning rate (1e-4), as we have more epochs. This value is used throughout litterature to fine-tune pretrained models :"],"metadata":{"id":"lX-eLOdDJYVT"}},{"cell_type":"code","source":["def create_googlenet():\n","    model = googlenet(weights=\"IMAGENET1K_V1\")\n","    model.fc = nn.Linear(model.fc.in_features, 2)\n","    return model\n","\n","# Define optimizer function\n","def optimizer_fn(params):\n","    return torch.optim.Adam(params, lr=1e-5)\n","\n","criterion = nn.CrossEntropyLoss()"],"metadata":{"id":"RGSJIuQ4Ejw-","executionInfo":{"status":"ok","timestamp":1734435299803,"user_tz":-60,"elapsed":16,"user":{"displayName":"ombrali","userId":"07436965216173521894"}}},"execution_count":8,"outputs":[]},{"cell_type":"markdown","source":["### Reduce LR on plateau"],"metadata":{"id":"dpY5Sd4DHgAA"}},{"cell_type":"code","source":["def train_and_plot_reduceLRplateau(train_loader, val_loader, model_fn, criterion, optimizer_fn, device, num_epochs, n_trials, patience, save_dir):\n","    \"\"\"\n","    Trains a model n times with a ReduceLROnPlateau scheduler, saves the model after each trial,\n","    and plots the training and validation loss per epoch. Implements early stopping.\n","\n","    Args:\n","        train_loader (DataLoader): DataLoader for training data.\n","        val_loader (DataLoader): DataLoader for validation data.\n","        model_fn (function): A callable that returns a new model instance initialized with pre-trained weights.\n","        criterion (torch.nn.Module): Loss function.\n","        optimizer_fn (function): Function to create a new optimizer instance for each trial.\n","        device (torch.device): Device to use (CPU or GPU).\n","        num_epochs (int): Number of epochs per training.\n","        n_trials (int): Number of training repetitions.\n","        patience (int): Number of epochs to wait for validation loss improvement before stopping early.\n","        save_dir (str): Directory where the model for each trial will be saved.\n","    \"\"\"\n","    # Ensure the save directory exists\n","    os.makedirs(save_dir, exist_ok=True)\n","\n","    sample_model = model_fn()\n","    model_name = type(sample_model).__name__\n","\n","    plt.figure(figsize=(10, 6))\n","\n","    # To store all losses for averaging\n","    all_train_losses = []\n","    all_val_losses = []\n","\n","    for trial in range(n_trials):\n","        # Reinitialize the model with ImageNet weights\n","        model = model_fn().to(device)\n","\n","        # Create a new optimizer instance for this trial\n","        optimizer = optimizer_fn(model.parameters())\n","\n","        # Set up ReduceLROnPlateau scheduler\n","        lr_scheduler = lr_scheduler = ReduceLROnPlateau(optimizer, mode='min', patience=5, factor=0.1, verbose=True, min_lr=1e-6)\n","\n","        train_losses = []\n","        val_losses = []\n","\n","        best_val_loss = float('inf')  # Initialize to a large value\n","        patience_counter = 0  # Counter to track early stopping patience\n","\n","        for epoch in range(num_epochs):\n","            # Training phase\n","            model.train()\n","            running_loss = 0.0\n","            for images, labels in train_loader:\n","                images, labels = images.to(device), labels.to(device)\n","\n","                optimizer.zero_grad()\n","                outputs = model(images)\n","                loss = criterion(outputs, labels)\n","                loss.backward()\n","                optimizer.step()\n","\n","                running_loss += loss.item()\n","            train_loss = running_loss / len(train_loader)\n","            train_losses.append(train_loss)\n","\n","            # Validation phase\n","            model.eval()\n","            val_running_loss = 0.0\n","            with torch.no_grad():\n","                for images, labels in val_loader:\n","                    images, labels = images.to(device), labels.to(device)\n","                    outputs = model(images)\n","                    loss = criterion(outputs, labels)\n","                    val_running_loss += loss.item()\n","            val_loss = val_running_loss / len(val_loader)\n","            val_losses.append(val_loss)\n","\n","            # Update the scheduler\n","            lr_scheduler.step(val_loss)\n","\n","            # Print loss and current learning rate for the epoch\n","            current_lr = optimizer.param_groups[0]['lr']\n","            print(f\"Trial {trial + 1}, Epoch {epoch + 1}, Train Loss: {train_loss:.4f}, Val Loss: {val_loss:.4f}, LR: {current_lr:.6f}\")\n","\n","            # Check for early stopping\n","            if val_loss < best_val_loss:\n","                best_val_loss = val_loss\n","                patience_counter = 0  # Reset patience counter\n","                # Optionally save the best model for this trial\n","                trial_best_model_path = os.path.join(save_dir, f\"{model_name}_trial_{trial + 1}_best.pth\")\n","                torch.save(model.state_dict(), trial_best_model_path)\n","                print(f\"New best model for Trial {trial + 1} saved to {trial_best_model_path}\")\n","            else:\n","                patience_counter += 1\n","                if patience_counter >= patience:\n","                    print(f\"Early stopping triggered for Trial {trial + 1} at Epoch {epoch + 1}\")\n","                    break\n","\n","        # Save the final model for the trial\n","        trial_model_path = os.path.join(save_dir, f\"{model_name}_trial_{trial + 1}.pth\")\n","        torch.save(model.state_dict(), trial_model_path)\n","        print(f\"Final model for Trial {trial + 1} saved to {trial_model_path}\")\n","\n","        # Store losses for averaging\n","        all_train_losses.append(train_losses)\n","        all_val_losses.append(val_losses)\n","\n","        # Plot training and validation losses for this trial\n","        plt.plot(range(1, len(train_losses) + 1), train_losses, color='blue', alpha=0.3, label='Training Loss' if trial == 0 else \"\")\n","        plt.plot(range(1, len(val_losses) + 1), val_losses, color='orange', alpha=0.3, label='Validation Loss' if trial == 0 else \"\")\n","\n","    # Calculate average losses per epoch\n","    avg_train_losses = [sum(epoch_losses) / n_trials for epoch_losses in zip(*all_train_losses)]\n","    avg_val_losses = [sum(epoch_losses) / n_trials for epoch_losses in zip(*all_val_losses)]\n","\n","    # Plot average lines\n","    plt.plot(range(1, len(avg_train_losses) + 1), avg_train_losses, color='blue', linewidth=2, label='Avg Training Loss')\n","    plt.plot(range(1, len(avg_val_losses) + 1), avg_val_losses, color='orange', linewidth=2, label='Avg Validation Loss')\n","\n","    # Finalize plot\n","    plt.xticks(range(1, num_epochs + 1))  # Ensure x-axis shows integer epochs\n","    plt.xlabel(\"Epoch\")\n","    plt.ylabel(\"Loss\")\n","    plt.title(\"Training and Validation Loss Across Trials (ReduceLROnPlateau)\")\n","    plt.legend(loc=\"upper right\")\n","    plt.grid()\n","    plt.show()"],"metadata":{"id":"KBFQ9iz5IRt3"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["# Train and plot\n","train_and_plot_reduceLRplateau(train_loader, val_loader, create_googlenet, criterion, optimizer_fn,\n","               device, num_epochs=20, n_trials=1, patience=20, save_dir='/content/drive/MyDrive/ML Project 2 :)/Model_weights/Step_4_Hyperparameter_tuning/Amélie/plateau')"],"metadata":{"id":"oCybdY2XIVMv","colab":{"base_uri":"https://localhost:8080/","height":965},"executionInfo":{"status":"ok","timestamp":1734397104287,"user_tz":-60,"elapsed":10126418,"user":{"displayName":"ombrali","userId":"07436965216173521894"}},"outputId":"b0f04a64-1fe3-4b61-e8fd-62388c0ca423"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Trial 1, Epoch 1, Train Loss: 0.1502, Val Loss: 0.2122, LR: 0.000100\n","New best model for Trial 1 saved to /content/drive/MyDrive/ML Project 2 :)/Model_weights/Step_4_Hyperparameter_tuning/Amélie/plateau/GoogLeNet_trial_1_best.pth\n","Trial 1, Epoch 2, Train Loss: 0.0954, Val Loss: 0.3064, LR: 0.000100\n","Trial 1, Epoch 3, Train Loss: 0.0703, Val Loss: 0.2318, LR: 0.000100\n","Trial 1, Epoch 4, Train Loss: 0.0541, Val Loss: 0.2386, LR: 0.000100\n","Trial 1, Epoch 5, Train Loss: 0.0442, Val Loss: 0.2926, LR: 0.000100\n","Trial 1, Epoch 6, Train Loss: 0.0396, Val Loss: 0.3125, LR: 0.000100\n","Trial 1, Epoch 7, Train Loss: 0.0346, Val Loss: 0.2932, LR: 0.000010\n","Trial 1, Epoch 8, Train Loss: 0.0193, Val Loss: 0.2892, LR: 0.000010\n","Trial 1, Epoch 9, Train Loss: 0.0136, Val Loss: 0.2811, LR: 0.000010\n","Trial 1, Epoch 10, Train Loss: 0.0109, Val Loss: 0.3201, LR: 0.000010\n","Trial 1, Epoch 11, Train Loss: 0.0097, Val Loss: 0.3369, LR: 0.000010\n","Trial 1, Epoch 12, Train Loss: 0.0076, Val Loss: 0.3390, LR: 0.000010\n","Trial 1, Epoch 13, Train Loss: 0.0072, Val Loss: 0.3341, LR: 0.000001\n","Trial 1, Epoch 14, Train Loss: 0.0059, Val Loss: 0.3383, LR: 0.000001\n","Trial 1, Epoch 15, Train Loss: 0.0052, Val Loss: 0.3404, LR: 0.000001\n","Trial 1, Epoch 16, Train Loss: 0.0060, Val Loss: 0.3461, LR: 0.000001\n","Trial 1, Epoch 17, Train Loss: 0.0055, Val Loss: 0.3492, LR: 0.000001\n","Trial 1, Epoch 18, Train Loss: 0.0053, Val Loss: 0.3400, LR: 0.000001\n","Trial 1, Epoch 19, Train Loss: 0.0049, Val Loss: 0.3496, LR: 0.000001\n","Trial 1, Epoch 20, Train Loss: 0.0053, Val Loss: 0.3507, LR: 0.000001\n","Final model for Trial 1 saved to /content/drive/MyDrive/ML Project 2 :)/Model_weights/Step_4_Hyperparameter_tuning/Amélie/plateau/GoogLeNet_trial_1.pth\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 1000x600 with 1 Axes>"],"image/png":"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\n"},"metadata":{}}]},{"cell_type":"markdown","source":["### Cosine annealing"],"metadata":{"id":"gxUn_H_-I6wI"}},{"cell_type":"code","source":["def train_and_plot_cosineAnnealingLR(train_loader, val_loader, model_fn, criterion, optimizer_fn, device, num_epochs, n_trials, patience, save_dir):\n","    \"\"\"\n","    Trains a model n times with a Cosine Annealing LR scheduler, saves the model after each trial,\n","    and plots the training and validation loss per epoch. Implements early stopping.\n","\n","    Args:\n","        train_loader (DataLoader): DataLoader for training data.\n","        val_loader (DataLoader): DataLoader for validation data.\n","        model_fn (function): A callable that returns a new model instance initialized with pre-trained weights.\n","        criterion (torch.nn.Module): Loss function.\n","        optimizer_fn (function): Function to create a new optimizer instance for each trial.\n","        device (torch.device): Device to use (CPU or GPU).\n","        num_epochs (int): Number of epochs per training.\n","        n_trials (int): Number of training repetitions.\n","        save_dir (str): Directory where the model for each trial will be saved.\n","        patience (int): Number of epochs to wait for validation loss improvement before stopping early.\n","    \"\"\"\n","    # Ensure the save directory exists\n","    os.makedirs(save_dir, exist_ok=True)\n","\n","    sample_model = model_fn()\n","    model_name = type(sample_model).__name__\n","\n","    plt.figure(figsize=(10, 6))\n","\n","    # To store all losses for averaging\n","    all_train_losses = []\n","    all_val_losses = []\n","\n","    for trial in range(n_trials):\n","        # Reinitialize the model with ImageNet weights\n","        model = model_fn().to(device)\n","\n","        # Create a new optimizer instance for this trial\n","        optimizer = optimizer_fn(model.parameters())\n","\n","        # Set up Cosine Annealing LR scheduler with minimum LR of 1e-6\n","        scheduler = CosineAnnealingLR(optimizer, T_max=num_epochs, eta_min=1e-6)\n","\n","        train_losses = []\n","        val_losses = []\n","\n","        best_val_loss = float('inf')  # Initialize to a large value\n","        patience_counter = 0  # Counter to track early stopping patience\n","\n","        for epoch in range(num_epochs):\n","            # Training phase\n","            model.train()\n","            running_loss = 0.0\n","            for images, labels in train_loader:\n","                images, labels = images.to(device), labels.to(device)\n","\n","                optimizer.zero_grad()\n","                outputs = model(images)\n","                loss = criterion(outputs, labels)\n","                loss.backward()\n","                optimizer.step()\n","\n","                running_loss += loss.item()\n","            train_loss = running_loss / len(train_loader)\n","            train_losses.append(train_loss)\n","\n","            # Validation phase\n","            model.eval()\n","            val_running_loss = 0.0\n","            with torch.no_grad():\n","                for images, labels in val_loader:\n","                    images, labels = images.to(device), labels.to(device)\n","                    outputs = model(images)\n","                    loss = criterion(outputs, labels)\n","                    val_running_loss += loss.item()\n","            val_loss = val_running_loss / len(val_loader)\n","            val_losses.append(val_loss)\n","\n","            # Print loss for the current epoch\n","            print(f\"Trial {trial + 1}, Epoch {epoch + 1}, Train Loss: {train_loss:.4f}, Val Loss: {val_loss:.4f}\")\n","\n","            # Check for early stopping\n","            if val_loss < best_val_loss:\n","                best_val_loss = val_loss\n","                patience_counter = 0  # Reset patience counter\n","                # Optionally save the best model for this trial\n","                trial_best_model_path = os.path.join(save_dir, f\"{model_name}_trial_{trial + 1}_best.pth\")\n","                torch.save(model.state_dict(), trial_best_model_path)\n","                print(f\"New best model for Trial {trial + 1} saved to {trial_best_model_path}\")\n","            else:\n","                patience_counter += 1\n","                if patience_counter >= patience:\n","                    print(f\"Early stopping triggered for Trial {trial + 1} at Epoch {epoch + 1}\")\n","                    break\n","\n","\n","        # Save the final model for the trial\n","        trial_model_path = os.path.join(save_dir, f\"{model_name}_trial_{trial + 1}.pth\")\n","        torch.save(model.state_dict(), trial_model_path)\n","        print(f\"Final model for Trial {trial + 1} saved to {trial_model_path}\")\n","\n","        # Store losses for averaging\n","        all_train_losses.append(train_losses)\n","        all_val_losses.append(val_losses)\n","\n","        # Plot training and validation losses for this trial\n","        plt.plot(range(1, len(train_losses) + 1), train_losses, color='blue', alpha=0.3, label='Training Loss' if trial == 0 else \"\")\n","        plt.plot(range(1, len(val_losses) + 1), val_losses, color='orange', alpha=0.3, label='Validation Loss' if trial == 0 else \"\")\n","\n","    # Calculate average losses per epoch\n","    avg_train_losses = [sum(epoch_losses) / n_trials for epoch_losses in zip(*all_train_losses)]\n","    avg_val_losses = [sum(epoch_losses) / n_trials for epoch_losses in zip(*all_val_losses)]\n","\n","    # Plot average lines\n","    plt.plot(range(1, len(avg_train_losses) + 1), avg_train_losses, color='blue', linewidth=2, label='Avg Training Loss')\n","    plt.plot(range(1, len(avg_val_losses) + 1), avg_val_losses, color='orange', linewidth=2, label='Avg Validation Loss')\n","\n","    # Finalize plot\n","    plt.xticks(range(1, num_epochs + 1))  # Ensure x-axis shows integer epochs\n","    plt.xlabel(\"Epoch\")\n","    plt.ylabel(\"Loss\")\n","    plt.title(\"Training and Validation Loss Across Trials\")\n","    plt.legend(loc=\"upper right\")\n","    plt.grid()\n","    plt.show()"],"metadata":{"id":"O02iY5U6GbVp","executionInfo":{"status":"ok","timestamp":1734435299803,"user_tz":-60,"elapsed":14,"user":{"displayName":"ombrali","userId":"07436965216173521894"}}},"execution_count":9,"outputs":[]},{"cell_type":"code","source":["# Train and plot\n","train_and_plot_cosineAnnealingLR(train_loader, val_loader, create_googlenet, criterion, optimizer_fn,\n","               device, num_epochs=20, n_trials=1, patience=20, save_dir='/content/drive/MyDrive/ML Project 2 :)/Model_weights/Step_4_Hyperparameter_tuning/Amélie/cosine')"],"metadata":{"id":"0D4K6M1jHfAY","colab":{"base_uri":"https://localhost:8080/","height":0},"outputId":"f5a697b6-024b-4daf-a9cf-48144133de15","executionInfo":{"status":"ok","timestamp":1734445178144,"user_tz":-60,"elapsed":9878352,"user":{"displayName":"ombrali","userId":"07436965216173521894"}}},"execution_count":10,"outputs":[{"output_type":"stream","name":"stderr","text":["Downloading: \"https://download.pytorch.org/models/googlenet-1378be20.pth\" to /root/.cache/torch/hub/checkpoints/googlenet-1378be20.pth\n","100%|██████████| 49.7M/49.7M [00:00<00:00, 117MB/s]\n"]},{"output_type":"stream","name":"stdout","text":["Trial 1, Epoch 1, Train Loss: 0.2141, Val Loss: 0.2594\n","New best model for Trial 1 saved to /content/drive/MyDrive/ML Project 2 :)/Model_weights/Step_4_Hyperparameter_tuning/Amélie/cosine/GoogLeNet_trial_1_best.pth\n","Trial 1, Epoch 2, Train Loss: 0.1437, Val Loss: 0.2280\n","New best model for Trial 1 saved to /content/drive/MyDrive/ML Project 2 :)/Model_weights/Step_4_Hyperparameter_tuning/Amélie/cosine/GoogLeNet_trial_1_best.pth\n","Trial 1, Epoch 3, Train Loss: 0.1197, Val Loss: 0.2253\n","New best model for Trial 1 saved to /content/drive/MyDrive/ML Project 2 :)/Model_weights/Step_4_Hyperparameter_tuning/Amélie/cosine/GoogLeNet_trial_1_best.pth\n","Trial 1, Epoch 4, Train Loss: 0.1000, Val Loss: 0.2173\n","New best model for Trial 1 saved to /content/drive/MyDrive/ML Project 2 :)/Model_weights/Step_4_Hyperparameter_tuning/Amélie/cosine/GoogLeNet_trial_1_best.pth\n","Trial 1, Epoch 5, Train Loss: 0.0864, Val Loss: 0.2807\n","Trial 1, Epoch 6, Train Loss: 0.0738, Val Loss: 0.2468\n","Trial 1, Epoch 7, Train Loss: 0.0647, Val Loss: 0.2397\n","Trial 1, Epoch 8, Train Loss: 0.0557, Val Loss: 0.2666\n","Trial 1, Epoch 9, Train Loss: 0.0473, Val Loss: 0.3280\n","Trial 1, Epoch 10, Train Loss: 0.0447, Val Loss: 0.2828\n","Trial 1, Epoch 11, Train Loss: 0.0401, Val Loss: 0.3147\n","Trial 1, Epoch 12, Train Loss: 0.0365, Val Loss: 0.3046\n","Trial 1, Epoch 13, Train Loss: 0.0315, Val Loss: 0.3231\n","Trial 1, Epoch 14, Train Loss: 0.0290, Val Loss: 0.2933\n","Trial 1, Epoch 15, Train Loss: 0.0265, Val Loss: 0.3044\n","Trial 1, Epoch 16, Train Loss: 0.0242, Val Loss: 0.3481\n","Trial 1, Epoch 17, Train Loss: 0.0222, Val Loss: 0.3355\n","Trial 1, Epoch 19, Train Loss: 0.0204, Val Loss: 0.3351\n","Trial 1, Epoch 20, Train Loss: 0.0183, Val Loss: 0.3176\n","Final model for Trial 1 saved to /content/drive/MyDrive/ML Project 2 :)/Model_weights/Step_4_Hyperparameter_tuning/Amélie/cosine/GoogLeNet_trial_1.pth\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 1000x600 with 1 Axes>"],"image/png":"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\n"},"metadata":{}}]},{"cell_type":"markdown","source":["### Constant learning rate"],"metadata":{"id":"F6d2JsKvF0pI"}},{"cell_type":"code","source":["def train_and_plot_constantLR(train_loader, val_loader, model_fn, criterion, optimizer_fn, device, num_epochs, n_trials, patience, save_dir):\n","    \"\"\"\n","    Trains a model n times, saves the model after each trial, and plots the training and validation loss per epoch.\n","    Implements early stopping.\n","\n","    Args:\n","        train_loader (DataLoader): DataLoader for training data.\n","        val_loader (DataLoader): DataLoader for validation data.\n","        model_fn (function): A callable that returns a new model instance initialized with pre-trained weights.\n","        criterion (torch.nn.Module): Loss function.\n","        optimizer_fn (function): Function to create a new optimizer instance for each trial.\n","        device (torch.device): Device to use (CPU or GPU).\n","        num_epochs (int): Number of epochs per training.\n","        n_trials (int): Number of training repetitions.\n","        save_dir (str): Directory where the model for each trial will be saved.\n","        patience (int): Number of epochs to wait for validation loss improvement before stopping early.\n","    \"\"\"\n","    # Ensure the save directory exists\n","    os.makedirs(save_dir, exist_ok=True)\n","\n","    sample_model = model_fn()\n","    model_name = type(sample_model).__name__\n","\n","    plt.figure(figsize=(10, 6))\n","\n","    # To store all losses for averaging\n","    all_train_losses = []\n","    all_val_losses = []\n","\n","    for trial in range(n_trials):\n","        # Reinitialize the model with ImageNet weights\n","        model = model_fn().to(device)\n","\n","        # Create a new optimizer instance for this trial\n","        optimizer = optimizer_fn(model.parameters())\n","\n","        train_losses = []\n","        val_losses = []\n","\n","        best_val_loss = float('inf')  # Initialize to a large value\n","        patience_counter = 0  # Counter to track early stopping patience\n","\n","        for epoch in range(num_epochs):\n","            # Training phase\n","            model.train()\n","            running_loss = 0.0\n","            for images, labels in train_loader:\n","                images, labels = images.to(device), labels.to(device)\n","\n","                optimizer.zero_grad()\n","                outputs = model(images)\n","                loss = criterion(outputs, labels)\n","                loss.backward()\n","                optimizer.step()\n","\n","                running_loss += loss.item()\n","            train_loss = running_loss / len(train_loader)\n","            train_losses.append(train_loss)\n","\n","            # Validation phase\n","            model.eval()\n","            val_running_loss = 0.0\n","            with torch.no_grad():\n","                for images, labels in val_loader:\n","                    images, labels = images.to(device), labels.to(device)\n","                    outputs = model(images)\n","                    loss = criterion(outputs, labels)\n","                    val_running_loss += loss.item()\n","            val_loss = val_running_loss / len(val_loader)\n","            val_losses.append(val_loss)\n","\n","            # Print loss for the current epoch\n","            print(f\"Trial {trial + 1}, Epoch {epoch + 1}, Train Loss: {train_loss:.4f}, Val Loss: {val_loss:.4f}\")\n","\n","            # Check for early stopping\n","            if val_loss < best_val_loss:\n","                best_val_loss = val_loss\n","                patience_counter = 0  # Reset patience counter\n","                # Optionally save the best model for this trial\n","                trial_best_model_path = os.path.join(save_dir, f\"{model_name}_trial_{trial + 1}_best.pth\")\n","                torch.save(model.state_dict(), trial_best_model_path)\n","                print(f\"New best model for Trial {trial + 1} saved to {trial_best_model_path}\")\n","            else:\n","                patience_counter += 1\n","                if patience_counter >= patience:\n","                    print(f\"Early stopping triggered for Trial {trial + 1} at Epoch {epoch + 1}\")\n","                    break\n","\n","\n","        # Save the final model for the trial\n","        trial_model_path = os.path.join(save_dir, f\"{model_name}_trial_{trial + 1}.pth\")\n","        torch.save(model.state_dict(), trial_model_path)\n","        print(f\"Final model for Trial {trial + 1} saved to {trial_model_path}\")\n","\n","        # Store losses for averaging\n","        all_train_losses.append(train_losses)\n","        all_val_losses.append(val_losses)\n","\n","        # Plot training and validation losses for this trial\n","        plt.plot(range(1, len(train_losses) + 1), train_losses, color='blue', alpha=0.3, label='Training Loss' if trial == 0 else \"\")\n","        plt.plot(range(1, len(val_losses) + 1), val_losses, color='orange', alpha=0.3, label='Validation Loss' if trial == 0 else \"\")\n","\n","    # Calculate average losses per epoch\n","    avg_train_losses = [sum(epoch_losses) / n_trials for epoch_losses in zip(*all_train_losses)]\n","    avg_val_losses = [sum(epoch_losses) / n_trials for epoch_losses in zip(*all_val_losses)]\n","\n","    # Plot average lines\n","    plt.plot(range(1, len(avg_train_losses) + 1), avg_train_losses, color='blue', linewidth=2, label='Avg Training Loss')\n","    plt.plot(range(1, len(avg_val_losses) + 1), avg_val_losses, color='orange', linewidth=2, label='Avg Validation Loss')\n","\n","    # Finalize plot\n","    plt.xticks(range(1, num_epochs + 1))  # Ensure x-axis shows integer epochs\n","    plt.xlabel(\"Epoch\")\n","    plt.ylabel(\"Loss\")\n","    plt.title(\"Training and Validation Loss Across Trials\")\n","    plt.legend(loc=\"upper right\")\n","    plt.grid()\n","    plt.show()"],"metadata":{"id":"-63ILaDBFjcO"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["# Train and plot\n","train_and_plot_constantLR(train_loader, val_loader, create_googlenet, criterion, optimizer_fn,\n","               device, num_epochs=20, n_trials=1, patience=20, save_dir='/content/drive/MyDrive/ML Project 2 :)/Model_weights/Step_4_Hyperparameter_tuning/Amélie/constantLR')"],"metadata":{"id":"F7kaeDatEoPO"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":[],"metadata":{"id":"dDz9ioijevNs"},"execution_count":null,"outputs":[]}]}