diff --git a/README.md b/README.md index 19307cabc0..13839ec64f 100644 --- a/README.md +++ b/README.md @@ -170,3 +170,6 @@ This notebook demonstrates the image transformations on histology images using #### [varautoencoder_mednist](./modules/varautoencoder_mednist) This tutorial uses the MedNIST scan (or alternatively the MNIST) dataset to demonstrate MONAI's variational autoencoder class. + +#### [interpretability](./modules/interpretability) +Tutorials in this folder demonstrate model visualisation and interpretability features of MONAI. Currently, it consists of class activation mapping and occlusion sensitivity for 3D classification model visualisations and analysis. \ No newline at end of file diff --git a/modules/interpretability/bbox_gen.py b/modules/interpretability/bbox_gen.py new file mode 100644 index 0000000000..142ef60991 --- /dev/null +++ b/modules/interpretability/bbox_gen.py @@ -0,0 +1,99 @@ +# Copyright 2020 MONAI Consortium +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# http://www.apache.org/licenses/LICENSE-2.0 +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +""" + +Script used to generate lesion/non-lesion patches from MSD lung. +(requires numpy/torch/skimage.measure/monai) + +The original dataset could be downloaded via the MONAI API: + + import monai + monai.apps.DecathlonDataset(root_dir="./", task="Task06_Lung", section="training", download=True) + +- After running these command, the dataset will be downloaded and unzipped at `root_dir`. +- Lesion bounding boxes are generated from the connected components in the segmentation masks. +- Non-lesion patches are generated from randomly from the volume. + +""" + +import glob +import os +import sys + +import numpy as np +import skimage.measure as measure +from monai.data import write_nifti +from monai.transforms import ( + AddChanneld, + BoundingRect, + LoadImaged, + RandWeightedCropd, + Resized, + SpatialCropd, +) +from monai.utils import set_determinism + +# optionally give folder +folder = sys.argv[1] if len(sys.argv) > 1 else '.' +# create output folder +os.makedirs(folder+'/patch', exist_ok=True) +set_determinism(0) + +image_names = sorted(glob.glob(folder+"/Task06_Lung/imagesTr/*")) +label_names = sorted(glob.glob(folder+"/Task06_Lung/labelsTr/*")) +if len(image_names) * len(label_names) == 0: + raise AssertionError('no images and/or labels found') + +data_names = [{"label": ll, "image": ii} for ll, ii in zip(label_names, image_names)] + +patch_size = (72, 72, 48) + +for name in data_names: + print(f"---on {name['label']}---") + name_id = os.path.basename(name["label"]) + keys = ("image", "label") + data = LoadImaged(keys)(name) + labels, n_comp = measure.label(data["label"] == 1, connectivity=3, return_num=True) + print("total components", n_comp) + for i in range(n_comp + 1): + if i == 0: + continue # skipping background + b_label = labels == i + bb = BoundingRect()(b_label[None]) + area = (bb[0, 1] - bb[0, 0]) * (bb[0, 3] - bb[0, 2]) * (bb[0, 5] - bb[0, 4]) + if area <= 500: + continue + print(bb, area) + s = [bb[0, 0] - 16, bb[0, 2] - 16, bb[0, 4] - 16] + e = [bb[0, 1] + 16, bb[0, 3] + 16, bb[0, 5] + 16] + + # generate lesion patches based on the bounding boxes + data_out = AddChanneld(keys)(data) + data_out = SpatialCropd(keys, roi_start=s, roi_end=e)(data_out) + resize = Resized(keys, patch_size, mode=("trilinear", "nearest")) + data_out = resize(data_out) + + patch_out = f"{folder}/patch/lesion_{s[0]}_{s[1]}_{s[2]}_{e[0]}_{e[1]}_{e[2]}_{name_id}" + label_out = f"{folder}/patch/labels_{s[0]}_{s[1]}_{s[2]}_{e[0]}_{e[1]}_{e[2]}_{name_id}" + write_nifti(data_out["image"][0], file_name=patch_out) + write_nifti(data_out["label"][0], file_name=label_out) + + # generate random negative samples + rand_data_out = AddChanneld(keys)(data) + rand_data_out["inv_label"] = ( + rand_data_out["label"] == 0 + ) # non-lesion sampling map + rand_crop = RandWeightedCropd(keys, "inv_label", patch_size, num_samples=3) + rand_data_out = rand_crop(rand_data_out) + for idx, d in enumerate(rand_data_out): + if np.sum(d["label"]) > 0: + continue + write_nifti(d["image"][0], file_name=f"{folder}/patch/norm_{idx}_{name_id}") diff --git a/modules/interpretability/class_lung_lesion.ipynb b/modules/interpretability/class_lung_lesion.ipynb new file mode 100644 index 0000000000..a58e25adf3 --- /dev/null +++ b/modules/interpretability/class_lung_lesion.ipynb @@ -0,0 +1,633 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Copy of 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" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "AbhFzvu3JbZV" + }, + "source": [ + "%pip install \"monai[nibabel, tqdm]\"" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "nZYowi8fUVp5", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "10e08d85-02d9-4064-df3b-41050d13c005" + }, + "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\")" + ], + "execution_count": 3, + "outputs": [ + { + "output_type": "stream", + "text": [ + "MONAI version: 0.4.0\n", + "Numpy version: 1.19.4\n", + "Pytorch version: 1.7.0+cu101\n", + "MONAI flags: HAS_EXT = False, USE_COMPILED = False\n", + "MONAI rev id: 0563a4467fa602feca92d91c7f47261868d171a1\n", + "\n", + "Optional dependencies:\n", + "Pytorch Ignite version: NOT INSTALLED or UNKNOWN VERSION.\n", + "Nibabel version: 3.0.2\n", + "scikit-image version: 0.16.2\n", + "Pillow version: 7.0.0\n", + "Tensorboard version: 2.4.0\n", + "gdown version: 3.6.4\n", + "TorchVision version: 0.8.1+cu101\n", + "ITK version: NOT INSTALLED or UNKNOWN VERSION.\n", + "tqdm version: 4.55.1\n", + "lmdb version: 0.99\n", + "psutil version: 5.4.8\n", + "\n", + "For details about installing the optional dependencies, please visit:\n", + " https://docs.monai.io/en/latest/installation.html#installing-the-recommended-dependencies\n", + "\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "YcfTvuxyy9jX", + "scrolled": false + }, + "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", + "if use_patch_dataset:\n", + " data_path=os.path.join(root_dir, \"patch\")\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", + " task=\"Task06_Lung\"\n", + " monai.apps.DecathlonDataset(root_dir=root_dir, task=task, section=\"training\", download=True)\n", + " %run -i ./bbox_gen.py {root_dir}\n", + " data_path=os.path.join(root_dir, \"patch\")" + ], + "execution_count": 4, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "iTP8wvhS83ZS", + "outputId": "9378fa98-408f-4234-82c3-b1824166fc4c" + }, + "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)}\")" + ], + "execution_count": 5, + "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": "50e2aa67-f73e-40c6-91f4-e6940f9117f8" + }, + "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": 6, + "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", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "bb8ceb46-a66e-4026-b0d7-29bce94777c5" + }, + "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": 7, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Accessing lmdb file: /content/cache/monai_cache.lmdb.\n", + "Accessing lmdb file: /content/cache/monai_cache.lmdb.\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "cST2NTu2zUk_" + }, + "source": [ + "Start the model, loss function, and optimizer." + ] + }, + { + "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": 8, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "f2iAlkBTzYQD" + }, + "source": [ + "Run training iterations." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "rA_cp54ebxRv" + }, + "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", + " 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": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "6s4S1zNgc__g", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 279 + }, + "outputId": "2d4860d0-a50b-4f90-e95a-691df9e6e023" + }, + "source": [ + "plt.plot(epoch_loss_values,label='training loss')\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 acc')\n", + "plt.legend()\n", + "plt.xlabel('Epoch')\n", + "plt.ylabel('Value');" + ], + "execution_count": 10, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "iHE0RMEFIera" + }, + "source": [ + "Initialise the CAM visualiser" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ZD5DvgwFIdwj", + "outputId": "7ad3f98f-7c77-4f3e-f30c-c7936c7a1b81" + }, + "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": 11, + "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" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 240 + }, + "id": "SI3hJJ2R-wjZ", + "outputId": "61c7a100-0064-4e26-94ba-82956d00fd7c" + }, + "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": 12, + "outputs": [ + { + "output_type": "stream", + "text": [ + "100%|██████████| 201/201 [00:00<00:00, 34292.84it/s]\n" + ], + "name": "stderr" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Kaj6XG2eAaIB", + "outputId": "d1371f07-d42e-4e2d-8e8f-62a3da3f8315" + }, + "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", + "train_transforms.set_random_state(random_seed)\n", + "for idx in rand_indices:\n", + " \n", + " data = train_ds[idx] # this fetches training data with random augmentations\n", + " label = data[\"label\"][1] # if label==1, lesion; else non-lesion.\n", + "\n", + " # only bother predicting if we're missing a spot in the confusion matrix\n", + " if None not in confusion_examples.values():\n", + " break\n", + " \n", + " image = data[\"image\"].to(device).unsqueeze(0)\n", + " model_3d.eval()\n", + " predicted_label = model_3d(image).argmax(1).item()\n", + "\n", + " if label > 0 and predicted_label == 1:\n", + " confusion_examples[\"TP -- input: lesion, predicted: lesion\"] = idx\n", + " elif label > 0 and predicted_label == 0:\n", + " confusion_examples[\"FN -- input: lesion, predicted: non-lesion\"] = idx\n", + " elif label < 1.0 and predicted_label == 1:\n", + " confusion_examples[\"FP -- input: non-lesion, predicted: lesion\"] = idx\n", + " elif label < 1.0 and predicted_label == 0:\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}\")" + ], + "execution_count": 18, + "outputs": [ + { + "output_type": "stream", + "text": [ + "TP -- input: lesion, predicted: lesion, idx: 133\n", + "FN -- input: lesion, predicted: non-lesion, idx: 110\n", + "FP -- input: non-lesion, predicted: lesion, idx: 80\n", + "TN -- input: non-lesion, predicted: non-lesion, idx: 7\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 986 + }, + "id": "b-6RwNJvdOWQ", + "outputId": "0dfd103b-c8d4-4859-8cec-5baa742fdd60" + }, + "source": [ + "from monai.metrics import compute_occlusion_sensitivity\n", + "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", + " if not item:\n", + " continue\n", + " data = train_ds[item] # this fetches training data with random augmentations\n", + " image, label = data[\"image\"].to(device).unsqueeze(0), data[\"label\"]\n", + " label = label.argmax(0).item()\n", + " predicted_label = model_3d(image).argmax(1).item()\n", + " \n", + " # run CAM\n", + " model_3d.train()\n", + " model_3d.load_state_dict(torch.load(\"model_classification3d_array.pth\"))\n", + " cam_result = cam(x=image, class_idx=None)\n", + " \n", + " # run occlusion\n", + " bounds=[-1, -1, -1, -1, -1, -1, the_slice, the_slice]\n", + " model_3d.eval()\n", + " model_3d.load_state_dict(torch.load(\"model_classification3d_array.pth\"))\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')" + ], + "execution_count": 22, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Computing occlusion sensitivity: 100%|██████████| 81/81 [00:10<00:00, 7.64it/s]\n", + "/usr/local/lib/python3.6/dist-packages/torch/nn/functional.py:3063: UserWarning: Default upsampling behavior when mode=trilinear is changed to align_corners=False since 0.4.0. Please specify align_corners=True if the old behavior is desired. See the documentation of nn.Upsample for details.\n", + " \"See the documentation of nn.Upsample for details.\".format(mode))\n", + "Computing occlusion sensitivity: 100%|██████████| 81/81 [00:10<00:00, 7.52it/s]\n", + "Computing occlusion sensitivity: 100%|██████████| 81/81 [00:10<00:00, 7.66it/s]\n", + "Computing occlusion sensitivity: 100%|██████████| 81/81 [00:10<00:00, 7.77it/s]\n" + ], + "name": "stderr" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [] + } + } + ] + } + ] +} \ No newline at end of file