Configuration File¶

All parameters used for loading data, training and predicting are contained within a single JSON configuration file. This section describes how to set up this configuration file.

For convenience, here is an generic configuration file: config_config.json.

Below are other, more specific configuration files:

config_classification.json: Trains a classification model.
config_sctTesting.json: Trains a 2D segmentation task with the U-Net architecture.
config_spineGeHemis.json: Trains a segmentation task with the HeMIS-UNet architecture.
config_tumorSeg.json: Trains a segmentation task with a 3D U-Net architecture.

General Parameters¶

command¶

Run the specified command.
type	string
options
`train`	train a model on a training/validation sub-datasets
`test`	evaluate a trained model on a testing sub-dataset
`segment`	segment a entire dataset using a trained model

{
    "command": "train"
}

gpu_ids¶

List of IDs of one or more GPUs to use.
type	list integer*

{
    "gpu_ids": [1,2,3]
}

Note

Currently only ivadomed_automate_training supports the use of more than one GPU.

log_directory¶

Folder name that will contain the output files (e.g., trained model, predictions, results).
type	string

{
    "path_output": "tmp/spineGeneric"
}

model_name¶

Folder name containing the trained model (ONNX format) and its configuration file, located within `log_directory/`
type	string

"log_directory/seg_gm_t2star/seg_gm_t2star.onnx"
"log_directory/seg_gm_t2star/seg_gm_t2star.json"

When possible, the folder name will follow the following convention: task_(animal)_region_(contrast) with

task = {seg, label, find}
animal = {human, dog, cat, rat, mouse, ...}
region = {sc, gm, csf, brainstem, ...}
contrast = {t1, t2, t2star, dwi, ...}

{
    "model_name": "seg_gm_t2star"
}

debugging¶

Extended verbosity and intermediate outputs.
type	boolean

{
    "debugging": true
}

log_file¶

Name of the file to be logged to, located within `log_directory/`
type	string

{
    "log_file": "log"
}

Loader Parameters¶

path_data¶

Path(s) of the BIDS folder(s).
type	list or str

{
    "loader_parameters": {
        "path_data": ["path/to/data_example_spinegeneric", "path/to/other_data_example"]
    }
}

Alternatively:

{
    "loader_parameters": {
        "path_data": "path/to/data_example_spinegeneric"
    }
}

bids_config¶

(Optional). Path of the custom BIDS configuration file for BIDS non-compliant modalities
type	string

{
    "loader_parameters": {
        "bids_config": "ivadomed/config/config_bids.json"
    }
}

subject_selection¶

Used to specify a custom subject selection from a dataset.
type	dict
options
`n`	List containing the number subjects of each metadata.
	type	list
`metadata`	List of metadata used to select the subjects. Each metadata should be the name of a column from the participants.tsv file.
	type	list
`value`	List of metadata values of the subject to be selected.
	type	list

{
    "loader_parameters": {
        "subject_selection": {
            "n": [5, 10],
            "metadata": ["disease", "disease"],
            "value": ["healthy", "ms"]
        }
    }
}

In this example, a subdataset composed of 5 healthy subjects and 10 ms subjects will be selected for training/testing.

target_suffix¶

Suffix list of the derivative file containing the ground-truth of interest.
type	list string*

{
    "loader_parameters": {
        "target_suffix": ["_seg-manual", "_lesion-manual"]
    }
}

