code/models/ResNet-50_240526.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sXcYn45Zv_Kr"
      },
      "source": [
        "# Training and evaluation of model for PAI-scoring\n",
        "2024.05.31 Gerald Torgersen\n",
        "# Model: ResNet-50\n",
        "# Data\n",
        "- csv files with column for filename, PAI, weight\n",
        "- RGB clips of radiographs centered around apex, 224 x 224 pixels\n",
        "\n",
        "The weight in the data refers to the quality of scoring."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "n_6JaXgwaI-T",
        "outputId": "9fb782a9-9feb-4aa5-c7f7-d934d4d849f2"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "from torch.utils.data import DataLoader, Dataset, WeightedRandomSampler\n",
        "from torchvision import transforms\n",
        "from torchvision.models import resnet50\n",
        "from sklearn.metrics import mean_absolute_error\n",
        "from sklearn.model_selection import train_test_split\n",
        "from PIL import Image\n",
        "from collections import Counter\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lwJA2l2mdC8-"
      },
      "outputs": [],
      "source": [
        "# Custom dataset\n",
        "class CustomDataset(Dataset):\n",
        "    def __init__(self, data, transform=None):\n",
        "        self.data = data\n",
        "        self.transform = transform\n",
        "\n",
        "        # Normalize class labels to 0-based\n",
        "        self.data['PAI'] = self.data['PAI'] - 1\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.data)\n",
        "\n",
        "    def __getitem__(self, idx):\n",
        "        img_name = self.data.iloc[idx]['filename']\n",
        "        root_dir = self.data.iloc[idx]['root_dir']\n",
        "        img_path = os.path.join(root_dir, img_name)\n",
        "        if os.path.exists(img_path):\n",
        "            image = Image.open(img_path).convert('RGB')\n",
        "        else:\n",
        "            raise FileNotFoundError(f\"Image {img_name} not found in the root directory.\")\n",
        "\n",
        "        label = self.data.iloc[idx]['PAI']\n",
        "        weight = self.data.iloc[idx]['weight']\n",
        "\n",
        "        if self.transform:\n",
        "            image = self.transform(image)\n",
        "\n",
        "        return image, label, weight\n",
        "\n",
        "# Early stopping class\n",
        "class EarlyStopping:\n",
        "    def __init__(self, patience=10, min_delta=0.001):\n",
        "        self.patience = patience\n",
        "        self.min_delta = min_delta\n",
        "        self.best_loss = np.inf\n",
        "        self.counter = 0\n",
        "\n",
        "    def __call__(self, val_loss):\n",
        "        if val_loss < self.best_loss - self.min_delta:\n",
        "            self.best_loss = val_loss\n",
        "            self.counter = 0\n",
        "            print(f'Validation loss improved to {val_loss:.4f}, resetting counter.')\n",
        "            return False\n",
        "        else:\n",
        "            self.counter += 1\n",
        "            print(f'Validation loss did not improve. Counter: {self.counter}/{self.patience}')\n",
        "            if self.counter >= self.patience:\n",
        "                print(\"Early stopping triggered.\")\n",
        "                return True\n",
        "            return False\n",
        "\n",
        "# Function to save the checkpoint\n",
        "def save_checkpoint(model, optimizer, epoch, filename):\n",
        "    state = {\n",
        "        'epoch': epoch,\n",
        "        'state_dict': model.state_dict(),\n",
        "        'optimizer': optimizer.state_dict(),\n",
        "    }\n",
        "    torch.save(state, filename)\n",
        "\n",
        "# Function to load the checkpoint\n",
        "def load_checkpoint(model, optimizer, filename):\n",
        "    if os.path.isfile(filename):\n",
        "        print(f\"Loading checkpoint '{filename}'\")\n",
        "        checkpoint = torch.load(filename)\n",
        "        model.load_state_dict(checkpoint['state_dict'])\n",
        "        optimizer.load_state_dict(checkpoint['optimizer'])\n",
        "        start_epoch = checkpoint['epoch']\n",
        "        return model, optimizer, start_epoch\n",
        "    else:\n",
        "        raise FileNotFoundError\n",
        "\n",
        "# Enhanced data augmentation\n",
        "data_transforms = {\n",
        "    'train': transforms.Compose([\n",
        "        transforms.RandomHorizontalFlip(),\n",
        "        transforms.RandomRotation(15),\n",
        "        transforms.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4, hue=0.2),\n",
        "        transforms.ToTensor(),\n",
        "        transforms.Normalize(mean=[0.37887412, 0.37887412, 0.37887412], std=[0.09176591, 0.09176591, 0.09176591])\n",
        "    ]),\n",
        "    'val': transforms.Compose([\n",
        "        transforms.ToTensor(),\n",
        "        transforms.Normalize(mean=[0.37887412, 0.37887412, 0.37887412], std=[0.09176591, 0.09176591, 0.09176591])\n",
        "    ]),\n",
        "}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UEygYn0QdR8t"
      },
      "outputs": [],
      "source": [
        "# Load and combine data one ore more datasets\n",
        "all_data = pd.DataFrame()\n",
        "csv_files = [\"path1/data1.csv\", \"path2/data2.csv\"] # Replace with your csv paths\n",
        "root_dirs = [\"images_path1\", \"images_path2\"] # Replace with your image paths\n",
        "\n",
        "for csv_file, root_dir in zip(csv_files, root_dirs):\n",
        "    data = pd.read_csv(csv_file)\n",
        "    data['root_dir'] = root_dir  # Add the root directory to the dataframe\n",
        "    all_data = pd.concat([all_data, data], ignore_index=True)\n",
        "\n",
        "# Split the combined dataset into training and validation sets\n",
        "train_data, val_data = train_test_split(all_data, test_size=0.2, random_state=42, stratify=all_data['PAI'])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "K1LMfmDurJdY",
        "outputId": "9ebc8a97-92e1-4dd3-aff2-8b1aba66ab78"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Class distribution after oversampling:\n",
            "PAI\n",
            "4    372\n",
            "5    372\n",
            "3    372\n",
            "2    372\n",
            "1    372\n",
            "Name: count, dtype: int64\n",
            "Training dataset size: 1860\n",
            "Validation dataset size: 225\n"
          ]
        }
      ],
      "source": [
        "# Handle unbalanced data by ramdom oversampling\n",
        "\n",
        "from imblearn.over_sampling import RandomOverSampler\n",
        "\n",
        "# Separate features and target for SMOTE\n",
        "X_train = train_data.drop(columns=['PAI'])\n",
        "y_train = train_data['PAI']\n",
        "\n",
        "# Apply RandomOverSampler to balance the classes\n",
        "ros = RandomOverSampler(random_state=42)\n",
        "X_resampled, y_resampled = ros.fit_resample(X_train, y_train)\n",
        "\n",
        "# Combine resampled features and target\n",
        "train_data_balanced = pd.concat([X_resampled, y_resampled], axis=1)\n",
        "\n",
        "# Verify class distribution\n",
        "print('Class distribution after oversampling:')\n",
        "print(train_data_balanced['PAI'].value_counts())\n",
        "\n",
        "# Create training and validation datasets\n",
        "train_dataset = CustomDataset(train_data_balanced, transform=data_transforms['train'])\n",
        "val_dataset = CustomDataset(val_data, transform=data_transforms['val'])\n",
        "\n",
        "# Create DataLoaders\n",
        "train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True, num_workers=4)\n",
        "val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False, num_workers=4)\n",
        "\n",
        "print(f'Training dataset size: {len(train_dataset)}')\n",
        "print(f'Validation dataset size: {len(val_dataset)}')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "T_m-vYaUufBP",
        "outputId": "56e4bc53-cbed-44b6-d72e-fa7f2c60e013"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "Statistics for Training set:\n",
            "   Class  Count Percentage (%)\n",
            "0      3    372           20.0\n",
            "1      4    372           20.0\n",
            "2      2    372           20.0\n",
            "3      1    372           20.0\n",
            "4      0    372           20.0\n",
            "\n",
            "Statistics for Validation set:\n",
            "   Class  Count Percentage (%)\n",
            "0      0     46           20.4\n",
            "1      2     93           41.3\n",
            "2      3     37           16.4\n",
            "3      1     38           16.9\n",
            "4      4     11            4.9\n"
          ]
        }
      ],
      "source": [
        "from collections import Counter\n",
        "\n",
        "# Function to display dataset statistics\n",
        "def display_dataset_statistics(data, name):\n",
        "    class_counts = Counter(data['PAI'])\n",
        "    total_samples = len(data)\n",
        "    class_percentages = {cls: count / total_samples * 100 for cls, count in class_counts.items()}\n",
        "\n",
        "    stats_df = pd.DataFrame({\n",
        "        'Class': list(class_counts.keys()),\n",
        "        'Count': list(class_counts.values()),\n",
        "        'Percentage (%)': [f\"{percentage:.1f}\" for percentage in class_percentages.values()]\n",
        "    })\n",
        "\n",
        "    print(f\"\\nStatistics for {name} set:\")\n",
        "    print(stats_df)\n",
        "\n",
        "# Display statistics for training and validation sets\n",
        "display_dataset_statistics(train_data_balanced, 'Training')  # Using the balanced training data\n",
        "display_dataset_statistics(val_data, 'Validation')\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7YbWV-fDdXAy",
        "outputId": "1830a020-bbdd-45c2-c09c-e576b5e3299d"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/torchvision/models/_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.10/dist-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=ResNet50_Weights.IMAGENET1K_V1`. You can also use `weights=ResNet50_Weights.DEFAULT` to get the most up-to-date weights.\n",
            "  warnings.warn(msg)\n"
          ]
        }
      ],
      "source": [
        "# Load ResNet-50\n",
        "model = resnet50(pretrained=True)\n",
        "num_features = model.fc.in_features\n",
        "\n",
        "# Adjust the final fully connected layer with dropout\n",
        "model.fc = nn.Sequential(\n",
        "    nn.Dropout(0.5),  # Add dropout layer\n",
        "    nn.Linear(num_features, 5)  # Assuming 5 classes\n",
        ")\n",
        "\n",
        "\n",
        "# Unlock the last two layers and the classifier\n",
        "for name, param in model.named_parameters():\n",
        "    if \"layer3\" in name or \"layer4\" in name or \"fc\" in name:  # Adjust to unfreeze more layers if needed\n",
        "        param.requires_grad = True\n",
        "    else:\n",
        "        param.requires_grad = False\n",
        "\n",
        "# Move model to device\n",
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "model = model.to(device)\n",
        "\n",
        "# Define optimizer with adjusted learning rate and weight decay\n",
        "optimizer = optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr=0.0001, weight_decay=1e-4)\n",
        "scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=10, eta_min=1e-6)\n",
        "\n",
        "# Define the criterion\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "\n",
        "# Initialize early stopping\n",
        "early_stopping = EarlyStopping(patience=10, min_delta=0.001)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ac_mqWpRnjZw"
      },
      "outputs": [],
      "source": [
        "# Lists to collect training data\n",
        "train_loss_list = []\n",
        "val_loss_list = []\n",
        "train_accuracy_list = []\n",
        "val_accuracy_list = []\n",
        "mae_list = []"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-T8WYS8MdJr8",
        "outputId": "6b3ef797-86aa-44ed-9557-bad72622d7e0"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "No checkpoint found. Starting training from scratch.\n",
            "Starting epoch 1/40\n",
            "Epoch 1/40 - Train Loss: 1.4610, Train Accuracy: 0.3484, Validation Loss: 1.7783, Validation Accuracy: 0.2178, MAE: 1.0933\n",
            "Validation loss improved to 1.7783, resetting counter.\n",
            "Starting epoch 2/40\n",
            "Epoch 2/40 - Train Loss: 1.0885, Train Accuracy: 0.5376, Validation Loss: 1.4965, Validation Accuracy: 0.3511, MAE: 1.0622\n",
            "Validation loss improved to 1.4965, resetting counter.\n",
            "Starting epoch 3/40\n",
            "Epoch 3/40 - Train Loss: 0.8593, Train Accuracy: 0.6425, Validation Loss: 1.4352, Validation Accuracy: 0.4133, MAE: 0.9837\n",
            "Validation loss improved to 1.4352, resetting counter.\n",
            "Starting epoch 4/40\n",
            "Epoch 4/40 - Train Loss: 0.6802, Train Accuracy: 0.7355, Validation Loss: 1.5566, Validation Accuracy: 0.4222, MAE: 0.9344\n",
            "Validation loss did not improve. Counter: 1/10\n",
            "Starting epoch 5/40\n",
            "Epoch 5/40 - Train Loss: 0.5540, Train Accuracy: 0.7941, Validation Loss: 1.5971, Validation Accuracy: 0.4356, MAE: 0.9067\n",
            "Validation loss did not improve. Counter: 2/10\n",
            "Starting epoch 6/40\n",
            "Epoch 6/40 - Train Loss: 0.4335, Train Accuracy: 0.8371, Validation Loss: 1.5257, Validation Accuracy: 0.4933, MAE: 0.8719\n",
            "Validation loss did not improve. Counter: 3/10\n",
            "Starting epoch 7/40\n",
            "Epoch 7/40 - Train Loss: 0.3576, Train Accuracy: 0.8742, Validation Loss: 1.5829, Validation Accuracy: 0.4756, MAE: 0.8527\n",
            "Validation loss did not improve. Counter: 4/10\n",
            "Starting epoch 8/40\n",
            "Epoch 8/40 - Train Loss: 0.2720, Train Accuracy: 0.9113, Validation Loss: 1.5362, Validation Accuracy: 0.4978, MAE: 0.8317\n",
            "Validation loss did not improve. Counter: 5/10\n",
            "Starting epoch 9/40\n",
            "Epoch 9/40 - Train Loss: 0.2373, Train Accuracy: 0.9328, Validation Loss: 1.5118, Validation Accuracy: 0.4578, MAE: 0.8232\n",
            "Validation loss did not improve. Counter: 6/10\n",
            "Starting epoch 10/40\n",
            "Epoch 10/40 - Train Loss: 0.2304, Train Accuracy: 0.9247, Validation Loss: 1.5555, Validation Accuracy: 0.4622, MAE: 0.8142\n",
            "Validation loss did not improve. Counter: 7/10\n",
            "Starting epoch 11/40\n",
            "Epoch 11/40 - Train Loss: 0.2058, Train Accuracy: 0.9317, Validation Loss: 1.4885, Validation Accuracy: 0.4622, MAE: 0.8093\n",
            "Validation loss did not improve. Counter: 8/10\n",
            "Starting epoch 12/40\n",
            "Epoch 12/40 - Train Loss: 0.2067, Train Accuracy: 0.9349, Validation Loss: 1.5624, Validation Accuracy: 0.4667, MAE: 0.8044\n",
            "Validation loss did not improve. Counter: 9/10\n",
            "Starting epoch 13/40\n",
            "Epoch 13/40 - Train Loss: 0.1740, Train Accuracy: 0.9473, Validation Loss: 1.5311, Validation Accuracy: 0.4622, MAE: 0.8021\n",
            "Validation loss did not improve. Counter: 10/10\n",
            "Early stopping triggered.\n",
            "Early stopping\n"
          ]
        }
      ],
      "source": [
        "import time  # Import time to measure the duration of each epoch\n",
        "import torch.nn.functional as F\n",
        "\n",
        "# Path to save the checkpoint\n",
        "check_point_path = 'ResNet50_model_checkpoint.pth'\n",
        "\n",
        "# Initialize start_epoch and total_epochs\n",
        "start_epoch = 0\n",
        "total_epochs = 40\n",
        "\n",
        "# Attempt to load checkpoint\n",
        "try:\n",
        "    model, optimizer, start_epoch = load_checkpoint(model, optimizer, check_point_path)\n",
        "    total_epochs = start_epoch + 10\n",
        "except FileNotFoundError:\n",
        "    start_epoch = 0\n",
        "    total_epochs = 40\n",
        "    print(\"No checkpoint found. Starting training from scratch.\")\n",
        "\n",
        "# Lists to store the probabilities for each class\n",
        "all_probs = []\n",
        "all_true_labels = []\n",
        "\n",
        "for epoch in range(start_epoch, total_epochs):\n",
        "    epoch_start_time = time.time()  # Start timing the epoch\n",
        "    print(f'Starting epoch {epoch+1}/{total_epochs}')\n",
        "\n",
        "    train_loss = 0.0\n",
        "    train_corrects = 0\n",
        "    val_loss = 0.0\n",
        "    val_corrects = 0\n",
        "\n",
        "    model.train()\n",
        "    for batch_idx, (inputs, labels, _) in enumerate(train_loader):\n",
        "        inputs, labels = inputs.to(device), labels.to(device)\n",
        "        optimizer.zero_grad()\n",
        "        outputs = model(inputs)\n",
        "        loss = criterion(outputs, labels)\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "        train_loss += loss.item() * inputs.size(0)\n",
        "        _, preds = torch.max(outputs, 1)\n",
        "        train_corrects += torch.sum(preds == labels.data)\n",
        "\n",
        "    model.eval()\n",
        "    with torch.no_grad():\n",
        "        for batch_idx, (inputs, labels, _) in enumerate(val_loader):\n",
        "            inputs, labels = inputs.to(device), labels.to(device)\n",
        "            outputs = model(inputs)\n",
        "            loss = criterion(outputs, labels)\n",
        "\n",
        "            val_loss += loss.item() * inputs.size(0)\n",
        "            _, preds = torch.max(outputs, 1)\n",
        "            val_corrects += torch.sum(preds == labels.data)\n",
        "\n",
        "            # Collect true labels and probabilities for each class\n",
        "            probs = F.softmax(outputs, dim=1)\n",
        "            all_probs.extend(probs.cpu().numpy())\n",
        "            all_true_labels.extend(labels.cpu().numpy())\n",
        "\n",
        "\n",
        "    mae = mean_absolute_error(all_true_labels, [np.argmax(p) for p in all_probs])\n",
        "    mae_list.append(mae)\n",
        "\n",
        "    train_loss = train_loss / len(train_loader.dataset)\n",
        "    train_accuracy = train_corrects.double() / len(train_loader.dataset)\n",
        "    val_loss = val_loss / len(val_loader.dataset)\n",
        "    val_accuracy = val_corrects.double() / len(val_loader.dataset)\n",
        "\n",
        "    train_loss_list.append(train_loss)\n",
        "    train_accuracy_list.append(train_accuracy)\n",
        "    val_loss_list.append(val_loss)\n",
        "    val_accuracy_list.append(val_accuracy)\n",
        "\n",
        "    print(f'Epoch {epoch+1}/{total_epochs} - '\n",
        "          f'Train Loss: {train_loss:.4f}, '\n",
        "          f'Train Accuracy: {train_accuracy:.4f}, '\n",
        "          f'Validation Loss: {val_loss:.4f}, '\n",
        "          f'Validation Accuracy: {val_accuracy:.4f}, '\n",
        "          f'MAE: {mae:.4f}')\n",
        "\n",
        "    save_checkpoint(model, optimizer, epoch + 1, check_point_path)\n",
        "\n",
        "    if early_stopping(val_loss):\n",
        "        print(\"Early stopping\")\n",
        "        break\n",
        "\n",
        "    scheduler.step()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 718
        },
        "id": "MqE_Wl1EudBl",
        "outputId": "6607e27e-dada-467e-f4e9-7ce44c4c0d21"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1000x800 with 2 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "from sklearn.metrics import confusion_matrix\n",
        "import seaborn as sns\n",
        "\n",
        "num_classes = 5\n",
        "\n",
        "# Compute the confusion matrix\n",
        "conf_matrix = confusion_matrix(all_true_labels, [np.argmax(p) for p in all_probs])\n",
        "\n",
        "# Adjust the labels to start from 1 instead of 0\n",
        "labels = range(1, num_classes + 1)\n",
        "\n",
        "# Plot the confusion matrix\n",
        "plt.figure(figsize=(10, 8))\n",
        "sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', xticklabels=labels, yticklabels=labels)\n",
        "plt.xlabel('Predicted Class')\n",
        "plt.ylabel('True Class')\n",
        "plt.title('Confusion Matrix')\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 300
        },
        "id": "Yjsw08Ddp4MD",
        "outputId": "578c398b-e505-46e5-ab68-1f13532d355e"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1800x600 with 3 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Ensure all elements are floats\n",
        "train_loss_list = [loss.item() if torch.is_tensor(loss) else loss for loss in train_loss_list]\n",
        "val_loss_list = [loss.item() if torch.is_tensor(loss) else loss for loss in val_loss_list]\n",
        "train_accuracy_list = [accuracy.cpu().numpy() if torch.is_tensor(accuracy) else accuracy for accuracy in train_accuracy_list]\n",
        "val_accuracy_list = [accuracy.cpu().numpy() if torch.is_tensor(accuracy) else accuracy for accuracy in val_accuracy_list]\n",
        "\n",
        "# Plot training and validation loss\n",
        "plt.figure(figsize=(18, 6))\n",
        "\n",
        "plt.subplot(1, 3, 1)\n",
        "plt.plot(range(len(train_loss_list)), train_loss_list, label='Training Loss')\n",
        "plt.plot(range(len(val_loss_list)), val_loss_list, label='Validation Loss')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Loss')\n",
        "plt.legend()\n",
        "plt.title('Training and Validation Loss')\n",
        "\n",
        "# Plot training and validation accuracy\n",
        "plt.subplot(1, 3, 2)\n",
        "plt.plot(range(len(train_accuracy_list)), train_accuracy_list, label='Training Accuracy')\n",
        "plt.plot(range(len(val_accuracy_list)), val_accuracy_list, label='Validation Accuracy')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.legend()\n",
        "plt.title('Training and Validation Accuracy')\n",
        "\n",
        "# Plot mean absolute error\n",
        "plt.subplot(1, 3, 3)\n",
        "plt.plot(range(len(mae_list)), mae_list, label='Mean Absolute Error')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('MAE')\n",
        "plt.legend()\n",
        "plt.title('Mean Absolute Error')\n",
        "\n",
        "plt.tight_layout()\n",
        "plt.show()\n"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "gpuType": "L4",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}