def build_longitudinal_consensus(labels_dir_1,
labels_dir_2,
result_dir,
recompute=True):
# create result dir
utils.mkdir(result_dir)
# list all segmentations
path_labels_1 = utils.list_files(labels_dir_1)
path_labels_2 = utils.list_files(labels_dir_2)
for path_lab_1, path_lab_2 in zip(path_labels_1, path_labels_2):
# check if result is already saved
path_result = os.path.join(result_dir, os.path.basename(path_lab_1))
if (not os.path.isfile(path_result)) | recompute:
# load volumes
lab_1, aff, h = utils.load_volume(path_lab_1, im_only=False)
lab_2 = utils.load_volume(path_lab_2)
# compute and save consensus
dist_masp_1 = edit_volumes.compute_distance_map(lab_1,
crop_margin=20)
dist_masp_2 = edit_volumes.compute_distance_map(lab_2,
crop_margin=20)
consensus = (np.mean(np.stack([dist_masp_1, dist_masp_2], axis=-1),
axis=-1) > 0) * 1
utils.save_volume(consensus, aff, h, path_result)
def validate_training(image_dir,
gt_dir,
models_dir,
validation_main_dir,
path_label_list,
step_eval=1,
cropping=None,
conv_size=3,
n_levels=5,
nb_conv_per_level=2,
feat_multiplier=1,
activation='elu',
recompute=True):
"""This function validates models saved at different epochs of the same training.
All models are assumed to be in the same folder.contained in models_dir.
The results of each model are saved in a subfolder in validation_main_dir.
:param image_dir: path of the folder with validation images.
:param gt_dir: path of the folder with ground truth label maps.
These are matched to the validation images by sorting order.
:param models_dir: path of the folder with the models to validate.
:param validation_main_dir: path of the folder where all the models validation subfolders will be saved.
:param path_label_list: path of the numpy array containing all the label values to validate on.
:param step_eval: (optional) If step_eval > 1 skips models when validating, by validating on models step_eval apart.
:param cropping: (optional) whether to crop the input to smaller size while being run through the network.
The result is then given in the original image space. Can be an int, a sequence, or a 1d numpy array.
:param n_levels: (optional) number of level for the Unet. Default is 5.
:param nb_conv_per_level: (optional) number of convolutional layers per level. Default is 2.
:param conv_size: (optional) size of the convolution kernels. Default is 2.
:param feat_multiplier: (optional) multiply the number of feature by this nummber at each new level. Default is 1.
:param activation: (optional) activation function. Can be 'elu', 'relu'.
:param recompute: (optional) whether to recompute result files even if they already exists."""
# create result folder
if not os.path.exists(os.path.join(validation_main_dir)):
os.mkdir(validation_main_dir)
# loop over models
list_models = utils.list_files(models_dir, expr=['dice', 'h5'], cond_type='and')[::step_eval]
for model_idx, path_model in enumerate(list_models):
# build names and create folders
model_val_dir = os.path.join(validation_main_dir, os.path.basename(path_model).replace('.h5', ''))
dice_path = os.path.join(model_val_dir, 'dice.npy')
if not os.path.exists(os.path.join(model_val_dir)):
os.mkdir(model_val_dir)
if (not os.path.isfile(dice_path)) | recompute:
predict(path_images=image_dir,
path_segmentations=model_val_dir,
path_model=path_model,
segmentation_label_list=path_label_list,
cropping=cropping,
conv_size=conv_size,
n_levels=n_levels,
nb_conv_per_level=nb_conv_per_level,
feat_multiplier=feat_multiplier,
activation=activation,
gt_folder=gt_dir)
def validate_training(image_dir,
gt_dir,
models_dir,
validation_main_dir,
path_label_list,
step_eval=1,
recompute=True):
"""This function validates models saved at different epochs of the same training.
All models are assumed to be in the same folder.contained in models_dir.
The results of each model are saved in a subfolder in validation_main_dir.
:param image_dir: path of the folder with validation images.
:param gt_dir: path of the folder with ground truth label maps.
These are matched to the validation images by sorting order.
:param models_dir: path of the folder with the models to validate.
:param validation_main_dir: path of the folder where all the models validation subfolders will be saved.
:param path_label_list: path of the numpy array containing all the label values to validate on.
:param step_eval: (optional) If step_eval > 1 skips models when validating, by validating on models step_eval apart.
:param recompute: (optional) whether to recompute result files even if they already exists."""
# create result folder
if not os.path.exists(os.path.join(validation_main_dir)):
os.mkdir(validation_main_dir)
# loop over models
list_models = utils.list_files(models_dir,
expr=['dice', 'h5'],
cond_type='and')[::step_eval]
for model_idx, path_model in enumerate(list_models):
# build names and create folders
model_val_dir = os.path.join(
validation_main_dir,
os.path.basename(path_model).replace('.h5', ''))
dice_path = os.path.join(model_val_dir, 'dice.npy')
if not os.path.exists(os.path.join(model_val_dir)):
os.mkdir(model_val_dir)
if (not os.path.isfile(dice_path)) | recompute:
predict(path_images=image_dir,
path_model=path_model,
path_segmentation_label_list=path_label_list,
path_segmentations=model_val_dir,
path_posteriors=None,
path_volumes=None,
gt_folder=gt_dir,
cropping=198)
def validate_training(image_dir,
gt_dir,
models_dir,
validation_main_dir,
segmentation_label_list,
evaluation_label_list=None,
dist_map=False,
step_eval=1,
aff_ref='FS',
sigma_smoothing=0,
keep_biggest_component=False,
padding=None,
cropping=None,
conv_size=3,
n_levels=5,
nb_conv_per_level=2,
unet_feat_count=24,
feat_multiplier=2,
activation='elu',
compute_distances=False,
recompute=True):
"""This function validates models saved at different epochs of the same training.
All models are assumed to be in the same folder.contained in models_dir.
The results of each model are saved in a subfolder in validation_main_dir.
:param image_dir: path of the folder with validation images.
:param gt_dir: path of the folder with ground truth label maps.
These are matched to the validation images by sorting order.
:param models_dir: path of the folder with the models to validate.
:param validation_main_dir: path of the folder where all the models validation subfolders will be saved.
:param segmentation_label_list: path of the numpy array containing all the segmentation labels used during training.
:param evaluation_label_list: (optional) label values to validate on. Must be a subset of the segmentation labels.
Can be a sequence, a 1d numpy array, or the path to a numpy 1d array. Default is the same as segmentation_label_list
:param dist_map: (optional) whether the input will contain distance maps channels (between each intenisty channels)
Default is False.
:param step_eval: (optional) If step_eval > 1 skips models when validating, by validating on models step_eval apart.
:param aff_ref: (optional) affine matrix with which the models were trained. Can be 'FS' (default), or 'identity.
:param sigma_smoothing: (optional) If not None, the posteriors are smoothed with a gaussian kernel of the specified
standard deviation.
:param keep_biggest_component: (optional) whether to only keep the biggest component in the predicted segmentation.
:param padding: (optional) pad the images to the specified shape before predicting the segmentation maps.
Can be an int, a sequence or a 1d numpy array.
:param cropping: (optional) whether to crop the input to smaller size while being run through the network.
The result is then given in the original image space. Can be an int, a sequence, or a 1d numpy array.
:param n_levels: (optional) number of level for the Unet. Default is 5.
:param nb_conv_per_level: (optional) number of convolutional layers per level. Default is 2.
:param conv_size: (optional) size of the convolution kernels. Default is 2.
:param unet_feat_count: (optional) number of feature maps for the first level. Default is 24.
:param feat_multiplier: (optional) multiply the number of feature by this nummber at each new level. Default is 1.
:param activation: (optional) activation function. Can be 'elu', 'relu'.
:param compute_distances: (optional) whether to compute the Haussdorf and mean surface distance.
:param recompute: (optional) whether to recompute result files even if they already exists."""
# create result folder
utils.mkdir(validation_main_dir)
# loop over models
list_models = utils.list_files(models_dir,
expr=['dice', 'h5'],
cond_type='and')[::step_eval]
loop_info = utils.LoopInfo(len(list_models), 1, 'validating', True)
for model_idx, path_model in enumerate(list_models):
# build names and create folders
model_val_dir = os.path.join(
validation_main_dir,
os.path.basename(path_model).replace('.h5', ''))
dice_path = os.path.join(model_val_dir, 'dice.npy')
utils.mkdir(model_val_dir)
if (not os.path.isfile(dice_path)) | recompute:
loop_info.update(model_idx)
predict(path_images=image_dir,
path_model=path_model,
segmentation_label_list=segmentation_label_list,
dist_map=dist_map,
path_segmentations=model_val_dir,
padding=padding,
cropping=cropping,
aff_ref=aff_ref,
sigma_smoothing=sigma_smoothing,
keep_biggest_component=keep_biggest_component,
conv_size=conv_size,
n_levels=n_levels,
nb_conv_per_level=nb_conv_per_level,
unet_feat_count=unet_feat_count,
feat_multiplier=feat_multiplier,
activation=activation,
gt_folder=gt_dir,
evaluation_label_list=evaluation_label_list,
compute_distances=compute_distances,
recompute=recompute,
verbose=False)
def validate_training(image_dir,
gt_dir,
models_dir,
validation_main_dir,
segmentation_labels,
n_neutral_labels=None,
evaluation_labels=None,
step_eval=1,
padding=None,
cropping=None,
target_res=1.,
gradients=False,
flip=False,
topology_classes=None,
sigma_smoothing=0,
keep_biggest_component=False,
conv_size=3,
n_levels=5,
nb_conv_per_level=2,
unet_feat_count=24,
feat_multiplier=2,
activation='elu',
mask_dir=None,
compute_distances=False,
recompute=True):
"""This function validates models saved at different epochs of the same training.
All models are assumed to be in the same folder.contained in models_dir.
The results of each model are saved in a subfolder in validation_main_dir.
:param image_dir: path of the folder with validation images.
:param gt_dir: path of the folder with ground truth label maps.
These are matched to the validation images by sorting order.
:param models_dir: path of the folder with the models to validate.
:param validation_main_dir: path of the folder where all the models validation subfolders will be saved.
:param segmentation_labels: path of the numpy array containing all the segmentation labels used during training.
:param n_neutral_labels: (optional) value of n_neutral_labels used during training. Used only if flip is True.
:param evaluation_labels: (optional) label values to validate on. Must be a subset of the segmentation labels.
Can be a sequence, a 1d numpy array, or the path to a numpy 1d array. Default is the same as segmentation_label_list
:param step_eval: (optional) If step_eval > 1 skips models when validating, by validating on models step_eval apart.
:param padding: (optional) pad the images to the specified shape before predicting the segmentation maps.
Can be an int, a sequence or a 1d numpy array.
:param cropping: (optional) whether to crop the input to smaller size while being run through the network.
The result is then given in the original image space. Can be an int, a sequence, or a 1d numpy array.
:param target_res: (optional) target resolution at which the network operates (and thus resolution of the output
segmentations). This must match the resolution of the training data ! target_res is used to automatically resampled
the images with resolutions outside [target_res-0.05, target_res+0.05].
Can be a sequence, a 1d numpy array. Set to None to disable the automatic resampling. Default is 1mm.
:param flip: (optional) whether to perform test-time augmentation, where the input image is segmented along with
a right/left flipped version on it. If set to True (default), be careful because this requires more memory.
:param topology_classes: List of classes corresponding to all segmentation labels, in order to group them into
classes, for each of which we will operate a smooth version of biggest connected component.
Can be a sequence, a 1d numpy array, or the path to a numpy 1d array in the same order as segmentation_label_list.
Default is None, where no topological analysis is performed.
:param sigma_smoothing: (optional) If not None, the posteriors are smoothed with a gaussian kernel of the specified
standard deviation.
:param keep_biggest_component: (optional) whether to only keep the biggest component in the predicted segmentation.
This is applied independently of topology_classes, and it is applied to the whole segmentation
:param conv_size: (optional) size of the convolution kernels. Default is 2.
:param n_levels: (optional) number of level for the Unet. Default is 5.
:param nb_conv_per_level: (optional) number of convolutional layers per level. Default is 2.
:param unet_feat_count: (optional) number of feature maps for the first level. Default is 24.
:param feat_multiplier: (optional) multiply the number of feature by this nummber at each new level. Default is 1.
:param activation: (optional) activation function. Can be 'elu', 'relu'.
:param mask_dir: (optional) path of masks that will be used to mask out some parts of the obtained segmentations
during the evaluation. Default is None, where nothing is masked.
:param compute_distances: (optional) whether to add Hausdorff and mean surface distance evaluations to the default
Dice evaluation. Default is True.
:param recompute: (optional) whether to recompute result files even if they already exists."""
# create result folder
utils.mkdir(validation_main_dir)
# loop over models
list_models = utils.list_files(models_dir,
expr=['dice', '.h5'],
cond_type='and')[::step_eval]
# list_models = [p for p in list_models if int(os.path.basename(p)[-6:-3]) % 10 == 0]
loop_info = utils.LoopInfo(len(list_models), 1, 'validating', True)
for model_idx, path_model in enumerate(list_models):
# build names and create folders
model_val_dir = os.path.join(
validation_main_dir,
os.path.basename(path_model).replace('.h5', ''))
dice_path = os.path.join(model_val_dir, 'dice.npy')
utils.mkdir(model_val_dir)
if (not os.path.isfile(dice_path)) | recompute:
loop_info.update(model_idx)
predict(path_images=image_dir,
path_model=path_model,
segmentation_labels=segmentation_labels,
n_neutral_labels=n_neutral_labels,
path_segmentations=model_val_dir,
padding=padding,
cropping=cropping,
target_res=target_res,
gradients=gradients,
flip=flip,
topology_classes=topology_classes,
sigma_smoothing=sigma_smoothing,
keep_biggest_component=keep_biggest_component,
conv_size=conv_size,
n_levels=n_levels,
nb_conv_per_level=nb_conv_per_level,
unet_feat_count=unet_feat_count,
feat_multiplier=feat_multiplier,
activation=activation,
gt_folder=gt_dir,
mask_folder=mask_dir,
evaluation_labels=evaluation_labels,
compute_distances=compute_distances,
recompute=recompute,
verbose=False)