From 93682e319623bb9d9201d0bf18b6035fb99c1e70 Mon Sep 17 00:00:00 2001 From: Eric Kerfoot <17726042+ericspod@users.noreply.github.com> Date: Thu, 12 Oct 2023 11:44:14 +0100 Subject: [PATCH] Segment Template (#514) Fixes #513 . ### Description This is the template for segmentation bundles. Users can create their own new bundles by copying and adapting this one. Multi-GPU support is a work in progress, it doesn't work for me but it should be fine. ### Status **Ready** ### Please ensure all the checkboxes: - [x] Codeformat tests passed locally by running `./runtests.sh --codeformat`. - [ ] In-line docstrings updated. - [ ] Update `version` and `changelog` in `metadata.json` if changing an existing bundle. - [ ] Please ensure the naming rules in config files meet our requirements (please refer to: `CONTRIBUTING.md`). - [x] Ensure versions of packages such as `monai`, `pytorch` and `numpy` are correct in `metadata.json`. - [x] Descriptions should be consistent with the content, such as `eval_metrics` of the provided weights and TorchScript modules. - [x] Files larger than 25MB are excluded and replaced by providing download links in `large_file.yml`. - [x] Avoid using path that contains personal information within config files (such as use `/home/your_name/` for `"bundle_root"`). --------- Signed-off-by: Eric Kerfoot Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com> --- README.md | 8 + models/segmentation_template/LICENSE | 21 ++ .../configs/inference.yaml | 113 ++++++++ .../configs/logging.conf | 21 ++ .../configs/metadata.json | 64 +++++ .../configs/multi_gpu_train.yaml | 37 +++ .../segmentation_template/configs/test.yaml | 125 +++++++++ .../segmentation_template/configs/train.yaml | 243 ++++++++++++++++++ models/segmentation_template/docs/README.md | 75 ++++++ .../docs/generate_data.ipynb | 195 ++++++++++++++ .../segmentation_template/docs/inference.sh | 18 ++ .../docs/run_monailabel.sh | 28 ++ models/segmentation_template/docs/test.sh | 18 ++ models/segmentation_template/docs/train.sh | 18 ++ .../docs/train_multigpu.sh | 34 +++ .../docs/visualise_inference.ipynb | 122 +++++++++ models/segmentation_template/large_files.yml | 5 + 17 files changed, 1145 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/multi_gpu_train.yaml 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 100755 models/segmentation_template/docs/inference.sh create mode 100755 models/segmentation_template/docs/run_monailabel.sh create mode 100755 models/segmentation_template/docs/test.sh create mode 100755 models/segmentation_template/docs/train.sh create mode 100755 models/segmentation_template/docs/train_multigpu.sh create mode 100644 models/segmentation_template/docs/visualise_inference.ipynb create mode 100644 models/segmentation_template/large_files.yml diff --git a/README.md b/README.md index aeb22edb..01e01496 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). 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..bbbb2c7f --- /dev/null +++ b/models/segmentation_template/configs/inference.yaml @@ -0,0 +1,113 @@ +# This implements the workflow for applying the network to a directory of images and saving the predicted segmentations. + +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' + inferer: '@inferer' + 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..17b5d21c --- /dev/null +++ b/models/segmentation_template/configs/metadata.json @@ -0,0 +1,64 @@ +{ + "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" + }, + "monai_version": "1.2.0", + "pytorch_version": "2.0.1", + "numpy_version": "1.24.4", + "optional_packages_version": { + "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", + "copyright": "Copyright (c) 2023 MONAI Consortium", + "network_data_format": { + "inputs": { + "image": { + "type": "image", + "format": "magnitude", + "modality": "none", + "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 2", + "3": "category 3" + } + } + } + } +} 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..26cf222b --- /dev/null +++ b/models/segmentation_template/configs/multi_gpu_train.yaml @@ -0,0 +1,37 @@ +# 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' +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) + 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) # 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 new file mode 100644 index 00000000..70f0991b --- /dev/null +++ b/models/segmentation_template/configs/test.yaml @@ -0,0 +1,125 @@ +# This implements the workflow for applying the network to a directory of images and measuring network performance with metrics. + +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 +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 if save_pred is true + +# 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 +imgs: '$sorted(glob.glob(@dataset_dir+''/img*.nii.gz''))' +lbls: '$[i.replace(''img'',''lbl'') for i in @imgs]' +data_dicts: '$[{@image: i, @label: l} for i, l in zip(@imgs, @lbls)]' + +# these transforms are used for inference to load and regularise inputs +transforms: +- _target_: LoadImaged + keys: '@both_keys' + image_only: true +- _target_: EnsureChannelFirstd + keys: '@both_keys' +- _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 + _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' + +# 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' + key_val_metric: + val_mean_dice: + _target_: MeanDice + include_background: false + output_transform: $monai.handlers.from_engine([@pred, @label]) + val_handlers: '@handlers' + +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 new file mode 100644 index 00000000..8f7a20b4 --- /dev/null +++ b/models/segmentation_template/configs/train.yaml @@ -0,0 +1,243 @@ +# 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 +- $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'] + +# 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 +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: 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 + +# 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 + _disabled_: '@is_not_rank0' # only need rank 0 to save + 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 + _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' + 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..e524b4ed --- /dev/null +++ b/models/segmentation_template/docs/README.md @@ -0,0 +1,75 @@ + +# 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. 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. diff --git a/models/segmentation_template/docs/generate_data.ipynb b/models/segmentation_template/docs/generate_data.ipynb new file mode 100644 index 00000000..19b7ef0c --- /dev/null +++ b/models/segmentation_template/docs/generate_data.ipynb @@ -0,0 +1,195 @@ +{ + "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", + "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:" + ] + }, + { + "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 100755 index 00000000..091e11c6 --- /dev/null +++ b/models/segmentation_template/docs/inference.sh @@ -0,0 +1,18 @@ +#! /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" \ + $@ diff --git a/models/segmentation_template/docs/run_monailabel.sh b/models/segmentation_template/docs/run_monailabel.sh new file mode 100755 index 00000000..955fd440 --- /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 $* diff --git a/models/segmentation_template/docs/test.sh b/models/segmentation_template/docs/test.sh new file mode 100755 index 00000000..b5b6603f --- /dev/null +++ b/models/segmentation_template/docs/test.sh @@ -0,0 +1,18 @@ +#! /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" \ + $@ diff --git a/models/segmentation_template/docs/train.sh b/models/segmentation_template/docs/train.sh new file mode 100755 index 00000000..b56eef64 --- /dev/null +++ b/models/segmentation_template/docs/train.sh @@ -0,0 +1,18 @@ +#! /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" \ + $@ diff --git a/models/segmentation_template/docs/train_multigpu.sh b/models/segmentation_template/docs/train_multigpu.sh new file mode 100755 index 00000000..fc58def5 --- /dev/null +++ b/models/segmentation_template/docs/train_multigpu.sh @@ -0,0 +1,34 @@ +#! /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" + +# 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 + +# 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 \ + --config_file "$CONFIG" \ + --bundle_root $BUNDLE \ + $@ diff --git a/models/segmentation_template/docs/visualise_inference.ipynb b/models/segmentation_template/docs/visualise_inference.ipynb new file mode 100644 index 00000000..2b408e20 --- /dev/null +++ b/models/segmentation_template/docs/visualise_inference.ipynb @@ -0,0 +1,122 @@ +{ + "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", + "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", + "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": 4, + "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": 4, + "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 +} 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"