Upload segmentation_template version 0.0.3

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.

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:
+- [email protected]()

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

configs/metadata.json

@@ -0,0 +1,66 @@
+{
+    "schema": "https://github.com/Project-MONAI/MONAI-extra-test-data/releases/download/0.8.1/meta_schema_20220324.json",
+    "version": "0.0.3",
+    "changelog": {
+        "0.0.3": "update to huggingface hosting",
+        "0.0.2": "Minor train.yaml clarifications",
+        "0.0.1": "Initial version"
+    },
+    "monai_version": "1.4.0",
+    "pytorch_version": "2.4.0",
+    "numpy_version": "1.24.4",
+    "optional_packages_version": {
+        "nibabel": "5.2.1",
+        "pytorch-ignite": "0.4.11"
+    },
+    "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"
+                }
+            }
+        }
+    }
+}

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
+- [email protected]()
+- $dist.destroy_process_group()

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:
+- [email protected]()
+- '$print(''Per-image Dice:\n'',@evaluator.state.metric_details[''val_mean_dice''].cpu().numpy())'

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  # convert ground truth to one-hot for training
+  softmax: true  # softmax applied to prediction
+
+# hyperparameters could be added for other arguments of this class
+optimizer:
+  _target_: torch.optim.Adam
+  params: [email protected]()
+  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 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'  # uncomment if you have train metrics that need post-processing
+  key_train_metric: null
+  train_handlers: '@handlers'
+
+run:
+- [email protected]()

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.

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": [
+       "<matplotlib.image.AxesImage at 0x7fe2c5f74be0>"
+      ]
+     },
+     "execution_count": 47,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "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
+}

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" \
+    $@

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 $*

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" \
+    $@

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" \
+    $@

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 \
+    $@

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": [
+       "<matplotlib.image.AxesImage at 0x7fb2d02e7130>"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x1000 with 3 Axes>"
+      ]
+     },
+     "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
+}

models/model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c8a904f1ae9f7f1ff2a7936e93ca546dda8e4fce692af53ab808652a390fbd21
+size 1218370