From ffeca8ffeb5a899934d0cddffe5715d7deb84e5f Mon Sep 17 00:00:00 2001 From: Konstantinos Ntatsis Date: Thu, 10 Nov 2022 18:56:10 +0100 Subject: [PATCH 1/2] ENH: Add notebook for MONAI with itk-elastix With the help of Niels Dekker. --- ...K_Example17_MONAIWithPreregistration.ipynb | 518 ++++++++++++++++++ 1 file changed, 518 insertions(+) create mode 100644 examples/ITK_Example17_MONAIWithPreregistration.ipynb diff --git a/examples/ITK_Example17_MONAIWithPreregistration.ipynb b/examples/ITK_Example17_MONAIWithPreregistration.ipynb new file mode 100644 index 00000000..cf348a56 --- /dev/null +++ b/examples/ITK_Example17_MONAIWithPreregistration.ipynb @@ -0,0 +1,518 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b974cf01-3d75-4e1b-99d6-bba8b738c92e", + "metadata": {}, + "source": [ + "### 17. MONAI deep learning registration with affine pre-alignment using itk-elastix" + ] + }, + { + "cell_type": "markdown", + "id": "54fad620-2c6a-4272-8f28-8a6fed7a66e2", + "metadata": {}, + "source": [ + "A global (rigid/affine) registration is often used as a pre-processing step for deep learning applications. This notebook shows how to apply affine pre-alignment using Elastix before local (non-linear) deep learning registration via project MONAI. The pre-aligning registration is calculated only once, and then it is cached allowing for a faster training." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "ec508d4e-4464-462c-adbb-8e2272268ad6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Device: cuda:0\n" + ] + } + ], + "source": [ + "import os\n", + "import itk\n", + "import torch\n", + "import numpy as np\n", + "from tqdm import tqdm\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from monai.utils import set_determinism\n", + "from monai.transforms import MapTransform, Compose, LoadImaged, EnsureChannelFirstD, ScaleIntensityRanged\n", + "from monai.data import CacheDataset, ITKReader, DataLoader\n", + "from monai.config import print_config, USE_COMPILED\n", + "from monai.networks.nets import GlobalNet, LocalNet\n", + "from monai.networks.blocks import Warp\n", + "from monai.apps import MedNISTDataset\n", + "from monai.losses import GlobalMutualInformationLoss, BendingEnergyLoss\n", + "\n", + "set_determinism(42)\n", + "\n", + "if torch.cuda.is_available():\n", + " device = \"cuda:0\"\n", + " max_epochs = 500\n", + "else:\n", + " device = \"cpu\"\n", + " max_epochs=3\n", + "\n", + "print(\"Device: \", device)" + ] + }, + { + "cell_type": "markdown", + "id": "8bf43d93-a977-4de6-bf94-31e3b642fe2c", + "metadata": {}, + "source": [ + "### Dataset" + ] + }, + { + "cell_type": "markdown", + "id": "b6a4ae54-c2dc-4413-a68a-cb4171822aab", + "metadata": {}, + "source": [ + "After downloading the MedNISTDataset, we keep only the x-ray hand images dataset and create random pairs of images (fixed and moving) to register." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "624e35ad-50c0-45bf-832a-fc78b784df6e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022-11-23 11:33:08,067 - INFO - Verified 'MedNIST.tar.gz', md5: 0bc7306e7427e00ad1c5526a6677552d.\n", + "2022-11-23 11:33:08,073 - INFO - File exists: MedNIST.tar.gz, skipped downloading.\n", + "2022-11-23 11:33:08,073 - INFO - Non-empty folder exists in MedNIST, skipped extracting.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading dataset: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 47164/47164 [00:00<00:00, 589246.76it/s]\n" + ] + } + ], + "source": [ + "# Download MedNISTDataset\n", + "root_dir = './'\n", + "train_data = MedNISTDataset(root_dir=root_dir, section=\"training\", download=True, transform=None)\n", + "\n", + "# Keep only the hand x-rays\n", + "hands = [os.path.join(root_dir, item[\"image\"]) for item in train_data.data if item[\"label\"]==4] # label 4 is for xray hands\n", + "hands = hands[:1000] # use only a subset of the whole data\n", + "\n", + "# Create a dictionary with random pairs of fixed-moving images \n", + "training_datadict = [\n", + " {\"fixed_hand\": fixed_hand, \"moving_hand\": moving_hand}\n", + " for fixed_hand, moving_hand in np.random.choice(hands, size=(len(hands)//2, 2), replace=False)\n", + "]" + ] + }, + { + "cell_type": "markdown", + "id": "00cca67b-19d2-4b3f-a927-e974fa9a7be0", + "metadata": {}, + "source": [ + "### Elastix affine parameter map" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "6aa50c9b-9929-4986-a59a-c063559286cd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AutomaticParameterEstimation ('true',)\n", + "AutomaticScalesEstimation ('true',)\n", + "CheckNumberOfSamples ('true',)\n", + "DefaultPixelValue ('0',)\n", + "FinalBSplineInterpolationOrder ('3',)\n", + "FixedImagePyramid ('FixedSmoothingImagePyramid',)\n", + "ImageSampler ('RandomCoordinate',)\n", + "Interpolator ('LinearInterpolator',)\n", + "MaximumNumberOfIterations ('64',)\n", + "MaximumNumberOfSamplingAttempts ('8',)\n", + "Metric ('AdvancedMattesMutualInformation',)\n", + "MovingImagePyramid ('MovingSmoothingImagePyramid',)\n", + "NewSamplesEveryIteration ('true',)\n", + "NumberOfResolutions ('2',)\n", + "NumberOfSamplesForExactGradient ('4096',)\n", + "NumberOfSpatialSamples ('2048',)\n", + "Optimizer ('AdaptiveStochasticGradientDescent',)\n", + "Registration ('MultiResolutionRegistration',)\n", + "ResampleInterpolator ('FinalBSplineInterpolator',)\n", + "Resampler ('DefaultResampler',)\n", + "ResultImageFormat ('nii',)\n", + "Transform ('AffineTransform',)\n", + "WriteIterationInfo ('false',)\n", + "WriteResultImage ('true',)\n" + ] + } + ], + "source": [ + "# Elastix affine parameter map\n", + "parameter_object = itk.ParameterObject()\n", + "affine_parameter_map = parameter_object.GetDefaultParameterMap('affine')\n", + "affine_parameter_map['NumberOfResolutions'] = \"2\"\n", + "affine_parameter_map['MaximumNumberOfIterations'] = (\"64\", )\n", + "parameter_object.AddParameterMap(affine_parameter_map)\n", + "\n", + "for key in affine_parameter_map.keys():\n", + " print(key, affine_parameter_map[key])" + ] + }, + { + "cell_type": "markdown", + "id": "3e7ee356-49cb-467b-b78a-e049e0faa59e", + "metadata": {}, + "source": [ + "### Pre-alignment steps" + ] + }, + { + "cell_type": "markdown", + "id": "61e60e16-7eec-419c-a8c3-c5c37c80bdc0", + "metadata": {}, + "source": [ + "The custom pre-processing is as follows: 1) Read the images using itk, 2) Register the pairs using Elastix, 3) Convert to numpy array. The rest of the steps are more general (add channel dimension and scale intensities). " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "791e2fcf-7af0-47a9-821b-e3a2e08300cf", + "metadata": {}, + "outputs": [], + "source": [ + "# Pre-processing steps as MONAI transforms\n", + "class ITKReadD(MapTransform):\n", + " def __init__(self, keys):\n", + " super().__init__(keys)\n", + " self.keys = keys\n", + "\n", + " def __call__(self, data):\n", + " new_data = dict.fromkeys(self.keys)\n", + " for key in self.keys:\n", + " new_data[key] = itk.imread(data[key], itk.F)\n", + " return new_data\n", + "\n", + "\n", + "class ElastixPreregistrationD(MapTransform):\n", + " def __init__(self, keys):\n", + " super().__init__(keys)\n", + " self.keys = keys\n", + "\n", + " def __call__(self, data):\n", + " data[\"aligned_hand\"], result_transform_parameters = itk.elastix_registration_method(\n", + " data[self.keys[0]], data[self.keys[1]],\n", + " parameter_object=parameter_object,\n", + " log_to_console=False)\n", + " return data\n", + "\n", + "\n", + "class ConvertToArrayD(MapTransform):\n", + " def __init__(self, keys):\n", + " super().__init__(keys)\n", + " self.keys = keys\n", + "\n", + " def __call__(self, data):\n", + " for key in self.keys:\n", + " data[key] = itk.GetArrayFromImage(data[key]) \n", + " return data\n", + "\n", + "keys = [\"fixed_hand\", \"moving_hand\", \"aligned_hand\"]\n", + "transforms = Compose([\n", + " ITKReadD(keys=keys[:2]),\n", + " ElastixPreregistrationD(keys=keys[:2]),\n", + " ConvertToArrayD(keys=keys), \n", + " EnsureChannelFirstD(keys=keys),\n", + " ScaleIntensityRanged(keys=keys, a_min=0., a_max=255., b_min=0.0, b_max=1.0, clip=True,),\n", + " ])" + ] + }, + { + "cell_type": "markdown", + "id": "e5f15eda-7658-4985-9c7a-6df4e7ea0ff3", + "metadata": {}, + "source": [ + "### Perform pre-alignment, and store the calculations" + ] + }, + { + "cell_type": "markdown", + "id": "46d708a9-fff2-43b1-a87a-bda83769dd6e", + "metadata": {}, + "source": [ + "We are using CacheDataset from MONAI to conveniently perform the pre-alignment and store the result. Later during the training loop, directly the already aligned images will be loaded for training of the model." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "d6109397-b9a0-4691-86af-9ac831e98e0f", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading dataset: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 500/500 [01:14<00:00, 6.70it/s]\n" + ] + } + ], + "source": [ + "dataset = CacheDataset(data=training_datadict, transform=transforms)\n", + "dataloader = DataLoader(dataset=dataset, batch_size=16, shuffle=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "bf09527b-deaa-4f76-882f-d293ece25c5c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Show examples of the pre-alignment\n", + "fixed, moving, aligned = dataset[0].values()\n", + "\n", + "fig = plt.figure(figsize=(14, 6))\n", + "plt.subplot(1, 3, 1)\n", + "plt.imshow(fixed.squeeze(), cmap='gray')\n", + "plt.title('fixed', fontsize=10)\n", + "plt.axis('off')\n", + "\n", + "plt.subplot(1, 3, 2)\n", + "plt.imshow(moving.squeeze(), cmap='gray')\n", + "plt.title('original moving', fontsize=10)\n", + "plt.axis('off')\n", + "\n", + "plt.subplot(1, 3, 3)\n", + "plt.imshow(aligned.squeeze(), cmap='gray')\n", + "plt.title('moving after elastix pre-alignment', fontsize=10)\n", + "plt.axis('off')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "724c078c-f4ef-4f2a-9c30-82425b6f730f", + "metadata": {}, + "source": [ + "### Deep learning registration model" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "c8a5932c-4b91-4108-b394-85188dabe176", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "monai.networks.blocks.Warp: Using PyTorch native grid_sample.\n" + ] + } + ], + "source": [ + "device = torch.device(device)\n", + " \n", + "model = LocalNet(\n", + " spatial_dims=2,\n", + " in_channels=2,\n", + " out_channels=2,\n", + " num_channel_initial=16,\n", + " extract_levels=[0, 1, 2, 3],\n", + " out_activation=None,\n", + " out_kernel_initializer=\"zeros\").to(device)\n", + "warp_layer = Warp(mode=\"bicubic\").to(device)\n", + "criterion = GlobalMutualInformationLoss()\n", + "regularization = BendingEnergyLoss()\n", + "optimizer = torch.optim.Adam(model.parameters(), 1e-3)" + ] + }, + { + "cell_type": "markdown", + "id": "bae99718-54dc-48f2-8c62-edeaae8ecf82", + "metadata": {}, + "source": [ + "### Training loop" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "25cba48e-ce9e-4f17-8390-0dd0a26c749c", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 500/500 [09:09<00:00, 1.10s/it]\n" + ] + } + ], + "source": [ + "epoch_loss_values = []\n", + "\n", + "for epoch in tqdm(range(max_epochs)):\n", + " model.train()\n", + " epoch_loss = 0\n", + " for i, batch_data in enumerate(dataloader):\n", + " optimizer.zero_grad()\n", + "\n", + " fixed = batch_data[\"fixed_hand\"].to(device)\n", + " pre_aligned = batch_data[\"aligned_hand\"].to(device)\n", + " ddf = model(torch.cat((pre_aligned, fixed), dim=1))\n", + " pred_image = warp_layer(pre_aligned, ddf)\n", + "\n", + " loss = criterion(pred_image, fixed) + 0.3*regularization(ddf)\n", + " loss.backward()\n", + " optimizer.step()\n", + " epoch_loss += loss.item()*fixed.shape[0]\n", + "\n", + " epoch_loss /= len(dataset)\n", + " epoch_loss_values.append(epoch_loss)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "4ea6ba46-a8a8-431b-9b44-f80b91a528bf", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(epoch_loss_values, linewidth=2)\n", + "plt.xlabel('epoch', fontsize=14)\n", + "plt.ylabel('loss', fontsize=14)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "9114039f-9c9e-437b-96f9-ae26603994e1", + "metadata": {}, + "source": [ + "### Visualise example results" + ] + }, + { + "cell_type": "markdown", + "id": "9a08aeff-3ea2-414e-a6ac-62b64732f28d", + "metadata": {}, + "source": [ + "For the shake of simplicity we visualise the results in the training set and not in the validation/test set." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "7d6154f0-747a-4cfd-b8c7-0ded58d40a8d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ind = 3\n", + "example_fixed = batch_data['fixed_hand'][ind, 0, :, :]\n", + "example_moving = batch_data['moving_hand'][ind, 0, :, :]\n", + "example_prealigned = batch_data['aligned_hand'][ind, 0, :, :]\n", + "example_result = pred_image[ind, 0, :, :].detach().cpu()\n", + "\n", + "fig = plt.figure(figsize=(14, 6))\n", + "plt.subplot(1, 4, 1)\n", + "plt.imshow(example_fixed, cmap='gray')\n", + "plt.title('fixed', fontsize=10)\n", + "plt.axis('off')\n", + "\n", + "plt.subplot(1, 4, 2)\n", + "plt.imshow(example_moving, cmap='gray')\n", + "plt.title('original moving', fontsize=10)\n", + "plt.axis('off')\n", + "\n", + "plt.subplot(1, 4, 3)\n", + "plt.imshow(example_prealigned, cmap='gray')\n", + "plt.title('moving after elastix pre-alignment', fontsize=10)\n", + "plt.axis('off')\n", + "\n", + "plt.subplot(1, 4, 4)\n", + "plt.imshow(example_result, cmap='gray')\n", + "plt.title('final registered', fontsize=10)\n", + "plt.axis('off')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "815e6076-3d65-4a29-9529-63fa713749d9", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 71610a5c557c3fd64ffabcc6d71c900ae14c6d67 Mon Sep 17 00:00:00 2001 From: Konstantinos Ntatsis Date: Tue, 15 Nov 2022 15:24:19 +0100 Subject: [PATCH 2/2] ENH: Update .binder/requirements for MONAI --- .binder/requirements.txt | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.binder/requirements.txt b/.binder/requirements.txt index 690c7f6d..767ff961 100644 --- a/.binder/requirements.txt +++ b/.binder/requirements.txt @@ -5,8 +5,11 @@ imageio ipywidgets>=7.5.1 ipympl>=0.5.7 numpy==1.21.0 +torch>=1.9 +monai>=1.0.1 matplotlib==3.3.1 PyQt5==5.15.0 PyQt5-sip==12.8.0 QtPy==1.9.0 voila +tqdm