diff --git a/README.md b/README.md index d19d367d33..dcb7ae8d4b 100644 --- a/README.md +++ b/README.md @@ -204,6 +204,8 @@ This tutorial shows a straightforward ensemble application to instruct users on **computer_assisted_intervention** #### [video segmentation](./computer_assisted_intervention/video_seg.ipynb) This tutorial shows how to train a surgical tool segmentation model to locate tools in a given image. In addition, it also builds an example pipeline of an end-to-end video tool segmentation, with video input and video output. +#### [endoscopic inbody classification](./computer_assisted_intervention/endoscopic_inbody_classification.ipynb) +Tutorial to show the pipeline of fine tuning an endoscopic inbody classification model based on a corresponding pretrained bundle in monai model zoo. **modules** #### [bundle](./bundle) diff --git a/computer_assisted_intervention/endoscopic_inbody_classification.ipynb b/computer_assisted_intervention/endoscopic_inbody_classification.ipynb new file mode 100644 index 0000000000..5d1a9e6802 --- /dev/null +++ b/computer_assisted_intervention/endoscopic_inbody_classification.ipynb @@ -0,0 +1,530 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "85ccaf4e", + "metadata": {}, + "source": [ + "# Endoscopic Inbody Classification\n", + "\n", + "This notebook shows how to fine tune an endoscopic inbody classification task with a pretrained model from the [monai model zoo](https://monai.io/model-zoo.html). The model is a binary classification model, which takes an image as input and a 0-1 digital implied whether the image's in-body or out-body as output.\n", + "\n", + "Datasets used in this work were provided by Activ Surgical. 20 images (10 in-body and 10 out-body samples) are used to show how the pipeline works. And it's just an example of how to build the pipeline. A real classification dataset should be adopt if the model needs to be transfered to new datasets.\n" + ] + }, + { + "cell_type": "markdown", + "id": "61142d14", + "metadata": {}, + "source": [ + "## Setup environment" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "5f9e4066", + "metadata": {}, + "outputs": [], + "source": [ + "!python -c \"import monai\" || pip install -q \"monai-weekly[pillow, ignite, tqdm]\"\n", + "!python -c \"import matplotlib\" || pip install -q matplotlib\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "id": "f0543b94", + "metadata": {}, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4a0d92f8", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/conda/lib/python3.8/site-packages/tqdm/auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MONAI version: 0.10.dev2236\n", + "Numpy version: 1.22.3\n", + "Pytorch version: 1.12.0a0+bd13bc6\n", + "MONAI flags: HAS_EXT = False, USE_COMPILED = False, USE_META_DICT = False\n", + "MONAI rev id: a803c6ba5a9e9829771547df7a7de05e4fd3b6d4\n", + "MONAI __file__: /opt/conda/lib/python3.8/site-packages/monai/__init__.py\n", + "\n", + "Optional dependencies:\n", + "Pytorch Ignite version: 0.4.8\n", + "Nibabel version: 3.2.2\n", + "scikit-image version: 0.19.2\n", + "Pillow version: 9.0.1\n", + "Tensorboard version: 2.8.0\n", + "gdown version: 4.4.0\n", + "TorchVision version: 0.13.0a0\n", + "tqdm version: 4.64.0\n", + "lmdb version: 1.3.0\n", + "psutil version: 5.9.0\n", + "pandas version: 1.3.5\n", + "einops version: 0.4.1\n", + "transformers version: 4.19.2\n", + "mlflow version: 1.26.0\n", + "pynrrd version: 0.4.3\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" + ] + } + ], + "source": [ + "# Copyright 2022 MONAI Consortium\n", + "# Licensed under the Apache License, Version 2.0 (the \"License\");\n", + "# you may not use this file except in compliance with the License.\n", + "# You may obtain a copy of the License at\n", + "# http://www.apache.org/licenses/LICENSE-2.0\n", + "# Unless required by applicable law or agreed to in writing, software\n", + "# distributed under the License is distributed on an \"AS IS\" BASIS,\n", + "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n", + "# See the License for the specific language governing permissions and\n", + "# limitations under the License.\n", + "\n", + "import os\n", + "import tempfile\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from tqdm import trange\n", + "import torch\n", + "\n", + "\n", + "import monai\n", + "from monai.data import Dataset, DataLoader\n", + "from monai.networks.nets import SEResNet50\n", + "from monai.transforms import (\n", + " AsDiscrete,\n", + " LoadImaged,\n", + " Compose,\n", + " ToTensord,\n", + " AsChannelFirstd,\n", + " Resized,\n", + " CastToTyped,\n", + " NormalizeIntensityd,\n", + " EnsureTyped,\n", + " RandRotated,\n", + " RandScaleIntensityd,\n", + " RandShiftIntensityd,\n", + " RandGaussianNoised,\n", + " RandFlipd,\n", + ")\n", + "from monai.utils import set_determinism\n", + "from monai.apps import download_and_extract\n", + "from ignite.metrics import Precision\n", + "from monai.data import decollate_batch\n", + "\n", + "monai.config.print_config()\n", + "\n", + "# Set deterministic training for reproducibility\n", + "set_determinism(seed=0)" + ] + }, + { + "cell_type": "markdown", + "id": "7049fd4b", + "metadata": {}, + "source": [ + "## Setup data directory\n", + "\n", + "You can specify a directory with the `MONAI_DATA_DIRECTORY` environment variable. This allows you to save results and reuse downloads. If not specified a temporary directory will be used." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f5e536dd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/tmp/tmptvcelywl\n" + ] + } + ], + "source": [ + "directory = os.environ.get(\"MONAI_DATA_DIRECTORY\")\n", + "root_dir = tempfile.mkdtemp() if directory is None else directory\n", + "print(root_dir)\n", + "endo_dir = os.path.join(root_dir, \"endo_cls\")" + ] + }, + { + "cell_type": "markdown", + "id": "d1e151ec", + "metadata": {}, + "source": [ + "## Download data\n", + "\n", + "The data here are 20 images from Activ Surgical with 10 in-body images in \"inbody\" directory and 10 out-body images in \"outbody\" directory. " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "495b1db7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-10-14 03:45:48,012 - INFO - Verified 'inbody_outbody_samples.zip', md5: cce8f3beb1fb2e8fc2429e073c927489.\n", + "2022-10-14 03:45:48,012 - INFO - File exists: inbody_outbody_samples.zip, skipped downloading.\n", + "2022-10-14 03:45:48,012 - INFO - Writing into directory: /tmp/tmptvcelywl/endo_cls.\n" + ] + } + ], + "source": [ + "set_url = r\"https://github.com/Project-MONAI/MONAI-extra-test-data/releases/download/0.8.1/inbody_outbody_samples.zip\"\n", + "md5_hash = r\"cce8f3beb1fb2e8fc2429e073c927489\"\n", + "compress_filename = r\"inbody_outbody_samples.zip\"\n", + "download_and_extract(set_url, compress_filename, endo_dir, md5_hash)" + ] + }, + { + "cell_type": "markdown", + "id": "258174ca", + "metadata": {}, + "source": [ + "## Transform, Dataloader, Network, Loss and Optimizer\n", + "\n", + "Set up the whole pipeline for endoscopy inbody classification training. Build up classification transforms and dataloaders based on the downloaded dataset. Use SEResNet50 as the classification network structure, cross entropy as loss and Adam as the optimizer." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "8d0e9249", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "There are total 20 samples.\n", + "Train set has 16 samples.\n", + "Validation set has 4 samples.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ": Class `AsChannelFirst` has been deprecated since version 0.8. please use MetaTensor data type and monai.transforms.EnsureChannelFirst instead.\n" + ] + } + ], + "source": [ + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "\n", + "\n", + "def get_sample_list(image_root):\n", + " sample_list = []\n", + " for root, _, filenames in os.walk(image_root):\n", + " for filename in filenames:\n", + " if \".jpg\" in filename:\n", + " image_path = os.path.join(root, filename)\n", + " image_dir = os.path.basename(root)\n", + " image_label = 0 if \"inbody\" in image_dir else 1\n", + " sample_list.append({\n", + " \"image\": image_path,\n", + " \"label\": image_label,\n", + " })\n", + " return sample_list\n", + "\n", + "\n", + "image_root = os.path.join(endo_dir, \"inbody_outbody_samples\")\n", + "sample_list = get_sample_list(image_root)\n", + "inbody_list = [x for x in sample_list if x[\"label\"] == 0]\n", + "outbody_list = [x for x in sample_list if x[\"label\"] == 1]\n", + "train_sample_len_inbody = int(0.8 * len(inbody_list))\n", + "train_sample_len_outbody = int(0.8 * len(outbody_list))\n", + "train_sample_list = inbody_list[:train_sample_len_inbody] + outbody_list[:train_sample_len_outbody]\n", + "val_sample_list = inbody_list[train_sample_len_inbody:] + outbody_list[train_sample_len_outbody:]\n", + "print(f\"There are total {len(sample_list)} samples.\")\n", + "print(f\"Train set has {len(train_sample_list)} samples.\")\n", + "print(f\"Validation set has {len(val_sample_list)} samples.\")\n", + "\n", + "train_transform = Compose(\n", + " [\n", + " LoadImaged(keys=[\"image\"]),\n", + " ToTensord(keys=[\"label\"]),\n", + " AsChannelFirstd(keys=[\"image\"]),\n", + " Resized(keys=[\"image\"], spatial_size=[256, 256], mode=\"bilinear\"),\n", + " CastToTyped(keys=[\"image\"], dtype=torch.float32),\n", + " NormalizeIntensityd(keys=[\"image\"], nonzero=True, channel_wise=True),\n", + " EnsureTyped(keys=[\"image\"]),\n", + " RandRotated(keys=[\"image\"], range_x=0.3, prob=0.2, mode=\"bilinear\"),\n", + " RandScaleIntensityd(keys=[\"image\"], factors=0.3, prob=0.5),\n", + " RandShiftIntensityd(keys=[\"image\"], offsets=0.1, prob=0.5),\n", + " RandGaussianNoised(keys=[\"image\"], std=0.01, prob=0.15),\n", + " RandFlipd(keys=[\"image\"], spatial_axis=0, prob=0.5),\n", + " RandFlipd(keys=[\"image\"], spatial_axis=1, prob=0.5),\n", + " ]\n", + " )\n", + "\n", + "val_transform = Compose(\n", + " [\n", + " LoadImaged(keys=[\"image\"]),\n", + " ToTensord(keys=[\"label\"]),\n", + " AsChannelFirstd(keys=[\"image\"]),\n", + " Resized(keys=[\"image\"], spatial_size=[256, 256], mode=\"bilinear\"),\n", + " CastToTyped(keys=[\"image\", \"label\"], dtype=torch.float32),\n", + " NormalizeIntensityd(keys=[\"image\"], nonzero=True, channel_wise=True),\n", + " EnsureTyped(keys=[\"image\"]),\n", + " ]\n", + " )\n", + "\n", + "check_transform = Compose(\n", + " [\n", + " LoadImaged(keys=[\"image\"]),\n", + " ToTensord(keys=[\"label\"]),\n", + " AsChannelFirstd(keys=[\"image\"]),\n", + " Resized(keys=[\"image\"], spatial_size=[256, 256], mode=\"bilinear\"),\n", + " CastToTyped(keys=[\"image\", \"label\"], dtype=[np.uint8, torch.float32]),\n", + " ]\n", + " )\n", + "\n", + "# set up train/val dataloader\n", + "train_dataset = Dataset(data=train_sample_list, transform=train_transform)\n", + "val_dataset = Dataset(data=val_sample_list, transform=val_transform)\n", + "check_val_dataset = Dataset(data=val_sample_list, transform=check_transform)\n", + "train_dataloader = DataLoader(train_dataset, batch_size=4, shuffle=True, num_workers=4)\n", + "val_dataloader = DataLoader(val_dataset, batch_size=1, shuffle=False)\n", + "\n", + "# set up model, optimizer and loss\n", + "model = SEResNet50(spatial_dims=2, in_channels=3, num_classes=2)\n", + "model.to(device)\n", + "\n", + "optimizer = torch.optim.Adam(model.parameters(), 1e-4)\n", + "\n", + "loss = torch.nn.CrossEntropyLoss(reduction=\"mean\")\n", + "\n", + "# set up post processing for inference\n", + "post_trans = AsDiscrete(argmax=True, to_onehot=2)\n", + "post_label = AsDiscrete(argmax=False, to_onehot=2)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "f16dbef5", + "metadata": {}, + "source": [ + "## Check samples\n", + "\n", + "Pick some samples from the validation set to make sure they are correctly processed." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "c6699a23", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "nrow, ncol = 2, 2\n", + "fig, axes = plt.subplots(nrow, ncol, figsize=(ncol * 3, nrow * 3), facecolor='white')\n", + "nexamples = nrow * ncol\n", + "samples = sorted(np.random.choice(len(check_val_dataset), size=nexamples, replace=False))\n", + "for sample, ax in zip(samples, axes.flatten()):\n", + " _ds = check_val_dataset[sample]\n", + " img, lbl = _ds[\"image\"], _ds[\"label\"]\n", + " blended = img\n", + " class_type = \"outbody\" if lbl else \"inbody\"\n", + " blended = np.moveaxis(blended, 0, -1) # RGB to end\n", + " ax.imshow(blended)\n", + " ax.set_title(f\"{class_type}\")\n", + " ax.axis(\"off\")" + ] + }, + { + "cell_type": "markdown", + "id": "c115efff", + "metadata": {}, + "source": [ + "## Fine Tune\n", + "\n", + "Do the typical fine tuning process for 5 epochs based on the pretrained endoscopy_inbody_classification bundle from monai model zoo. " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "4784fe9e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-10-14 03:45:50,523 - INFO - --- input summary of monai.bundle.scripts.download ---\n", + "2022-10-14 03:45:50,523 - INFO - > name: 'endoscopic_inbody_classification'\n", + "2022-10-14 03:45:50,523 - INFO - > version: '0.2.0'\n", + "2022-10-14 03:45:50,524 - INFO - > bundle_dir: PosixPath('.')\n", + "2022-10-14 03:45:50,524 - INFO - > source: 'github'\n", + "2022-10-14 03:45:50,524 - INFO - > repo: 'Project-MONAI/model-zoo/hosting_storage_v1'\n", + "2022-10-14 03:45:50,524 - INFO - > progress: True\n", + "2022-10-14 03:45:50,524 - INFO - ---\n", + "\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "endoscopic_inbody_classification_v0.2.0.zip: 185MB [03:02, 1.06MB/s] \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-10-14 03:48:53,588 - INFO - Downloaded: endoscopic_inbody_classification_v0.2.0.zip\n", + "2022-10-14 03:48:53,588 - INFO - Expected md5 is None, skip md5 check for file endoscopic_inbody_classification_v0.2.0.zip.\n", + "2022-10-14 03:48:53,589 - INFO - Writing into directory: ..\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████████████████████████████████████████| 5/5 [00:03<00:00, 1.32it/s]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "max_epochs = 5\n", + "\n", + "pretrained_model = monai.bundle.load(\n", + " name=\"endoscopic_inbody_classification\", bundle_dir=\"./\", version=\"0.2.0\"\n", + ")\n", + "\n", + "model.load_state_dict(pretrained_model)\n", + "\n", + "model.train()\n", + "losses = []\n", + "\n", + "for _ in trange(max_epochs):\n", + " epoch_loss = 0\n", + " for data in train_dataloader:\n", + " inputs, labels = data[\"image\"].to(device), data[\"label\"].to(device)\n", + " optimizer.zero_grad()\n", + " predictions = model(inputs)\n", + " loss_iter = loss(predictions, labels)\n", + " loss_iter.backward()\n", + " optimizer.step()\n", + " epoch_loss += loss_iter.item()\n", + " losses.append(epoch_loss/len(train_dataloader))\n", + "\n", + "fig, ax = plt.subplots(1, 1, figsize=(6, 6), facecolor=\"white\")\n", + "ax.set_xlabel(\"Epoch\")\n", + "epochs = list(range(len(losses)))\n", + "ax.plot(epochs, losses, label=\"loss\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "513952d6", + "metadata": {}, + "source": [ + "## Inference\n", + "Do inference on the validation dataset to get the accuracy of the fine tuned model." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "218fcb8b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The accuracy of classification model is 1.0 after fine tune.\n" + ] + } + ], + "source": [ + "model.eval()\n", + "precision = Precision()\n", + "for data in val_dataloader:\n", + " images, labels = data[\"image\"].to(device), data[\"label\"].to(device)\n", + " predictions = model(images)\n", + " labels = [post_label(x) for x in decollate_batch(labels)]\n", + " predictions = [post_trans(x) for x in decollate_batch(predictions)]\n", + " for label, pred in zip(labels, predictions):\n", + " precision.update((pred, label))\n", + "print(f\"The accuracy of classification model is {precision.compute()} after fine tune.\")" + ] + } + ], + "metadata": { + "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.8.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/computer_assisted_intervention/video_seg.ipynb b/computer_assisted_intervention/video_seg.ipynb index f975e06f20..dcec27cf35 100644 --- a/computer_assisted_intervention/video_seg.ipynb +++ b/computer_assisted_intervention/video_seg.ipynb @@ -233,7 +233,9 @@ "\n", "For the dataset, we use two instances of `VideoFileDataset`, one for the input video and the other for the ground truth segmentations. We create a `CombinedVidDataset` that enables us to iterate across these two at the same time.\n", "\n", - "The data loader is the standard." + "The data loader is a thread dataloader, which is able to accelerate inference and training.\n", + "\n", + "When videos cannot be opened by `VideoFileDataset`, check if python-opencv library is installed with ffmpeg. If not, please uninstall and reinstall python-opencv in your environment." ] }, { @@ -373,7 +375,7 @@ "There is a pretrained bundle for surgical tool segmentation task in the MONAI model-zoo, the model can be automatically downloaded and loaded to the network by adding codes to the block below:\n", "```\n", "pretrained_weights = monai.bundle.load(\n", - " name=\"surgical_tool_segmentation\", bundle_dir=\"./\", version=\"0.2.0\"\n", + " name=\"endoscopic_tool_segmentation\", bundle_dir=\"./\", version=\"0.2.0\"\n", ")\n", "model.load_state_dict(pretrained_weights)\n", "```" @@ -505,7 +507,7 @@ "source": [ "## Generating video\n", "\n", - "A video with masks will be generated by using the trained model to predict tool segmentation results." + "A video with masks will be generated by using the trained model to predict tool segmentation results. If cannot open video in notebook, please check saved video in local specified directory." ] }, {