diff --git a/modules/2d_slices_from_3d_sampling.ipynb b/modules/2d_slices_from_3d_sampling.ipynb new file mode 100644 index 0000000000..eddc8dd406 --- /dev/null +++ b/modules/2d_slices_from_3d_sampling.ipynb @@ -0,0 +1,575 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Training with 2D samples from volumes\n", + "\n", + "This tutorial shows how to train a network with 2D samples from 3D inputs.\n", + "\n", + "It mainly demonstrates sampling of 2d slice dataset using `monai.transforms.RandSpatialCropSamplesd` and `monai.data.PatchDataset`.\n", + "\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Project-MONAI/tutorials/blob/main/modules/2d_slices_from_3d.ipynb)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup environment" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "!python -c \"import monai\" || pip install -q \"monai-weekly[tqdm, nibabel]\"\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup imports" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MONAI version: 0.9.dev2224\n", + "Numpy version: 1.22.4\n", + "Pytorch version: 1.11.0\n", + "MONAI flags: HAS_EXT = False, USE_COMPILED = False\n", + "MONAI rev id: cb6ecb1a22042d4a559b864e74c64d99352dcf7c\n", + "MONAI __file__: /usr/local/anaconda3/envs/py38/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.1.1\n", + "Tensorboard version: 2.9.0\n", + "gdown version: 4.4.0\n", + "TorchVision version: 0.12.0\n", + "tqdm version: 4.64.0\n", + "lmdb version: 1.3.0\n", + "psutil version: 5.9.1\n", + "pandas version: 1.4.2\n", + "einops version: 0.4.1\n", + "transformers version: 4.19.2\n", + "mlflow version: 1.26.1\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 (c) 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", + "from glob import glob\n", + "import shutil\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import monai\n", + "import nibabel as nib\n", + "import numpy as np\n", + "import torch\n", + "from monai.data import DataLoader, PatchDataset, create_test_image_3d\n", + "from monai.inferers import SliceInferer\n", + "from monai.metrics import DiceMetric\n", + "from monai.transforms import (\n", + " Compose,\n", + " EnsureChannelFirstd,\n", + " EnsureTyped,\n", + " LoadImaged,\n", + " RandRotate90d,\n", + " Resized,\n", + " ScaleIntensityd,\n", + " SqueezeDimd,\n", + ")\n", + "from monai.visualize import matshow3d\n", + "\n", + "monai.config.print_config()\n", + "monai.utils.set_determinism(0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup data directory\n", + "\n", + "You can specify a directory with the `MONAI_DATA_DIRECTORY` environment variable. \n", + "This allows you to save results and reuse downloads. \n", + "If not specified a temporary directory will be used." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/Users/wenqili/Documents/monai_data\n" + ] + } + ], + "source": [ + "directory = os.environ.get(\"MONAI_DATA_DIRECTORY\")\n", + "root_dir = tempfile.mkdtemp() if directory is None else directory\n", + "print(root_dir)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create a dataset\n", + "\n", + "The example volumes are created with different spatial shapes for demo purposes\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "generating synthetic data to /Users/wenqili/Documents/monai_data (this may take a while)\n" + ] + } + ], + "source": [ + "print(f\"generating synthetic data to {root_dir} (this may take a while)\")\n", + "for i in range(40):\n", + " # make the input volumes different spatial shapes for demo purposes\n", + " H, W, D = 30 + i, 40 + i, 50 + i\n", + " im, seg = create_test_image_3d(\n", + " H, W, D, num_seg_classes=1, channel_dim=-1, rad_max=10\n", + " )\n", + "\n", + " n = nib.Nifti1Image(im, np.eye(4))\n", + " nib.save(n, os.path.join(root_dir, f\"img{i:d}.nii.gz\"))\n", + " n = nib.Nifti1Image(seg, np.eye(4))\n", + " nib.save(n, os.path.join(root_dir, f\"seg{i:d}.nii.gz\"))\n", + "\n", + "images = sorted(glob(os.path.join(root_dir, \"img*.nii.gz\")))\n", + "segs = sorted(glob(os.path.join(root_dir, \"seg*.nii.gz\")))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "train_files = [{\"img\": img, \"seg\": seg} for img, seg in zip(images[:35], segs[:35])]\n", + "val_files = [{\"img\": img, \"seg\": seg} for img, seg in zip(images[-3:], segs[-3:])]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Volume-level preprocessing" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading dataset: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 35/35 [00:00<00:00, 121.13it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "first volume's shape: torch.Size([1, 1, 50, 30, 40]) torch.Size([1, 1, 50, 30, 40])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# volume-level transforms for both image and segmentation\n", + "train_transforms = Compose(\n", + " [\n", + " LoadImaged(keys=[\"img\", \"seg\"]),\n", + " EnsureChannelFirstd(keys=[\"img\", \"seg\"]),\n", + " ScaleIntensityd(keys=\"img\"),\n", + " RandRotate90d(keys=[\"img\", \"seg\"], prob=0.5, spatial_axes=[0, 2]),\n", + " EnsureTyped(keys=[\"img\", \"seg\"]),\n", + " ]\n", + ")\n", + "# 3D dataset with preprocessing transforms\n", + "volume_ds = monai.data.CacheDataset(data=train_files, transform=train_transforms)\n", + "# use batch_size=1 to check the volumes because the input volumes have different shapes\n", + "check_loader = DataLoader(volume_ds, batch_size=1)\n", + "check_data = monai.utils.misc.first(check_loader)\n", + "print(\"first volume's shape: \", check_data[\"img\"].shape, check_data[\"seg\"].shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## volume to patch processing\n", + "\n", + "- define the 2d sampling transforms, could also be other spatial cropping transforms\n", + "https://docs.monai.io/en/stable/transforms.html#crop-and-pad-dict\n", + "\n", + "- patch-level preprocessing, resize the sampled slices to a consistent size so that we can batch\n", + "the last spatial dim is always 1, so we squeeze dim." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "first patch's shape: torch.Size([3, 1, 48, 48]) torch.Size([3, 1, 48, 48])\n" + ] + } + ], + "source": [ + "num_samples = 4\n", + "patch_func = monai.transforms.RandSpatialCropSamplesd(\n", + " keys=[\"img\", \"seg\"],\n", + " roi_size=[-1, -1, 1], # dynamic spatial_size for the first two dimensions\n", + " num_samples=num_samples,\n", + " random_size=False,\n", + ")\n", + "# this can also be balanced samples:\n", + "# patch_func = RandCropByPosNegLabeld(\n", + "# keys=[\"img\", \"seg\"],\n", + "# label_key=\"seg\",\n", + "# spatial_size=[-1, -1, 1], # dynamic spatial_size for the first two dimensions\n", + "# pos=1,\n", + "# neg=1,\n", + "# num_samples=num_samples,\n", + "# )\n", + "patch_transform = Compose(\n", + " [\n", + " SqueezeDimd(keys=[\"img\", \"seg\"], dim=-1), # squeeze the last dim\n", + " Resized(keys=[\"img\", \"seg\"], spatial_size=[48, 48]),\n", + " # to use crop/pad instead of reszie:\n", + " # ResizeWithPadOrCropd(keys=[\"img\", \"seg\"], spatial_size=[48, 48], mode=\"replicate\"),\n", + " ]\n", + ")\n", + "patch_ds = PatchDataset(\n", + " volume_ds,\n", + " transform=patch_transform,\n", + " patch_func=patch_func,\n", + " samples_per_image=num_samples,\n", + ")\n", + "train_loader = DataLoader(\n", + " patch_ds,\n", + " batch_size=3,\n", + " shuffle=True, # this shuffles slices from different volumes\n", + " num_workers=2,\n", + " pin_memory=torch.cuda.is_available(),\n", + ")\n", + "check_data = monai.utils.misc.first(train_loader)\n", + "print(\"first patch's shape: \", check_data[\"img\"].shape, check_data[\"seg\"].shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define 2D network and losses" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "model = monai.networks.nets.UNet(\n", + " spatial_dims=2,\n", + " in_channels=1,\n", + " out_channels=1,\n", + " channels=(16, 32, 64, 128),\n", + " strides=(2, 2, 2),\n", + " num_res_units=2,\n", + ").to(device)\n", + "loss_function = monai.losses.DiceLoss(sigmoid=True)\n", + "optimizer = torch.optim.Adam(model.parameters(), 5e-3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The training loop" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------\n", + "epoch 1/5\n", + "25/46, train_loss: 0.5968\n", + "epoch 1 average loss: 0.7530\n", + "----------\n", + "epoch 2/5\n", + "25/46, train_loss: 0.7140\n", + "epoch 2 average loss: 0.6856\n", + "----------\n", + "epoch 3/5\n", + "25/46, train_loss: 0.2901\n", + "epoch 3 average loss: 0.5425\n", + "----------\n", + "epoch 4/5\n", + "25/46, train_loss: 0.4971\n", + "epoch 4 average loss: 0.4795\n", + "----------\n", + "epoch 5/5\n", + "25/46, train_loss: 0.3957\n", + "epoch 5 average loss: 0.3271\n", + "train completed\n" + ] + } + ], + "source": [ + "epoch_loss_values = []\n", + "num_epochs = 5\n", + "for epoch in range(num_epochs):\n", + " print(\"-\" * 10)\n", + " print(f\"epoch {epoch + 1}/{num_epochs}\")\n", + " model.train()\n", + " epoch_loss, step = 0, 0\n", + " for batch_data in train_loader:\n", + " step += 1\n", + " inputs, labels = batch_data[\"img\"].to(device), batch_data[\"seg\"].to(device)\n", + " optimizer.zero_grad()\n", + " outputs = model(inputs)\n", + " loss = loss_function(outputs, labels)\n", + " loss.backward()\n", + " optimizer.step()\n", + " epoch_loss += loss.item()\n", + " epoch_len = len(patch_ds) // train_loader.batch_size\n", + " if step % 25 == 0:\n", + " print(f\"{step}/{epoch_len}, train_loss: {loss.item():.4f}\")\n", + " epoch_loss /= step\n", + " epoch_loss_values.append(epoch_loss)\n", + " print(f\"epoch {epoch + 1} average loss: {epoch_loss:.4f}\")\n", + "print(\"train completed\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## SliceInferer" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dice: tensor(0.9784)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dice: tensor(0.9706)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dice: tensor(0.9727)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Avg Dice: 0.9738895297050476\n" + ] + } + ], + "source": [ + "val_transform = Compose(\n", + " [\n", + " LoadImaged(keys=[\"img\", \"seg\"]),\n", + " EnsureChannelFirstd(keys=[\"img\", \"seg\"]),\n", + " ScaleIntensityd(keys=\"img\"),\n", + " EnsureTyped(keys=[\"img\", \"seg\"]),\n", + " ]\n", + ")\n", + "val_files = [{\"img\": img, \"seg\": seg} for img, seg in zip(images[-3:], segs[-3:])]\n", + "val_ds = monai.data.Dataset(data=val_files, transform=val_transform)\n", + "data_loader = DataLoader(val_ds, num_workers=1, pin_memory=torch.cuda.is_available())\n", + "dice_metric = DiceMetric(include_background=True, reduction=\"mean\", get_not_nans=False)\n", + "model.eval()\n", + "with torch.no_grad():\n", + " for val_data in data_loader:\n", + " val_images = val_data[\"img\"].to(device)\n", + " roi_size = (48, 48)\n", + " sw_batch_size = 3\n", + " slice_inferer = SliceInferer(\n", + " roi_size=roi_size,\n", + " sw_batch_size=sw_batch_size,\n", + " spatial_dim=1, # Spatial dim to slice along is defined here\n", + " device=torch.device(\"cpu\"),\n", + " padding_mode=\"replicate\",\n", + " )\n", + " val_output = slice_inferer(val_images, model)\n", + " dice_metric(y_pred=val_output > 0.5, y=val_data[\"seg\"])\n", + " print(\"Dice: \", dice_metric.get_buffer()[-1][0])\n", + " fig = plt.figure(figsize=(10, 4))\n", + " plt.subplot(1, 2, 1)\n", + " matshow3d(val_output[0], fig=plt.gca())\n", + " plt.subplot(1, 2, 2)\n", + " matshow3d(val_images[0], fig=plt.gca())\n", + " plt.show()\n", + " print(f\"Avg Dice: {dice_metric.aggregate().item()}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Cleanup data directory\n", + "\n", + "Remove directory if a temporary was used." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "if directory is None:\n", + " shutil.rmtree(root_dir)" + ] + } + ], + "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.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/modules/2d_slices_from_3d_training.ipynb b/modules/2d_slices_from_3d_training.ipynb new file mode 100644 index 0000000000..bc4d968f29 --- /dev/null +++ b/modules/2d_slices_from_3d_training.ipynb @@ -0,0 +1,557 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Training with 2D slices from volumes\n", + "\n", + "This tutorial shows how to train a network with 2D samples from 3D inputs.\n", + "\n", + "It mainly demonstrates 2d slice dataset using `monai.data.PatchIterd` and `monai.data.GridPatchDataset`.\n", + "\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Project-MONAI/tutorials/blob/main/modules/2d_slices_from_3d.ipynb)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup environment" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "!python -c \"import monai\" || pip install -q \"monai-weekly[tqdm, nibabel]\"\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup imports" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MONAI version: 0.9.dev2224\n", + "Numpy version: 1.22.4\n", + "Pytorch version: 1.11.0\n", + "MONAI flags: HAS_EXT = False, USE_COMPILED = False\n", + "MONAI rev id: cb6ecb1a22042d4a559b864e74c64d99352dcf7c\n", + "MONAI __file__: /usr/local/anaconda3/envs/py38/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.1.1\n", + "Tensorboard version: 2.9.0\n", + "gdown version: 4.4.0\n", + "TorchVision version: 0.12.0\n", + "tqdm version: 4.64.0\n", + "lmdb version: 1.3.0\n", + "psutil version: 5.9.1\n", + "pandas version: 1.4.2\n", + "einops version: 0.4.1\n", + "transformers version: 4.19.2\n", + "mlflow version: 1.26.1\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 (c) 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", + "from glob import glob\n", + "import shutil\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import monai\n", + "import nibabel as nib\n", + "import numpy as np\n", + "import torch\n", + "from monai.data import DataLoader, create_test_image_3d\n", + "from monai.inferers import SliceInferer\n", + "from monai.metrics import DiceMetric\n", + "from monai.transforms import (\n", + " Compose,\n", + " EnsureChannelFirstd,\n", + " EnsureTyped,\n", + " LoadImaged,\n", + " RandRotate90d,\n", + " Resized,\n", + " ScaleIntensityd,\n", + " SqueezeDimd,\n", + ")\n", + "from monai.visualize import matshow3d\n", + "\n", + "monai.config.print_config()\n", + "monai.utils.set_determinism(0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup data directory\n", + "\n", + "You can specify a directory with the `MONAI_DATA_DIRECTORY` environment variable. \n", + "This allows you to save results and reuse downloads. \n", + "If not specified a temporary directory will be used." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/Users/wenqili/Documents/monai_data\n" + ] + } + ], + "source": [ + "directory = os.environ.get(\"MONAI_DATA_DIRECTORY\")\n", + "root_dir = tempfile.mkdtemp() if directory is None else directory\n", + "print(root_dir)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create a dataset\n", + "\n", + "The example volumes are created with different spatial shapes for demo purposes\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "generating synthetic data to /Users/wenqili/Documents/monai_data (this may take a while)\n" + ] + } + ], + "source": [ + "print(f\"generating synthetic data to {root_dir} (this may take a while)\")\n", + "for i in range(40):\n", + " # make the input volumes different spatial shapes for demo purposes\n", + " H, W, D = 30 + i, 40 + i, 50 + i\n", + " im, seg = create_test_image_3d(\n", + " H, W, D, num_seg_classes=1, channel_dim=-1, rad_max=10\n", + " )\n", + "\n", + " n = nib.Nifti1Image(im, np.eye(4))\n", + " nib.save(n, os.path.join(root_dir, f\"img{i:d}.nii.gz\"))\n", + " n = nib.Nifti1Image(seg, np.eye(4))\n", + " nib.save(n, os.path.join(root_dir, f\"seg{i:d}.nii.gz\"))\n", + "\n", + "images = sorted(glob(os.path.join(root_dir, \"img*.nii.gz\")))\n", + "segs = sorted(glob(os.path.join(root_dir, \"seg*.nii.gz\")))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "train_files = [{\"img\": img, \"seg\": seg} for img, seg in zip(images[:35], segs[:35])]\n", + "val_files = [{\"img\": img, \"seg\": seg} for img, seg in zip(images[-3:], segs[-3:])]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Volume-level preprocessing" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading dataset: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 35/35 [00:00<00:00, 107.81it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "first volume's shape: torch.Size([1, 1, 50, 30, 40]) torch.Size([1, 1, 50, 30, 40])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# volume-level transforms for both image and segmentation\n", + "train_transforms = Compose(\n", + " [\n", + " LoadImaged(keys=[\"img\", \"seg\"]),\n", + " EnsureChannelFirstd(keys=[\"img\", \"seg\"]),\n", + " ScaleIntensityd(keys=\"img\"),\n", + " RandRotate90d(keys=[\"img\", \"seg\"], prob=0.5, spatial_axes=[0, 2]),\n", + " EnsureTyped(keys=[\"img\", \"seg\"]),\n", + " ]\n", + ")\n", + "# 3D dataset with preprocessing transforms\n", + "volume_ds = monai.data.CacheDataset(data=train_files, transform=train_transforms)\n", + "# use batch_size=1 to check the volumes because the input volumes have different shapes\n", + "check_loader = DataLoader(volume_ds, batch_size=1)\n", + "check_data = monai.utils.misc.first(check_loader)\n", + "print(\"first volume's shape: \", check_data[\"img\"].shape, check_data[\"seg\"].shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## volume to patch processing\n", + "\n", + "- define the 2d slice dataset using `monai.data.PatchIterd` and `monai.data.GridPatchDataset`\n", + "- patch-level preprocessing, resize the sampled slices to a consistent size so that we can batch\n", + "the last spatial dim is always 1, so we squeeze dim." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "first patch's shape: torch.Size([5, 1, 48, 48]) torch.Size([5, 1, 48, 48])\n" + ] + } + ], + "source": [ + "patch_func = monai.data.PatchIterd(\n", + " keys=[\"img\", \"seg\"],\n", + " patch_size=(None, None, 1), # dynamic first two dimensions\n", + " start_pos=(0, 0, 0)\n", + ")\n", + "patch_transform = Compose(\n", + " [\n", + " SqueezeDimd(keys=[\"img\", \"seg\"], dim=-1), # squeeze the last dim\n", + " Resized(keys=[\"img\", \"seg\"], spatial_size=[48, 48]),\n", + " # to use crop/pad instead of reszie:\n", + " # ResizeWithPadOrCropd(keys=[\"img\", \"seg\"], spatial_size=[48, 48], mode=\"replicate\"),\n", + " ]\n", + ")\n", + "patch_ds = monai.data.GridPatchDataset(\n", + " data=volume_ds, patch_iter=patch_func, transform=patch_transform, with_coordinates=False)\n", + "shuffle_ds = monai.data.ShuffleBuffer(patch_ds, buffer_size=30, seed=0)\n", + "train_loader = DataLoader(\n", + " shuffle_ds,\n", + " batch_size=5,\n", + " num_workers=2,\n", + " pin_memory=torch.cuda.is_available(),\n", + ")\n", + "check_data = monai.utils.misc.first(train_loader)\n", + "print(\"first patch's shape: \", check_data[\"img\"].shape, check_data[\"seg\"].shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define 2D network and losses" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "model = monai.networks.nets.UNet(\n", + " spatial_dims=2,\n", + " in_channels=1,\n", + " out_channels=1,\n", + " channels=(16, 32, 64, 128),\n", + " strides=(2, 2, 2),\n", + " num_res_units=2,\n", + ").to(device)\n", + "loss_function = monai.losses.DiceLoss(sigmoid=True)\n", + "optimizer = torch.optim.Adam(model.parameters(), 5e-3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The training loop" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------\n", + "epoch 1/5\n", + "200, train_loss: 0.6586\n", + "epoch 1 average loss: 0.5654\n", + "----------\n", + "epoch 2/5\n", + "200, train_loss: 0.4702\n", + "epoch 2 average loss: 0.2818\n", + "----------\n", + "epoch 3/5\n", + "200, train_loss: 0.4618\n", + "epoch 3 average loss: 0.2705\n", + "----------\n", + "epoch 4/5\n", + "200, train_loss: 0.4595\n", + "epoch 4 average loss: 0.2643\n", + "----------\n", + "epoch 5/5\n", + "200, train_loss: 0.4590\n", + "epoch 5 average loss: 0.2640\n", + "train completed\n" + ] + } + ], + "source": [ + "epoch_loss_values = []\n", + "num_epochs = 5\n", + "for epoch in range(num_epochs):\n", + " print(\"-\" * 10)\n", + " print(f\"epoch {epoch + 1}/{num_epochs}\")\n", + " model.train()\n", + " epoch_loss, step = 0, 0\n", + " for batch_data in train_loader:\n", + " step += 1\n", + " inputs, labels = batch_data[\"img\"].to(device), batch_data[\"seg\"].to(device)\n", + " optimizer.zero_grad()\n", + " outputs = model(inputs)\n", + " loss = loss_function(outputs, labels)\n", + " loss.backward()\n", + " optimizer.step()\n", + " epoch_loss += loss.item()\n", + " if step % 200 == 0:\n", + " print(f\"{step}, train_loss: {loss.item():.4f}\")\n", + " epoch_loss /= step\n", + " epoch_loss_values.append(epoch_loss)\n", + " print(f\"epoch {epoch + 1} average loss: {epoch_loss:.4f}\")\n", + "print(\"train completed\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## SliceInferer" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dice: tensor(0.9846)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dice: tensor(0.9769)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dice: tensor(0.9803)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Avg Dice: 0.9806270599365234\n" + ] + } + ], + "source": [ + "val_transform = Compose(\n", + " [\n", + " LoadImaged(keys=[\"img\", \"seg\"]),\n", + " EnsureChannelFirstd(keys=[\"img\", \"seg\"]),\n", + " ScaleIntensityd(keys=\"img\"),\n", + " EnsureTyped(keys=[\"img\", \"seg\"]),\n", + " ]\n", + ")\n", + "val_files = [{\"img\": img, \"seg\": seg} for img, seg in zip(images[-3:], segs[-3:])]\n", + "val_ds = monai.data.Dataset(data=val_files, transform=val_transform)\n", + "data_loader = DataLoader(val_ds, num_workers=1, pin_memory=torch.cuda.is_available())\n", + "dice_metric = DiceMetric(include_background=True, reduction=\"mean\", get_not_nans=False)\n", + "model.eval()\n", + "with torch.no_grad():\n", + " for val_data in data_loader:\n", + " val_images = val_data[\"img\"].to(device)\n", + " roi_size = (48, 48)\n", + " sw_batch_size = 3\n", + " slice_inferer = SliceInferer(\n", + " roi_size=roi_size,\n", + " sw_batch_size=sw_batch_size,\n", + " spatial_dim=1, # Spatial dim to slice along is defined here\n", + " device=torch.device(\"cpu\"),\n", + " padding_mode=\"replicate\",\n", + " )\n", + " val_output = slice_inferer(val_images, model)\n", + " dice_metric(y_pred=val_output > 0.5, y=val_data[\"seg\"])\n", + " print(\"Dice: \", dice_metric.get_buffer()[-1][0])\n", + " fig = plt.figure(figsize=(10, 4))\n", + " plt.subplot(1, 2, 1)\n", + " matshow3d(val_output[0], fig=plt.gca())\n", + " plt.subplot(1, 2, 2)\n", + " matshow3d(val_images[0], fig=plt.gca())\n", + " plt.show()\n", + " print(f\"Avg Dice: {dice_metric.aggregate().item()}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Cleanup data directory\n", + "\n", + "Remove directory if a temporary was used." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "if directory is None:\n", + " shutil.rmtree(root_dir)" + ] + } + ], + "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.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}