The length of this list controls the number of output channels of the model (i.e. out_channel). If the list has a length greater than 1, then a multi-class model will be trained. If a list of list(s) is input for a training, (e.g. [["_seg-manual-rater1", "_seg-manual-rater2"], ["_lesion-manual-rater1", "_lesion-manual-rater2"]), then each sublist is associated with one class but contains the annotations from different experts: at each training iteration, one of these annotations will be randomly chosen.

extensions¶

Used to specify a list of file extensions to be selected for training/testing. If not specified, then .nii and .nii.gz will be used by default.
type	list, string

{
    "loader_parameters": {
        "extensions": [".png"]
    }
}

contrast_params¶

type	dict
options
`train_validation`	List of image contrasts (e.g. `T1w`, `T2w`) loaded for the training and validation. If `multichannel` is `true`, this list represents the different channels of the input tensors (i.e. its length equals model’s `in_channel`). Otherwise, the contrasts are mixed and the model has only one input channel (i.e. model’s `in_channel=1`)
	type	list, string
`test`	List of image contrasts (e.g. `T1w`, `T2w`) loaded in the testing dataset. Same comment as for `train_validation` regarding `multichannel`.
	type	list, string
`balance`	Enables to weight the importance of specific channels (or contrasts) in the dataset: e.g. `{'T1w': 0.1}` means that only 10% of the available `T1w` images will be included into the training/validation/test set. Please set `multichannel` to `false` if you are using this parameter.
	type	dict

{
    "loader_parameters": {
        "contrast_params": {
            "training_validation": ["T1w", "T2w", "T2star"],
            "testing": ["T1w", "T2w", "T2star"],
            "balance": {}
        }
    }
}

multichannel¶

Indicated if more than a contrast (e.g. `T1w` and `T2w`) is used by the model.
type	boolean

See details in both train_validation and test for the contrasts that are input.

{
    "loader_parameters": {
        "multichannel": false
    }
}

slice_axis¶

Sets the slice orientation for 3D NIfTI files on which the model will be used.
type	string
options
`sagittal`	plane dividing body into left/right
`coronal`	plane dividing body into front/back
`axial`	plane dividing body into top/bottom

{
    "loader_parameters": {
        "slice_axis": "sagittal"
    }
}

slice_filter_params¶

Discard a slice from the dataset if it meets a condition, see below.
type	dict
options
`filter_empty_input`	Discard slices where all voxel intensities are zeros.
	type	boolean
`filter_empty_mask`	Discard slices where all voxel labels are zeros.
	type	boolean
`filter_absent_class`	Discard slices where all voxel labels are zero for one or more classes (this is most relevant for multi-class models that need GT for all classes at train time).
	type	boolean
`filter_classification`	Discard slices where all images fail a custom classifier filter. If used, `classifier_path` must also be specified, pointing to a saved PyTorch classifier.
	type	boolean

{
    "loader_parameters": {
        "slice_filter_params": {
            "filter_empty_mask": false,
            "filter_empty_input": true
        }
    }
}

roi_params¶

Parameters for the region of interest
type	dict
options
`suffix`	Suffix of the derivative file containing the ROI used to crop (e.g. `_seg-manual`) with `ROICrop` as transform. Please use `null` if you do not want to use an ROI to crop.
	type	string
`slice_filter_roi`	If the ROI mask contains less than `slice_filter_roi` non-zero voxels the slice will be discarded from the dataset. This feature helps with noisy labels, e.g., if a slice contains only 2-3 labeled voxels, we do not want to use these labels to crop the image. This parameter is only considered when using `ROICrop`.
	type	int

{
    "loader_parameters": {
        "roi_params": {
            "suffix": null,
            "slice_filter_roi": null
        }
    }
}

soft_gt¶

Indicates if a soft mask will be used as ground-truth to train

and / or evaluate a model. In particular, the masks are not binarized

after interpolations implied by preprocessing or data-augmentation operations.

type

boolean

{
    "loader_parameters": {
        "soft_gt": true
    }
}

is_input_dropout¶

Indicates if input-level dropout should be applied during training.

This option trains a model to be robust to missing modalities by setting

to zero input channels (from 0 to all channels - 1). Always at least one

channel will remain. If one or more modalities are already missing, they will

be considered as dropped.

type

boolean

{
    "loader_parameters": {
        "is_input_dropout": true
    }
}

Split Dataset¶

fname_split¶

File name of the log (joblib)

that contains the list of training/validation/testing filenames. This file can later

be used to re-train a model using the same data splitting scheme. If null,

a new splitting scheme is performed. If specified, the .joblib file data splitting scheme

bypasses all the other split dataset parameters.

type string

{
    "split_dataset": {
        "fname_split": null
    }
}

random_seed¶

Seed used by the random number generator to split the dataset between

training/validation/testing sets. The use of the same seed ensures the same split between

the sub-datasets, which is useful for reproducibility.

type

int

{
    "split_dataset": {
        "random_seed": 6
    }
}

split_method¶

Metadata contained in a BIDS tabular file on which the files are shuffled, then split

between train/validation/test, according to train_fraction and test_fraction.

For example, participant_id from the participants.tsv file will shuffle all participants,

then split between train/validation/test sets.

type string

{
    "split_dataset": {
        "split_method": "participant_id"
    }
}

data_testing¶

(Optional) Used to specify a custom metadata to only include in the testing dataset (not validation). For example, to not mix participants from different institutions between the train/validation set and the test set, use the column `institution_id` from `participants.tsv` in `data_type`.
type	dict
options
`data_type`	Metadata to include in the testing dataset. If specified, the `test_fraction` is applied to this metadata.
	type	string
`data_value`	(Optional) List of metadata values from the `data_type` column to include in the testing dataset. If specified, the testing set contains only files from the `data_value` list and the `test_fraction` is not used.
	type	list

{
    "split_dataset": {
        "data_testing": {"data_type": "institution_id", "data_value":[]}
    }
}

balance¶

Metadata contained in participants.tsv file with categorical values. Each category

will be evenly distributed in the training, validation and testing datasets.

type string

required false

{
    "split_dataset": {
        "balance": null
    }
}

train_fraction¶

Fraction of the dataset used as training set.
type	float
range	[0, 1]

{
    "split_dataset": {
        "train_fraction": 0.6
    }
}

test_fraction¶

Fraction of the dataset used as testing set.
type	float
range	[0, 1]

{
    "split_dataset": {
        "test_fraction": 0.2
    }
}

Training Parameters¶

batch_size¶

type	int
range	(0, inf)

{
    "training_parameters": {
        "batch_size": 24
    }
}

loss¶

Metadata for the loss function. Other parameters that could be needed in the Loss function definition: see attributes of the Loss function of interest (e.g. `'gamma': 0.5` for `FocalLoss`).
type	dict
options
`name`	Name of the loss function class. See `ivadomed.losses`
	type	string

{
    "training_parameters": {
        "loss": {
            "name": "DiceLoss"
        }
    }
}

training_time¶

Metadata for the loss function. Other parameters that could be needed in the Loss function definition: see attributes of the Loss function of interest (e.g. `'gamma': 0.5` for `FocalLoss`).
type	dict
options
`num_epochs`	type	int
	range	(0, inf)
`early_stopping_epsilon`	If the validation loss difference during one epoch (i.e. `abs(validation_loss[n] - validation_loss[n-1]` where n is the current epoch) is inferior to this epsilon for `early_stopping_patience` consecutive epochs, then training stops.
	type	float
`early_stopping_patience`	Number of epochs after which the training is stopped if the validation loss improvement is smaller than `early_stopping_epsilon`.
	type	int
	range	(0, inf)

{
    "training_parameters": {
        "training_time": {
            "num_epochs": 100,
            "early_stopping_patience": 50,
            "early_stopping_epsilon": 0.001
        }
    }
}

scheduler¶

type	dict
options
`initial_lr`	Initial learning rate.
	type	float
`scheduler_lr`	Other parameters depend on the scheduler of interest
	type	dict
	options
	`name`	One of `CosineAnnealingLR`, `CosineAnnealingWarmRestarts` and `CyclicLR`. Please find documentation here.
		type	string

{
    "training_parameters": {
        "scheduler": {
            "initial_lr": 0.001,
            "scheduler_lr": {
                "name": "CosineAnnealingLR",
                "max_lr": 1e-2,
                "base_lr": 1e-5
            }
        }
    }
}

balance_samples¶

Balance labels in both the training and the validation datasets.
type	dict
options
`applied`	Indicates whether to use a balanced sampler or not.
	type	boolean
`type`	Indicates which metadata to use to balance the sampler. Choices: `gt` or the name of a column from the `participants.tsv` file (i.e. subject-based metadata)
	type	string

{
    "training_parameters": {
        "balance_samples": {
            "applied": false,
            "type": "gt"
        }
    }
}

mixup_alpha¶

Alpha parameter of the Beta distribution, see original paper on the Mixup technique.
type	float

{
    "training_parameters": {
        "mixup_alpha": null
    }
}

transfer_learning¶

type	dict
options
`retrain_model`	Filename of the pretrained model (`path/to/pretrained-model`). If `null`, no transfer learning is performed and the network is trained from scratch.
	type	string
`retrain_fraction`	Controls the fraction of the pre-trained model that will be fine-tuned. For instance, if set to 0.5, the second half of the model will be fine-tuned while the first layers will be frozen.
	type	float
	range	[0, 1]
`reset`	If true, the weights of the layers that are not frozen are reset. If false, they are kept as loaded.
	type	boolean

 {
     "training_parameters": {
         "transfer_learning": {
             "retrain_model": null,
             "retrain_fraction": 1.0,
             "reset": true
         }
     }
}

Architecture¶

Architectures for both segmentation and classification are available and described in the Architectures section. If the selected architecture is listed in the loader file, a classification (not segmentation) task is run. In the case of a classification task, the ground truth will correspond to a single label value extracted from target, instead being an array (the latter being used for the segmentation task).

default_model¶

Define the default model (`Unet`) and mandatory parameters that are common to all available Architectures. For custom architectures (see below), the default parameters are merged with the parameters that are specific to the tailored architecture.
type	dict
required	true
options
`name`	Default: `Unet`
	type	string
`dropout_rate`	type	float
`bn_momentum`	Defines the importance of the running average: (1 - bn_momentum). A large running average factor will lead to a slow and smooth learning. See PyTorch’s BatchNorm classes for more details. for more details.
	type	float
`depth`	Number of down-sampling operations.
	type	int
	range	(0, inf)
`final_activation`	Final activation layer. Options: `sigmoid` (default), relu``(normalized ReLU), or ``softmax.
	type	string
	required	false
`length_2D`	(Optional) Size of the 2D patches used as model’s input tensors.
	type	[int, int]
	required	false
`stride_2D`	(Optional) Strictly positive integers: Pixels’ shift over the input matrix to create 2D patches. Ex: Stride of [1, 2] will cause a patch translation of 1 pixel in the 1st dimension and 2 pixels in the 2nd dimension at every iteration until the whole input matrix is covered.
	type	[int, int]
	required	false
`is_2d`	Indicates if the model is 2D, if not the model is 3D. If `is_2d` is `False`, then parameters `length_3D` and `stride_3D` for 3D loader need to be specified (see Modified3DUNet).
	type	boolean

{
    "default_model": {
        "name": "Unet",
        "dropout_rate": 0.4,
        "batch_norm_momentum": 0.1
    }
}

FiLMedUnet¶

type	dict
required	false
options
`applied`	Set to `true` to use this model.
	type	boolean
`metadata`	Choice between `mri_params`, `contrasts` (i.e. image-based metadata) or the name of a column from the participants.tsv file (i.e. subject-based metadata).
	type	string
	options
	`mri_params`	Vectors of `[FlipAngle, EchoTime, RepetitionTime, Manufacturer]` (defined in the json of each image) are input to the FiLM generator.
	`contrast`	Image contrasts (according to `config/contrast_dct.json`) are input to the FiLM generator.

{
    "FiLMedUnet": {
        "applied": false,
        "metadata": "contrasts",
        "film_layers": [0, 1, 0, 0, 0, 0, 0, 0, 0, 0]
    }
}

HeMISUnet¶

type	dict
required	false
options
`applied`	Set to `true` to use this model.
	type	boolean
`missing_probability`	Initial probability of missing image contrasts as model’s input (e.g. 0.25 results in a quarter of the image contrasts, i.e. channels, that will not be sent to the model for training).
	type	float
	range	[0, 1]
`missing_probability_growth`	Controls missing probability growth at each epoch: at each epoch, the `missing_probability` is modified with the exponent `missing_probability_growth`.
	type	float

{
    "HeMISUnet": {
        "applied": true,
        "missing_probability": 0.00001,
        "missing_probability_growth": 0.9,
        "contrasts": ["T1w", "T2w"],
        "ram": true,
        "path_hdf5": "/path/to/HeMIS.hdf5",
        "csv_path": "/path/to/HeMIS.csv",
        "target_lst": ["T2w"],
        "roi_lst": null
    }
}

Modified3DUNet¶

type	dict
required	false
options
`length_3D`	Size of the 3D patches used as model’s input tensors.
	type	[int, int, int]
`stride_3D`	Voxels’ shift over the input matrix to create patches. Ex: Stride of [1, 2, 3] will cause a patch translation of 1 voxel in the 1st dimension, 2 voxels in the 2nd dimension and 3 voxels in the 3rd dimension at every iteration until the whole input matrix is covered.
	type	[int, int, int]
`attention_unet`	Use attention gates in the Unet’s decoder.
	type	boolean
	required	false
`n_filters`	Number of filters in the first convolution of the UNet. This number of filters will be doubled at each convolution.
	type	int
	required	false

{
    "Modified3DUNet": {
        "applied": false,
        "length_3D": [128, 128, 16],
        "stride_3D": [128, 128, 16],
        "attention": false,
        "n_filters": 8
    }
}

Cascaded Architecture Features¶

object_detection_params¶

type	dict
required	false
options
`object_detection_path`	Path to object detection model and the configuration file. The folder, configuration file, and model need to have the same name (e.g. `findcord_tumor/`, `findcord_tumor/findcord_tumor.json`, and `findcord_tumor/findcord_tumor.onnx`, respectively). The model’s prediction will be used to generate bounding boxes.
	type	string
`safety_factor`	List of length 3 containing the factors to multiply each dimension of the bounding box. Ex: If the original bounding box has a size of 10x20x30 with a safety factor of [1.5, 1.5, 1.5], the final dimensions of the bounding box will be 15x30x45 with an unchanged center.
	type	[int, int, int]

{
    "object_detection_params": {
        "object_detection_path": null,
        "safety_factor": [1.0, 1.0, 1.0]
    }
}

Transformations¶

Transformations applied during data augmentation. Transformations are sorted in the order they are applied to the image samples. For each transformation, the following parameters are customizable:

applied_to: list between "im", "gt", "roi". If not specified, then the transformation is applied to all loaded samples. Otherwise, only applied to the specified types: Example: ["gt"] implies that this transformation is only applied to the ground-truth data.
dataset_type: list between "training", "validation", "testing". If not specified, then the transformation is applied to the three sub-datasets. Otherwise, only applied to the specified subdatasets. Example: ["testing"] implies that this transformation is only applied to the testing sub-dataset.

Available Transformations:¶

NumpyToTensor¶

Converts nd array to tensor object.
type	dict

{
    "transformation": {
        "NumpyToTensor": {
            "applied_to": ["im", "gt"]
        }
    }
}

CenterCrop¶

type	dict
options
`size`	type	list, int
`applied_to`	type	list, string

{
    "transformation": {
        "CenterCrop": {
            "applied_to": ["im", "gt"],
            "size":  [512, 256, 16]
        }
    }
}

ROICrop¶

type	dict
options
`size`	type	list, int
`applied_to`	type	list, string

{
    "transformation": {
        "ROICrop": {
            "size": [48, 48]
        }
    }
}

NormalizeInstance¶

Normalize a tensor or an array image with mean and standard deviation estimated from

the sample itself.

type

dict

{
    "transformation": {
        "NormalizeInstance": {}
    }
}

RandomAffine¶

type	dict
options
`degrees`	Positive float or list (or tuple) of length two. Angles in degrees. If only a float is provided, then rotation angle is selected within the range [-degrees, degrees]. Otherwise, the tuple defines this range.
	type	float or tuple of float
	range	(0, inf)
`translate`	Length 2 or 3 depending on the sample shape (2D or 3D). Defines the maximum range of translation along each axis.
	type	list, float
	range	[0, 1]
`scale`	Length 2 or 3 depending on the sample shape (2D or 3D). Defines the maximum range of scaling along each axis.
	type	list, float
	range	[0, 1]

{
    "transformation": {
        "RandomAffine": {
            "translate": [0.03, 0.03],
            "applied_to": ["im"],
            "dataset_type": ["training"],
            "scale": [0.1, 0.5],
            "degrees": 180
        }
    }
}

RandomShiftIntensity¶

type	dict
options
`shift_range`	Range from which the offset applied is randomly selected.
	type	[float, float]

{
    "transformation": {
        "RandomShiftIntensity": {
            "shift_range": [28.0, 30.0]
        }
    }
 }

ElasticTransform¶

Applies elastic transformation. See also: Best practices for convolutional neural networks applied to visual document analysis.
type	dict
options
`alpha_range`	Deformation coefficient.
	type	(float, float)
`sigma_range`	Standard deviation.
	type	(float, float)
`p`	type	float

{
    "transformation": {
        "ElasticTransform": {
            "alpha_range": [28.0, 30.0],
            "sigma_range":  [3.5, 4.5],
            "p": 0.1,
            "applied_to": ["im", "gt"],
            "dataset_type": ["training"]
        }
    }
}

Resample¶

type	dict
options
`wspace`	Resolution along the first axis, in mm.
	type	float
	range	[0, 1]
`hspace`	Resolution along the second axis, in mm.
	type	float
	range	[0, 1]
`dspace`	Resolution along the third axis, in mm.
	type	float
	range	[0, 1]

{
    "transformation": {
        "Resample": {
            "wspace": 0.75,
            "hspace": 0.75,
            "dspace": 1
        }
    }
}

AdditiveGaussianNoise¶

type	dict
options
`mean`	Mean of Gaussian noise.
	type	float
`std`	Standard deviation of Gaussian noise.
	type	float

{
    "transformation": {
        "AdditiveGaussianNoise": {
            "mean": 0.0,
            "std": 0.02
        }
    }
}

DilateGT¶

type	dict
options
`dilation_factor`	Controls the number of iterations of ground-truth dilation depending on the size of each individual lesion, data augmentation of the training set. Use `0` to disable.
	type	float

{
    "transformation": {
        "DilateGT": {
            "dilation_factor": 0
        }
    }
}

HistogramClipping¶

Perform intensity clipping based on percentiles.
type	dict
options
`min_percentile`	type	float
	range	[0, 100]
`max_percentile`	type	float
	range	[0, 100]

{
    "transformation": {
        "HistogramClipping": {
            "min_percentile": 50,
            "max_percentile": 75
        }
    }
}

Clahe¶

type	dict
options
`clip_limit`	type	float
`kernel_size`	Defines the shape of contextual regions used in the algorithm. List length = dimension, i.e. 2D or 3D
	type	list, int

{
    "transformation": {
        "Clahe": {
            "clip_limit": 0.5,
            "kernel_size": [8, 8]
        }
    }
}

RandomReverse¶

Make a randomized symmetric inversion of the different values of each dimensions.
type	dict

{
    "transformation": {
        "RandomReverse": {
            "applied_to": ["im"]
        }
    }
}

Uncertainty¶

Uncertainty computation is performed if n_it>0 and at least epistemic or aleatoric is true. Note: both epistemic and aleatoric can be true.

epistemic¶

Model-based uncertainty with Monte Carlo Dropout.
type	boolean

{
    "uncertainty": {
        "epistemic": true
    }
}

aleatoric¶

Image-based uncertainty with test-time augmentation.
type	boolean

{
    "uncertainty": {
        "aleatoric": true
    }
}

n_it¶

Number of Monte Carlo iterations. Set to 0 for no uncertainty computation.
type	int

{
    "uncertainty": {
        "n_it": 2
    }
}

Postprocessing¶

binarize_prediction¶

Binarizes predictions according to the given threshold `thr`. Predictions below the threshold become 0, and predictions above or equal to threshold become 1.
type	dict
options
`thr`	Threshold. To use soft predictions (i.e. no binarisation, float between 0 and 1) for metric computation, indicate -1.
	type	float
	range	[0, 1]

{
    "postprocessing": {
        "binarize_prediction": {
            "thr": 0.1
        }
    }
}

binarize_maxpooling¶

Binarize by setting to 1 the voxel having the maximum prediction across all classes.

Useful for multiclass models. No parameters required (i.e., {}).

type

dict

{
    "postprocessing": {
        "binarize_maxpooling": {}
    }
}

fill_holes¶

Fill holes in the predictions. No parameters required (i.e., {}).
type	dict

{
    "postprocessing": {
        "fill_holes": {}
    }
}

keep_largest¶

Keeps only the largest connected object in prediction. Only nearest neighbors are

connected to the center, diagonally-connected elements are not considered neighbors.

No parameters required (i.e., {})

type

dict

{
    "postprocessing": {
        "keep_largest": {}
    }
}

remove_noise¶

Sets to zero prediction values strictly below the given threshold `thr`.
type	dict
options
`thr`	Threshold. Threshold set to `-1` will not apply this postprocessing step.
	type	float
	range	[0, 1]

{
    "postprocessing": {
        "remove_noise": {
            "thr": 0.1
        }
    }
}

remove_small¶

Remove small objects from the prediction. An object is defined as a group of connected voxels. Only nearest neighbors are connected to the center, diagonally-connected elements are not considered neighbors.
type	dict
options
`thr`	Minimal object size. If a list of thresholds is chosen, the length should match the number of predicted classes.
	type	int or list
`unit`	Either vox for voxels or mm3. Indicates the unit used to define the minimal object size.
	type	string

{
    "postprocessing": {
        "remove_small": {
            "unit": "vox",
            "thr": 3
        }
    }
}

threshold_uncertainty¶

Removes the most uncertain predictions (set to 0) according to a threshold `thr` using the uncertainty file with the suffix `suffix`. To apply this method, uncertainty needs to be evaluated on the predictions with the uncertainty parameter.
type	dict
options
`thr`	Threshold. Threshold set to `-1` will not apply this postprocessing step.
	type	float
	range	[0, 1]
`suffix`	Indicates the suffix of an uncertainty file. Choices: `_unc-vox.nii.gz` for voxel-wise uncertainty, `_unc-avgUnc.nii.gz` for structure-wise uncertainty derived from mean value of `_unc-vox.nii.gz` within a given connected object, `_unc-cv.nii.gz` for structure-wise uncertainty derived from coefficient of variation, `_unc-iou.nii.gz` for structure-wise measure of uncertainty derived from the Intersection-over-Union of the predictions, or `_soft.nii.gz` to threshold on the average of Monte Carlo iterations.
	type	string

{
    "postprocessing": {
        "threshold_uncertainty": {
            "thr": -1,
            "suffix": "_unc-vox.nii.gz"
        }
    }
}

Evaluation Parameters¶

Dict. Parameters to get object detection metrics (true positive and false detection rates), and this, for defined object sizes.

target_size¶

type	dict
options
`thr`	These values will create several consecutive target size bins. For instance with a list of two values, we will have three target size bins: minimal size to first list element, first list element to second list element, and second list element to infinity.
	type	list, int
`unit`	Either vox for voxels or mm3. Indicates the unit used to define the target object sizes.
	type	string

{
    "evaluation_parameters": {
        "target_size": {
            "thr": [20, 100],
            "unit": "vox"
        }
    }
}

overlap¶

type	dict
options
`thr`	Minimal object size overlapping to be considered a TP, FP, or FN.
	type	int
`unit`	Either vox for voxels or mm3. Indicates the unit used to define the overlap.
	type	string

{
    "evaluation_parameters": {
        "overlap": {
            "thr": 30,
            "unit": "vox"
        }
    }
}