ROC_and_PR.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/eshal26/Convolutional-Neural-Networks/blob/main/ROC_and_PR.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "<h2>PR and ROC</h2>\n",
        "I've created custom CNN models of famous CNN architectures including resnet, vgg, inception and xception. Trained them on leukemia classification then compared their performance using PR and ROC curves for a research project."
      ],
      "metadata": {
        "id": "QGw5QFOPmV48"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "<h2>Data preprocessing</h2>"
      ],
      "metadata": {
        "id": "7enLHYbR-kSY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torchvision.transforms as transforms\n",
        "from torchvision.datasets import ImageFolder\n",
        "from torch.utils.data import DataLoader\n",
        "\n",
        "# Define transformations\n",
        "transform = transforms.Compose([\n",
        "    transforms.Resize((224, 224)),\n",
        "    transforms.ToTensor(),\n",
        "    transforms.Normalize(mean = [0.8245, 0.8547, 0.9387], std = [0.1323, 0.1431, 0.0530])\n",
        "])\n",
        "\n",
        "\n",
        "# Path to your dataset in Google Drive\n",
        "dataset_path = 'test_dataset'\n",
        "\n",
        "# Load the dataset\n",
        "dataset = ImageFolder(root=dataset_path, transform=transform)\n",
        "\n",
        "# Create a DataLoader\n",
        "test_loader = DataLoader(dataset, batch_size=32, shuffle=True)\n",
        "\n",
        "# Iterate through the DataLoader\n",
        "for images, labels in test_loader:\n",
        "    print(images.size(), labels.size())\n",
        "    break\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ePkj8_tIdBt-",
        "outputId": "aaa99be1-1347-4c67-9bd2-6d40d3424f9a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([32, 3, 224, 224]) torch.Size([32])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "<h2>Defining Model Architectures</h2>"
      ],
      "metadata": {
        "id": "ElXEpVq5-qiN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "class DepthwiseSeparableConv(nn.Module):\n",
        "    def __init__(self, in_channels, out_channels, kernel_size=3, stride=1, padding=1):\n",
        "        super(DepthwiseSeparableConv, self).__init__()\n",
        "        self.depthwise = nn.Conv2d(in_channels, in_channels, kernel_size=kernel_size, stride=stride, padding=padding, groups=in_channels)\n",
        "        self.pointwise = nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=1, padding=0)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.depthwise(x)\n",
        "        x = self.pointwise(x)\n",
        "        return x\n",
        "\n",
        "class SimplifiedXception(nn.Module):\n",
        "    def __init__(self, num_classes=2):\n",
        "        super(SimplifiedXception, self).__init__()\n",
        "        self.flow = nn.Sequential(\n",
        "            DepthwiseSeparableConv(3, 64, kernel_size=3, stride=2, padding=1),\n",
        "            nn.ReLU(),\n",
        "            nn.BatchNorm2d(64),\n",
        "            nn.MaxPool2d(kernel_size=3, stride=2, padding=1)\n",
        "        )\n",
        "\n",
        "        # Dropout layers\n",
        "        self.dropout1 = nn.Dropout(p=0.5)\n",
        "        self.dropout2 = nn.Dropout(p=0.5)\n",
        "\n",
        "        # Fully connected layer\n",
        "        self.fc = nn.Linear(in_features=64 * 56 * 56, out_features=num_classes)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.flow(x)\n",
        "        x = self.dropout1(x)\n",
        "        x = x.view(x.size(0), -1)  # Flatten layer\n",
        "        x = self.dropout2(x)\n",
        "        x = self.fc(x)\n",
        "        return x\n",
        "\n",
        "\n",
        "class CustomVGG(nn.Module):\n",
        "    def __init__(self, num_classes=2):\n",
        "        super(CustomVGG, self).__init__()\n",
        "\n",
        "        # Features: Convolutional layers\n",
        "        self.features = nn.Sequential(\n",
        "            nn.Conv2d(in_channels=3, out_channels=64, kernel_size=3, padding=1),\n",
        "            nn.ReLU(inplace=True),\n",
        "            nn.MaxPool2d(kernel_size=2, stride=2),  # Output: 112x112x64\n",
        "\n",
        "            nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, padding=1),\n",
        "            nn.ReLU(inplace=True),\n",
        "            nn.MaxPool2d(kernel_size=2, stride=2),  # Output: 56x56x128\n",
        "        )\n",
        "\n",
        "        # Classifier: Dropout, Flatten, Fully Connected layer  # Dropout before flattening\n",
        "        self.flatten = nn.Flatten()\n",
        "        self.fc = nn.Linear(128 * 56 * 56, num_classes)\n",
        "        self.dropout1 = nn.Dropout(p=0.5)\n",
        "        self.dropout2 = nn.Dropout(p=0.5)   # Dropout after FC layer\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.features(x)  # Pass through convolutional layers\n",
        "        x = self.flatten(x)\n",
        "        x = self.fc(x)        # Apply the fully connected layer\n",
        "        x = self.dropout1(x)\n",
        "        x = self.dropout2(x)  # Apply dropout after the FC layer\n",
        "        return x\n",
        "\n",
        "class BasicBlock(nn.Module):\n",
        "    def __init__(self, in_channels, out_channels):\n",
        "        super(BasicBlock, self).__init__()\n",
        "        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1, bias=False)\n",
        "        self.bn1 = nn.BatchNorm2d(out_channels)\n",
        "        self.relu = nn.ReLU(inplace=True)\n",
        "        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1, bias=False)\n",
        "        self.bn2 = nn.BatchNorm2d(out_channels)\n",
        "\n",
        "        # Adjust shortcut to match dimensions if needed\n",
        "        if in_channels != out_channels:\n",
        "            self.shortcut = nn.Sequential(\n",
        "                nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=1, bias=False),\n",
        "                nn.BatchNorm2d(out_channels)\n",
        "            )\n",
        "        else:\n",
        "            self.shortcut = nn.Identity()\n",
        "\n",
        "    def forward(self, x):\n",
        "        out = self.conv1(x)\n",
        "        out = self.bn1(out)\n",
        "        out = self.relu(out)\n",
        "        out = self.conv2(out)\n",
        "        out = self.bn2(out)\n",
        "        shortcut = self.shortcut(x)\n",
        "        out += shortcut\n",
        "        out = self.relu(out)\n",
        "        return out\n",
        "\n",
        "class SimpleResNet(nn.Module):\n",
        "    def __init__(self, num_classes=2):\n",
        "        super(SimpleResNet, self).__init__()\n",
        "\n",
        "        # Residual Block with correct channel dimensions\n",
        "        self.layer1 = BasicBlock(3, 64)\n",
        "\n",
        "\n",
        "        self.dropout1 = nn.Dropout(p=0.5)  # First dropout layer\n",
        "        self.dropout2 = nn.Dropout(p=0.5)  # Second dropout layer\n",
        "\n",
        "        # Pooling and Fully Connected Layer\n",
        "        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))\n",
        "        self.fc = nn.Linear(64, num_classes)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.layer1(x)\n",
        "        x = self.dropout1(x)\n",
        "\n",
        "        x = self.avgpool(x)\n",
        "        x = torch.flatten(x, 1) #flatten\n",
        "        x = self.dropout2(x)\n",
        "        x = self.fc(x)\n",
        "        return x\n",
        "\n",
        "class SimpleInceptionBlock(nn.Module):\n",
        "    def __init__(self, in_channels):\n",
        "        super(SimpleInceptionBlock, self).__init__()\n",
        "\n",
        "        # Convolution followed by ReLU activation\n",
        "        self.branch3x3 = nn.Sequential(\n",
        "            nn.Conv2d(in_channels, 16, kernel_size=3, padding=1),\n",
        "            nn.ReLU(inplace=True)\n",
        "        )\n",
        "\n",
        "        # 3x3 max pooling followed by 1x1 conv branch and ReLU activation\n",
        "        self.branch_pool = nn.Sequential(\n",
        "            nn.MaxPool2d(kernel_size=3, stride=1, padding=1),\n",
        "            nn.Conv2d(in_channels, 16, kernel_size=1),\n",
        "            nn.ReLU(inplace=True)\n",
        "        )\n",
        "\n",
        "    def forward(self, x):\n",
        "        branch3x3_out = self.branch3x3(x)\n",
        "        branch_pool_out = self.branch_pool(x)\n",
        "        outputs = [branch3x3_out, branch_pool_out]\n",
        "        return torch.cat(outputs, 1)  # Concatenate along channel dimension\n",
        "\n",
        "class SimpleInceptionModel(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(SimpleInceptionModel, self).__init__()\n",
        "\n",
        "        # Initial convolutional layer\n",
        "        self.conv1 = nn.Conv2d(3, 16, kernel_size=3, stride=1, padding=1)\n",
        "\n",
        "        # Inception block\n",
        "        self.inception = SimpleInceptionBlock(16)\n",
        "\n",
        "        # Dropout layers\n",
        "        self.dropout1 = nn.Dropout(0.3)\n",
        "        self.dropout2 = nn.Dropout(0.3)\n",
        "\n",
        "        # Flatten layer\n",
        "        self.flatten = nn.Flatten()\n",
        "\n",
        "        # Calculate the output size after InceptionBlock\n",
        "        self.fc1 = nn.Linear(32 * 224 * 224, 2)  # Adjust this if the spatial dimensions are different\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.conv1(x)\n",
        "        x = self.inception(x)\n",
        "        x = self.flatten(x)\n",
        "        x = self.dropout1(x)\n",
        "        x = self.dropout2(x)\n",
        "        x = self.fc1(x)\n",
        "        return x\n",
        "\n"
      ],
      "metadata": {
        "id": "v0HFTRVPzs4j"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "<h2>Loading Trained Model Parameters</h2>"
      ],
      "metadata": {
        "id": "uHho4jd5-x3j"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import gdown\n",
        "import numpy as np\n",
        "from sklearn.metrics import roc_curve, auc, precision_recall_curve, average_precision_score\n",
        "import matplotlib.pyplot as plt\n",
        "import torchvision.transforms as transforms\n",
        "from torchvision.datasets import ImageFolder\n",
        "from torch.utils.data import DataLoader\n",
        "import torchvision.models as tv_models\n",
        "\n",
        "\n",
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "\n",
        "# Define the function to download and load the models\n",
        "def download_and_load_model(file_id, output_name):\n",
        "    url = f'https://drive.google.com/uc?id={file_id}'\n",
        "    gdown.download(url, output_name, quiet=False)\n",
        "    model = torch.load(output_name)\n",
        "    model.to(device)\n",
        "    model.eval()\n",
        "    return model\n",
        "\n",
        "model_files = [\n",
        "    ('1waH9vN-74yUaNdkgC7bmzwys5JT1dbOf', 'xception.pth'),\n",
        "    ('1wuTf6B6w4g15bwhMih_pJUrg5i_gtD8_', 'vgg.pth'),\n",
        "    ('1lDbj8vBAnxKj_7m-2mFsZyxlBOMqXfbc', 'resnet.pth'),\n",
        "    ('1R6JAcdacUoJzbEOut11_ZLfNY5ul7t9m', 'inception.pth')\n",
        "]\n",
        "\n",
        "loaded_models = []\n",
        "\n",
        "for file_id, output_name in model_files:\n",
        "    model = download_and_load_model(file_id, output_name)\n",
        "    loaded_models.append(model)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8_ajntYwk2pC",
        "outputId": "38ebc2cf-d58f-44d0-d1fe-b094179a72a7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Downloading...\n",
            "From: https://drive.google.com/uc?id=1waH9vN-74yUaNdkgC7bmzwys5JT1dbOf\n",
            "To: /content/xception.pth\n",
            "100%|██████████| 1.62M/1.62M [00:00<00:00, 175MB/s]\n",
            "Downloading...\n",
            "From: https://drive.google.com/uc?id=1wuTf6B6w4g15bwhMih_pJUrg5i_gtD8_\n",
            "To: /content/vgg.pth\n",
            "100%|██████████| 3.52M/3.52M [00:00<00:00, 134MB/s]\n",
            "Downloading...\n",
            "From: https://drive.google.com/uc?id=1lDbj8vBAnxKj_7m-2mFsZyxlBOMqXfbc\n",
            "To: /content/resnet.pth\n",
            "100%|██████████| 170k/170k [00:00<00:00, 68.7MB/s]\n",
            "Downloading...\n",
            "From: https://drive.google.com/uc?id=1R6JAcdacUoJzbEOut11_ZLfNY5ul7t9m\n",
            "To: /content/inception.pth\n",
            "100%|██████████| 12.9M/12.9M [00:00<00:00, 121MB/s]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "<h2>Calculating AUC score</h2>"
      ],
      "metadata": {
        "id": "Nc0Ze-vg-4rj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "from sklearn.metrics import roc_curve, auc, precision_recall_curve, average_precision_score\n",
        "model_names = ['Xception', 'VGG', 'ResNet', 'Inception']\n",
        "# Define the function to get model outputs\n",
        "def get_model_outputs(model, test_loader, device):\n",
        "    y_true, y_scores = [], []\n",
        "    model.eval()  # Set the model to evaluation mode\n",
        "    with torch.no_grad():\n",
        "        for inputs, labels in test_loader:\n",
        "            inputs, labels = inputs.to(device), labels.to(device)\n",
        "            outputs = model(inputs)\n",
        "            # For binary classification, sigmoid activation function\n",
        "            if outputs.size(1) == 2:\n",
        "                probabilities = torch.softmax(outputs, dim=1)[:, 1]\n",
        "            else:\n",
        "                probabilities = torch.sigmoid(outputs).squeeze()\n",
        "\n",
        "            y_true.extend(labels.cpu().numpy())\n",
        "            y_scores.extend(probabilities.cpu().numpy())\n",
        "    return np.array(y_true), np.array(y_scores)\n",
        "\n",
        "# Get model outputs and calculate metrics\n",
        "roc_curves = []\n",
        "pr_curves = []\n",
        "\n",
        "for model, model_name in zip(loaded_models, model_names):\n",
        "    y_true, y_scores = get_model_outputs(model, test_loader, device)\n",
        "\n",
        "    if y_true.ndim > 1:\n",
        "        y_true = y_true[:, 0]\n",
        "\n",
        "    # Compute ROC curves and AUC scores\n",
        "    fpr, tpr, _ = roc_curve(y_true, y_scores)\n",
        "    auc_score = auc(fpr, tpr)\n",
        "\n",
        "    # Compute PR curves and AUC scores\n",
        "    precision, recall, _ = precision_recall_curve(y_true, y_scores)\n",
        "    auc_pr_score = average_precision_score(y_true, y_scores)\n",
        "\n",
        "    # Store curves\n",
        "    roc_curves.append((fpr, tpr, auc_score, model_name))\n",
        "    pr_curves.append((precision, recall, auc_pr_score, model_name))\n"
      ],
      "metadata": {
        "id": "VK604Egz4w1A"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "<h2>Plot PR and ROC curves</h2>"
      ],
      "metadata": {
        "id": "srEdzjoN_Gzw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "def plot_curves(roc_curves, pr_curves):\n",
        "    plt.figure(figsize=(14, 6))\n",
        "\n",
        "    # Define colors for each model\n",
        "    colors = ['b', 'g', 'r', 'c', 'm', 'y', 'k', 'orange', 'purple', 'lime']\n",
        "\n",
        "    # Plot ROC Curves\n",
        "    plt.subplot(1, 2, 1)\n",
        "    for i, (fpr, tpr, auc_score, model_name) in enumerate(roc_curves):\n",
        "        plt.plot(fpr, tpr, color=colors[i % len(colors)], lw=2, alpha=0.8, label=f'{model_name} (AUC = {auc_score:.2f})')\n",
        "    plt.plot([0, 1], [0, 1], color='gray', lw=2, linestyle='--')\n",
        "    plt.xlim([0.0, 1.0])\n",
        "    plt.ylim([0.0, 1.05])\n",
        "    plt.xlabel('False Positive Rate')\n",
        "    plt.ylabel('True Positive Rate')\n",
        "    plt.title('Receiver Operating Characteristic for All Models')\n",
        "    plt.legend(loc='lower right')\n",
        "\n",
        "    # Plot PR Curves\n",
        "    plt.subplot(1, 2, 2)\n",
        "    for i, (precision, recall, auc_pr_score, model_name) in enumerate(pr_curves):\n",
        "        plt.plot(recall, precision, color=colors[i % len(colors)], lw=2, alpha=0.8, label=f'{model_name} (AP = {auc_pr_score:.2f})')\n",
        "    plt.xlabel('Recall')\n",
        "    plt.ylabel('Precision')\n",
        "    plt.title('Precision-Recall Curve for All Models')\n",
        "    plt.legend(loc='lower left')\n",
        "    plt.grid(True)\n",
        "\n",
        "    plt.tight_layout()\n",
        "    plt.show()\n",
        "\n",
        "plot_curves(roc_curves, pr_curves)"
      ],
      "metadata": {
        "id": "-uN9OlG5ZsAM",
        "outputId": "3345ba6c-e59a-404e-b46b-d872e6a7f7d0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 396
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1400x600 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "def plot_curves(roc_curves, pr_curves):\n",
        "    plt.figure(figsize=(14, 6))\n",
        "\n",
        "    # Define colors for each model\n",
        "    colors = ['b', 'g', 'r', 'c', 'm', 'y', 'k', 'orange', 'purple', 'lime']\n",
        "\n",
        "    # Plot ROC Curves\n",
        "    plt.subplot(1, 2, 1)\n",
        "    for i, (fpr, tpr, auc_score, model_name) in enumerate(roc_curves):\n",
        "        plt.plot(fpr, tpr, color=colors[i % len(colors)], lw=2, alpha=0.8, label=f'{model_name} (AUC = {auc_score:.2f})')\n",
        "    plt.plot([0, 1], [0, 1], color='gray', lw=2, linestyle='--')\n",
        "    plt.xlim([0.0, 0.2])  # Zoom in on the ROC curve\n",
        "    plt.ylim([0.8, 1.0])  # Adjust y-axis limits\n",
        "    plt.xlabel('False Positive Rate')\n",
        "    plt.ylabel('True Positive Rate')\n",
        "    plt.title('Receiver Operating Characteristic for All Models')\n",
        "    plt.legend(loc='lower right')\n",
        "\n",
        "    # Plot PR Curves\n",
        "    plt.subplot(1, 2, 2)\n",
        "    for i, (precision, recall, auc_pr_score, model_name) in enumerate(pr_curves):\n",
        "        plt.plot(recall, precision, color=colors[i % len(colors)], lw=2, alpha=0.8, label=f'{model_name} (AP = {auc_pr_score:.2f})')\n",
        "    plt.xlim([0.8, 1.0])  # Zoom in on the PR curve\n",
        "    plt.ylim([0.8, 1.0])  # Adjust y-axis limits\n",
        "    plt.xlabel('Recall')\n",
        "    plt.ylabel('Precision')\n",
        "    plt.title('Precision-Recall Curve for All Models')\n",
        "    plt.legend(loc='lower left')\n",
        "    plt.grid(True)\n",
        "\n",
        "    plt.tight_layout()\n",
        "    plt.show()\n",
        "\n",
        "plot_curves(roc_curves, pr_curves)\n"
      ],
      "metadata": {
        "id": "5oMIQQ-z51LT",
        "outputId": "0ad21b58-ffaa-4075-900d-20d6a33edbca",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 396
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1400x600 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    }
  ]
}