From fc7980257b5b09443d3bb90fc571f92bfbe2817d Mon Sep 17 00:00:00 2001 From: Konstantinos Ntatsis Date: Mon, 6 Feb 2023 18:33:36 +0100 Subject: [PATCH] ENH: Add notebook with MONAI-affine and Elastix-bspline --- ...ple18_MONAI_affine_Elastix_nonlinear.ipynb | 572 ++++++++++++++++++ 1 file changed, 572 insertions(+) create mode 100644 examples/ITK_Example18_MONAI_affine_Elastix_nonlinear.ipynb diff --git a/examples/ITK_Example18_MONAI_affine_Elastix_nonlinear.ipynb b/examples/ITK_Example18_MONAI_affine_Elastix_nonlinear.ipynb new file mode 100644 index 00000000..ab2caed0 --- /dev/null +++ b/examples/ITK_Example18_MONAI_affine_Elastix_nonlinear.ipynb @@ -0,0 +1,572 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b974cf01-3d75-4e1b-99d6-bba8b738c92e", + "metadata": {}, + "source": [ + "### 18. MONAI deep learning affine registration and non-linear with ITKElastix" + ] + }, + { + "cell_type": "markdown", + "id": "54fad620-2c6a-4272-8f28-8a6fed7a66e2", + "metadata": {}, + "source": [ + "This notebook shows to perform affine registration with MONAI, convert the resulting affine parameters to a format compatible with Elastix and then further refine the result using Elastix b-splines." + ] + }, + { + "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 Compose, LoadImageD, EnsureChannelFirstD, ScaleIntensityRangeD, Rotate90D, Rand2DElasticD\n", + "from monai.data import CacheDataset, ITKReader, DataLoader, MetaTensor, itk_torch_bridge\n", + "from monai.config import USE_COMPILED\n", + "from monai.networks.nets import DenseNet\n", + "from monai.networks.nets.regunet import AffineHead\n", + "from monai.networks.blocks import Warp\n", + "from monai.apps import MedNISTDataset\n", + "from torch.nn import MSELoss\n", + "\n", + "# Set the random seed to a fixed number, just to ensure that the example always produces the same result \n", + "set_determinism(42)\n", + "\n", + "if torch.cuda.is_available():\n", + " device = \"cuda:0\"\n", + " max_epochs = 100\n", + "else:\n", + " # For the case of running the model in the CPU, we restrict the number of epochs so that it runs in considerable time.\n", + " # However, the final results might look sub-optimal.\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 pairs of fixed and moving images by applying random affine and grid transforms to fixed images." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "624e35ad-50c0-45bf-832a-fc78b784df6e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2023-07-28 16:35:43,039 - INFO - Verified 'MedNIST.tar.gz', md5: 0bc7306e7427e00ad1c5526a6677552d.\n", + "2023-07-28 16:35:43,041 - INFO - File exists: MedNIST.tar.gz, skipped downloading.\n", + "2023-07-28 16:35:43,043 - 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, 84379.40it/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", + "\n", + "# Create training dictionary with only a subset of the whole data\n", + "training_datadict = [\n", + " {\"fixed_hand\": hand, \"moving_hand\": hand}\n", + " for hand in hands[:500]\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "a9bf1ee5", + "metadata": {}, + "outputs": [], + "source": [ + "train_transforms = Compose(\n", + " [\n", + " LoadImageD(keys=[\"fixed_hand\", \"moving_hand\"], image_only=True),\n", + " EnsureChannelFirstD(keys=[\"fixed_hand\", \"moving_hand\"]),\n", + " ScaleIntensityRangeD(keys=[\"fixed_hand\", \"moving_hand\"],\n", + " a_min=0., a_max=255., b_min=0.0, b_max=1.0, clip=True,),\n", + " Rotate90D(keys=[\"fixed_hand\", \"moving_hand\"], k=-1),\n", + " Rand2DElasticD(keys=[\"moving_hand\"], \n", + " spacing=4.0,\n", + " magnitude_range=(0, 1),\n", + " prob=1.0, \n", + " rotate_range=(-0.2, 0.2), \n", + " shear_range=(-0.05, 0.05), \n", + " translate_range=(-15, 15),\n", + " padding_mode=\"zeros\"), \n", + " ]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "092e452a", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading dataset: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 500/500 [00:02<00:00, 246.09it/s]\n" + ] + } + ], + "source": [ + "dataset = CacheDataset(data=training_datadict, transform=train_transforms)\n", + "dataloader = DataLoader(dataset=dataset, batch_size=16, shuffle=True)" + ] + }, + { + "cell_type": "markdown", + "id": "1ded6253", + "metadata": {}, + "source": [ + "### Deep learning registration model" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "1507956f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The model has 127744 trainable parameters.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "monai.networks.blocks.Warp: Using PyTorch native grid_sample.\n" + ] + } + ], + "source": [ + "# Create model\n", + "class AffineRegistrationModel(torch.nn.Module):\n", + " def __init__(self, image_size):\n", + " super().__init__()\n", + " self.densenet = DenseNet(\n", + " spatial_dims=2, \n", + " in_channels=2, \n", + " out_channels=6, \n", + " init_features=16, \n", + " growth_rate=6,\n", + " block_config=(6, 12, 18)).to(device)\n", + " \n", + " # Init fully connected layer\n", + " self.densenet.class_layers.out.weight.data.zero_()\n", + " self.densenet.class_layers.out.bias.data.copy_(torch.tensor([1, 0, 0, 0, 1, 0], dtype=torch.float))\n", + "\n", + " # Grid\n", + " self.grid = AffineHead.get_reference_grid(image_size).to(device=device)\n", + " \n", + " def affine_transform(self, theta):\n", + " grid_padded = torch.cat([self.grid, torch.ones_like(self.grid[:1])])\n", + " grid_warped = torch.einsum(\"qij,bpq->bpij\", grid_padded, theta.reshape(-1, 2, 3))\n", + " return grid_warped\n", + " \n", + " def forward(self, x):\n", + " theta = self.densenet(x)\n", + " out = self.affine_transform(theta) - self.grid\n", + " return out, theta\n", + "\n", + "model = AffineRegistrationModel(image_size=(64, 64))\n", + "criterion = MSELoss()\n", + "optimizer = torch.optim.Adam(model.parameters(), 1e-5)\n", + "\n", + "if USE_COMPILED:\n", + " # Use experimental resampler under the hood \n", + " # (see: https://github.com/Project-MONAI/MONAI/discussions/4505#discussioncomment-2953180)\n", + " warp_layer = Warp(3, \"border\").to(device)\n", + "else:\n", + " # Using the standard MONAI resampler\n", + " warp_layer = Warp(\"bilinear\", \"border\").to(device)\n", + "\n", + "def count_parameters(model):\n", + " return sum(p.numel() for p in model.parameters() if p.requires_grad)\n", + " \n", + "print(f\"The model has {count_parameters(model)} trainable parameters.\")" + ] + }, + { + "cell_type": "markdown", + "id": "bad6e77e", + "metadata": {}, + "source": [ + "### Training loop" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "22d393a0", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 100/100 [07:57<00:00, 4.78s/it]\n" + ] + } + ], + "source": [ + "epoch_loss_values = []\n", + "model.train()\n", + "\n", + "for epoch in tqdm(range(max_epochs)):\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[\"moving_hand\"].to(device)\n", + " \n", + " ddf, theta = model(torch.cat((pre_aligned, fixed), dim=1))\n", + " pred_image = warp_layer(pre_aligned, ddf)\n", + "\n", + " loss = criterion(pred_image, fixed)\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)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "e0b15ac0", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "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": "code", + "execution_count": 8, + "id": "0230d9a8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Show examples of the pre-alignment using MONAI\n", + "ind = 2\n", + "fixed = batch_data['fixed_hand'][ind].squeeze().numpy()\n", + "moving = batch_data['moving_hand'][ind].squeeze().numpy()\n", + "aligned = pred_image[ind].squeeze().detach().cpu().numpy()\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 MONAI pre-alignment', fontsize=10)\n", + "plt.axis('off')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "9bfd4df4", + "metadata": {}, + "source": [ + "### Convert MONAI affine parameters to ITK Affine Transform" + ] + }, + { + "cell_type": "markdown", + "id": "a79df45b-967c-4313-8f98-e06ac9075728", + "metadata": {}, + "source": [ + "We convert the computed MONAI affine transform to an ITK transform using the utility function `monai.data.itk_torch_bridge`, and then pass it as initial transform to itk-elastix (requires >0.17.3 version)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "bb332ee3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AffineTransform (00000211A505A5F0)\n", + " RTTI typeinfo: class itk::AffineTransform\n", + " Reference Count: 1\n", + " Modified Time: 38\n", + " Debug: Off\n", + " Object Name: \n", + " Observers: \n", + " none\n", + " Matrix: \n", + " 1.05321 0.0656178 \n", + " 0.00755561 0.920415 \n", + " Offset: [-3.6547, 2.27981]\n", + " Center: [31.5, 31.5]\n", + " Translation: [0.0883499, 0.0108792]\n", + " Inverse: \n", + " 0.949965 -0.0677244 \n", + " -0.00779819 1.08702 \n", + " Singular: 0\n", + "\n" + ] + } + ], + "source": [ + "# Convert the output of the model to a 3x3 affine matrix\n", + "monai_affine_matrix = torch.eye(3, dtype=torch.float64)\n", + "monai_affine_matrix[:2, :] = theta.reshape(-1, 2, 3).detach().cpu()[ind]\n", + "\n", + "# Convert the tensors to ITK images. NOTE: We use the util function metatensor_to_itk_image() because\n", + "# it also does the necessary transposition of the images.\n", + "fixed_image = itk_torch_bridge.metatensor_to_itk_image(MetaTensor(batch_data['fixed_hand'][ind]))\n", + "moving_image = itk_torch_bridge.metatensor_to_itk_image(MetaTensor(batch_data['moving_hand'][ind]))\n", + "\n", + "# Convert MONAI affine matrix to ITK\n", + "matrix, translation = itk_torch_bridge.monai_to_itk_affine(moving_image, affine_matrix=monai_affine_matrix)\n", + "\n", + "# Affine transform\n", + "itk_transform = itk.AffineTransform[itk.D, moving_image.ndim].New()\n", + "\n", + "# Set center\n", + "itk_transform.SetCenter(itk_torch_bridge.get_itk_image_center(moving_image))\n", + "\n", + "# Set matrix and translation\n", + "itk_transform.SetMatrix(itk.matrix_from_array(matrix))\n", + "itk_transform.Translate(translation)\n", + "\n", + "print(itk_transform)" + ] + }, + { + "cell_type": "markdown", + "id": "816e3d5f", + "metadata": {}, + "source": [ + "### Refine MONAI result with Elastix registration" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "fa3ee1e4", + "metadata": {}, + "outputs": [], + "source": [ + "# B-spline parameter object\n", + "parameter_object = itk.ParameterObject()\n", + "parameter_map = parameter_object.GetDefaultParameterMap('bspline')\n", + "parameter_object.AddParameterMap(parameter_map)\n", + "\n", + "result_image, _ = itk.elastix_registration_method(fixed_image, \n", + " moving_image, \n", + " parameter_object=parameter_object,\n", + " initial_transform=itk_transform,\n", + " log_to_console=False)\n", + "\n", + "result = np.asarray(result_image).T" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "78eeaa2c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Show previous results together with final result from Elastix\n", + "fig = plt.figure(figsize=(14, 6))\n", + "plt.subplot(1, 4, 1)\n", + "plt.imshow(fixed.squeeze(), cmap='gray')\n", + "plt.title('fixed', fontsize=10)\n", + "plt.axis('off')\n", + "\n", + "plt.subplot(1, 4, 2)\n", + "plt.imshow(moving.squeeze(), cmap='gray')\n", + "plt.title('original moving', fontsize=10)\n", + "plt.axis('off')\n", + "\n", + "plt.subplot(1, 4, 3)\n", + "plt.imshow(aligned.squeeze(), cmap='gray')\n", + "plt.title('moving after MONAI pre-alignment', fontsize=10)\n", + "plt.axis('off')\n", + "\n", + "plt.subplot(1, 4, 4)\n", + "plt.imshow(result, cmap='gray')\n", + "plt.title('MONAI pre + Elastix refinement', fontsize=10)\n", + "plt.axis('off')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "2a66dfd4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MSE moving: 0.1083\n", + "MSE MONAI: 0.0832\n", + "MSE MONAI+Elastix: 0.0129\n" + ] + } + ], + "source": [ + "# Perform numerical comparison using the mean square error (MSE)\n", + "MSE_moving = criterion(torch.tensor(fixed).unsqueeze(0), torch.tensor(moving).unsqueeze(0))\n", + "MSE_monai_aligned = criterion(torch.tensor(fixed).unsqueeze(0), torch.tensor(aligned).unsqueeze(0))\n", + "MSE_monai_and_elastix = criterion(torch.tensor(fixed).unsqueeze(0), torch.tensor(result).unsqueeze(0))\n", + "\n", + "print(\"MSE moving: {:.4f}\".format(MSE_moving))\n", + "print(\"MSE MONAI: {:.4f}\".format(MSE_monai_aligned))\n", + "print(\"MSE MONAI+Elastix: {:.4f}\".format(MSE_monai_and_elastix))" + ] + }, + { + "cell_type": "markdown", + "id": "b4d6580a-7507-4e90-b8f5-321576a3ea96", + "metadata": {}, + "source": [ + "### Conclusion" + ] + }, + { + "cell_type": "markdown", + "id": "1c47a50b-375f-4446-8a9e-0da802603ef2", + "metadata": {}, + "source": [ + "We observe that the MSE after the Elastix refinement is lower than when registering only using MONAI. The images above indicate the same result but in a qualitative manner." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a84fc608-c796-4b7b-a91c-2fa740081375", + "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.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}