diff --git a/modules/interpretability/class_lung_lesion.ipynb b/modules/interpretability/class_lung_lesion.ipynb index 3a0bea8621..98997e19ae 100644 --- a/modules/interpretability/class_lung_lesion.ipynb +++ b/modules/interpretability/class_lung_lesion.ipynb @@ -1,414 +1,569 @@ { - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "name": "class_lung_lesion.ipynb", - "provenance": [], - "collapsed_sections": [] - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - }, - "accelerator": "GPU" + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "nI1LCVMKcfO1" + }, + "source": [ + "This tutorial trains a 3D densenet for lung lesion classification from CT image patches. \n", + "\n", + "The goal is to demonstrate MONAI's class activation mapping functions for visualising the classification models.\n", + "\n", + "For the demo data:\n", + "- Please see the `bbox_gen.py` script for generating the patch classification data from MSD task06_lung (available via `monai.apps.DecathlonDataset`).\n", + "- Alternatively, the patch dataset (~130MB) is available for direct downloading at: https://drive.google.com/drive/folders/1vl330aJew1NCc31IVYJSAh3y0XdDdydi" + ] }, - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "nI1LCVMKcfO1" - }, - "source": [ - "This tutorial trains a 3D densenet for lung lesion classification from CT image patches. \n", - "\n", - "The goal is to demonstrate MONAI's class activation mapping functions for visualising the classification models.\n", - "\n", - "For the demo data:\n", - "- Please see the `bbox_gen.py` script for generating the patch classification data from MSD task06_lung (available via `monai.apps.DecathlonDataset`).\n", - "- Alternatively, the patch dataset (~130MB) is available for direct downloading at: https://drive.google.com/drive/folders/1vl330aJew1NCc31IVYJSAh3y0XdDdydi" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "AbhFzvu3JbZV" - }, - "source": [ - "%pip install \"git+https://github.com/Project-MONAI/MONAI#egg=MONAI[nibabel, tqdm]\"" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "nZYowi8fUVp5" - }, - "source": [ - "import glob\n", - "import random\n", - "import numpy as np\n", - "import torch\n", - "from torch.utils.tensorboard import SummaryWriter\n", - "\n", - "import monai\n", - "from monai.transforms import (\n", - " AddChanneld, Compose, LoadImaged, RandRotate90d, \n", - " Resized, ScaleIntensityRanged, ToTensord, \n", - " RandFlipd, RandSpatialCropd,\n", - ")\n", - "\n", - "monai.config.print_config()\n", - "monai.utils.set_determinism(42)\n", - "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "YcfTvuxyy9jX" - }, - "source": [ - "Collecting all the patch data\n" - ] - }, - { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "Ty91LRwqUikZ", - "outputId": "773bfa78-4a34-4692-9540-f6bb0babd7d9" - }, - "source": [ - "lesion = glob.glob(\"./patch/lesion_*\")\n", - "non_lesion = glob.glob(\"./patch/norm_*\")\n", - "labels = np.asarray([[0., 1.]] * len(lesion) + [[1., 0.]] * len(non_lesion))\n", - "\n", - "all_files = [{\"image\": img, \"label\": label} for img, label in zip(lesion + non_lesion, labels)]\n", - "random.shuffle(all_files)\n", - "print(f\"total items: {len(all_files)}\")" - ], - "execution_count": 30, - "outputs": [ - { - "output_type": "stream", - "text": [ - "total items: 251\n" - ], - "name": "stdout" - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "NnSCws-GzA2k" - }, - "source": [ - "Split the data into 80% training and 20% validation\n" - ] - }, - { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "V6MQhLrgYyPV", - "outputId": "050abf8c-9fcb-4bf7-afb2-8a15d2530435" - }, - "source": [ - "train_frac, val_frac = 0.8, 0.2\n", - "n_train = int(train_frac * len(all_files)) + 1\n", - "n_val = min(len(all_files) - n_train, int(val_frac * len(all_files)))\n", - "\n", - "train_files, val_files = all_files[:n_train], all_files[-n_val:]\n", - "train_labels = [data[\"label\"] for data in train_files]\n", - "print(f\"total train: {len(train_files)}\")\n", - "\n", - "val_labels = [data[\"label\"] for data in val_files]\n", - "n_neg, n_pos = np.sum(np.asarray(val_labels) == 0), np.sum(np.asarray(val_labels)== 1)\n", - "print(f\"total valid: {len(val_labels)}\")" - ], - "execution_count": 31, - "outputs": [ - { - "output_type": "stream", - "text": [ - "total train: 201\n", - "total valid: 50\n" - ], - "name": "stdout" - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "WF7QPpXczLuE" - }, - "source": [ - "Create the data loaders. These loaders will be used for both training/validation, as well as visualisations." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "SSOwnizoaX0Z" - }, - "source": [ - "# Define transforms for image\n", - "win_size = (196, 196, 144)\n", - "train_transforms = Compose(\n", - " [\n", - " LoadImaged(\"image\"),\n", - " AddChanneld(\"image\"),\n", - " ScaleIntensityRanged(\"image\", a_min=-1000.0, a_max=500.0, b_min=0.0, b_max=1.0, clip=True),\n", - " RandFlipd(\"image\", spatial_axis=0, prob=0.5),\n", - " RandFlipd(\"image\", spatial_axis=1, prob=0.5),\n", - " RandFlipd(\"image\", spatial_axis=2, prob=0.5),\n", - " RandSpatialCropd(\"image\", roi_size=(64, 64, 40)),\n", - " Resized(\"image\", win_size, \"trilinear\", True),\n", - " RandRotate90d(\"image\", prob=0.5, spatial_axes=[0, 1]),\n", - " ToTensord(\"image\"),\n", - " ]\n", - ")\n", - "val_transforms = Compose(\n", - " [\n", - " LoadImaged(\"image\"),\n", - " AddChanneld(\"image\"),\n", - " ScaleIntensityRanged(\"image\", a_min=-1000.0, a_max=500.0, b_min=0.0, b_max=1.0, clip=True),\n", - " Resized(\"image\", win_size, \"trilinear\", True),\n", - " ToTensord((\"image\", \"label\")),\n", - " ]\n", - ")\n", - "\n", - "train_ds = monai.data.LMDBDataset(data=train_files, transform=train_transforms)\n", - "train_loader = monai.data.DataLoader(train_ds, batch_size=2, shuffle=True, num_workers=2, pin_memory=True)\n", - "val_ds = monai.data.LMDBDataset(data=val_files, transform=val_transforms)\n", - "val_loader = monai.data.DataLoader(val_ds, batch_size=2, num_workers=2, pin_memory=True)" - ], - "execution_count": 32, - "outputs": [] + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "AbhFzvu3JbZV" + }, + "outputs": [], + "source": [ + "%pip install \"git+https://github.com/Project-MONAI/MONAI#egg=MONAI[nibabel, tqdm]\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "nZYowi8fUVp5" + }, + "outputs": [], + "source": [ + "import os\n", + "import glob\n", + "import random\n", + "import numpy as np\n", + "import torch\n", + "from torch.utils.tensorboard import SummaryWriter\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import monai\n", + "from monai.transforms import (\n", + " AddChanneld, Compose, LoadImaged, RandRotate90d, \n", + " Resized, ScaleIntensityRanged, ToTensord, \n", + " RandFlipd, RandSpatialCropd,\n", + ")\n", + "from monai.metrics import compute_occlusion_sensitivity\n", + "\n", + "monai.config.print_config()\n", + "random_seed = 42\n", + "monai.utils.set_determinism(random_seed)\n", + "np.random.seed(random_seed)\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "use_patch_dataset=True # switch this to use partial dataset or whole thing\n", + "\n", + "directory = os.environ.get(\"MONAI_DATA_DIRECTORY\")\n", + "root_dir = tempfile.mkdtemp() if directory is None else os.path.expanduser(directory)\n", + "data_path=os.path.join(root_dir, \"patch\")\n", + "if use_patch_dataset:\n", + " !cd {root_dir} && [ -f \"lung_lesion_patches.tar.gz\" ] || gdown --id 1Jte6L7B_5q9XMgOCAq1Ldn29F1aaIxjW \\\n", + " && mkdir -p {data_path} && tar -xvf \"lung_lesion_patches.tar.gz\" -C {data_path} > /dev/null\n", + "else:\n", + " monai.apps.DecathlonDataset(root_dir=root_dir, task=\"Task06_Lung\", section=\"training\", download=True)\n", + " %run -i './bbox_gen.py {root_dir}'" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "YcfTvuxyy9jX" + }, + "source": [ + "Collecting all the patch data\n" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" }, + "id": "Ty91LRwqUikZ", + "outputId": "773bfa78-4a34-4692-9540-f6bb0babd7d9" + }, + "outputs": [ { - "cell_type": "markdown", - "metadata": { - "id": "cST2NTu2zUk_" - }, - "source": [ - "Start the model, loss function, and optimizer." - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "total items: 251\n" + ] + } + ], + "source": [ + "lesion = glob.glob(os.path.join(data_path,\"lesion_*\"))\n", + "non_lesion = glob.glob(os.path.join(data_path,\"norm_*\"))\n", + "labels = np.asarray([[0., 1.]] * len(lesion) + [[1., 0.]] * len(non_lesion))\n", + "\n", + "all_files = [{\"image\": img, \"label\": label} for img, label in zip(lesion + non_lesion, labels)]\n", + "random.shuffle(all_files)\n", + "print(f\"total items: {len(all_files)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "NnSCws-GzA2k" + }, + "source": [ + "Split the data into 80% training and 20% validation\n" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" }, + "id": "V6MQhLrgYyPV", + "outputId": "050abf8c-9fcb-4bf7-afb2-8a15d2530435" + }, + "outputs": [ { - "cell_type": "code", - "metadata": { - "id": "bdGF-VX9bs6l" - }, - "source": [ - "model = monai.networks.nets.densenet.densenet121(spatial_dims=3, in_channels=1, out_channels=2).to(device)\n", - "bce = torch.nn.BCEWithLogitsLoss()\n", - "def criterion(logits, target): \n", - " return bce(logits.view(-1), target.view(-1))\n", - "optimizer = torch.optim.Adam(model.parameters(), 1e-5)" - ], - "execution_count": null, - "outputs": [] - }, + "name": "stdout", + "output_type": "stream", + "text": [ + "total train: 201\n", + "total valid: 50\n" + ] + } + ], + "source": [ + "train_frac, val_frac = 0.8, 0.2\n", + "n_train = int(train_frac * len(all_files)) + 1\n", + "n_val = min(len(all_files) - n_train, int(val_frac * len(all_files)))\n", + "\n", + "train_files, val_files = all_files[:n_train], all_files[-n_val:]\n", + "train_labels = [data[\"label\"] for data in train_files]\n", + "print(f\"total train: {len(train_files)}\")\n", + "\n", + "val_labels = [data[\"label\"] for data in val_files]\n", + "n_neg, n_pos = np.sum(np.asarray(val_labels) == 0), np.sum(np.asarray(val_labels)== 1)\n", + "print(f\"total valid: {len(val_labels)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "WF7QPpXczLuE" + }, + "source": [ + "Create the data loaders. These loaders will be used for both training/validation, as well as visualisations." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "id": "SSOwnizoaX0Z" + }, + "outputs": [], + "source": [ + "# Define transforms for image\n", + "win_size = (196, 196, 144)\n", + "train_transforms = Compose(\n", + " [\n", + " LoadImaged(\"image\"),\n", + " AddChanneld(\"image\"),\n", + " ScaleIntensityRanged(\"image\", a_min=-1000.0, a_max=500.0, b_min=0.0, b_max=1.0, clip=True),\n", + " RandFlipd(\"image\", spatial_axis=0, prob=0.5),\n", + " RandFlipd(\"image\", spatial_axis=1, prob=0.5),\n", + " RandFlipd(\"image\", spatial_axis=2, prob=0.5),\n", + " RandSpatialCropd(\"image\", roi_size=(64, 64, 40)),\n", + " Resized(\"image\", win_size, \"trilinear\", True),\n", + " RandRotate90d(\"image\", prob=0.5, spatial_axes=[0, 1]),\n", + " ToTensord(\"image\"),\n", + " ]\n", + ")\n", + "val_transforms = Compose(\n", + " [\n", + " LoadImaged(\"image\"),\n", + " AddChanneld(\"image\"),\n", + " ScaleIntensityRanged(\"image\", a_min=-1000.0, a_max=500.0, b_min=0.0, b_max=1.0, clip=True),\n", + " Resized(\"image\", win_size, \"trilinear\", True),\n", + " ToTensord((\"image\", \"label\")),\n", + " ]\n", + ")\n", + "\n", + "train_ds = monai.data.LMDBDataset(data=train_files, transform=train_transforms)\n", + "train_loader = monai.data.DataLoader(train_ds, batch_size=2, shuffle=True, num_workers=2, pin_memory=True)\n", + "val_ds = monai.data.LMDBDataset(data=val_files, transform=val_transforms)\n", + "val_loader = monai.data.DataLoader(val_ds, batch_size=2, num_workers=2, pin_memory=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "cST2NTu2zUk_" + }, + "source": [ + "Start the model, loss function, and optimizer." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "bdGF-VX9bs6l" + }, + "outputs": [], + "source": [ + "model = monai.networks.nets.densenet.densenet121(spatial_dims=3, in_channels=1, out_channels=2).to(device)\n", + "bce = torch.nn.BCEWithLogitsLoss()\n", + "def criterion(logits, target): \n", + " return bce(logits.view(-1), target.view(-1))\n", + "optimizer = torch.optim.Adam(model.parameters(), 1e-5)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "f2iAlkBTzYQD" + }, + "source": [ + "Run training iterations." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "rA_cp54ebxRv" + }, + "outputs": [], + "source": [ + "from IPython.display import clear_output\n", + "\n", + "# start training\n", + "val_interval, total_epochs = 1, 30\n", + "best_metric = best_metric_epoch = -1\n", + "epoch_loss_values = []\n", + "metric_values = []\n", + "scaler = torch.cuda.amp.GradScaler()\n", + "for epoch in range(total_epochs):\n", + " clear_output()\n", + " print(\"-\" * 10)\n", + " print(f\"epoch {epoch + 1}/{total_epochs}\")\n", + " model.train()\n", + " epoch_loss = step = 0\n", + " for batch_data in train_loader:\n", + " inputs, labels = batch_data[\"image\"].to(device), batch_data[\"label\"].to(device)\n", + " optimizer.zero_grad()\n", + " with torch.cuda.amp.autocast():\n", + " outputs = model(inputs)\n", + " loss = criterion(outputs.float(), labels.float())\n", + " scaler.scale(loss).backward()\n", + " scaler.step(optimizer)\n", + " scaler.update()\n", + " epoch_loss += loss.item()\n", + " epoch_len = len(train_ds) // train_loader.batch_size\n", + " if step % 50 == 0:\n", + " print(f\"{step}/{epoch_len}, train_loss: {loss.item():.4f}\")\n", + " step += 1\n", + " epoch_loss /= step\n", + " epoch_loss_values.append(epoch_loss)\n", + " print(f\"epoch {epoch + 1} average loss: {epoch_loss:.4f}\")\n", + "\n", + " if (epoch + 1) % val_interval == 0:\n", + " model.eval()\n", + " with torch.no_grad():\n", + " num_correct = 0.0\n", + " metric_count = 0\n", + " for val_data in val_loader:\n", + " val_images, val_labels = val_data[\"image\"].to(device), val_data[\"label\"].to(device)\n", + " val_outputs = model(val_images)\n", + " value = torch.eq(val_outputs.argmax(dim=1), val_labels.argmax(dim=1))\n", + " metric_count += len(value)\n", + " num_correct += value.sum().item()\n", + " metric = num_correct / metric_count\n", + " metric_values.append(metric)\n", + " if metric >= best_metric:\n", + " best_metric = metric\n", + " best_metric_epoch = epoch + 1\n", + " torch.save(model.state_dict(), \"best_metric_model_classification3d_array.pth\")\n", + " torch.save(model.state_dict(), \"model_classification3d_array.pth\")\n", + " print(\n", + " \"current epoch: {} current accuracy: {:.4f} best accuracy: {:.4f} at epoch {}\".format(\n", + " epoch + 1, metric, best_metric, best_metric_epoch\n", + " )\n", + " )\n", + "print(f\"train completed, best_metric: {best_metric:.4f} at epoch: {best_metric_epoch}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ { - "cell_type": "markdown", - "metadata": { - "id": "f2iAlkBTzYQD" - }, - "source": [ - "Run training iterations." + "data": { + "image/png": "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\n", + "text/plain": [ + "
" ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(epoch_loss_values,label='train')\n", + "val_epochs=np.linspace(1, total_epochs,np.floor(total_epochs/val_interval).astype(np.int32))\n", + "plt.plot(val_epochs, metric_values,label='validation')\n", + "plt.legend()\n", + "plt.xlabel('Epoch')\n", + "plt.ylabel('Loss');" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "iHE0RMEFIera" + }, + "source": [ + "Initialise the CAM visualiser" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" }, + "id": "ZD5DvgwFIdwj", + "outputId": "70f5f242-4b69-4a3d-a3d4-4a236f9123e8" + }, + "outputs": [ { - "cell_type": "code", - "metadata": { - "id": "rA_cp54ebxRv" - }, - "source": [ - "# start training\n", - "val_interval, total_epochs = 1, 30\n", - "best_metric = best_metric_epoch = -1\n", - "epoch_loss_values = []\n", - "metric_values = []\n", - "scaler = torch.cuda.amp.GradScaler()\n", - "for epoch in range(total_epochs):\n", - " print(\"-\" * 10)\n", - " print(f\"epoch {epoch + 1}/{total_epochs}\")\n", - " model.train()\n", - " epoch_loss = step = 0\n", - " for batch_data in train_loader:\n", - " inputs, labels = batch_data[\"image\"].to(device), batch_data[\"label\"].to(device)\n", - " optimizer.zero_grad()\n", - " with torch.cuda.amp.autocast():\n", - " outputs = model(inputs)\n", - " loss = criterion(outputs.float(), labels.float())\n", - " scaler.scale(loss).backward()\n", - " scaler.step(optimizer)\n", - " scaler.update()\n", - " epoch_loss += loss.item()\n", - " epoch_len = len(train_ds) // train_loader.batch_size\n", - " if step % 50 == 0:\n", - " print(f\"{step}/{epoch_len}, train_loss: {loss.item():.4f}\")\n", - " step += 1\n", - " epoch_loss /= step\n", - " epoch_loss_values.append(epoch_loss)\n", - " print(f\"epoch {epoch + 1} average loss: {epoch_loss:.4f}\")\n", - "\n", - " if (epoch + 1) % val_interval == 0:\n", - " model.eval()\n", - " with torch.no_grad():\n", - " num_correct = 0.0\n", - " metric_count = 0\n", - " for val_data in val_loader:\n", - " val_images, val_labels = val_data[\"image\"].to(device), val_data[\"label\"].to(device)\n", - " val_outputs = model(val_images)\n", - " value = torch.eq(val_outputs.argmax(dim=1), val_labels.argmax(dim=1))\n", - " metric_count += len(value)\n", - " num_correct += value.sum().item()\n", - " metric = num_correct / metric_count\n", - " metric_values.append(metric)\n", - " if metric >= best_metric:\n", - " best_metric = metric\n", - " best_metric_epoch = epoch + 1\n", - " torch.save(model.state_dict(), \"best_metric_model_classification3d_array.pth\")\n", - " torch.save(model.state_dict(), \"model_classification3d_array.pth\")\n", - " print(\n", - " \"current epoch: {} current accuracy: {:.4f} best accuracy: {:.4f} at epoch {}\".format(\n", - " epoch + 1, metric, best_metric, best_metric_epoch\n", - " )\n", - " )\n", - "print(f\"train completed, best_metric: {best_metric:.4f} at epoch: {best_metric_epoch}\")" - ], - "execution_count": null, - "outputs": [] - }, + "name": "stdout", + "output_type": "stream", + "text": [ + "original feature shape torch.Size([1, 1, 6, 6, 4])\n", + "upsampled feature shape [1, 1, 196, 196, 144]\n" + ] + } + ], + "source": [ + "model_3d = monai.networks.nets.densenet.densenet121(spatial_dims=3, in_channels=1, out_channels=2).to(device)\n", + "model_3d.load_state_dict(torch.load(\"model_classification3d_array.pth\"))\n", + "model_3d.eval()\n", + "# cam = monai.visualize.CAM(nn_module=model_3d, target_layers=\"class_layers.relu\", fc_layers=\"class_layers.out\")\n", + "cam = monai.visualize.GradCAM(nn_module=model_3d, target_layers=\"class_layers.relu\")\n", + "# cam = monai.visualize.GradCAMpp(nn_module=model_3d, target_layers=\"class_layers.relu\")\n", + "print(\"original feature shape\", cam.feature_map_size([1, 1] + list(win_size), device))\n", + "print(\"upsampled feature shape\", [1, 1] + list(win_size))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# GradCAM and occlusion sensitivity for elements in confusion matrix\n", + "\n", + "When visualising a network, we want to get a feeling for why/when it works and why/when it doesn't. \n", + "\n", + "For this, we'll find four examples, corresponding to all the elements in the confusion matrix (TP, TN, FP, FN) and then visualise them." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ { - "cell_type": "markdown", - "metadata": { - "id": "iHE0RMEFIera" - }, - "source": [ - "Initialise the CAM visualiser" - ] - }, + "name": "stdout", + "output_type": "stream", + "text": [ + "TP -- input: lesion, predicted: lesion, idx: 69\n", + "FN -- input: lesion, predicted: non-lesion, idx: 45\n", + "FP -- input: non-lesion, predicted: lesion, idx: 115\n", + "TN -- input: non-lesion, predicted: non-lesion, idx: 171\n" + ] + } + ], + "source": [ + "# Get examples of TP, FP, TN, FN\n", + "confusion_examples = {\n", + " \"TP -- input: lesion, predicted: lesion\": None,\n", + " \"FN -- input: lesion, predicted: non-lesion\": None,\n", + " \"FP -- input: non-lesion, predicted: lesion\": None,\n", + " \"TN -- input: non-lesion, predicted: non-lesion\": None,\n", + "}\n", + "\n", + "np.random.seed(random_seed)\n", + "rand_indices = np.arange(len(train_ds))\n", + "np.random.shuffle(rand_indices)\n", + "for idx in rand_indices:\n", + " \n", + " data = train_ds[idx] # this fetches training data with random augmentations \n", + " # if label==0, lesion. else non-lesion.\n", + " label = data[\"label\"][0]\n", + "\n", + " # only bother predicting if we're missing a spot in the confusion matrix\n", + " vals = list(confusion_examples.values())\n", + " if (label == 0 and None not in vals[0:2]):\n", + " continue\n", + " if (label == 1 and None not in vals[3:4]):\n", + " continue\n", + " \n", + " image = data[\"image\"].to(device).unsqueeze(0)\n", + " predicted_label = model_3d(image).argmax(1).item()\n", + "\n", + " if label == 0 and predicted_label == 0:\n", + " confusion_examples[\"TP -- input: lesion, predicted: lesion\"] = idx\n", + " elif label == 0 and predicted_label == 1:\n", + "\n", + " confusion_examples[\"FN -- input: lesion, predicted: non-lesion\"] = idx\n", + " elif label == 1 and predicted_label == 0:\n", + "\n", + " confusion_examples[\"FP -- input: non-lesion, predicted: lesion\"] = idx\n", + " elif label == 1 and predicted_label == 1:\n", + "\n", + " confusion_examples[\"TN -- input: non-lesion, predicted: non-lesion\"] = idx\n", + "\n", + "for name, item in confusion_examples.items():\n", + " print(f\"{name}, idx: {item}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "ZD5DvgwFIdwj", - "outputId": "70f5f242-4b69-4a3d-a3d4-4a236f9123e8" - }, - "source": [ - "model_3d = monai.networks.nets.densenet.densenet121(spatial_dims=3, in_channels=1, out_channels=2).to(device)\n", - "model_3d.load_state_dict(torch.load(\"model_classification3d_array.pth\"))\n", - "# cam = monai.visualize.CAM(nn_module=model_3d, target_layers=\"class_layers.relu\", fc_layers=\"class_layers.out\")\n", - "cam = monai.visualize.GradCAM(nn_module=model_3d, target_layers=\"class_layers.relu\")\n", - "# cam = monai.visualize.GradCAMpp(nn_module=model_3d, target_layers=\"class_layers.relu\")\n", - "print(\"original feature shape\", cam.feature_map_size([1, 1] + list(win_size), device))\n", - "print(\"upsampled feature shape\", [1, 1] + list(win_size))" - ], - "execution_count": 79, - "outputs": [ - { - "output_type": "stream", - "text": [ - "original feature shape torch.Size([1, 1, 6, 6, 4])\n", - "upsampled feature shape [1, 1, 196, 196, 144]\n" - ], - "name": "stdout" - } - ] + "name": "stderr", + "output_type": "stream", + "text": [ + "Computing occlusion sensitivity: 100%|██████████| 81/81 [00:03<00:00, 20.57it/s]\n", + "Computing occlusion sensitivity: 100%|██████████| 81/81 [00:03<00:00, 20.59it/s]\n", + "Computing occlusion sensitivity: 100%|██████████| 81/81 [00:03<00:00, 20.59it/s]\n", + "Computing occlusion sensitivity: 100%|██████████| 81/81 [00:03<00:00, 20.57it/s]\n" + ] }, { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 223 - }, - "id": "Kaj6XG2eAaIB", - "outputId": "ffcda223-4c1a-42be-a0b6-7f393d06e25a" - }, - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "monai.utils.set_determinism(42)\n", - "train_transforms.set_random_state(42)\n", - "items = [41, 45, 80, 78, 10]\n", - "plt.subplots(2, len(items))\n", - "for idx, item in enumerate(items):\n", - " # run CAM\n", - " data = train_ds[item] # this fetches training data with random augmentations\n", - " image, label = data[\"image\"].to(device), data[\"label\"]\n", - " result = cam(x=image[None], class_idx=1)\n", - "\n", - " # the rest is for visualisations\n", - " name = \"lesion\" if label[1] == 1 else \"non-lesion\"\n", - " the_slice = 72\n", - " img = image.detach().cpu().numpy()\n", - " mix = result[0]\n", - " ax = plt.subplot(2, len(items), idx + 1); plt.imshow(img[0, :, :, the_slice], cmap='gray')\n", - " ax.set_title(f\"{name}\")\n", - " plt.axis('off')\n", - " fig = plt.subplot(2, len(items), len(items) + idx + 1); plt.imshow(mix[0, :, :, the_slice], cmap=\"jet\", vmin=0, vmax=1)\n", - " plt.axis('off')" - ], - "execution_count": 80, - "outputs": [ - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "tags": [], - "needs_background": "light" - } - } + "data": { + "image/png": "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\n", + "text/plain": [ + "
" ] - }, - { - "cell_type": "code", - "metadata": { - "id": "t09BSlRBdwsJ" - }, - "source": [ - "from monai.visualize import plot_2d_or_3d_image\n", - "from torch.utils.tensorboard import SummaryWriter\n", - "\n", - "with SummaryWriter(log_dir=\"logs\") as writer:\n", - " plot_2d_or_3d_image(mix[None], step=0, writer=writer, tag=\"CAM\")\n", - " plot_2d_or_3d_image(image[None], step=0, writer=writer, tag=\"Input\")" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "B1IavBxrePt5" - }, - "source": [ - "%load_ext tensorboard\n", - "%tensorboard --logdir logs" - ], - "execution_count": null, - "outputs": [] + }, + "metadata": {}, + "output_type": "display_data" } - ] -} \ No newline at end of file + ], + "source": [ + "train_transforms.set_random_state(random_seed)\n", + "subplot_shape = [3, 4]\n", + "plt.subplots(*subplot_shape, figsize=(25,15), facecolor='white')\n", + "for idx, (name, item) in enumerate(confusion_examples.items()):\n", + " the_slice = 72\n", + " \n", + " data = train_ds[item] # this fetches training data with random augmentations\n", + " image, label = data[\"image\"].to(device).unsqueeze(0), data[\"label\"]\n", + " predicted_label = model_3d(image).argmax(1).item()\n", + " \n", + " # run CAM\n", + " cam_result = cam(x=image, class_idx=predicted_label)\n", + " \n", + " # run occlusion\n", + " bounds=[-1, -1, -1, -1, -1, -1, the_slice, the_slice]\n", + " occ_result = compute_occlusion_sensitivity(model_3d, image, predicted_label, margin=10, n_batch=1, b_box=bounds, stride=20, upsample_mode='trilinear')\n", + "\n", + " # the rest is for visualisations\n", + " img = image.detach().cpu().numpy()\n", + " mix = cam_result[0]\n", + " ax = plt.subplot(*subplot_shape, idx + 1); plt.imshow(img[0, 0, :, :, the_slice], cmap='gray')\n", + " ax.set_title(name, fontsize=15)\n", + " plt.axis('off')\n", + " fig = plt.subplot(*subplot_shape, subplot_shape[1] + idx + 1); plt.imshow(mix[0, :, :, the_slice], cmap=\"jet\", vmin=0, vmax=1)\n", + " fig.set_title(f\"CAM\\n({name})\", fontsize=15)\n", + " plt.axis('off')\n", + " fig = plt.subplot(*subplot_shape, 2*subplot_shape[1] + idx + 1); plt.imshow(occ_result, cmap='jet')\n", + " fig.set_title(f\"Occ. sens.\\n({name})\", fontsize=15)\n", + " plt.axis('off')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "t09BSlRBdwsJ" + }, + "outputs": [], + "source": [ + "from monai.visualize import plot_2d_or_3d_image\n", + "from torch.utils.tensorboard import SummaryWriter\n", + "\n", + "with SummaryWriter(log_dir=\"logs\") as writer:\n", + " plot_2d_or_3d_image(mix[None], step=0, writer=writer, tag=\"CAM\")\n", + " plot_2d_or_3d_image(image[None], step=0, writer=writer, tag=\"Input\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "B1IavBxrePt5" + }, + "outputs": [], + "source": [ + "%load_ext tensorboard\n", + "%tensorboard --logdir logs" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "collapsed_sections": [], + "name": "class_lung_lesion.ipynb", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.0" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +}