3d_cnn.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "99WdgO6AMrqq"
   },
   "source": [
    "# 3D image classification from CT scans\n",
    "\n",
    "**Author:** []()<br>\n",
    "**Date created:** 2020/09/23<br>\n",
    "**Last modified:** 2024/01/11<br>\n",
    "**Description:** Train a 3D convolutional neural network to predict presence of pneumonia."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Skp-bvaEMrqt"
   },
   "source": [
    "## Introduction\n",
    "\n",
    "This example will show the steps needed to build a 3D convolutional neural network (CNN)\n",
    "to predict the presence of viral pneumonia in computer tomography (CT) scans. 2D CNNs are\n",
    "commonly used to process RGB images (3 channels). A 3D CNN is simply the 3D\n",
    "equivalent: it takes as input a 3D volume or a sequence of 2D frames (e.g. slices in a CT scan),\n",
    "3D CNNs are a powerful model for learning representations for volumetric data.\n",
    "\n",
    "## References\n",
    "\n",
    "- [A survey on Deep Learning Advances on Different 3D DataRepresentations](https://arxiv.org/abs/1808.01462)\n",
    "- [VoxNet: A 3D Convolutional Neural Network for Real-Time Object Recognition](https://www.ri.cmu.edu/pub_files/2015/9/voxnet_maturana_scherer_iros15.pdf)\n",
    "- [FusionNet: 3D Object Classification Using MultipleData Representations](https://arxiv.org/abs/1607.05695)\n",
    "- [Uniformizing Techniques to Process CT scans with 3D CNNs for Tuberculosis Prediction](https://arxiv.org/abs/2007.13224)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "uTNm8DT6Mrqv"
   },
   "source": [
    "## Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-06-06T23:48:58.844723Z",
     "iopub.status.busy": "2024-06-06T23:48:58.844193Z",
     "iopub.status.idle": "2024-06-06T23:49:07.863602Z",
     "shell.execute_reply": "2024-06-06T23:49:07.862735Z",
     "shell.execute_reply.started": "2024-06-06T23:48:58.844697Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: nibabel in /usr/local/lib/python3.11/dist-packages (5.2.1)\n",
      "Requirement already satisfied: numpy>=1.20 in /usr/local/lib/python3.11/dist-packages (from nibabel) (1.26.3)\n",
      "Requirement already satisfied: packaging>=17 in /usr/local/lib/python3.11/dist-packages (from nibabel) (23.2)\n",
      "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n",
      "\u001b[0mRequirement already satisfied: SimpleITK in /usr/local/lib/python3.11/dist-packages (2.3.1)\n",
      "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n",
      "\u001b[0mRequirement already satisfied: grad-cam in /usr/local/lib/python3.11/dist-packages (1.5.2)\n",
      "Requirement already satisfied: numpy in /usr/local/lib/python3.11/dist-packages (from grad-cam) (1.26.3)\n",
      "Requirement already satisfied: Pillow in /usr/local/lib/python3.11/dist-packages (from grad-cam) (9.5.0)\n",
      "Requirement already satisfied: torch>=1.7.1 in /usr/local/lib/python3.11/dist-packages (from grad-cam) (2.1.1+cu121)\n",
      "Requirement already satisfied: torchvision>=0.8.2 in /usr/local/lib/python3.11/dist-packages (from grad-cam) (0.16.1+cu121)\n",
      "Requirement already satisfied: ttach in /usr/local/lib/python3.11/dist-packages (from grad-cam) (0.0.3)\n",
      "Requirement already satisfied: tqdm in /usr/local/lib/python3.11/dist-packages (from grad-cam) (4.66.1)\n",
      "Requirement already satisfied: opencv-python in /usr/local/lib/python3.11/dist-packages (from grad-cam) (4.8.0.76)\n",
      "Requirement already satisfied: matplotlib in /usr/local/lib/python3.11/dist-packages (from grad-cam) (3.7.3)\n",
      "Requirement already satisfied: scikit-learn in /usr/local/lib/python3.11/dist-packages (from grad-cam) (1.3.0)\n",
      "Requirement already satisfied: filelock in /usr/local/lib/python3.11/dist-packages (from torch>=1.7.1->grad-cam) (3.13.1)\n",
      "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.11/dist-packages (from torch>=1.7.1->grad-cam) (4.9.0)\n",
      "Requirement already satisfied: sympy in /usr/local/lib/python3.11/dist-packages (from torch>=1.7.1->grad-cam) (1.12)\n",
      "Requirement already satisfied: networkx in /usr/local/lib/python3.11/dist-packages (from torch>=1.7.1->grad-cam) (3.2.1)\n",
      "Requirement already satisfied: jinja2 in /usr/local/lib/python3.11/dist-packages (from torch>=1.7.1->grad-cam) (3.1.3)\n",
      "Requirement already satisfied: fsspec in /usr/local/lib/python3.11/dist-packages (from torch>=1.7.1->grad-cam) (2023.6.0)\n",
      "Requirement already satisfied: triton==2.1.0 in /usr/local/lib/python3.11/dist-packages (from torch>=1.7.1->grad-cam) (2.1.0)\n",
      "Requirement already satisfied: requests in /usr/local/lib/python3.11/dist-packages (from torchvision>=0.8.2->grad-cam) (2.31.0)\n",
      "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib->grad-cam) (1.2.0)\n",
      "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.11/dist-packages (from matplotlib->grad-cam) (0.12.1)\n",
      "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.11/dist-packages (from matplotlib->grad-cam) (4.47.2)\n",
      "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib->grad-cam) (1.4.5)\n",
      "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.11/dist-packages (from matplotlib->grad-cam) (23.2)\n",
      "Requirement already satisfied: pyparsing>=2.3.1 in /usr/lib/python3/dist-packages (from matplotlib->grad-cam) (2.4.7)\n",
      "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.11/dist-packages (from matplotlib->grad-cam) (2.8.2)\n",
      "Requirement already satisfied: scipy>=1.5.0 in /usr/local/lib/python3.11/dist-packages (from scikit-learn->grad-cam) (1.11.2)\n",
      "Requirement already satisfied: joblib>=1.1.1 in /usr/local/lib/python3.11/dist-packages (from scikit-learn->grad-cam) (1.3.2)\n",
      "Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.11/dist-packages (from scikit-learn->grad-cam) (3.2.0)\n",
      "Requirement already satisfied: six>=1.5 in /usr/lib/python3/dist-packages (from python-dateutil>=2.7->matplotlib->grad-cam) (1.16.0)\n",
      "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.11/dist-packages (from jinja2->torch>=1.7.1->grad-cam) (2.1.4)\n",
      "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.11/dist-packages (from requests->torchvision>=0.8.2->grad-cam) (3.3.2)\n",
      "Requirement already satisfied: idna<4,>=2.5 in /usr/lib/python3/dist-packages (from requests->torchvision>=0.8.2->grad-cam) (3.3)\n",
      "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.11/dist-packages (from requests->torchvision>=0.8.2->grad-cam) (2.0.7)\n",
      "Requirement already satisfied: certifi>=2017.4.17 in /usr/lib/python3/dist-packages (from requests->torchvision>=0.8.2->grad-cam) (2020.6.20)\n",
      "Requirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.11/dist-packages (from sympy->torch>=1.7.1->grad-cam) (1.3.0)\n",
      "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n",
      "\u001b[0m"
     ]
    }
   ],
   "source": [
    "!pip install nibabel\n",
    "!pip install SimpleITK\n",
    "!pip install grad-cam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-06-06T23:23:48.643328Z",
     "iopub.status.busy": "2024-06-06T23:23:48.642588Z",
     "iopub.status.idle": "2024-06-06T23:23:48.647494Z",
     "shell.execute_reply": "2024-06-06T23:23:48.647036Z",
     "shell.execute_reply.started": "2024-06-06T23:23:48.643290Z"
    },
    "id": "gbalBhvpMrqv"
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import zipfile\n",
    "import random\n",
    "import numpy as np\n",
    "import nibabel as nib\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy import ndimage\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "from torchvision.transforms import Compose, ToTensor, Lambda\n",
    "from torch.optim.lr_scheduler import ExponentialLR"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "FTwYU8fqMrqw"
   },
   "source": [
    "## Downloading the MosMedData: Chest CT Scans with COVID-19 Related Findings\n",
    "\n",
    "In this example, we use a subset of the\n",
    "[MosMedData: Chest CT Scans with COVID-19 Related Findings](https://www.medrxiv.org/content/10.1101/2020.05.20.20100362v1).\n",
    "This dataset consists of lung CT scans with COVID-19 related findings, as well as without such findings.\n",
    "\n",
    "We will be using the associated radiological findings of the CT scans as labels to build\n",
    "a classifier to predict presence of viral pneumonia.\n",
    "Hence, the task is a binary classification problem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-06-06T23:23:48.648479Z",
     "iopub.status.busy": "2024-06-06T23:23:48.648124Z",
     "iopub.status.idle": "2024-06-06T23:23:48.653068Z",
     "shell.execute_reply": "2024-06-06T23:23:48.652564Z",
     "shell.execute_reply.started": "2024-06-06T23:23:48.648458Z"
    },
    "id": "Wq2u7jgcMrqx"
   },
   "outputs": [],
   "source": [
    "import urllib.request\n",
    "\n",
    "def download_and_extract(url, output_dir):\n",
    "    zip_path = os.path.join(output_dir, os.path.basename(url))\n",
    "    urllib.request.urlretrieve(url, zip_path)\n",
    "    with zipfile.ZipFile(zip_path, 'r') as z_fp:\n",
    "        z_fp.extractall(output_dir)\n",
    "\n",
    "# Create directories\n",
    "output_dir = os.path.join(os.getcwd(), \"MosMedData\")\n",
    "os.makedirs(output_dir, exist_ok=True)\n",
    "\n",
    "# Download and extract data\n",
    "# download_and_extract(\"https://github.com/hasibzunair/3D-image-classification-tutorial/releases/download/v0.2/CT-0.zip\", output_dir)\n",
    "# download_and_extract(\"https://github.com/hasibzunair/3D-image-classification-tutorial/releases/download/v0.2/CT-23.zip\", output_dir)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "phaGcd73Mrqx"
   },
   "source": [
    "## Loading data and preprocessing\n",
    "\n",
    "The files are provided in Nifti format with the extension .nii. To read the\n",
    "scans, we use the `nibabel` package.\n",
    "You can install the package via `pip install nibabel`. CT scans store raw voxel\n",
    "intensity in Hounsfield units (HU). They range from -1024 to above 2000 in this dataset.\n",
    "Above 400 are bones with different radiointensity, so this is used as a higher bound. A threshold\n",
    "between -1000 and 400 is commonly used to normalize CT scans.\n",
    "\n",
    "To process the data, we do the following:\n",
    "\n",
    "* We first rotate the volumes by 90 degrees, so the orientation is fixed\n",
    "* We scale the HU values to be between 0 and 1.\n",
    "* We resize width, height and depth.\n",
    "\n",
    "Here we define several helper functions to process the data. These functions\n",
    "will be used when building training and validation datasets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-06-06T23:23:48.654319Z",
     "iopub.status.busy": "2024-06-06T23:23:48.653888Z",
     "iopub.status.idle": "2024-06-06T23:23:48.659862Z",
     "shell.execute_reply": "2024-06-06T23:23:48.659196Z",
     "shell.execute_reply.started": "2024-06-06T23:23:48.654296Z"
    },
    "id": "28MnrIoLMrqy"
   },
   "outputs": [],
   "source": [
    "\n",
    "import nibabel as nib\n",
    "\n",
    "from scipy import ndimage\n",
    "\n",
    "def read_nifti_file(filepath):\n",
    "    scan = nib.load(filepath)\n",
    "    scan = scan.get_fdata()\n",
    "    return scan\n",
    "\n",
    "def normalize(volume):\n",
    "    min, max = -1000, 400\n",
    "    volume[volume < min] = min\n",
    "    volume[volume > max] = max\n",
    "    volume = (volume - min) / (max - min)\n",
    "    volume = volume.astype(\"float32\")\n",
    "    return volume\n",
    "\n",
    "def resize_volume(img):\n",
    "    desired_depth, desired_width, desired_height = 64, 128, 128\n",
    "    current_depth, current_width, current_height = img.shape[-1], img.shape[0], img.shape[1]\n",
    "    depth_factor, width_factor, height_factor = current_depth / desired_depth, current_width / desired_width, current_height / desired_height\n",
    "    depth_factor, width_factor, height_factor = 1 / depth_factor, 1 / width_factor, 1 / height_factor\n",
    "    img = ndimage.rotate(img, 90, reshape=False)\n",
    "    img = ndimage.zoom(img, (width_factor, height_factor, depth_factor), order=1)\n",
    "    return img\n",
    "\n",
    "def process_scan(path):\n",
    "    volume = read_nifti_file(path)\n",
    "    volume = normalize(volume)\n",
    "    volume = resize_volume(volume)\n",
    "    return volume\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6JlnAmXlMrqz"
   },
   "source": [
    "Let's read the paths of the CT scans from the class directories."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "execution": {
     "iopub.execute_input": "2024-06-06T23:23:48.661962Z",
     "iopub.status.busy": "2024-06-06T23:23:48.661548Z",
     "iopub.status.idle": "2024-06-06T23:31:56.578684Z",
     "shell.execute_reply": "2024-06-06T23:31:56.577871Z",
     "shell.execute_reply.started": "2024-06-06T23:23:48.661942Z"
    },
    "id": "al541TsPMrqz",
    "outputId": "570542d8-c00e-434d-88bb-2396f5c19b65"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CT scans with normal lung tissue: 100\n",
      "CT scans with abnormal lung tissue: 100\n"
     ]
    }
   ],
   "source": [
    "class CTScanDataset(Dataset):\n",
    "    def __init__(self, scan_paths, labels, transform=None):\n",
    "        self.scan_paths = scan_paths\n",
    "        self.labels = labels\n",
    "        self.transform = transform\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.scan_paths)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        scan = self.scan_paths[idx]\n",
    "        label = self.labels[idx]\n",
    "        if self.transform:\n",
    "            scan = self.transform(scan)\n",
    "        return scan, label\n",
    "\n",
    "# Prepare data\n",
    "normal_scan_paths = [os.path.join(output_dir, \"CT-0\", x) for x in os.listdir(os.path.join(output_dir, \"CT-0\"))]\n",
    "abnormal_scan_paths = [os.path.join(output_dir, \"CT-23\", x) for x in os.listdir(os.path.join(output_dir, \"CT-23\"))]\n",
    "\n",
    "print(\"CT scans with normal lung tissue: \" + str(len(normal_scan_paths)))\n",
    "print(\"CT scans with abnormal lung tissue: \" + str(len(abnormal_scan_paths)))\n",
    "\n",
    "# Process scans\n",
    "abnormal_scans = [process_scan(path) for path in abnormal_scan_paths]\n",
    "normal_scans = [process_scan(path) for path in normal_scan_paths]\n",
    "\n",
    "abnormal_labels = [1 for _ in range(len(abnormal_scans))]\n",
    "normal_labels = [0 for _ in range(len(normal_scans))]\n",
    "\n",
    "# Split data\n",
    "x_train = abnormal_scans[:70] + normal_scans[:70]\n",
    "y_train = abnormal_labels[:70] + normal_labels[:70]\n",
    "x_val = abnormal_scans[70:] + normal_scans[70:]\n",
    "y_val = abnormal_labels[70:] + normal_labels[70:]\n",
    "\n",
    "# Define transforms\n",
    "train_transform = Compose([\n",
    "    ToTensor(),\n",
    "    Lambda(lambda x: x.unsqueeze(0))  # Add channel dimension\n",
    "])\n",
    "\n",
    "val_transform = Compose([\n",
    "    ToTensor(),\n",
    "    Lambda(lambda x: x.unsqueeze(0))  # Add channel dimension\n",
    "])\n",
    "\n",
    "# Create datasets\n",
    "train_dataset = CTScanDataset(x_train, y_train, transform=train_transform)\n",
    "val_dataset = CTScanDataset(x_val, y_val, transform=val_transform)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-06-06T23:31:56.579817Z",
     "iopub.status.busy": "2024-06-06T23:31:56.579602Z",
     "iopub.status.idle": "2024-06-06T23:31:56.585224Z",
     "shell.execute_reply": "2024-06-06T23:31:56.584347Z",
     "shell.execute_reply.started": "2024-06-06T23:31:56.579798Z"
    },
    "id": "9sZRwCDnMrq0"
   },
   "outputs": [],
   "source": [
    "# # Define data loaders.\n",
    "\n",
    "batch_size = 2\n",
    "\n",
    "train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=4)\n",
    "val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False, num_workers=4)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OUvROCKOMrq2"
   },
   "source": [
    "## Define a 3D convolutional neural network\n",
    "\n",
    "To make the model easier to understand, we structure it into blocks.\n",
    "The architecture of the 3D CNN used in this example\n",
    "is based on [this paper](https://arxiv.org/abs/2007.13224)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "execution": {
     "iopub.execute_input": "2024-06-07T00:49:47.520209Z",
     "iopub.status.busy": "2024-06-07T00:49:47.519573Z",
     "iopub.status.idle": "2024-06-07T00:49:47.578952Z",
     "shell.execute_reply": "2024-06-07T00:49:47.578312Z",
     "shell.execute_reply.started": "2024-06-07T00:49:47.520182Z"
    },
    "id": "fag8KMXJMrq2",
    "outputId": "35fe5edd-3ddf-4b0c-f3aa-8057e6c0b818"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using device: cuda\n"
     ]
    }
   ],
   "source": [
    "torch.cuda.empty_cache()\n",
    "torch.set_grad_enabled(True)\n",
    "class CNN3D(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(CNN3D, self).__init__()\n",
    "        self.conv1 = nn.Conv3d(1, 64, kernel_size=3, padding=1)\n",
    "        self.pool1 = nn.MaxPool3d(kernel_size=2)\n",
    "        self.bn1 = nn.BatchNorm3d(64)\n",
    "\n",
    "        self.conv2 = nn.Conv3d(64, 64, kernel_size=3, padding=1)\n",
    "        self.pool2 = nn.MaxPool3d(kernel_size=2)\n",
    "        self.bn2 = nn.BatchNorm3d(64)\n",
    "\n",
    "        self.conv3 = nn.Conv3d(64, 128, kernel_size=3, padding=1)\n",
    "        self.pool3 = nn.MaxPool3d(kernel_size=2)\n",
    "        self.bn3 = nn.BatchNorm3d(128)\n",
    "\n",
    "        self.conv4 = nn.Conv3d(128, 256, kernel_size=3, padding=1)\n",
    "        self.pool4 = nn.MaxPool3d(kernel_size=2)\n",
    "        self.bn4 = nn.BatchNorm3d(256)\n",
    "\n",
    "        self.global_pool = nn.AdaptiveAvgPool3d((1, 1, 1))\n",
    "        self.fc1 = nn.Linear(256, 512)\n",
    "        self.dropout = nn.Dropout(0.3)\n",
    "        self.fc2 = nn.Linear(512, 2)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.bn1(self.pool1(self.conv1(x))))\n",
    "        x = F.relu(self.bn2(self.pool2(self.conv2(x))))\n",
    "        x = F.relu(self.bn3(self.pool3(self.conv3(x))))\n",
    "        x = F.relu(self.bn4(self.pool4(self.conv4(x))))\n",
    "        x = self.global_pool(x)\n",
    "        x = x.view(-1, 256)\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = self.dropout(x)\n",
    "        x = self.fc2(x)\n",
    "        return x\n",
    "\n",
    "\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(f\"Using device: {device}\")\n",
    "\n",
    "# Initialize model\n",
    "model = CNN3D().to(device)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "aZYZDwGpMrq2"
   },
   "source": [
    "## Train model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "execution": {
     "iopub.execute_input": "2024-06-07T01:26:31.132179Z",
     "iopub.status.busy": "2024-06-07T01:26:31.131897Z",
     "iopub.status.idle": "2024-06-07T01:27:55.260805Z",
     "shell.execute_reply": "2024-06-07T01:27:55.259727Z",
     "shell.execute_reply.started": "2024-06-07T01:26:31.132157Z"
    },
    "id": "o_i5hPGeMrq2",
    "outputId": "315b6b5f-ec48-4080-d7b6-ec0d9ff2635d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10, Train Loss: 0.6650, Train Acc: 0.6071, Val Loss: 0.6503, Val Acc: 0.6167\n",
      "Epoch 2/10, Train Loss: 0.6673, Train Acc: 0.6071, Val Loss: 0.6487, Val Acc: 0.6167\n",
      "Epoch 3/10, Train Loss: 0.6382, Train Acc: 0.6500, Val Loss: 0.6504, Val Acc: 0.6333\n",
      "Epoch 4/10, Train Loss: 0.6605, Train Acc: 0.5857, Val Loss: 0.6535, Val Acc: 0.6500\n",
      "Epoch 5/10, Train Loss: 0.6209, Train Acc: 0.6857, Val Loss: 0.6565, Val Acc: 0.6333\n",
      "Epoch 6/10, Train Loss: 0.6540, Train Acc: 0.6286, Val Loss: 0.6532, Val Acc: 0.6500\n",
      "Epoch 7/10, Train Loss: 0.6535, Train Acc: 0.6071, Val Loss: 0.6544, Val Acc: 0.6500\n",
      "Epoch 8/10, Train Loss: 0.6450, Train Acc: 0.6429, Val Loss: 0.6557, Val Acc: 0.6667\n",
      "Epoch 9/10, Train Loss: 0.6336, Train Acc: 0.6143, Val Loss: 0.6551, Val Acc: 0.6500\n",
      "Epoch 10/10, Train Loss: 0.6414, Train Acc: 0.6214, Val Loss: 0.6590, Val Acc: 0.6000\n"
     ]
    }
   ],
   "source": [
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = optim.Adam(model.parameters(), lr=0.0001)\n",
    "scheduler = ExponentialLR(optimizer, gamma=0.96)\n",
    "\n",
    "num_epochs = 10\n",
    "best_val_acc = 0\n",
    "\n",
    "history = {\n",
    "    'train_loss': [],\n",
    "    'val_loss': [],\n",
    "    'train_acc': [],\n",
    "    'val_acc': []\n",
    "}\n",
    "\n",
    "for epoch in range(num_epochs):\n",
    "    model.train()\n",
    "    train_loss = 0.0\n",
    "    train_correct = 0\n",
    "\n",
    "    for inputs, labels in train_loader:\n",
    "        inputs, labels = inputs.to(device), labels.to(device, dtype=torch.long)\n",
    "        optimizer.zero_grad()\n",
    "        outputs = model(inputs)\n",
    "        loss = criterion(outputs, labels)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        scheduler.step()\n",
    "        train_loss += loss.item() * inputs.size(0)\n",
    "        train_correct += (outputs.argmax(dim=1) == labels).sum().item()\n",
    "\n",
    "    train_loss = train_loss / len(train_loader.dataset)\n",
    "    train_acc = train_correct / len(train_loader.dataset)\n",
    "\n",
    "    model.eval()\n",
    "    val_loss = 0.0\n",
    "    val_correct = 0\n",
    "\n",
    "    # with torch.no_grad():\n",
    "    for inputs, labels in val_loader:\n",
    "        inputs, labels = inputs.to(device), labels.to(device, dtype=torch.long)\n",
    "        outputs = model(inputs)\n",
    "        loss = criterion(outputs, labels)\n",
    "        val_loss += loss.item() * inputs.size(0)\n",
    "        val_correct += (outputs.argmax(dim=1) == labels).sum().item()\n",
    "\n",
    "    val_loss = val_loss / len(val_loader.dataset)\n",
    "    val_acc = val_correct / len(val_loader.dataset)\n",
    "\n",
    "    if val_acc > best_val_acc:\n",
    "        best_val_acc = val_acc\n",
    "        torch.save(model.state_dict(), \"3d_image_classification.pth\")\n",
    "\n",
    "    # After training loop, append the performance metrics to history for visualization\n",
    "    history['train_loss'].append(train_loss)\n",
    "    history['val_loss'].append(val_loss)\n",
    "    history['train_acc'].append(train_acc)\n",
    "    history['val_acc'].append(val_acc)\n",
    "\n",
    "    print(f\"Epoch {epoch+1}/{num_epochs}, \"\n",
    "          f\"Train Loss: {train_loss:.4f}, Train Acc: {train_acc:.4f}, \"\n",
    "          f\"Val Loss: {val_loss:.4f}, Val Acc: {val_acc:.4f}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QGcSetZQMrq2"
   },
   "source": [
    "It is important to note that the number of samples is very small (only 200) and we don't\n",
    "specify a random seed. As such, you can expect significant variance in the results. The full dataset\n",
    "which consists of over 1000 CT scans can be found [here](https://www.medrxiv.org/content/10.1101/2020.05.20.20100362v1). Using the full\n",
    "dataset, an accuracy of 83% was achieved. A variability of 6-7% in the classification\n",
    "performance is observed in both cases."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "AkNhKZMLMrq2"
   },
   "source": [
    "## Visualizing model performance\n",
    "\n",
    "Here the model accuracy and loss for the training and the validation sets are plotted.\n",
    "Since the validation set is class-balanced, accuracy provides an unbiased representation\n",
    "of the model's performance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-06-07T01:29:02.638537Z",
     "iopub.status.busy": "2024-06-07T01:29:02.638212Z",
     "iopub.status.idle": "2024-06-07T01:29:02.923931Z",
     "shell.execute_reply": "2024-06-07T01:29:02.923107Z",
     "shell.execute_reply.started": "2024-06-07T01:29:02.638516Z"
    },
    "id": "xwMdwWJUMrq3"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(1, 2, figsize=(20, 5))\n",
    "ax[0].plot(history['train_loss'], label='Train Loss')\n",
    "ax[0].plot(history['val_loss'], label='Val Loss')\n",
    "ax[0].set_title('Loss')\n",
    "ax[0].legend()\n",
    "\n",
    "ax[1].plot(history['train_acc'], label='Train Acc')\n",
    "ax[1].plot(history['val_acc'], label='Val Acc')\n",
    "ax[1].set_title('Accuracy')\n",
    "ax[1].legend()\n",
    "\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WUeJTtXPMrq3"
   },
   "source": [
    "## Make predictions on a single CT scan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-06-07T01:29:06.370849Z",
     "iopub.status.busy": "2024-06-07T01:29:06.370249Z",
     "iopub.status.idle": "2024-06-07T01:29:06.474105Z",
     "shell.execute_reply": "2024-06-07T01:29:06.473481Z",
     "shell.execute_reply.started": "2024-06-07T01:29:06.370821Z"
    },
    "id": "g3YeOerGMrq3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "logits:  tensor([[-0.5714,  0.4936]], device='cuda:0', grad_fn=<AddmmBackward0>)\n",
      "probabilities:  tensor([[0.2564, 0.7436]], device='cuda:0', grad_fn=<SoftmaxBackward0>)\n",
      "[[('normal', 25.636297464370728), ('abnormal', 74.36370253562927)]]\n"
     ]
    }
   ],
   "source": [
    "model.load_state_dict(torch.load(\"3d_image_classification.pth\"))\n",
    "\n",
    "model.eval()\n",
    "\n",
    "class_names = [\"normal\", \"abnormal\"]\n",
    "predictions= []\n",
    "# with torch.no_grad():\n",
    "sample = torch.tensor(x_val[0]).unsqueeze(0).unsqueeze(0).to(device, dtype=torch.float32)\n",
    "logits = model(sample)\n",
    "print(\"logits: \", logits)\n",
    "probabilities = F.softmax(logits, dim=1)\n",
    "print(\"probabilities: \", probabilities)\n",
    "label_confidences = [(class_names[i], prob.item() * 100) for i, prob in enumerate(probabilities.squeeze())]\n",
    "predictions.append(label_confidences)\n",
    "print(predictions)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-06-07T01:53:40.889576Z",
     "iopub.status.busy": "2024-06-07T01:53:40.888978Z",
     "iopub.status.idle": "2024-06-07T01:53:41.050619Z",
     "shell.execute_reply": "2024-06-07T01:53:41.049796Z",
     "shell.execute_reply.started": "2024-06-07T01:53:40.889550Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using device: cuda\n",
      "Input tensor requires grad: torch.Size([1, 1, 128, 128, 64])\n"
     ]
    },
    {
     "ename": "error",
     "evalue": "OpenCV(4.8.0) :-1: error: (-5:Bad argument) in function 'resize'\n> Overload resolution failed:\n>  - Can't parse 'dsize'. Expected sequence length 2, got 3\n>  - Can't parse 'dsize'. Expected sequence length 2, got 3\n",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31merror\u001b[0m                                     Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[51], line 74\u001b[0m\n\u001b[1;32m     72\u001b[0m sample \u001b[38;5;241m=\u001b[39m x_val[i]\n\u001b[1;32m     73\u001b[0m label \u001b[38;5;241m=\u001b[39m y_val[i]\n\u001b[0;32m---> 74\u001b[0m \u001b[43mvisualize_gradcam\u001b[49m\u001b[43m(\u001b[49m\u001b[43msample\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlabel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcam\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mclass_names\u001b[49m\u001b[43m)\u001b[49m\n",
      "Cell \u001b[0;32mIn[51], line 54\u001b[0m, in \u001b[0;36mvisualize_gradcam\u001b[0;34m(sample, label, cam, model, class_names)\u001b[0m\n\u001b[1;32m     52\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mInput tensor requires grad:\u001b[39m\u001b[38;5;124m\"\u001b[39m, sample\u001b[38;5;241m.\u001b[39mshape)\n\u001b[1;32m     53\u001b[0m \u001b[38;5;66;03m# Generate CAM\u001b[39;00m\n\u001b[0;32m---> 54\u001b[0m grayscale_cam \u001b[38;5;241m=\u001b[39m \u001b[43mcam\u001b[49m\u001b[43m(\u001b[49m\u001b[43minput_tensor\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msample\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtargets\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtargets\u001b[49m\u001b[43m)\u001b[49m[\u001b[38;5;241m0\u001b[39m, :]\n\u001b[1;32m     56\u001b[0m \u001b[38;5;66;03m# Convert sample to numpy array for visualization\u001b[39;00m\n\u001b[1;32m     57\u001b[0m sample_np \u001b[38;5;241m=\u001b[39m sample\u001b[38;5;241m.\u001b[39msqueeze()\u001b[38;5;241m.\u001b[39mcpu()\u001b[38;5;241m.\u001b[39mnumpy()\n",
      "File \u001b[0;32m/usr/local/lib/python3.11/dist-packages/pytorch_grad_cam/base_cam.py:186\u001b[0m, in \u001b[0;36mBaseCAM.__call__\u001b[0;34m(self, input_tensor, targets, aug_smooth, eigen_smooth)\u001b[0m\n\u001b[1;32m    183\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m aug_smooth \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mTrue\u001b[39;00m:\n\u001b[1;32m    184\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mforward_augmentation_smoothing(input_tensor, targets, eigen_smooth)\n\u001b[0;32m--> 186\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mforward\u001b[49m\u001b[43m(\u001b[49m\u001b[43minput_tensor\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtargets\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43meigen_smooth\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m/usr/local/lib/python3.11/dist-packages/pytorch_grad_cam/base_cam.py:110\u001b[0m, in \u001b[0;36mBaseCAM.forward\u001b[0;34m(self, input_tensor, targets, eigen_smooth)\u001b[0m\n\u001b[1;32m     99\u001b[0m     loss\u001b[38;5;241m.\u001b[39mbackward(retain_graph\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[1;32m    101\u001b[0m \u001b[38;5;66;03m# In most of the saliency attribution papers, the saliency is\u001b[39;00m\n\u001b[1;32m    102\u001b[0m \u001b[38;5;66;03m# computed with a single target layer.\u001b[39;00m\n\u001b[1;32m    103\u001b[0m \u001b[38;5;66;03m# Commonly it is the last convolutional layer.\u001b[39;00m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    108\u001b[0m \u001b[38;5;66;03m# use all conv layers for example, all Batchnorm layers,\u001b[39;00m\n\u001b[1;32m    109\u001b[0m \u001b[38;5;66;03m# or something else.\u001b[39;00m\n\u001b[0;32m--> 110\u001b[0m cam_per_layer \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcompute_cam_per_layer\u001b[49m\u001b[43m(\u001b[49m\u001b[43minput_tensor\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtargets\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43meigen_smooth\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    111\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39maggregate_multi_layers(cam_per_layer)\n",
      "File \u001b[0;32m/usr/local/lib/python3.11/dist-packages/pytorch_grad_cam/base_cam.py:143\u001b[0m, in \u001b[0;36mBaseCAM.compute_cam_per_layer\u001b[0;34m(self, input_tensor, targets, eigen_smooth)\u001b[0m\n\u001b[1;32m    141\u001b[0m     cam \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mget_cam_image(input_tensor, target_layer, targets, layer_activations, layer_grads, eigen_smooth)\n\u001b[1;32m    142\u001b[0m     cam \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mmaximum(cam, \u001b[38;5;241m0\u001b[39m)\n\u001b[0;32m--> 143\u001b[0m     scaled \u001b[38;5;241m=\u001b[39m \u001b[43mscale_cam_image\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcam\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtarget_size\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    144\u001b[0m     cam_per_target_layer\u001b[38;5;241m.\u001b[39mappend(scaled[:, \u001b[38;5;28;01mNone\u001b[39;00m, :])\n\u001b[1;32m    146\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m cam_per_target_layer\n",
      "File \u001b[0;32m/usr/local/lib/python3.11/dist-packages/pytorch_grad_cam/utils/image.py:172\u001b[0m, in \u001b[0;36mscale_cam_image\u001b[0;34m(cam, target_size)\u001b[0m\n\u001b[1;32m    169\u001b[0m             img \u001b[38;5;241m=\u001b[39m zoom(np\u001b[38;5;241m.\u001b[39mfloat32(img), [\n\u001b[1;32m    170\u001b[0m                        (t_s \u001b[38;5;241m/\u001b[39m i_s) \u001b[38;5;28;01mfor\u001b[39;00m i_s, t_s \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mzip\u001b[39m(img\u001b[38;5;241m.\u001b[39mshape, target_size[::\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m])])\n\u001b[1;32m    171\u001b[0m         \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 172\u001b[0m             img \u001b[38;5;241m=\u001b[39m \u001b[43mcv2\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mresize\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfloat32\u001b[49m\u001b[43m(\u001b[49m\u001b[43mimg\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtarget_size\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    174\u001b[0m     result\u001b[38;5;241m.\u001b[39mappend(img)\n\u001b[1;32m    175\u001b[0m result \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mfloat32(result)\n",
      "\u001b[0;31merror\u001b[0m: OpenCV(4.8.0) :-1: error: (-5:Bad argument) in function 'resize'\n> Overload resolution failed:\n>  - Can't parse 'dsize'. Expected sequence length 2, got 3\n>  - Can't parse 'dsize'. Expected sequence length 2, got 3\n"
     ]
    }
   ],
   "source": [
    "import torch.nn.functional as F\n",
    "from pytorch_grad_cam import GradCAM\n",
    "from pytorch_grad_cam.utils.model_targets import ClassifierOutputTarget\n",
    "from pytorch_grad_cam.utils.image import show_cam_on_image\n",
    "import matplotlib.pyplot as plt\n",
    "import nibabel as nib\n",
    "import numpy as np\n",
    "from scipy import ndimage\n",
    "torch.cuda.empty_cache()\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "torch.set_grad_enabled(True)\n",
    "print(f\"Using device: {device}\")\n",
    "\n",
    "# Create the model\n",
    "model = CNN3D().to(device)\n",
    "model.load_state_dict(torch.load('3d_image_classification.pth', map_location=device))\n",
    "model.eval()\n",
    "\n",
    "\n",
    "# def reshape_transform(tensor, height=8, width=8):\n",
    "#     result = tensor.permute(0, 2, 1, 3, 4).reshape(tensor.size(0), height * width, tensor.size(1), tensor.size(3), tensor.size(4))\n",
    "#     return result\n",
    "\n",
    "def reshape_transform(tensor):\n",
    "    # Permute and reshape tensor for GradCAM visualization\n",
    "    return tensor.permute(0, 2, 3, 4, 1).contiguous()\n",
    "\n",
    "\n",
    "# Create the Grad-CAM object\n",
    "target_layer = model.conv4  # Target the last convolutional layer\n",
    "cam = GradCAM(model=model, target_layers=[target_layer], reshape_transform=reshape_transform)\n",
    "\n",
    "\n",
    "# Load the input 3D image\n",
    "# Load the NIfTI file\n",
    "# output_dir = os.path.join(os.getcwd(), \"MosMedData\")\n",
    "# input_nifti_path = os.path.join(output_dir, \"CT-23\", \"study_0939.nii.gz\")\n",
    "# output_nifti_path =os.path.join(output_dir, \"output\", \"study_0939.nii.gz\")\n",
    "\n",
    "\n",
    "def visualize_gradcam(sample, label, cam, model, class_names):\n",
    "    model.eval()\n",
    "    sample = torch.tensor(sample).unsqueeze(0).unsqueeze(0).to(device, dtype=torch.float32)\n",
    "    sample.requires_grad = True\n",
    "    sample.retain_grad()\n",
    "    # Forward pass\n",
    "    output = model(sample)\n",
    "    probs = torch.sigmoid(output).squeeze()\n",
    "    predicted_class = torch.argmax(probs).item()\n",
    "    \n",
    "    targets = [ClassifierOutputTarget(predicted_class)]\n",
    "    print(\"Input tensor requires grad:\", sample.shape)\n",
    "    # Generate CAM\n",
    "    grayscale_cam = cam(input_tensor=sample, targets=targets)[0, :]\n",
    "    \n",
    "    # Convert sample to numpy array for visualization\n",
    "    sample_np = sample.squeeze().cpu().numpy()\n",
    "    \n",
    "    # Show CAM on image\n",
    "    visualization = show_cam_on_image(sample_np, grayscale_cam, use_rgb=True)\n",
    "    \n",
    "    plt.imshow(visualization)\n",
    "    plt.title(f'Predicted: {class_names[predicted_class]}, Label: {class_names[label]}')\n",
    "    plt.axis('off')\n",
    "    plt.show()\n",
    "\n",
    "    \n",
    "class_names = [\"normal\", \"abnormal\"]\n",
    "\n",
    "#with torch.no_grad():\n",
    "for i in range(5):  # Visualize the first 5 samples\n",
    "    sample = x_val[i]\n",
    "    label = y_val[i]\n",
    "    visualize_gradcam(sample, label, cam, model, class_names)\n"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [
    "eYck_2P1Mrqz",
    "965Iih1gMrq0",
    "OUvROCKOMrq2"
   ],
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}