From 88641b27075c6780d159362fad32eb429bb3a203 Mon Sep 17 00:00:00 2001 From: Eric Kerfoot Date: Thu, 5 Oct 2023 14:12:55 +0100 Subject: [PATCH 01/13] Segmentation template Signed-off-by: Eric Kerfoot --- models/segmentation_template/LICENSE | 21 ++ .../configs/inference.yaml | 110 +++++++++ .../configs/logging.conf | 21 ++ .../configs/metadata.json | 59 +++++ .../segmentation_template/configs/test.yaml | 173 +++++++++++++ .../segmentation_template/configs/train.yaml | 232 ++++++++++++++++++ models/segmentation_template/docs/README.md | 4 + .../docs/generate_data.ipynb | 193 +++++++++++++++ .../segmentation_template/docs/inference.sh | 19 ++ models/segmentation_template/docs/train.sh | 19 ++ .../docs/visualise_inference.ipynb | 126 ++++++++++ 11 files changed, 977 insertions(+) create mode 100644 models/segmentation_template/LICENSE create mode 100644 models/segmentation_template/configs/inference.yaml create mode 100644 models/segmentation_template/configs/logging.conf create mode 100644 models/segmentation_template/configs/metadata.json create mode 100644 models/segmentation_template/configs/test.yaml create mode 100644 models/segmentation_template/configs/train.yaml create mode 100644 models/segmentation_template/docs/README.md create mode 100644 models/segmentation_template/docs/generate_data.ipynb create mode 100644 models/segmentation_template/docs/inference.sh create mode 100644 models/segmentation_template/docs/train.sh create mode 100644 models/segmentation_template/docs/visualise_inference.ipynb diff --git a/models/segmentation_template/LICENSE b/models/segmentation_template/LICENSE new file mode 100644 index 00000000..5a2a4c0f --- /dev/null +++ b/models/segmentation_template/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2023 MONAI Consortium + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/models/segmentation_template/configs/inference.yaml b/models/segmentation_template/configs/inference.yaml new file mode 100644 index 00000000..506b3356 --- /dev/null +++ b/models/segmentation_template/configs/inference.yaml @@ -0,0 +1,110 @@ +imports: +- $import os +- $import torch +- $import glob + +# pull out some constants from MONAI +image: $monai.utils.CommonKeys.IMAGE +pred: $monai.utils.CommonKeys.PRED + +# hyperparameters for you to modify on the command line +batch_size: 1 # number of images per batch +num_workers: 0 # number of workers to generate batches with +num_classes: 4 # number of classes in training data which network should predict +device: $torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') + +# define various paths +bundle_root: . # root directory of the bundle +ckpt_path: $@bundle_root + '/models/model.pt' # checkpoint to load before starting +dataset_dir: $@bundle_root + '/test_data' # where data is coming from +output_dir: './outputs' # directory to store images to + +# network definition, this could be parameterised by pre-defined values or on the command line +network_def: + _target_: UNet + spatial_dims: 3 + in_channels: 1 + out_channels: '@num_classes' + channels: [8, 16, 32, 64] + strides: [2, 2, 2] + num_res_units: 2 +network: $@network_def.to(@device) + +# list all niftis in the input directory +file_pattern: '*.nii*' +data_list: '$list(sorted(glob.glob(os.path.join(@dataset_dir, @file_pattern))))' +# collect data dictionaries for all files +data_dicts: '$[{@image:i} for i in @data_list]' + +# these transforms are used for inference to load and regularise inputs +transforms: +- _target_: LoadImaged + keys: '@image' + image_only: true +- _target_: EnsureChannelFirstd + keys: '@image' +- _target_: ScaleIntensityd + keys: '@image' + +preprocessing: + _target_: Compose + transforms: $@transforms + +dataset: + _target_: Dataset + data: '@data_dicts' + transform: '@preprocessing' + +dataloader: + _target_: ThreadDataLoader # generate data ansynchronously from inference + dataset: '@dataset' + batch_size: '@batch_size' + num_workers: '@num_workers' + +# should be replaced with other inferer types if training process is different for your network +inferer: + _target_: SimpleInferer + +# transform to apply to data from network to be suitable for loss function and validation +postprocessing: + _target_: Compose + transforms: + - _target_: Activationsd + keys: '@pred' + softmax: true + - _target_: AsDiscreted + keys: '@pred' + argmax: true + - _target_: SaveImaged + keys: '@pred' + meta_keys: pred_meta_dict + data_root_dir: '@dataset_dir' + output_dir: '@output_dir' + dtype: $None + output_dtype: $None + output_postfix: '' + resample: false + separate_folder: true + +# inference handlers to load checkpoint, gather statistics +handlers: +- _target_: CheckpointLoader + _disabled_: $not os.path.exists(@ckpt_path) + load_path: '@ckpt_path' + load_dict: + model: '@network' +- _target_: StatsHandler + name: null # use engine.logger as the Logger object to log to + output_transform: '$lambda x: None' + +# engine for running inference, ties together objects defined above and has metric definitions +evaluator: + _target_: SupervisedEvaluator + device: '@device' + val_data_loader: '@dataloader' + network: '@network' + postprocessing: '@postprocessing' + val_handlers: '@handlers' + +run: +- $@evaluator.run() diff --git a/models/segmentation_template/configs/logging.conf b/models/segmentation_template/configs/logging.conf new file mode 100644 index 00000000..91c1a21c --- /dev/null +++ b/models/segmentation_template/configs/logging.conf @@ -0,0 +1,21 @@ +[loggers] +keys=root + +[handlers] +keys=consoleHandler + +[formatters] +keys=fullFormatter + +[logger_root] +level=INFO +handlers=consoleHandler + +[handler_consoleHandler] +class=StreamHandler +level=INFO +formatter=fullFormatter +args=(sys.stdout,) + +[formatter_fullFormatter] +format=%(asctime)s - %(name)s - %(levelname)s - %(message)s diff --git a/models/segmentation_template/configs/metadata.json b/models/segmentation_template/configs/metadata.json new file mode 100644 index 00000000..8ad534cc --- /dev/null +++ b/models/segmentation_template/configs/metadata.json @@ -0,0 +1,59 @@ +{ + "version": "0.0.1", + "changelog": { + "0.0.1": "Initial version" + }, + "monai_version": "1.3.0", + "pytorch_version": "2.0.1", + "numpy_version": "1.25.2", + "optional_packages_version": {}, + "task": "Segmentation of randomly generated spheres in 3D images", + "description": "This is a template bundle for segmenting in 3D, take this as a basis for your own bundles.", + "authors": "Eric Kerfoot", + "copyright": "Copyright (c) 2023 MONAI Consortium", + "network_data_format": { + "inputs": { + "image": { + "type": "image", + "format": "magnitude", + "modality": "MR", + "num_channels": 1, + "spatial_shape": [ + 128, + 128, + 128 + ], + "dtype": "float32", + "value_range": [], + "is_patch_data": false, + "channel_def": { + "0": "image" + } + } + }, + "outputs": { + "pred": { + "type": "image", + "format": "segmentation", + "num_channels": 4, + "spatial_shape": [ + 128, + 128, + 128 + ], + "dtype": "float32", + "value_range": [ + 0, + 3 + ], + "is_patch_data": false, + "channel_def": { + "0": "background", + "1": "category 1", + "2": "category 1", + "3": "category 1" + } + } + } + } +} \ No newline at end of file diff --git a/models/segmentation_template/configs/test.yaml b/models/segmentation_template/configs/test.yaml new file mode 100644 index 00000000..e2b43641 --- /dev/null +++ b/models/segmentation_template/configs/test.yaml @@ -0,0 +1,173 @@ +imports: +- $import os +- $import datetime +- $import torch +- $import glob + +# pull out some constants from MONAI +image: $monai.utils.CommonKeys.IMAGE +label: $monai.utils.CommonKeys.LABEL +pred: $monai.utils.CommonKeys.PRED +both_keys: ['@image', '@label'] + +# hyperparameters for you to modify on the command line +batch_size: 1 # number of images per batch +num_workers: 0 # number of workers to generate batches with +num_classes: 4 # number of classes in training data which network should predict +device: $torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') + +# define various paths +bundle_root: . # root directory of the bundle +ckpt_path: $@bundle_root + '/models/model.pt' # checkpoint to load before starting +dataset_dir: $@bundle_root + '/test_data' # where data is coming from +output_dir: './outputs' # directory to store images to + +# network definition, this could be parameterised by pre-defined values or on the command line +network_def: + _target_: UNet + spatial_dims: 3 + in_channels: 1 + out_channels: '@num_classes' + channels: [8, 16, 32, 64] + strides: [2, 2, 2] + num_res_units: 2 +network: $@network_def.to(@device) + +# dataset value, this assumes a directory filled with img##.nii.gz and lbl##.nii.gz files +imgs: '$sorted(glob.glob(@dataset_dir+''/img*.nii.gz''))' +lbls: '$[i.replace(''img'',''lbl'') for i in @imgs]' +all_pairs: '$[{@image: i, @label: l} for i, l in zip(@imgs, @lbls)]' + +# these transforms are used for training and validation transform sequences +transforms: +- _target_: LoadImaged + keys: '@both_keys' + image_only: true +- _target_: EnsureChannelFirstd + keys: '@both_keys' +- _target_: ScaleIntensityd + keys: '@image' + +# define the Compose objects for training and validation + +preprocessing: + _target_: Compose + transforms: $@transforms + +# define the datasets for training and validation + +dataset: + _target_: Dataset + data: '@all_pairs' + transform: '@preprocessing' + +# define the dataloaders for training and validation + +dataloader: + _target_: ThreadDataLoader # generate data ansynchronously from training + dataset: '@dataset' + batch_size: '@batch_size' + num_workers: '@num_workers' + +# should be replaced with other inferer types if training process is different for your network +inferer: + _target_: SimpleInferer + +# transform to apply to data from network to be suitable for loss function and validation +postprocessing: + _target_: Compose + transforms: + - _target_: Activationsd + keys: '@pred' + softmax: true + - _target_: AsDiscreted + keys: ['@pred', '@label'] + argmax: [true, false] + to_onehot: '@num_classes' + +# validation handlers to gather statistics, log these to a file, and save best checkpoint +val_handlers: +- _target_: StatsHandler + name: null # use engine.logger as the Logger object to log to + output_transform: '$lambda x: None' +- _target_: LogfileHandler # log outputs from the validation engine + output_dir: '@output_dir' +- _target_: CheckpointSaver + save_dir: '@output_dir' + save_dict: + model: '@network' + save_interval: 0 # don't save iterations, just when the metric improves + save_final: false + epoch_level: false + save_key_metric: true + key_metric_name: val_mean_dice # save the checkpoint when this value improves + +# engine for running validation, ties together objects defined above and has metric definitions +evaluator: + _target_: SupervisedEvaluator + device: '@device' + val_data_loader: '@val_dataloader' + network: '@network' + postprocessing: '@postprocessing' + key_val_metric: + val_mean_dice: + _target_: MeanDice + include_background: false + output_transform: $monai.handlers.from_engine([@pred, @label]) + val_mean_iou: + _target_: MeanIoUHandler + include_background: false + output_transform: $monai.handlers.from_engine([@pred, @label]) + additional_metrics: + val_mae: # can have other metrics, MAE not great for segmentation tasks so here just to demo + _target_: MeanAbsoluteError + output_transform: $monai.handlers.from_engine([@pred, @label]) + val_handlers: '@val_handlers' + +# gathers the loss and validation values for each iteration, referred to by CheckpointSaver so defined separately +metriclogger: + _target_: MetricLogger + evaluator: '@evaluator' + +handlers: +- '@metriclogger' +- _target_: CheckpointLoader + _disabled_: $not os.path.exists(@ckpt_path) + load_path: '@ckpt_path' + load_dict: + model: '@network' +- _target_: ValidationHandler # run validation at the set interval, bridge between trainer and evaluator objects + validator: '@evaluator' + epoch_level: true + interval: '@val_interval' +- _target_: CheckpointSaver + save_dir: '@output_dir' + save_dict: # every epoch checkpoint saves the network and the metric logger in a dictionary + model: '@network' + logger: '@metriclogger' + save_interval: '@ckpt_interval' + save_final: true + epoch_level: true +- _target_: StatsHandler + name: null # use engine.logger as the Logger object to log to + tag_name: train_loss + output_transform: $monai.handlers.from_engine(['loss'], first=True) # log loss value +- _target_: LogfileHandler # log outputs from the training engine + output_dir: '@output_dir' + +# engine for training, ties values defined above together into the main engine for the training process +trainer: + _target_: SupervisedTrainer + max_epochs: '@num_epochs' + device: '@device' + train_data_loader: '@train_dataloader' + network: '@network' + inferer: '@inferer' # unnecessary since SimpleInferer is the default if this isn't provided + loss_function: '@lossfn' + optimizer: '@optimizer' + postprocessing: '@postprocessing' + key_train_metric: null + train_handlers: '@handlers' + +run: +- $@trainer.run() diff --git a/models/segmentation_template/configs/train.yaml b/models/segmentation_template/configs/train.yaml new file mode 100644 index 00000000..edf62c7e --- /dev/null +++ b/models/segmentation_template/configs/train.yaml @@ -0,0 +1,232 @@ +imports: +- $import os +- $import datetime +- $import torch +- $import glob + +# pull out some constants from MONAI +image: $monai.utils.CommonKeys.IMAGE +label: $monai.utils.CommonKeys.LABEL +pred: $monai.utils.CommonKeys.PRED +both_keys: ['@image', '@label'] + +# hyperparameters for you to modify on the command line +val_interval: 1 # how often to perform validation after an epoch +ckpt_interval: 1 # how often to save a checkpoint after an epoch +rand_prob: 0.5 # probability a random transform is applied +batch_size: 5 # number of images per batch +num_epochs: 20 # number of epochs to train for +num_substeps: 1 # how many times to repeatly train with the same batch +num_workers: 4 # number of workers to generate batches with +learning_rate: 0.001 # initial learning rate +num_classes: 4 # number of classes in training data which network should predict +device: $torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') + +# define various paths +bundle_root: . # root directory of the bundle +ckpt_path: $@bundle_root + '/models/model.pt' # checkpoint to load before starting +dataset_dir: $@bundle_root + '/train_data' # where data is coming from +results_dir: $@bundle_root + '/results' # where results are being stored to +# a new output directory is chosen using a timestamp for every invocation +output_dir: '$datetime.datetime.now().strftime(@results_dir + ''/output_%y%m%d_%H%M%S'')' + +# network definition, this could be parameterised by pre-defined values or on the command line +network_def: + _target_: UNet + spatial_dims: 3 + in_channels: 1 + out_channels: '@num_classes' + channels: [8, 16, 32, 64] + strides: [2, 2, 2] + num_res_units: 2 +network: $@network_def.to(@device) + +# dataset value, this assumes a directory filled with img##.nii.gz and lbl##.nii.gz files +imgs: '$sorted(glob.glob(@dataset_dir+''/img*.nii.gz''))' +lbls: '$[i.replace(''img'',''lbl'') for i in @imgs]' +all_pairs: '$[{@image: i, @label: l} for i, l in zip(@imgs, @lbls)]' +partitions: '$monai.data.partition_dataset(@all_pairs, (4, 1), shuffle=True, seed=0)' +train_sub: '$@partitions[0]' # train partition +val_sub: '$@partitions[1]' # validation partition + +# these transforms are used for training and validation transform sequences +base_transforms: +- _target_: LoadImaged + keys: '@both_keys' + image_only: true +- _target_: EnsureChannelFirstd + keys: '@both_keys' + +# these are the random and regularising transforms used only for training +train_transforms: +- _target_: RandAxisFlipd + keys: '@both_keys' + prob: '@rand_prob' +- _target_: RandRotate90d + keys: '@both_keys' + prob: '@rand_prob' +- _target_: RandGaussianNoised + keys: '@image' + prob: '@rand_prob' + std: 0.05 +- _target_: ScaleIntensityd + keys: '@image' + +# these are used for validation data so no randomness +val_transforms: +- _target_: ScaleIntensityd + keys: '@image' + +# define the Compose objects for training and validation + +preprocessing: + _target_: Compose + transforms: $@base_transforms + @train_transforms + +val_preprocessing: + _target_: Compose + transforms: $@base_transforms + @val_transforms + +# define the datasets for training and validation + +train_dataset: + _target_: Dataset + data: '@train_sub' + transform: '@preprocessing' + +val_dataset: + _target_: Dataset + data: '@val_sub' + transform: '@val_preprocessing' + +# define the dataloaders for training and validation + +train_dataloader: + _target_: ThreadDataLoader # generate data ansynchronously from training + dataset: '@train_dataset' + batch_size: '@batch_size' + repeats: '@num_substeps' + num_workers: '@num_workers' + +val_dataloader: + _target_: DataLoader # faster transforms probably won't benefit from threading + dataset: '@val_dataset' + batch_size: '@batch_size' + num_workers: '@num_workers' + +# Simple Dice loss configured for multi-class segmentation, for binary segmentation +# use include_background==True and sigmoid==True instead of these values +lossfn: + _target_: DiceLoss + include_background: false + to_onehot_y: true + softmax: true + +# hyperparameters could be added for other arguments of this class +optimizer: + _target_: torch.optim.Adam + params: $@network.parameters() + lr: '@learning_rate' + +# should be replaced with other inferer types if training process is different for your network +inferer: + _target_: SimpleInferer + +# transform to apply to data from network to be suitable for loss function and validation +postprocessing: + _target_: Compose + transforms: + - _target_: Activationsd + keys: '@pred' + softmax: true + - _target_: AsDiscreted + keys: ['@pred', '@label'] + argmax: [true, false] + to_onehot: '@num_classes' + +# validation handlers to gather statistics, log these to a file, and save best checkpoint +val_handlers: +- _target_: StatsHandler + name: null # use engine.logger as the Logger object to log to + output_transform: '$lambda x: None' +- _target_: LogfileHandler # log outputs from the validation engine + output_dir: '@output_dir' +- _target_: CheckpointSaver + save_dir: '@output_dir' + save_dict: + model: '@network' + save_interval: 0 # don't save iterations, just when the metric improves + save_final: false + epoch_level: false + save_key_metric: true + key_metric_name: val_mean_dice # save the checkpoint when this value improves + +# engine for running validation, ties together objects defined above and has metric definitions +evaluator: + _target_: SupervisedEvaluator + device: '@device' + val_data_loader: '@val_dataloader' + network: '@network' + postprocessing: '@postprocessing' + key_val_metric: + val_mean_dice: + _target_: MeanDice + include_background: false + output_transform: $monai.handlers.from_engine([@pred, @label]) + val_mean_iou: + _target_: MeanIoUHandler + include_background: false + output_transform: $monai.handlers.from_engine([@pred, @label]) + additional_metrics: + val_mae: # can have other metrics, MAE not great for segmentation tasks so here just to demo + _target_: MeanAbsoluteError + output_transform: $monai.handlers.from_engine([@pred, @label]) + val_handlers: '@val_handlers' + +# gathers the loss and validation values for each iteration, referred to by CheckpointSaver so defined separately +metriclogger: + _target_: MetricLogger + evaluator: '@evaluator' + +handlers: +- '@metriclogger' +- _target_: CheckpointLoader + _disabled_: $not os.path.exists(@ckpt_path) + load_path: '@ckpt_path' + load_dict: + model: '@network' +- _target_: ValidationHandler # run validation at the set interval, bridge between trainer and evaluator objects + validator: '@evaluator' + epoch_level: true + interval: '@val_interval' +- _target_: CheckpointSaver + save_dir: '@output_dir' + save_dict: # every epoch checkpoint saves the network and the metric logger in a dictionary + model: '@network' + logger: '@metriclogger' + save_interval: '@ckpt_interval' + save_final: true + epoch_level: true +- _target_: StatsHandler + name: null # use engine.logger as the Logger object to log to + tag_name: train_loss + output_transform: $monai.handlers.from_engine(['loss'], first=True) # log loss value +- _target_: LogfileHandler # log outputs from the training engine + output_dir: '@output_dir' + +# engine for training, ties values defined above together into the main engine for the training process +trainer: + _target_: SupervisedTrainer + max_epochs: '@num_epochs' + device: '@device' + train_data_loader: '@train_dataloader' + network: '@network' + inferer: '@inferer' # unnecessary since SimpleInferer is the default if this isn't provided + loss_function: '@lossfn' + optimizer: '@optimizer' + postprocessing: '@postprocessing' + key_train_metric: null + train_handlers: '@handlers' + +run: +- $@trainer.run() diff --git a/models/segmentation_template/docs/README.md b/models/segmentation_template/docs/README.md new file mode 100644 index 00000000..140e5e72 --- /dev/null +++ b/models/segmentation_template/docs/README.md @@ -0,0 +1,4 @@ + +# Template Segmentation Bundle + +This bundle is meant to be an example of segmentation in 3D which you can copy and modify to create your own bundle. diff --git a/models/segmentation_template/docs/generate_data.ipynb b/models/segmentation_template/docs/generate_data.ipynb new file mode 100644 index 00000000..2bcb208d --- /dev/null +++ b/models/segmentation_template/docs/generate_data.ipynb @@ -0,0 +1,193 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b1c9de9d-6777-4a1d-bb7c-c2413d01bd7d", + "metadata": {}, + "source": [ + "# Generate Data\n", + "\n", + "This bundle uses simple synthetic data for training and testing. Using `create_test_image_3d` we'll create images of spheres with labels for each divided into 3 classes distinguished by intensity. The network will be able to train very quickly on this of course but it's for demonstration purposes and your specialised bundle will by modified for your data and its layout. \n", + "\n", + "First imports:" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "1e7cb4a8-f91a-4f15-a8aa-3136c2b954d6", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import os\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import nibabel as nib\n", + "import numpy as np\n", + "from monai.data import create_test_image_3d\n", + "\n", + "plt.rcParams[\"image.interpolation\"] = \"none\"" + ] + }, + { + "cell_type": "markdown", + "id": "2b2c3de5-01e5-4578-832b-b24a75d095d5", + "metadata": {}, + "source": [ + "As shown here, the images are spheres in a 3D volume with associated labels:" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "775be24b-3400-4e28-9cce-3c47ee796517", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(128, 128, 128) float32 (128, 128, 128) int32\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "img, lbl = create_test_image_3d(128, 128, 128, 4, num_seg_classes=3, noise_max=0.5)\n", + "\n", + "print(img.shape, img.dtype, lbl.shape, lbl.dtype)\n", + "\n", + "_, (ax0, ax1) = plt.subplots(1, 2)\n", + "ax0.imshow(np.average(img, 0), cmap=\"gray\")\n", + "ax1.imshow(np.max(lbl, 0), cmap=\"jet\")" + ] + }, + { + "cell_type": "markdown", + "id": "8e08c4a1-6630-4ab3-832b-e53face81e35", + "metadata": {}, + "source": [ + "50 image/label pairs are now generated into the directory `../data`, assuming this notebook is run from the `docs` directory this will be in the bundle root:" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "1c7e0188-e0a1-48fc-8249-d09a9cc466e3", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "num_images = 50\n", + "out_dir = os.path.abspath(\"../train_data\")\n", + "\n", + "os.makedirs(out_dir, exist_ok=True)\n", + "\n", + "for i in range(num_images):\n", + " img, lbl = create_test_image_3d(128, 128, 128, 4, num_seg_classes=3, noise_max=0.5)\n", + " n = nib.Nifti1Image(img, np.eye(4))\n", + " nib.save(n, os.path.join(out_dir, f\"img{i:02}.nii.gz\"))\n", + " n = nib.Nifti1Image(lbl, np.eye(4))\n", + " nib.save(n, os.path.join(out_dir, f\"lbl{i:02}.nii.gz\"))" + ] + }, + { + "cell_type": "markdown", + "id": "7fe344f7-d01d-49d5-adca-a7071939ca53", + "metadata": {}, + "source": [ + "We'll also generate some test data in a separate folder:" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "c3b8d8f3-8d73-4657-98f3-5605d4b1bad9", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "num_images = 10\n", + "out_dir = os.path.abspath(\"../test_data\")\n", + "\n", + "os.makedirs(out_dir, exist_ok=True)\n", + "\n", + "for i in range(num_images):\n", + " img, lbl = create_test_image_3d(128, 128, 128, 4, num_seg_classes=3, noise_max=0.5)\n", + " n = nib.Nifti1Image(img, np.eye(4))\n", + " nib.save(n, os.path.join(out_dir, f\"img{i:02}.nii.gz\"))\n", + " n = nib.Nifti1Image(lbl, np.eye(4))\n", + " nib.save(n, os.path.join(out_dir, f\"lbl{i:02}.nii.gz\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "id": "599cff25-4894-481b-aec3-6aedda327a09", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "img00.nii.gz img04.nii.gz img08.nii.gz lbl02.nii.gz\tlbl06.nii.gz\n", + "img01.nii.gz img05.nii.gz img09.nii.gz lbl03.nii.gz\tlbl07.nii.gz\n", + "img02.nii.gz img06.nii.gz lbl00.nii.gz lbl04.nii.gz\tlbl08.nii.gz\n", + "img03.nii.gz img07.nii.gz lbl01.nii.gz lbl05.nii.gz\tlbl09.nii.gz\n" + ] + } + ], + "source": [ + "!ls {out_dir}" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:monai1]", + "language": "python", + "name": "conda-env-monai1-py" + }, + "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.18" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/models/segmentation_template/docs/inference.sh b/models/segmentation_template/docs/inference.sh new file mode 100644 index 00000000..7ce03cd5 --- /dev/null +++ b/models/segmentation_template/docs/inference.sh @@ -0,0 +1,19 @@ +#! /bin/bash + +eval "$(conda shell.bash hook)" +conda activate monai + +homedir="$( cd -P "$( dirname "${BASH_SOURCE[0]}" )" && pwd )" + +BUNDLE="$(cd "$homedir/.." && pwd)" + +echo "Bundle root: $BUNDLE" + +export PYTHONPATH="$BUNDLE" + +python -m monai.bundle run \ + --meta_file "$BUNDLE/configs/metadata.json" \ + --config_file "$BUNDLE/configs/inference.yaml" \ + --bundle_root "$BUNDLE" \ + $@ + \ No newline at end of file diff --git a/models/segmentation_template/docs/train.sh b/models/segmentation_template/docs/train.sh new file mode 100644 index 00000000..57e0d84a --- /dev/null +++ b/models/segmentation_template/docs/train.sh @@ -0,0 +1,19 @@ +#! /bin/bash + +eval "$(conda shell.bash hook)" +conda activate monai + +homedir="$( cd -P "$( dirname "${BASH_SOURCE[0]}" )" && pwd )" + +BUNDLE="$(cd "$homedir/.." && pwd)" + +echo "Bundle root: $BUNDLE" + +export PYTHONPATH="$BUNDLE" + +python -m monai.bundle run \ + --meta_file "$BUNDLE/configs/metadata.json" \ + --config_file "$BUNDLE/configs/train.yaml" \ + --bundle_root "$BUNDLE" \ + $@ + \ No newline at end of file diff --git a/models/segmentation_template/docs/visualise_inference.ipynb b/models/segmentation_template/docs/visualise_inference.ipynb new file mode 100644 index 00000000..1f674cd3 --- /dev/null +++ b/models/segmentation_template/docs/visualise_inference.ipynb @@ -0,0 +1,126 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "f11e0dff-f19c-4f49-a430-4a5fbf8f42e7", + "metadata": {}, + "source": [ + "# Visualising Results\n", + "\n", + "In this notebook we'll run inference with a trained instance of the network and look at the results. This assumes you have trained weights already or have downloaded those for the bundle. Below we run the command line to invoke inference and produce segmentation images in an output directory. This assumes a number of things:\n", + "\n", + "* The dataset directory `test_data` exists and contains images and their labels.\n", + "* We only want to run inference of the images and not the labels so the file pattern is set to match only those.\n", + "* The output directory is `output` and will have results in separate subdirectories.\n", + "* The checkpoint path is provided to a pre-trained weight file, if this is omitted `$BUNDLE/models/model.py` is used instead." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3a5cde0f-1305-4cd2-af5f-2be63809c073", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "%%bash\n", + "\n", + "# assumes we're running in the docs directory\n", + "cd ..\n", + "\n", + "BUNDLE=\"$(pwd)\"\n", + "# change this to your checkpoint file\n", + "CKPT='$BUNDLE/results/output_231004_163050/model_key_metric=0.5544.pt'\n", + "\n", + "export PYTHONPATH=\"$BUNDLE\"\n", + "\n", + "python -m monai.bundle run \\\n", + " --meta_file \"$BUNDLE/configs/metadata.json\" \\\n", + " --config_file \"$BUNDLE/configs/inference.yaml\" \\\n", + " --bundle_root \"$BUNDLE\" \\\n", + " --dataset_dir \"$BUNDLE/test_data\" \\\n", + " --output_dir \"$BUNDLE/output\" \\\n", + " --file_pattern 'img*.nii.gz' \\\n", + " --ckpt_path \"$CKPT\"" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "308e8fd2-8fdc-4cb2-9b92-506f8b3b58a7", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(128, 128, 128) (128, 128, 128) (128, 128, 128)\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import nibabel as nib\n", + "\n", + "plt.rcParams[\"image.interpolation\"] = \"none\"\n", + "\n", + "img_orig=nib.load(\"../test_data/img01.nii.gz\").get_fdata()\n", + "lbl_orig=nib.load(\"../test_data/lbl01.nii.gz\").get_fdata()\n", + "pred=nib.load(\"../output/img01/img01.nii.gz\").get_fdata()\n", + "\n", + "print(img_orig.shape,lbl_orig.shape, pred.shape)\n", + "\n", + "_,(ax0,ax1,ax2)=plt.subplots(1,3,figsize=(10,10))\n", + "\n", + "ax0.imshow(np.average(img_orig, 0), cmap=\"gray\")\n", + "ax1.imshow(np.max(lbl_orig, 0), cmap=\"jet\")\n", + "ax2.imshow(np.max(pred, 0), cmap=\"jet\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:monai1]", + "language": "python", + "name": "conda-env-monai1-py" + }, + "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.18" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 7fad5a41f603cbdd0f08c6059e60f7ae676434d0 Mon Sep 17 00:00:00 2001 From: Eric Kerfoot Date: Thu, 5 Oct 2023 20:52:31 +0100 Subject: [PATCH 02/13] Adding testing Signed-off-by: Eric Kerfoot --- .../configs/multi_gpu_train.yaml | 36 ++++++ .../segmentation_template/configs/test.yaml | 122 ++++++------------ .../segmentation_template/configs/train.yaml | 6 + models/segmentation_template/docs/test.sh | 19 +++ 4 files changed, 97 insertions(+), 86 deletions(-) create mode 100644 models/segmentation_template/configs/multi_gpu_train.yaml create mode 100644 models/segmentation_template/docs/test.sh diff --git a/models/segmentation_template/configs/multi_gpu_train.yaml b/models/segmentation_template/configs/multi_gpu_train.yaml new file mode 100644 index 00000000..a8373521 --- /dev/null +++ b/models/segmentation_template/configs/multi_gpu_train.yaml @@ -0,0 +1,36 @@ + +is_dist: '$dist.is_initialized()' +rank: '$dist.get_rank() if @is_dist else 0' +# is_not_rank0: '$@rank > 0' +device: '$torch.device(f"cuda:{@rank}" if torch.cuda.is_available() else "cpu")' # assumes GPU # matches rank # + +network: + _target_: torch.nn.parallel.DistributedDataParallel + module: $@network_def.to(@device) + device_ids: ['@device'] + find_unused_parameters: true + +train_sampler: + _target_: DistributedSampler + dataset: '@train_dataset' + even_divisible: true + shuffle: true + +train_dataloader#sampler: '@train_sampler' +train_dataloader#shuffle: false + +val_sampler: + _target_: DistributedSampler + dataset: '@val_dataset' + even_divisible: false + shuffle: false + +val_dataloader#sampler: '@val_sampler' + +run: +- $import torch.distributed as dist +- $dist.init_process_group(backend='nccl') +- $torch.cuda.set_device(@device) +# - $monai.utils.set_determinism(seed=123) +- $@trainer.run() +- $dist.destroy_process_group() diff --git a/models/segmentation_template/configs/test.yaml b/models/segmentation_template/configs/test.yaml index e2b43641..842b5630 100644 --- a/models/segmentation_template/configs/test.yaml +++ b/models/segmentation_template/configs/test.yaml @@ -14,13 +14,14 @@ both_keys: ['@image', '@label'] batch_size: 1 # number of images per batch num_workers: 0 # number of workers to generate batches with num_classes: 4 # number of classes in training data which network should predict +save_pred: false # whether to save prediction images or just run metric tests device: $torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') # define various paths bundle_root: . # root directory of the bundle ckpt_path: $@bundle_root + '/models/model.pt' # checkpoint to load before starting dataset_dir: $@bundle_root + '/test_data' # where data is coming from -output_dir: './outputs' # directory to store images to +output_dir: './outputs' # directory to store images to if save_pred is true # network definition, this could be parameterised by pre-defined values or on the command line network_def: @@ -33,12 +34,15 @@ network_def: num_res_units: 2 network: $@network_def.to(@device) -# dataset value, this assumes a directory filled with img##.nii.gz and lbl##.nii.gz files +# list all niftis in the input directory +file_pattern: '*.nii*' +data_list: '$list(sorted(glob.glob(os.path.join(@dataset_dir, @file_pattern))))' +# collect data dictionaries for all files imgs: '$sorted(glob.glob(@dataset_dir+''/img*.nii.gz''))' lbls: '$[i.replace(''img'',''lbl'') for i in @imgs]' -all_pairs: '$[{@image: i, @label: l} for i, l in zip(@imgs, @lbls)]' +data_dicts: '$[{@image: i, @label: l} for i, l in zip(@imgs, @lbls)]' -# these transforms are used for training and validation transform sequences +# these transforms are used for inference to load and regularise inputs transforms: - _target_: LoadImaged keys: '@both_keys' @@ -48,23 +52,17 @@ transforms: - _target_: ScaleIntensityd keys: '@image' -# define the Compose objects for training and validation - preprocessing: _target_: Compose transforms: $@transforms -# define the datasets for training and validation - dataset: _target_: Dataset - data: '@all_pairs' + data: '@data_dicts' transform: '@preprocessing' - -# define the dataloaders for training and validation dataloader: - _target_: ThreadDataLoader # generate data ansynchronously from training + _target_: ThreadDataLoader # generate data ansynchronously from inference dataset: '@dataset' batch_size: '@batch_size' num_workers: '@num_workers' @@ -81,32 +79,36 @@ postprocessing: keys: '@pred' softmax: true - _target_: AsDiscreted - keys: ['@pred', '@label'] - argmax: [true, false] - to_onehot: '@num_classes' - -# validation handlers to gather statistics, log these to a file, and save best checkpoint -val_handlers: + keys: '@pred' + argmax: true + - _target_: SaveImaged + _disabled_: '$not @save_pred' + keys: '@pred' + meta_keys: pred_meta_dict + data_root_dir: '@dataset_dir' + output_dir: '@output_dir' + dtype: $None + output_dtype: $None + output_postfix: '' + resample: false + separate_folder: true + +# inference handlers to load checkpoint, gather statistics +handlers: +- _target_: CheckpointLoader + _disabled_: $not os.path.exists(@ckpt_path) + load_path: '@ckpt_path' + load_dict: + model: '@network' - _target_: StatsHandler name: null # use engine.logger as the Logger object to log to output_transform: '$lambda x: None' -- _target_: LogfileHandler # log outputs from the validation engine - output_dir: '@output_dir' -- _target_: CheckpointSaver - save_dir: '@output_dir' - save_dict: - model: '@network' - save_interval: 0 # don't save iterations, just when the metric improves - save_final: false - epoch_level: false - save_key_metric: true - key_metric_name: val_mean_dice # save the checkpoint when this value improves -# engine for running validation, ties together objects defined above and has metric definitions +# engine for running inference, ties together objects defined above and has metric definitions evaluator: _target_: SupervisedEvaluator device: '@device' - val_data_loader: '@val_dataloader' + val_data_loader: '@dataloader' network: '@network' postprocessing: '@postprocessing' key_val_metric: @@ -114,60 +116,8 @@ evaluator: _target_: MeanDice include_background: false output_transform: $monai.handlers.from_engine([@pred, @label]) - val_mean_iou: - _target_: MeanIoUHandler - include_background: false - output_transform: $monai.handlers.from_engine([@pred, @label]) - additional_metrics: - val_mae: # can have other metrics, MAE not great for segmentation tasks so here just to demo - _target_: MeanAbsoluteError - output_transform: $monai.handlers.from_engine([@pred, @label]) - val_handlers: '@val_handlers' - -# gathers the loss and validation values for each iteration, referred to by CheckpointSaver so defined separately -metriclogger: - _target_: MetricLogger - evaluator: '@evaluator' - -handlers: -- '@metriclogger' -- _target_: CheckpointLoader - _disabled_: $not os.path.exists(@ckpt_path) - load_path: '@ckpt_path' - load_dict: - model: '@network' -- _target_: ValidationHandler # run validation at the set interval, bridge between trainer and evaluator objects - validator: '@evaluator' - epoch_level: true - interval: '@val_interval' -- _target_: CheckpointSaver - save_dir: '@output_dir' - save_dict: # every epoch checkpoint saves the network and the metric logger in a dictionary - model: '@network' - logger: '@metriclogger' - save_interval: '@ckpt_interval' - save_final: true - epoch_level: true -- _target_: StatsHandler - name: null # use engine.logger as the Logger object to log to - tag_name: train_loss - output_transform: $monai.handlers.from_engine(['loss'], first=True) # log loss value -- _target_: LogfileHandler # log outputs from the training engine - output_dir: '@output_dir' - -# engine for training, ties values defined above together into the main engine for the training process -trainer: - _target_: SupervisedTrainer - max_epochs: '@num_epochs' - device: '@device' - train_data_loader: '@train_dataloader' - network: '@network' - inferer: '@inferer' # unnecessary since SimpleInferer is the default if this isn't provided - loss_function: '@lossfn' - optimizer: '@optimizer' - postprocessing: '@postprocessing' - key_train_metric: null - train_handlers: '@handlers' + val_handlers: '@handlers' run: -- $@trainer.run() +- $@evaluator.run() +- '$print(''Per-image Dice:\n'',@evaluator.state.metric_details[''val_mean_dice''].cpu().numpy())' diff --git a/models/segmentation_template/configs/train.yaml b/models/segmentation_template/configs/train.yaml index edf62c7e..c25e23fa 100644 --- a/models/segmentation_template/configs/train.yaml +++ b/models/segmentation_template/configs/train.yaml @@ -10,6 +10,10 @@ label: $monai.utils.CommonKeys.LABEL pred: $monai.utils.CommonKeys.PRED both_keys: ['@image', '@label'] +# multi-gpu values, `rank` will be replaced in a separate script implementing multi-gpu changes +rank: 0 # without multi-gpu support consider the process as rank 0 anyway +is_not_rank0: '$@rank > 0' # true if not main process, used to disable handlers for other ranks + # hyperparameters for you to modify on the command line val_interval: 1 # how often to perform validation after an epoch ckpt_interval: 1 # how often to save a checkpoint after an epoch @@ -152,6 +156,7 @@ val_handlers: - _target_: LogfileHandler # log outputs from the validation engine output_dir: '@output_dir' - _target_: CheckpointSaver + _disabled_: '@is_not_rank0' # only need rank 0 to save save_dir: '@output_dir' save_dict: model: '@network' @@ -200,6 +205,7 @@ handlers: epoch_level: true interval: '@val_interval' - _target_: CheckpointSaver + _disabled_: '@is_not_rank0' # only need rank 0 to save save_dir: '@output_dir' save_dict: # every epoch checkpoint saves the network and the metric logger in a dictionary model: '@network' diff --git a/models/segmentation_template/docs/test.sh b/models/segmentation_template/docs/test.sh new file mode 100644 index 00000000..2c314607 --- /dev/null +++ b/models/segmentation_template/docs/test.sh @@ -0,0 +1,19 @@ +#! /bin/bash + +eval "$(conda shell.bash hook)" +conda activate monai + +homedir="$( cd -P "$( dirname "${BASH_SOURCE[0]}" )" && pwd )" + +BUNDLE="$(cd "$homedir/.." && pwd)" + +echo "Bundle root: $BUNDLE" + +export PYTHONPATH="$BUNDLE" + +python -m monai.bundle run \ + --meta_file "$BUNDLE/configs/metadata.json" \ + --config_file "$BUNDLE/configs/test.yaml" \ + --bundle_root "$BUNDLE" \ + $@ + \ No newline at end of file From 5a15792c715538a0d8cb758a066d8ca27076cecc Mon Sep 17 00:00:00 2001 From: Eric Kerfoot Date: Thu, 5 Oct 2023 21:02:27 +0100 Subject: [PATCH 03/13] Update Signed-off-by: Eric Kerfoot --- .../segmentation_template/configs/train.yaml | 2 +- .../segmentation_template/docs/inference.sh | 0 models/segmentation_template/docs/test.sh | 0 models/segmentation_template/docs/train.sh | 0 .../docs/visualise_inference.ipynb | 47 ++++++++++++++++--- 5 files changed, 41 insertions(+), 8 deletions(-) mode change 100644 => 100755 models/segmentation_template/docs/inference.sh mode change 100644 => 100755 models/segmentation_template/docs/test.sh mode change 100644 => 100755 models/segmentation_template/docs/train.sh diff --git a/models/segmentation_template/configs/train.yaml b/models/segmentation_template/configs/train.yaml index c25e23fa..6708d974 100644 --- a/models/segmentation_template/configs/train.yaml +++ b/models/segmentation_template/configs/train.yaml @@ -122,7 +122,7 @@ val_dataloader: # use include_background==True and sigmoid==True instead of these values lossfn: _target_: DiceLoss - include_background: false + include_background: true # if your segmentations are relatively small it might help for this to be false to_onehot_y: true softmax: true diff --git a/models/segmentation_template/docs/inference.sh b/models/segmentation_template/docs/inference.sh old mode 100644 new mode 100755 diff --git a/models/segmentation_template/docs/test.sh b/models/segmentation_template/docs/test.sh old mode 100644 new mode 100755 diff --git a/models/segmentation_template/docs/train.sh b/models/segmentation_template/docs/train.sh old mode 100644 new mode 100755 diff --git a/models/segmentation_template/docs/visualise_inference.ipynb b/models/segmentation_template/docs/visualise_inference.ipynb index 1f674cd3..1914c620 100644 --- a/models/segmentation_template/docs/visualise_inference.ipynb +++ b/models/segmentation_template/docs/visualise_inference.ipynb @@ -17,12 +17,45 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "3a5cde0f-1305-4cd2-af5f-2be63809c073", "metadata": { "tags": [] }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2023-10-05 20:59:01,219 - INFO - --- input summary of monai.bundle.scripts.run ---\n", + "2023-10-05 20:59:01,219 - INFO - > meta_file: '/home/localek10/workspace/monai/model-zoo_mine/models/segmentation_template/configs/metadata.json'\n", + "2023-10-05 20:59:01,219 - INFO - > config_file: '/home/localek10/workspace/monai/model-zoo_mine/models/segmentation_template/configs/inference.yaml'\n", + "2023-10-05 20:59:01,219 - INFO - > bundle_root: '/home/localek10/workspace/monai/model-zoo_mine/models/segmentation_template'\n", + "2023-10-05 20:59:01,219 - INFO - > dataset_dir: '/home/localek10/workspace/monai/model-zoo_mine/models/segmentation_template/test_data'\n", + "2023-10-05 20:59:01,219 - INFO - > output_dir: '/home/localek10/workspace/monai/model-zoo_mine/models/segmentation_template/output'\n", + "2023-10-05 20:59:01,219 - INFO - > file_pattern: 'img*.nii.gz'\n", + "2023-10-05 20:59:01,219 - INFO - > ckpt_path: '/home/localek10/workspace/monai/model-zoo_mine/models/segmentation_template/results/output_231005_205402/model_key_metric=0.9349.pt'\n", + "2023-10-05 20:59:01,219 - INFO - ---\n", + "\n", + "\n", + "2023-10-05 20:59:01,219 - INFO - Setting logging properties based on config: configs/logging.conf.\n", + "2023-10-05 20:59:02,384 - ignite.engine.engine.SupervisedEvaluator - INFO - Engine run resuming from iteration 0, epoch 0 until 1 epochs\n", + "2023-10-05 20:59:02,393 - ignite.engine.engine.SupervisedEvaluator - INFO - Restored all variables from /home/localek10/workspace/monai/model-zoo_mine/models/segmentation_template/results/output_231005_205402/model_key_metric=0.9349.pt\n", + "2023-10-05 20:59:03,277 INFO image_writer.py:197 - writing: /home/localek10/workspace/monai/model-zoo_mine/models/segmentation_template/output/img00/img00.nii.gz\n", + "2023-10-05 20:59:03,354 INFO image_writer.py:197 - writing: /home/localek10/workspace/monai/model-zoo_mine/models/segmentation_template/output/img01/img01.nii.gz\n", + "2023-10-05 20:59:03,419 INFO image_writer.py:197 - writing: /home/localek10/workspace/monai/model-zoo_mine/models/segmentation_template/output/img02/img02.nii.gz\n", + "2023-10-05 20:59:03,487 INFO image_writer.py:197 - writing: /home/localek10/workspace/monai/model-zoo_mine/models/segmentation_template/output/img03/img03.nii.gz\n", + "2023-10-05 20:59:03,591 INFO image_writer.py:197 - writing: /home/localek10/workspace/monai/model-zoo_mine/models/segmentation_template/output/img04/img04.nii.gz\n", + "2023-10-05 20:59:03,701 INFO image_writer.py:197 - writing: /home/localek10/workspace/monai/model-zoo_mine/models/segmentation_template/output/img05/img05.nii.gz\n", + "2023-10-05 20:59:03,808 INFO image_writer.py:197 - writing: /home/localek10/workspace/monai/model-zoo_mine/models/segmentation_template/output/img06/img06.nii.gz\n", + "2023-10-05 20:59:03,912 INFO image_writer.py:197 - writing: /home/localek10/workspace/monai/model-zoo_mine/models/segmentation_template/output/img07/img07.nii.gz\n", + "2023-10-05 20:59:04,018 INFO image_writer.py:197 - writing: /home/localek10/workspace/monai/model-zoo_mine/models/segmentation_template/output/img08/img08.nii.gz\n", + "2023-10-05 20:59:04,118 INFO image_writer.py:197 - writing: /home/localek10/workspace/monai/model-zoo_mine/models/segmentation_template/output/img09/img09.nii.gz\n", + "2023-10-05 20:59:04,153 - ignite.engine.engine.SupervisedEvaluator - INFO - Epoch[1] Complete. Time taken: 00:00:01.760\n", + "2023-10-05 20:59:04,154 - ignite.engine.engine.SupervisedEvaluator - INFO - Engine run complete. Time taken: 00:00:01.769\n" + ] + } + ], "source": [ "%%bash\n", "\n", @@ -31,7 +64,7 @@ "\n", "BUNDLE=\"$(pwd)\"\n", "# change this to your checkpoint file\n", - "CKPT='$BUNDLE/results/output_231004_163050/model_key_metric=0.5544.pt'\n", + "CKPT=\"$BUNDLE/results/output_231005_205402/model_key_metric=0.9349.pt\"\n", "\n", "export PYTHONPATH=\"$BUNDLE\"\n", "\n", @@ -47,7 +80,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 4, "id": "308e8fd2-8fdc-4cb2-9b92-506f8b3b58a7", "metadata": { "tags": [] @@ -63,16 +96,16 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 1, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] From afbd71da3f92671d2b8239e8bda13237c965ed09 Mon Sep 17 00:00:00 2001 From: Eric Kerfoot Date: Fri, 6 Oct 2023 14:09:09 +0100 Subject: [PATCH 04/13] Multi-GPU updates Signed-off-by: Eric Kerfoot --- .../configs/inference.yaml | 5 +- .../configs/multi_gpu_train.yaml | 5 +- .../segmentation_template/configs/test.yaml | 2 + .../segmentation_template/configs/train.yaml | 5 ++ models/segmentation_template/docs/README.md | 63 +++++++++++++++++++ .../docs/generate_data.ipynb | 2 + .../docs/run_monailabel.sh | 28 +++++++++ .../docs/train_multigpu.sh | 32 ++++++++++ .../docs/visualise_inference.ipynb | 45 ++----------- models/segmentation_template/large_files.yml | 5 ++ 10 files changed, 148 insertions(+), 44 deletions(-) create mode 100755 models/segmentation_template/docs/run_monailabel.sh create mode 100644 models/segmentation_template/docs/train_multigpu.sh create mode 100644 models/segmentation_template/large_files.yml diff --git a/models/segmentation_template/configs/inference.yaml b/models/segmentation_template/configs/inference.yaml index 506b3356..67903c17 100644 --- a/models/segmentation_template/configs/inference.yaml +++ b/models/segmentation_template/configs/inference.yaml @@ -1,3 +1,5 @@ +# This implements the workflow for applying the network to a directory of images and saving the predicted segmentations. + imports: - $import os - $import torch @@ -103,8 +105,9 @@ evaluator: device: '@device' val_data_loader: '@dataloader' network: '@network' + inferer: '@inferer' postprocessing: '@postprocessing' val_handlers: '@handlers' - + run: - $@evaluator.run() diff --git a/models/segmentation_template/configs/multi_gpu_train.yaml b/models/segmentation_template/configs/multi_gpu_train.yaml index a8373521..d7a0bb2b 100644 --- a/models/segmentation_template/configs/multi_gpu_train.yaml +++ b/models/segmentation_template/configs/multi_gpu_train.yaml @@ -1,9 +1,10 @@ +# This file contains the changes to implement DDP training with the train.yaml config. is_dist: '$dist.is_initialized()' rank: '$dist.get_rank() if @is_dist else 0' -# is_not_rank0: '$@rank > 0' device: '$torch.device(f"cuda:{@rank}" if torch.cuda.is_available() else "cpu")' # assumes GPU # matches rank # +# wrap the network in a DistributedDataParallel instance, moving it to the chosen device for this process network: _target_: torch.nn.parallel.DistributedDataParallel module: $@network_def.to(@device) @@ -31,6 +32,6 @@ run: - $import torch.distributed as dist - $dist.init_process_group(backend='nccl') - $torch.cuda.set_device(@device) -# - $monai.utils.set_determinism(seed=123) +- $monai.utils.set_determinism(seed=123) # may want to choose a different seed or not do this here - $@trainer.run() - $dist.destroy_process_group() diff --git a/models/segmentation_template/configs/test.yaml b/models/segmentation_template/configs/test.yaml index 842b5630..4705d365 100644 --- a/models/segmentation_template/configs/test.yaml +++ b/models/segmentation_template/configs/test.yaml @@ -1,3 +1,5 @@ +# This implements the workflow for applying the network to a directory of images and measuring network performance with metrics. + imports: - $import os - $import datetime diff --git a/models/segmentation_template/configs/train.yaml b/models/segmentation_template/configs/train.yaml index 6708d974..55a6a289 100644 --- a/models/segmentation_template/configs/train.yaml +++ b/models/segmentation_template/configs/train.yaml @@ -1,3 +1,8 @@ +# This config file implements the training workflow. It can be combined with multi_gpu_train.yaml to use DDP for +# multi-GPU runs. Many definitions in this file are duplicated across other files for compatibility with MONAI +# Label, eg. network_def, but ideally these would be in a common.yaml file used in conjunction with this one +# or the other config files for testing or inference. + imports: - $import os - $import datetime diff --git a/models/segmentation_template/docs/README.md b/models/segmentation_template/docs/README.md index 140e5e72..ff0f64d5 100644 --- a/models/segmentation_template/docs/README.md +++ b/models/segmentation_template/docs/README.md @@ -2,3 +2,66 @@ # Template Segmentation Bundle This bundle is meant to be an example of segmentation in 3D which you can copy and modify to create your own bundle. +It is only roughly trained for the synthetic data you can generate with [this notebook](./generate_data.ipynb) +so doesn't do anything useful on its own. The purpose is to demonstrate the base line for segmentation network +bundles compatible with MONAILabel amongst other things. + +To use this bundle, copy the contents of the whole directory and change the definitions for network, data, transforms, +or whatever else you want for your own new segmentation bundle. Some of the names are critical for MONAILable but +otherwise you're free to change just about whatever else is defined here to suit your network. + +This bundle should also demonstrate good practice and design, however there is one caveat about definitions being +copied between config files. Ideally there should be a `common.yaml` file for all the definitions used by every other +config file which is then included with that file. MONAILabel doesn't support this yet so this bundle will be updated +once it does to exemplify this better practice. + +## Generating Demo Data + +Run all the cells of [this notebook](./generate_data.ipynb) to generate training and test data. These will be 3D +nifti files containing volumes with randomly generated spheres of varying intensities and some noise for fun. The +segmentation task is very easy so your network will train in minutes with the default configuration of values. A test +data directory will separately be created since the test and inference configs are configured to apply the network to +every nifti file in a given directory with a certain pattern. + +## Training + +To train a new network the `train.yaml` script can be used alone with no other arguments (assume `BUNDLE` is the root +directory of the bundle): + +```sh +python -m monai.bundle run \ + --meta_file "$BUNDLE/configs/metadata.json" \ + --config_file "$BUNDLE/configs/train.yaml" \ + --bundle_root "$BUNDLE" +``` + +A `train.sh` script is also provided in `docs` which implements this invocation with some helper commands. It +relies on a Conda environment called `monai` so comment or modify those lines if you're not using such an environment. +See MONAI installation information about what environment to create for the features you want. + +The training config includes a number of hyperparameters like `learning_rate` and `num_workers`. These control aspects +of how training operates in terms of how many processes to use, when to perform validation, when to save checkpoints, +and other things. Other aspects of the script can be modified on the command line so these aren't exhaustive but are a +guide to the kind of parameterisation that make sense for a bundle. + +## Testing and Inference + +Two configs are provided (`test.yaml` and `inference.yaml`) for doing post-training inference with the model. The first +requires image and segmentation pairs which are used with network outputs to assess performance using metrics. This is +very similar to training validation but is done on separate images. This config can be set to save predicted segmentations +by setting `save_pred` to true but by default it will just run metrics and print their results. + +The inference config is for generating new segmentations from images which don't have ground truths, so this is used for +actually applying the network in practice. This will apply the network to every image in an input directory matching a +pattern and save the predicted segmentations to an output directory. + +Using inference on the command line is demonstrated in [this notebook](./visualise_inference.ipynb) with visualisation. +Some explanation of some command line choices are given in the notebook as well, similar command line invocations can +also be done with the included `inference.sh` script file. + +## Other Considerations + +There is no `scripts` directory containing a valid Python module to be imported in your configs. This wasn't necessary +for this bundle but if you want to include custom code in a bundle please follow the bundle tutorials on how to do this. + +The `multi_gpu_train.yaml` config is defined as a "mixin" to implement DDP based multi-gpu training. \ No newline at end of file diff --git a/models/segmentation_template/docs/generate_data.ipynb b/models/segmentation_template/docs/generate_data.ipynb index 2bcb208d..19b7ef0c 100644 --- a/models/segmentation_template/docs/generate_data.ipynb +++ b/models/segmentation_template/docs/generate_data.ipynb @@ -9,6 +9,8 @@ "\n", "This bundle uses simple synthetic data for training and testing. Using `create_test_image_3d` we'll create images of spheres with labels for each divided into 3 classes distinguished by intensity. The network will be able to train very quickly on this of course but it's for demonstration purposes and your specialised bundle will by modified for your data and its layout. \n", "\n", + "Assuming this notebook is being run from the `docs` directory it will create two new directories in the root of the bundle, `train_data` and `test_data`.\n", + "\n", "First imports:" ] }, diff --git a/models/segmentation_template/docs/run_monailabel.sh b/models/segmentation_template/docs/run_monailabel.sh new file mode 100755 index 00000000..c724b681 --- /dev/null +++ b/models/segmentation_template/docs/run_monailabel.sh @@ -0,0 +1,28 @@ +#! /bin/bash + +eval "$(conda shell.bash hook)" +conda activate monailabel + +export CUDA_VISIBLE_DEVICES=0 + +homedir="$( cd -P "$( dirname "${BASH_SOURCE[0]}" )" && pwd )" + +BUNDLE="$(cd "$homedir/.." && pwd)" + +LABELDIR="$BUNDLE/monailabel" + +BUNDLENAME=$(basename "$BUNDLE") + +if [ ! -d "$LABELDIR" ] +then + mkdir "$LABELDIR" + mkdir "$LABELDIR/datasets" + cd "$LABELDIR" + monailabel apps --download --name monaibundle + mkdir "$LABELDIR/monaibundle/model" + cd "$LABELDIR/monaibundle/model" + ln -s "$BUNDLE" $BUNDLENAME +fi + +cd "$LABELDIR" +monailabel start_server --app monaibundle --studies datasets --conf models $BUNDLENAME $* \ No newline at end of file diff --git a/models/segmentation_template/docs/train_multigpu.sh b/models/segmentation_template/docs/train_multigpu.sh new file mode 100644 index 00000000..611ea919 --- /dev/null +++ b/models/segmentation_template/docs/train_multigpu.sh @@ -0,0 +1,32 @@ +#! /bin/bash + +set -v + +eval "$(conda shell.bash hook)" +conda activate monai + +homedir="$( cd -P "$( dirname "${BASH_SOURCE[0]}" )" && pwd )" + +BUNDLE="$(cd "$homedir/.." && pwd)" + +echo "Bundle root: $BUNDLE" + +export PYTHONPATH="$BUNDLE" + +export CUDA_VISIBLE_DEVICES="0,1,2,3" + +export OMP_NUM_THREADS=1 + +CKPT=none + +PYTHON="torchrun --standalone --nnodes=1 --nproc_per_node=4" + +CONFIG="['$BUNDLE/configs/train.yaml','$BUNDLE/configs/multi_gpu_train.yaml']" + + +$PYTHON -m monai.bundle run \ + --meta_file $BUNDLE/configs/metadata.json \ + --logging_file $BUNDLE/configs/logging.conf \ + --config_file "$CONFIG" \ + --bundle_root $BUNDLE \ + $@ diff --git a/models/segmentation_template/docs/visualise_inference.ipynb b/models/segmentation_template/docs/visualise_inference.ipynb index 1914c620..2b408e20 100644 --- a/models/segmentation_template/docs/visualise_inference.ipynb +++ b/models/segmentation_template/docs/visualise_inference.ipynb @@ -17,57 +17,20 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "3a5cde0f-1305-4cd2-af5f-2be63809c073", "metadata": { "tags": [] }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2023-10-05 20:59:01,219 - INFO - --- input summary of monai.bundle.scripts.run ---\n", - "2023-10-05 20:59:01,219 - INFO - > meta_file: '/home/localek10/workspace/monai/model-zoo_mine/models/segmentation_template/configs/metadata.json'\n", - "2023-10-05 20:59:01,219 - INFO - > config_file: '/home/localek10/workspace/monai/model-zoo_mine/models/segmentation_template/configs/inference.yaml'\n", - "2023-10-05 20:59:01,219 - INFO - > bundle_root: '/home/localek10/workspace/monai/model-zoo_mine/models/segmentation_template'\n", - "2023-10-05 20:59:01,219 - INFO - > dataset_dir: '/home/localek10/workspace/monai/model-zoo_mine/models/segmentation_template/test_data'\n", - "2023-10-05 20:59:01,219 - INFO - > output_dir: '/home/localek10/workspace/monai/model-zoo_mine/models/segmentation_template/output'\n", - "2023-10-05 20:59:01,219 - INFO - > file_pattern: 'img*.nii.gz'\n", - "2023-10-05 20:59:01,219 - INFO - > ckpt_path: '/home/localek10/workspace/monai/model-zoo_mine/models/segmentation_template/results/output_231005_205402/model_key_metric=0.9349.pt'\n", - "2023-10-05 20:59:01,219 - INFO - ---\n", - "\n", - "\n", - "2023-10-05 20:59:01,219 - INFO - Setting logging properties based on config: configs/logging.conf.\n", - "2023-10-05 20:59:02,384 - ignite.engine.engine.SupervisedEvaluator - INFO - Engine run resuming from iteration 0, epoch 0 until 1 epochs\n", - "2023-10-05 20:59:02,393 - ignite.engine.engine.SupervisedEvaluator - INFO - Restored all variables from /home/localek10/workspace/monai/model-zoo_mine/models/segmentation_template/results/output_231005_205402/model_key_metric=0.9349.pt\n", - "2023-10-05 20:59:03,277 INFO image_writer.py:197 - writing: /home/localek10/workspace/monai/model-zoo_mine/models/segmentation_template/output/img00/img00.nii.gz\n", - "2023-10-05 20:59:03,354 INFO image_writer.py:197 - writing: /home/localek10/workspace/monai/model-zoo_mine/models/segmentation_template/output/img01/img01.nii.gz\n", - "2023-10-05 20:59:03,419 INFO image_writer.py:197 - writing: /home/localek10/workspace/monai/model-zoo_mine/models/segmentation_template/output/img02/img02.nii.gz\n", - "2023-10-05 20:59:03,487 INFO image_writer.py:197 - writing: /home/localek10/workspace/monai/model-zoo_mine/models/segmentation_template/output/img03/img03.nii.gz\n", - "2023-10-05 20:59:03,591 INFO image_writer.py:197 - writing: /home/localek10/workspace/monai/model-zoo_mine/models/segmentation_template/output/img04/img04.nii.gz\n", - "2023-10-05 20:59:03,701 INFO image_writer.py:197 - writing: /home/localek10/workspace/monai/model-zoo_mine/models/segmentation_template/output/img05/img05.nii.gz\n", - "2023-10-05 20:59:03,808 INFO image_writer.py:197 - writing: /home/localek10/workspace/monai/model-zoo_mine/models/segmentation_template/output/img06/img06.nii.gz\n", - "2023-10-05 20:59:03,912 INFO image_writer.py:197 - writing: /home/localek10/workspace/monai/model-zoo_mine/models/segmentation_template/output/img07/img07.nii.gz\n", - "2023-10-05 20:59:04,018 INFO image_writer.py:197 - writing: /home/localek10/workspace/monai/model-zoo_mine/models/segmentation_template/output/img08/img08.nii.gz\n", - "2023-10-05 20:59:04,118 INFO image_writer.py:197 - writing: /home/localek10/workspace/monai/model-zoo_mine/models/segmentation_template/output/img09/img09.nii.gz\n", - "2023-10-05 20:59:04,153 - ignite.engine.engine.SupervisedEvaluator - INFO - Epoch[1] Complete. Time taken: 00:00:01.760\n", - "2023-10-05 20:59:04,154 - ignite.engine.engine.SupervisedEvaluator - INFO - Engine run complete. Time taken: 00:00:01.769\n" - ] - } - ], + "outputs": [], "source": [ "%%bash\n", "\n", "# assumes we're running in the docs directory\n", - "cd ..\n", - "\n", - "BUNDLE=\"$(pwd)\"\n", - "# change this to your checkpoint file\n", + "BUNDLE=\"$(cd .. && pwd)\"\n", + "# change this to your checkpoint file or omit to use saved weights that come with the bundle\n", "CKPT=\"$BUNDLE/results/output_231005_205402/model_key_metric=0.9349.pt\"\n", "\n", - "export PYTHONPATH=\"$BUNDLE\"\n", - "\n", "python -m monai.bundle run \\\n", " --meta_file \"$BUNDLE/configs/metadata.json\" \\\n", " --config_file \"$BUNDLE/configs/inference.yaml\" \\\n", diff --git a/models/segmentation_template/large_files.yml b/models/segmentation_template/large_files.yml new file mode 100644 index 00000000..9e6808f1 --- /dev/null +++ b/models/segmentation_template/large_files.yml @@ -0,0 +1,5 @@ +large_files: + - path: "models/model.pt" + url: "https://github.com/KCL-BMEIS/bundle-data/raw/main/segmentation_template/model.pt" + hash_val: "b11405475d2d3da1f8a2aec9286f0548" + hash_type: "md5" From 36f5c4b81639cb56d9e0da0b36359ad7bdd61eb8 Mon Sep 17 00:00:00 2001 From: Eric Kerfoot Date: Fri, 6 Oct 2023 14:19:34 +0100 Subject: [PATCH 05/13] Update Signed-off-by: Eric Kerfoot --- models/segmentation_template/docs/README.md | 3 ++- models/segmentation_template/docs/train_multigpu.sh | 8 +++++--- 2 files changed, 7 insertions(+), 4 deletions(-) mode change 100644 => 100755 models/segmentation_template/docs/train_multigpu.sh diff --git a/models/segmentation_template/docs/README.md b/models/segmentation_template/docs/README.md index ff0f64d5..907c2769 100644 --- a/models/segmentation_template/docs/README.md +++ b/models/segmentation_template/docs/README.md @@ -64,4 +64,5 @@ also be done with the included `inference.sh` script file. There is no `scripts` directory containing a valid Python module to be imported in your configs. This wasn't necessary for this bundle but if you want to include custom code in a bundle please follow the bundle tutorials on how to do this. -The `multi_gpu_train.yaml` config is defined as a "mixin" to implement DDP based multi-gpu training. \ No newline at end of file +The `multi_gpu_train.yaml` config is defined as a "mixin" to implement DDP based multi-gpu training. The script +`train_multigpu.sh` illustrates an example of how to invoke these configs together with `torchrun`. diff --git a/models/segmentation_template/docs/train_multigpu.sh b/models/segmentation_template/docs/train_multigpu.sh old mode 100644 new mode 100755 index 611ea919..fc58def5 --- a/models/segmentation_template/docs/train_multigpu.sh +++ b/models/segmentation_template/docs/train_multigpu.sh @@ -13,17 +13,19 @@ echo "Bundle root: $BUNDLE" export PYTHONPATH="$BUNDLE" -export CUDA_VISIBLE_DEVICES="0,1,2,3" +# set this to something else to use different numbered GPUs on your system +export CUDA_VISIBLE_DEVICES="0,1" +# seems to resolve some multiprocessing issues with certain libraries export OMP_NUM_THREADS=1 CKPT=none -PYTHON="torchrun --standalone --nnodes=1 --nproc_per_node=4" +# need to change this if you have multiple nodes or not 2 GPUs +PYTHON="torchrun --standalone --nnodes=1 --nproc_per_node=2" CONFIG="['$BUNDLE/configs/train.yaml','$BUNDLE/configs/multi_gpu_train.yaml']" - $PYTHON -m monai.bundle run \ --meta_file $BUNDLE/configs/metadata.json \ --logging_file $BUNDLE/configs/logging.conf \ From 51134d32a77710a2c862c799abfd38b37f91f34c Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Fri, 6 Oct 2023 14:41:12 +0000 Subject: [PATCH 06/13] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- .../configs/inference.yaml | 18 +++---- .../configs/metadata.json | 2 +- .../configs/multi_gpu_train.yaml | 4 +- .../segmentation_template/configs/test.yaml | 22 ++++---- .../segmentation_template/configs/train.yaml | 50 +++++++++---------- models/segmentation_template/docs/README.md | 14 +++--- .../segmentation_template/docs/inference.sh | 1 - .../docs/run_monailabel.sh | 2 +- models/segmentation_template/docs/test.sh | 1 - models/segmentation_template/docs/train.sh | 1 - 10 files changed, 56 insertions(+), 59 deletions(-) diff --git a/models/segmentation_template/configs/inference.yaml b/models/segmentation_template/configs/inference.yaml index 67903c17..bbbb2c7f 100644 --- a/models/segmentation_template/configs/inference.yaml +++ b/models/segmentation_template/configs/inference.yaml @@ -47,11 +47,11 @@ transforms: keys: '@image' - _target_: ScaleIntensityd keys: '@image' - -preprocessing: + +preprocessing: _target_: Compose transforms: $@transforms - + dataset: _target_: Dataset data: '@data_dicts' @@ -62,10 +62,10 @@ dataloader: dataset: '@dataset' batch_size: '@batch_size' num_workers: '@num_workers' - + # should be replaced with other inferer types if training process is different for your network inferer: - _target_: SimpleInferer + _target_: SimpleInferer # transform to apply to data from network to be suitable for loss function and validation postprocessing: @@ -86,8 +86,8 @@ postprocessing: output_dtype: $None output_postfix: '' resample: false - separate_folder: true - + separate_folder: true + # inference handlers to load checkpoint, gather statistics handlers: - _target_: CheckpointLoader @@ -98,7 +98,7 @@ handlers: - _target_: StatsHandler name: null # use engine.logger as the Logger object to log to output_transform: '$lambda x: None' - + # engine for running inference, ties together objects defined above and has metric definitions evaluator: _target_: SupervisedEvaluator @@ -109,5 +109,5 @@ evaluator: postprocessing: '@postprocessing' val_handlers: '@handlers' -run: +run: - $@evaluator.run() diff --git a/models/segmentation_template/configs/metadata.json b/models/segmentation_template/configs/metadata.json index 8ad534cc..446c56c5 100644 --- a/models/segmentation_template/configs/metadata.json +++ b/models/segmentation_template/configs/metadata.json @@ -56,4 +56,4 @@ } } } -} \ No newline at end of file +} diff --git a/models/segmentation_template/configs/multi_gpu_train.yaml b/models/segmentation_template/configs/multi_gpu_train.yaml index d7a0bb2b..26cf222b 100644 --- a/models/segmentation_template/configs/multi_gpu_train.yaml +++ b/models/segmentation_template/configs/multi_gpu_train.yaml @@ -25,10 +25,10 @@ val_sampler: dataset: '@val_dataset' even_divisible: false shuffle: false - + val_dataloader#sampler: '@val_sampler' -run: +run: - $import torch.distributed as dist - $dist.init_process_group(backend='nccl') - $torch.cuda.set_device(@device) diff --git a/models/segmentation_template/configs/test.yaml b/models/segmentation_template/configs/test.yaml index 4705d365..70f0991b 100644 --- a/models/segmentation_template/configs/test.yaml +++ b/models/segmentation_template/configs/test.yaml @@ -22,7 +22,7 @@ device: $torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') # define various paths bundle_root: . # root directory of the bundle ckpt_path: $@bundle_root + '/models/model.pt' # checkpoint to load before starting -dataset_dir: $@bundle_root + '/test_data' # where data is coming from +dataset_dir: $@bundle_root + '/test_data' # where data is coming from output_dir: './outputs' # directory to store images to if save_pred is true # network definition, this could be parameterised by pre-defined values or on the command line @@ -53,11 +53,11 @@ transforms: keys: '@both_keys' - _target_: ScaleIntensityd keys: '@image' - -preprocessing: + +preprocessing: _target_: Compose transforms: $@transforms - + dataset: _target_: Dataset data: '@data_dicts' @@ -68,10 +68,10 @@ dataloader: dataset: '@dataset' batch_size: '@batch_size' num_workers: '@num_workers' - + # should be replaced with other inferer types if training process is different for your network inferer: - _target_: SimpleInferer + _target_: SimpleInferer # transform to apply to data from network to be suitable for loss function and validation postprocessing: @@ -93,8 +93,8 @@ postprocessing: output_dtype: $None output_postfix: '' resample: false - separate_folder: true - + separate_folder: true + # inference handlers to load checkpoint, gather statistics handlers: - _target_: CheckpointLoader @@ -105,7 +105,7 @@ handlers: - _target_: StatsHandler name: null # use engine.logger as the Logger object to log to output_transform: '$lambda x: None' - + # engine for running inference, ties together objects defined above and has metric definitions evaluator: _target_: SupervisedEvaluator @@ -119,7 +119,7 @@ evaluator: include_background: false output_transform: $monai.handlers.from_engine([@pred, @label]) val_handlers: '@handlers' - -run: + +run: - $@evaluator.run() - '$print(''Per-image Dice:\n'',@evaluator.state.metric_details[''val_mean_dice''].cpu().numpy())' diff --git a/models/segmentation_template/configs/train.yaml b/models/segmentation_template/configs/train.yaml index 55a6a289..8f7a20b4 100644 --- a/models/segmentation_template/configs/train.yaml +++ b/models/segmentation_template/configs/train.yaml @@ -1,7 +1,7 @@ -# This config file implements the training workflow. It can be combined with multi_gpu_train.yaml to use DDP for +# This config file implements the training workflow. It can be combined with multi_gpu_train.yaml to use DDP for # multi-GPU runs. Many definitions in this file are duplicated across other files for compatibility with MONAI # Label, eg. network_def, but ideally these would be in a common.yaml file used in conjunction with this one -# or the other config files for testing or inference. +# or the other config files for testing or inference. imports: - $import os @@ -34,7 +34,7 @@ device: $torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') # define various paths bundle_root: . # root directory of the bundle ckpt_path: $@bundle_root + '/models/model.pt' # checkpoint to load before starting -dataset_dir: $@bundle_root + '/train_data' # where data is coming from +dataset_dir: $@bundle_root + '/train_data' # where data is coming from results_dir: $@bundle_root + '/results' # where results are being stored to # a new output directory is chosen using a timestamp for every invocation output_dir: '$datetime.datetime.now().strftime(@results_dir + ''/output_%y%m%d_%H%M%S'')' @@ -65,7 +65,7 @@ base_transforms: image_only: true - _target_: EnsureChannelFirstd keys: '@both_keys' - + # these are the random and regularising transforms used only for training train_transforms: - _target_: RandAxisFlipd @@ -80,34 +80,34 @@ train_transforms: std: 0.05 - _target_: ScaleIntensityd keys: '@image' - + # these are used for validation data so no randomness val_transforms: - _target_: ScaleIntensityd keys: '@image' - + # define the Compose objects for training and validation -preprocessing: +preprocessing: _target_: Compose transforms: $@base_transforms + @train_transforms - -val_preprocessing: + +val_preprocessing: _target_: Compose transforms: $@base_transforms + @val_transforms - + # define the datasets for training and validation train_dataset: _target_: Dataset data: '@train_sub' transform: '@preprocessing' - + val_dataset: _target_: Dataset data: '@val_sub' transform: '@val_preprocessing' - + # define the dataloaders for training and validation train_dataloader: @@ -116,13 +116,13 @@ train_dataloader: batch_size: '@batch_size' repeats: '@num_substeps' num_workers: '@num_workers' - + val_dataloader: _target_: DataLoader # faster transforms probably won't benefit from threading dataset: '@val_dataset' batch_size: '@batch_size' num_workers: '@num_workers' - + # Simple Dice loss configured for multi-class segmentation, for binary segmentation # use include_background==True and sigmoid==True instead of these values lossfn: @@ -130,16 +130,16 @@ lossfn: include_background: true # if your segmentations are relatively small it might help for this to be false to_onehot_y: true softmax: true - + # hyperparameters could be added for other arguments of this class optimizer: _target_: torch.optim.Adam params: $@network.parameters() lr: '@learning_rate' - + # should be replaced with other inferer types if training process is different for your network inferer: - _target_: SimpleInferer + _target_: SimpleInferer # transform to apply to data from network to be suitable for loss function and validation postprocessing: @@ -170,7 +170,7 @@ val_handlers: epoch_level: false save_key_metric: true key_metric_name: val_mean_dice # save the checkpoint when this value improves - + # engine for running validation, ties together objects defined above and has metric definitions evaluator: _target_: SupervisedEvaluator @@ -192,12 +192,12 @@ evaluator: _target_: MeanAbsoluteError output_transform: $monai.handlers.from_engine([@pred, @label]) val_handlers: '@val_handlers' - + # gathers the loss and validation values for each iteration, referred to by CheckpointSaver so defined separately -metriclogger: +metriclogger: _target_: MetricLogger - evaluator: '@evaluator' - + evaluator: '@evaluator' + handlers: - '@metriclogger' - _target_: CheckpointLoader @@ -224,7 +224,7 @@ handlers: output_transform: $monai.handlers.from_engine(['loss'], first=True) # log loss value - _target_: LogfileHandler # log outputs from the training engine output_dir: '@output_dir' - + # engine for training, ties values defined above together into the main engine for the training process trainer: _target_: SupervisedTrainer @@ -238,6 +238,6 @@ trainer: postprocessing: '@postprocessing' key_train_metric: null train_handlers: '@handlers' - -run: + +run: - $@trainer.run() diff --git a/models/segmentation_template/docs/README.md b/models/segmentation_template/docs/README.md index 907c2769..cc260c9e 100644 --- a/models/segmentation_template/docs/README.md +++ b/models/segmentation_template/docs/README.md @@ -1,14 +1,14 @@ # Template Segmentation Bundle -This bundle is meant to be an example of segmentation in 3D which you can copy and modify to create your own bundle. +This bundle is meant to be an example of segmentation in 3D which you can copy and modify to create your own bundle. It is only roughly trained for the synthetic data you can generate with [this notebook](./generate_data.ipynb) so doesn't do anything useful on its own. The purpose is to demonstrate the base line for segmentation network -bundles compatible with MONAILabel amongst other things. +bundles compatible with MONAILabel amongst other things. To use this bundle, copy the contents of the whole directory and change the definitions for network, data, transforms, or whatever else you want for your own new segmentation bundle. Some of the names are critical for MONAILable but -otherwise you're free to change just about whatever else is defined here to suit your network. +otherwise you're free to change just about whatever else is defined here to suit your network. This bundle should also demonstrate good practice and design, however there is one caveat about definitions being copied between config files. Ideally there should be a `common.yaml` file for all the definitions used by every other @@ -41,8 +41,8 @@ See MONAI installation information about what environment to create for the feat The training config includes a number of hyperparameters like `learning_rate` and `num_workers`. These control aspects of how training operates in terms of how many processes to use, when to perform validation, when to save checkpoints, -and other things. Other aspects of the script can be modified on the command line so these aren't exhaustive but are a -guide to the kind of parameterisation that make sense for a bundle. +and other things. Other aspects of the script can be modified on the command line so these aren't exhaustive but are a +guide to the kind of parameterisation that make sense for a bundle. ## Testing and Inference @@ -53,7 +53,7 @@ by setting `save_pred` to true but by default it will just run metrics and print The inference config is for generating new segmentations from images which don't have ground truths, so this is used for actually applying the network in practice. This will apply the network to every image in an input directory matching a -pattern and save the predicted segmentations to an output directory. +pattern and save the predicted segmentations to an output directory. Using inference on the command line is demonstrated in [this notebook](./visualise_inference.ipynb) with visualisation. Some explanation of some command line choices are given in the notebook as well, similar command line invocations can @@ -64,5 +64,5 @@ also be done with the included `inference.sh` script file. There is no `scripts` directory containing a valid Python module to be imported in your configs. This wasn't necessary for this bundle but if you want to include custom code in a bundle please follow the bundle tutorials on how to do this. -The `multi_gpu_train.yaml` config is defined as a "mixin" to implement DDP based multi-gpu training. The script +The `multi_gpu_train.yaml` config is defined as a "mixin" to implement DDP based multi-gpu training. The script `train_multigpu.sh` illustrates an example of how to invoke these configs together with `torchrun`. diff --git a/models/segmentation_template/docs/inference.sh b/models/segmentation_template/docs/inference.sh index 7ce03cd5..091e11c6 100755 --- a/models/segmentation_template/docs/inference.sh +++ b/models/segmentation_template/docs/inference.sh @@ -16,4 +16,3 @@ python -m monai.bundle run \ --config_file "$BUNDLE/configs/inference.yaml" \ --bundle_root "$BUNDLE" \ $@ - \ No newline at end of file diff --git a/models/segmentation_template/docs/run_monailabel.sh b/models/segmentation_template/docs/run_monailabel.sh index c724b681..955fd440 100755 --- a/models/segmentation_template/docs/run_monailabel.sh +++ b/models/segmentation_template/docs/run_monailabel.sh @@ -25,4 +25,4 @@ then fi cd "$LABELDIR" -monailabel start_server --app monaibundle --studies datasets --conf models $BUNDLENAME $* \ No newline at end of file +monailabel start_server --app monaibundle --studies datasets --conf models $BUNDLENAME $* diff --git a/models/segmentation_template/docs/test.sh b/models/segmentation_template/docs/test.sh index 2c314607..b5b6603f 100755 --- a/models/segmentation_template/docs/test.sh +++ b/models/segmentation_template/docs/test.sh @@ -16,4 +16,3 @@ python -m monai.bundle run \ --config_file "$BUNDLE/configs/test.yaml" \ --bundle_root "$BUNDLE" \ $@ - \ No newline at end of file diff --git a/models/segmentation_template/docs/train.sh b/models/segmentation_template/docs/train.sh index 57e0d84a..b56eef64 100755 --- a/models/segmentation_template/docs/train.sh +++ b/models/segmentation_template/docs/train.sh @@ -16,4 +16,3 @@ python -m monai.bundle run \ --config_file "$BUNDLE/configs/train.yaml" \ --bundle_root "$BUNDLE" \ $@ - \ No newline at end of file From 0b3d4b3b91a51b95971d7db8df562fa205c7b954 Mon Sep 17 00:00:00 2001 From: Eric Kerfoot Date: Fri, 6 Oct 2023 16:07:41 +0100 Subject: [PATCH 07/13] Update Signed-off-by: Eric Kerfoot --- models/segmentation_template/configs/metadata.json | 1 + 1 file changed, 1 insertion(+) diff --git a/models/segmentation_template/configs/metadata.json b/models/segmentation_template/configs/metadata.json index 446c56c5..30dedaed 100644 --- a/models/segmentation_template/configs/metadata.json +++ b/models/segmentation_template/configs/metadata.json @@ -1,4 +1,5 @@ { + "schema": "https://github.com/Project-MONAI/MONAI-extra-test-data/releases/download/0.8.1/meta_schema_20220324.json", "version": "0.0.1", "changelog": { "0.0.1": "Initial version" From 138d480ebbad90b9f0b51bdedb2380bd18ee4b0f Mon Sep 17 00:00:00 2001 From: Eric Kerfoot Date: Sat, 7 Oct 2023 00:52:32 +0100 Subject: [PATCH 08/13] Updates Signed-off-by: Eric Kerfoot --- models/segmentation_template/configs/metadata.json | 8 ++++---- models/segmentation_template/docs/README.md | 7 +++++++ 2 files changed, 11 insertions(+), 4 deletions(-) diff --git a/models/segmentation_template/configs/metadata.json b/models/segmentation_template/configs/metadata.json index 30dedaed..476df9ba 100644 --- a/models/segmentation_template/configs/metadata.json +++ b/models/segmentation_template/configs/metadata.json @@ -4,7 +4,7 @@ "changelog": { "0.0.1": "Initial version" }, - "monai_version": "1.3.0", + "monai_version": "1.3.0rc2", "pytorch_version": "2.0.1", "numpy_version": "1.25.2", "optional_packages_version": {}, @@ -17,7 +17,7 @@ "image": { "type": "image", "format": "magnitude", - "modality": "MR", + "modality": "none", "num_channels": 1, "spatial_shape": [ 128, @@ -51,8 +51,8 @@ "channel_def": { "0": "background", "1": "category 1", - "2": "category 1", - "3": "category 1" + "2": "category 2", + "3": "category 3" } } } diff --git a/models/segmentation_template/docs/README.md b/models/segmentation_template/docs/README.md index cc260c9e..6e145f7c 100644 --- a/models/segmentation_template/docs/README.md +++ b/models/segmentation_template/docs/README.md @@ -66,3 +66,10 @@ for this bundle but if you want to include custom code in a bundle please follow The `multi_gpu_train.yaml` config is defined as a "mixin" to implement DDP based multi-gpu training. The script `train_multigpu.sh` illustrates an example of how to invoke these configs together with `torchrun`. + +The `inference.yaml` config is compatible with MONAILabel such that you can load one of the synthetic images and perform +inference through a label server. This doesn't permit active learning however, that is a later enhancement for this +bundle. If you're changing definitions in the `inference.yaml` config file be careful about changing names and consult +the MONAILabel documentation about required definition names. An example script to start a server is given in +`run_monailabel.sh` which will download the bundle application and "install" this bundle using a symlink then start +the server. Future updates to MONAILabel will improve this process. From 483dc3cb602f6baf04823ee8fa00e63be40f1d58 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Fri, 6 Oct 2023 23:53:03 +0000 Subject: [PATCH 09/13] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- models/segmentation_template/docs/README.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/models/segmentation_template/docs/README.md b/models/segmentation_template/docs/README.md index 6e145f7c..e524b4ed 100644 --- a/models/segmentation_template/docs/README.md +++ b/models/segmentation_template/docs/README.md @@ -68,8 +68,8 @@ The `multi_gpu_train.yaml` config is defined as a "mixin" to implement DDP based `train_multigpu.sh` illustrates an example of how to invoke these configs together with `torchrun`. The `inference.yaml` config is compatible with MONAILabel such that you can load one of the synthetic images and perform -inference through a label server. This doesn't permit active learning however, that is a later enhancement for this +inference through a label server. This doesn't permit active learning however, that is a later enhancement for this bundle. If you're changing definitions in the `inference.yaml` config file be careful about changing names and consult -the MONAILabel documentation about required definition names. An example script to start a server is given in +the MONAILabel documentation about required definition names. An example script to start a server is given in `run_monailabel.sh` which will download the bundle application and "install" this bundle using a symlink then start -the server. Future updates to MONAILabel will improve this process. +the server. Future updates to MONAILabel will improve this process. From eb71e9aa1501e88ece51a49a3e99a6e7e43067b2 Mon Sep 17 00:00:00 2001 From: Eric Kerfoot Date: Mon, 9 Oct 2023 15:43:29 +0100 Subject: [PATCH 10/13] Updates Signed-off-by: Eric Kerfoot --- models/segmentation_template/configs/metadata.json | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/models/segmentation_template/configs/metadata.json b/models/segmentation_template/configs/metadata.json index 476df9ba..c9575ab9 100644 --- a/models/segmentation_template/configs/metadata.json +++ b/models/segmentation_template/configs/metadata.json @@ -4,10 +4,13 @@ "changelog": { "0.0.1": "Initial version" }, - "monai_version": "1.3.0rc2", + "monai_version": "1.2.0", "pytorch_version": "2.0.1", - "numpy_version": "1.25.2", - "optional_packages_version": {}, + "numpy_version": "1.24.4", + "optional_packages_version": { + "nibabel": "5.1.0", + "pytorch-ignite": "0.4.12" + }, "task": "Segmentation of randomly generated spheres in 3D images", "description": "This is a template bundle for segmenting in 3D, take this as a basis for your own bundles.", "authors": "Eric Kerfoot", From 97971e6c7ef780fb02bd318a8ab5663b229f47ba Mon Sep 17 00:00:00 2001 From: Eric Kerfoot <17726042+ericspod@users.noreply.github.com> Date: Mon, 9 Oct 2023 16:11:47 +0100 Subject: [PATCH 11/13] Update metadata.json Signed-off-by: Eric Kerfoot --- models/segmentation_template/configs/metadata.json | 1 + 1 file changed, 1 insertion(+) diff --git a/models/segmentation_template/configs/metadata.json b/models/segmentation_template/configs/metadata.json index c9575ab9..17b5d21c 100644 --- a/models/segmentation_template/configs/metadata.json +++ b/models/segmentation_template/configs/metadata.json @@ -11,6 +11,7 @@ "nibabel": "5.1.0", "pytorch-ignite": "0.4.12" }, + "name": "Segmentation Template", "task": "Segmentation of randomly generated spheres in 3D images", "description": "This is a template bundle for segmenting in 3D, take this as a basis for your own bundles.", "authors": "Eric Kerfoot", From a41ed83fd09e19fbbb9672c8b1228bc0c0ca70b1 Mon Sep 17 00:00:00 2001 From: Eric Kerfoot Date: Wed, 11 Oct 2023 14:11:17 +0100 Subject: [PATCH 12/13] Add to README Signed-off-by: Eric Kerfoot --- README.md | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/README.md b/README.md index aeb22edb..1c1d84d8 100644 --- a/README.md +++ b/README.md @@ -20,6 +20,14 @@ python -m monai.bundle download "wholeBody_ct_segmentation" --bundle_dir "bundle To get started with the models, please see [the example use cases](https://github.com/Project-MONAI/tutorials/tree/main/model_zoo). +## Template Bundles + +We aim to provide a number of template bundles in the zoo for you to copy and adapt to your own needs. +This should help you reduce effort in developing your own bundles and also demonstrate what we feel to be good practice and design. +We currently have the following: + + * [Segmentation Template](./models/segmentation_template) + ## License Bundles released on the MONAI Model Zoo require a license for the software itself comprising the configuration files and model weights. You are required to adhere to the license conditions included with each bundle, as well as any license conditions stated for data bundles may include or use (please check the file `docs/data_license.txt` if it is existing within the bundle directory). From ecc855128d7d3af9d49b01fb55123512a2bb05ef Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Wed, 11 Oct 2023 13:11:27 +0000 Subject: [PATCH 13/13] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 1c1d84d8..01e01496 100644 --- a/README.md +++ b/README.md @@ -22,7 +22,7 @@ To get started with the models, please see [the example use cases](https://githu ## Template Bundles -We aim to provide a number of template bundles in the zoo for you to copy and adapt to your own needs. +We aim to provide a number of template bundles in the zoo for you to copy and adapt to your own needs. This should help you reduce effort in developing your own bundles and also demonstrate what we feel to be good practice and design. We currently have the following: