def get_default_augmentation_withEDT(dataloader_train,
dataloader_val,
patch_size,
idx_of_edts,
params=default_3D_augmentation_params,
border_val_seg=-1,
pin_memory=True,
seeds_train=None,
seeds_val=None):
tr_transforms = []
if params.get("selected_data_channels") is not None:
tr_transforms.append(
DataChannelSelectionTransform(
params.get("selected_data_channels")))
if params.get("selected_seg_channels") is not None:
tr_transforms.append(
SegChannelSelectionTransform(params.get("selected_seg_channels")))
# don't do color augmentations while in 2d mode with 3d data because the color channel is overloaded!!
if params.get("dummy_2D") is not None and params.get("dummy_2D"):
tr_transforms.append(Convert3DTo2DTransform())
tr_transforms.append(
SpatialTransform(patch_size,
patch_center_dist_from_border=None,
do_elastic_deform=params.get("do_elastic"),
alpha=params.get("elastic_deform_alpha"),
sigma=params.get("elastic_deform_sigma"),
do_rotation=params.get("do_rotation"),
angle_x=params.get("rotation_x"),
angle_y=params.get("rotation_y"),
angle_z=params.get("rotation_z"),
do_scale=params.get("do_scaling"),
scale=params.get("scale_range"),
border_mode_data=params.get("border_mode_data"),
border_cval_data=0,
order_data=3,
border_mode_seg="constant",
border_cval_seg=border_val_seg,
order_seg=1,
random_crop=params.get("random_crop"),
p_el_per_sample=params.get("p_eldef"),
p_scale_per_sample=params.get("p_scale"),
p_rot_per_sample=params.get("p_rot")))
if params.get("dummy_2D") is not None and params.get("dummy_2D"):
tr_transforms.append(Convert2DTo3DTransform())
"""
##############################################################
##############################################################
Here we insert moving the EDT to a different key so that it does not get intensity transformed
##############################################################
##############################################################
"""
tr_transforms.append(
AppendChannelsTransform("data",
"bound",
idx_of_edts,
remove_from_input=True))
if params.get("do_gamma"):
tr_transforms.append(
GammaTransform(params.get("gamma_range"),
False,
True,
retain_stats=params.get("gamma_retain_stats"),
p_per_sample=params["p_gamma"]))
tr_transforms.append(MirrorTransform(params.get("mirror_axes")))
if params.get("mask_was_used_for_normalization") is not None:
mask_was_used_for_normalization = params.get(
"mask_was_used_for_normalization")
tr_transforms.append(
MaskTransform(mask_was_used_for_normalization,
mask_idx_in_seg=0,
set_outside_to=0))
tr_transforms.append(RemoveLabelTransform(-1, 0))
if params.get("move_last_seg_chanel_to_data") is not None and params.get(
"move_last_seg_chanel_to_data"):
tr_transforms.append(
MoveSegAsOneHotToData(1, params.get("all_segmentation_labels"),
'seg', 'data'))
if params.get(
"advanced_pyramid_augmentations") and not None and params.get(
"advanced_pyramid_augmentations"):
tr_transforms.append(
ApplyRandomBinaryOperatorTransform(channel_idx=list(
range(-len(params.get("all_segmentation_labels")), 0)),
p_per_sample=0.4,
key="data",
strel_size=(1, 8)))
tr_transforms.append(
RemoveRandomConnectedComponentFromOneHotEncodingTransform(
channel_idx=list(
range(-len(params.get("all_segmentation_labels")), 0)),
key="data",
p_per_sample=0.2,
fill_with_other_class_p=0.0,
dont_do_if_covers_more_than_X_percent=0.15))
tr_transforms.append(RenameTransform('seg', 'target', True))
tr_transforms.append(NumpyToTensor(['data', 'target', 'bound'], 'float'))
tr_transforms = Compose(tr_transforms)
batchgenerator_train = MultiThreadedAugmenter(
dataloader_train,
tr_transforms,
params.get('num_threads'),
params.get("num_cached_per_thread"),
seeds=seeds_train,
pin_memory=pin_memory)
val_transforms = []
val_transforms.append(RemoveLabelTransform(-1, 0))
if params.get("selected_data_channels") is not None:
val_transforms.append(
DataChannelSelectionTransform(
params.get("selected_data_channels")))
if params.get("selected_seg_channels") is not None:
val_transforms.append(
SegChannelSelectionTransform(params.get("selected_seg_channels")))
"""
##############################################################
##############################################################
Here we insert moving the EDT to a different key
##############################################################
##############################################################
"""
val_transforms.append(
AppendChannelsTransform("data",
"bound",
idx_of_edts,
remove_from_input=True))
if params.get("move_last_seg_chanel_to_data") is not None and params.get(
"move_last_seg_chanel_to_data"):
val_transforms.append(
MoveSegAsOneHotToData(1, params.get("all_segmentation_labels"),
'seg', 'data'))
val_transforms.append(RenameTransform('seg', 'target', True))
val_transforms.append(NumpyToTensor(['data', 'target', 'bound'], 'float'))
val_transforms = Compose(val_transforms)
batchgenerator_val = MultiThreadedAugmenter(
dataloader_val,
val_transforms,
max(params.get('num_threads') // 2, 1),
params.get("num_cached_per_thread"),
seeds=seeds_val,
pin_memory=pin_memory)
return batchgenerator_train, batchgenerator_val
def get_training_transforms(self):
assert self.params.get(
'mirror'
) is None, "old version of params, use new keyword do_mirror"
tr_transforms = []
if self.params.get("selected_data_channels"):
tr_transforms.append(
DataChannelSelectionTransform(
self.params.get("selected_data_channels")))
if self.params.get("selected_seg_channels"):
tr_transforms.append(
SegChannelSelectionTransform(
self.params.get("selected_seg_channels")))
# don't do color augmentations while in 2d mode with 3d data because the color channel is overloaded!!
if self.params.get("dummy_2D", False):
ignore_axes = (0, )
tr_transforms.append(Convert3DTo2DTransform())
else:
ignore_axes = None
tr_transforms.append(
SpatialTransform(
self._spatial_transform_patch_size,
patch_center_dist_from_border=None,
do_elastic_deform=self.params.get("do_elastic"),
alpha=self.params.get("elastic_deform_alpha"),
sigma=self.params.get("elastic_deform_sigma"),
do_rotation=self.params.get("do_rotation"),
angle_x=self.params.get("rotation_x"),
angle_y=self.params.get("rotation_y"),
angle_z=self.params.get("rotation_z"),
do_scale=self.params.get("do_scaling"),
scale=self.params.get("scale_range"),
order_data=self.params.get("order_data"),
border_mode_data=self.params.get("border_mode_data"),
border_cval_data=self.params.get("border_cval_data"),
order_seg=self.params.get("order_seg"),
border_mode_seg=self.params.get("border_mode_seg"),
border_cval_seg=self.params.get("border_cval_seg"),
random_crop=self.params.get("random_crop"),
p_el_per_sample=self.params.get("p_eldef"),
p_scale_per_sample=self.params.get("p_scale"),
p_rot_per_sample=self.params.get("p_rot"),
independent_scale_for_each_axis=self.params.get(
"independent_scale_factor_for_each_axis"),
))
if self.params.get("dummy_2D"):
tr_transforms.append(Convert2DTo3DTransform())
# we need to put the color augmentations after the dummy 2d part (if applicable). Otherwise the overloaded color
# channel gets in the way
tr_transforms.append(GaussianNoiseTransform(p_per_sample=0.15))
tr_transforms.append(
GaussianBlurTransform((0.5, 1.5),
different_sigma_per_channel=True,
p_per_sample=0.2,
p_per_channel=0.5), )
tr_transforms.append(
BrightnessMultiplicativeTransform(multiplier_range=(0.75, 1.3),
p_per_sample=0.15))
if self.params.get("do_additive_brightness"):
tr_transforms.append(
BrightnessTransform(
self.params.get("additive_brightness_mu"),
self.params.get("additive_brightness_sigma"),
True,
p_per_sample=self.params.get(
"additive_brightness_p_per_sample"),
p_per_channel=self.params.get(
"additive_brightness_p_per_channel")))
tr_transforms.append(
ContrastAugmentationTransform(contrast_range=(0.65, 1.5),
p_per_sample=0.15))
tr_transforms.append(
SimulateLowResolutionTransform(zoom_range=(0.5, 1),
per_channel=True,
p_per_channel=0.5,
order_downsample=0,
order_upsample=3,
p_per_sample=0.25,
ignore_axes=ignore_axes), )
tr_transforms.append(
GammaTransform(self.params.get("gamma_range"),
True,
True,
retain_stats=self.params.get("gamma_retain_stats"),
p_per_sample=0.15)) # inverted gamma
if self.params.get("do_gamma"):
tr_transforms.append(
GammaTransform(
self.params.get("gamma_range"),
False,
True,
retain_stats=self.params.get("gamma_retain_stats"),
p_per_sample=self.params["p_gamma"]))
if self.params.get("do_mirror") or self.params.get("mirror"):
tr_transforms.append(
MirrorTransform(self.params.get("mirror_axes")))
if self.params.get("use_mask_for_norm"):
use_mask_for_norm = self.params.get("use_mask_for_norm")
tr_transforms.append(
MaskTransform(use_mask_for_norm,
mask_idx_in_seg=0,
set_outside_to=0))
tr_transforms.append(RemoveLabelTransform(-1, 0))
tr_transforms.append(RenameTransform('seg', 'target', True))
tr_transforms.append(NumpyToTensor(['data', 'target'], 'float'))
return Compose(tr_transforms)
def get_default_augmentation(dataloader_train,
dataloader_val,
patch_size,
params=default_3D_augmentation_params,
border_val_seg=-1,
pin_memory=True,
seeds_train=None,
seeds_val=None,
regions=None):
assert params.get(
'mirror') is None, "old version of params, use new keyword do_mirror"
tr_transforms = []
if params.get("selected_data_channels") is not None:
tr_transforms.append(
DataChannelSelectionTransform(
params.get("selected_data_channels")))
if params.get("selected_seg_channels") is not None:
tr_transforms.append(
SegChannelSelectionTransform(params.get("selected_seg_channels")))
# don't do color augmentations while in 2d mode with 3d data because the color channel is overloaded!!
if params.get("dummy_2D") is not None and params.get("dummy_2D"):
tr_transforms.append(Convert3DTo2DTransform())
patch_size_spatial = patch_size[1:]
else:
patch_size_spatial = patch_size
tr_transforms.append(
SpatialTransform(patch_size_spatial,
patch_center_dist_from_border=None,
do_elastic_deform=params.get("do_elastic"),
alpha=params.get("elastic_deform_alpha"),
sigma=params.get("elastic_deform_sigma"),
do_rotation=params.get("do_rotation"),
angle_x=params.get("rotation_x"),
angle_y=params.get("rotation_y"),
angle_z=params.get("rotation_z"),
do_scale=params.get("do_scaling"),
scale=params.get("scale_range"),
border_mode_data=params.get("border_mode_data"),
border_cval_data=0,
order_data=3,
border_mode_seg="constant",
border_cval_seg=border_val_seg,
order_seg=1,
random_crop=params.get("random_crop"),
p_el_per_sample=params.get("p_eldef"),
p_scale_per_sample=params.get("p_scale"),
p_rot_per_sample=params.get("p_rot"),
independent_scale_for_each_axis=params.get(
"independent_scale_factor_for_each_axis")))
if params.get("dummy_2D") is not None and params.get("dummy_2D"):
tr_transforms.append(Convert2DTo3DTransform())
if params.get("do_gamma"):
tr_transforms.append(
GammaTransform(params.get("gamma_range"),
False,
True,
retain_stats=params.get("gamma_retain_stats"),
p_per_sample=params["p_gamma"]))
if params.get("do_mirror"):
tr_transforms.append(MirrorTransform(params.get("mirror_axes")))
if params.get("mask_was_used_for_normalization") is not None:
mask_was_used_for_normalization = params.get(
"mask_was_used_for_normalization")
tr_transforms.append(
MaskTransform(mask_was_used_for_normalization,
mask_idx_in_seg=0,
set_outside_to=0))
tr_transforms.append(RemoveLabelTransform(-1, 0))
if params.get("move_last_seg_chanel_to_data") is not None and params.get(
"move_last_seg_chanel_to_data"):
tr_transforms.append(
MoveSegAsOneHotToData(1, params.get("all_segmentation_labels"),
'seg', 'data'))
if params.get("cascade_do_cascade_augmentations"
) and not None and params.get(
"cascade_do_cascade_augmentations"):
tr_transforms.append(
ApplyRandomBinaryOperatorTransform(
channel_idx=list(
range(-len(params.get("all_segmentation_labels")), 0)),
p_per_sample=params.get(
"cascade_random_binary_transform_p"),
key="data",
strel_size=params.get(
"cascade_random_binary_transform_size")))
tr_transforms.append(
RemoveRandomConnectedComponentFromOneHotEncodingTransform(
channel_idx=list(
range(-len(params.get("all_segmentation_labels")), 0)),
key="data",
p_per_sample=params.get("cascade_remove_conn_comp_p"),
fill_with_other_class_p=params.get(
"cascade_remove_conn_comp_max_size_percent_threshold"),
dont_do_if_covers_more_than_X_percent=params.get(
"cascade_remove_conn_comp_fill_with_other_class_p")))
tr_transforms.append(RenameTransform('seg', 'target', True))
if regions is not None:
tr_transforms.append(
ConvertSegmentationToRegionsTransform(regions, 'target', 'target'))
tr_transforms.append(NumpyToTensor(['data', 'target'], 'float'))
tr_transforms = Compose(tr_transforms)
# from batchgenerators.dataloading import SingleThreadedAugmenter
# batchgenerator_train = SingleThreadedAugmenter(dataloader_train, tr_transforms)
# import IPython;IPython.embed()
batchgenerator_train = MultiThreadedAugmenter(
dataloader_train,
tr_transforms,
params.get('num_threads'),
params.get("num_cached_per_thread"),
seeds=seeds_train,
pin_memory=pin_memory)
val_transforms = []
val_transforms.append(RemoveLabelTransform(-1, 0))
if params.get("selected_data_channels") is not None:
val_transforms.append(
DataChannelSelectionTransform(
params.get("selected_data_channels")))
if params.get("selected_seg_channels") is not None:
val_transforms.append(
SegChannelSelectionTransform(params.get("selected_seg_channels")))
if params.get("move_last_seg_chanel_to_data") is not None and params.get(
"move_last_seg_chanel_to_data"):
val_transforms.append(
MoveSegAsOneHotToData(1, params.get("all_segmentation_labels"),
'seg', 'data'))
val_transforms.append(RenameTransform('seg', 'target', True))
if regions is not None:
val_transforms.append(
ConvertSegmentationToRegionsTransform(regions, 'target', 'target'))
val_transforms.append(NumpyToTensor(['data', 'target'], 'float'))
val_transforms = Compose(val_transforms)
# batchgenerator_val = SingleThreadedAugmenter(dataloader_val, val_transforms)
batchgenerator_val = MultiThreadedAugmenter(
dataloader_val,
val_transforms,
max(params.get('num_threads') // 2, 1),
params.get("num_cached_per_thread"),
seeds=seeds_val,
pin_memory=pin_memory)
return batchgenerator_train, batchgenerator_val
def get_insaneDA_augmentation(dataloader_train,
dataloader_val,
patch_size,
params=default_3D_augmentation_params,
border_val_seg=-1,
seeds_train=None,
seeds_val=None,
order_seg=1,
order_data=3,
deep_supervision_scales=None,
soft_ds=False,
classes=None,
pin_memory=True):
assert params.get(
'mirror') is None, "old version of params, use new keyword do_mirror"
tr_transforms = []
if params.get("selected_data_channels") is not None:
tr_transforms.append(
DataChannelSelectionTransform(
params.get("selected_data_channels")))
if params.get("selected_seg_channels") is not None:
tr_transforms.append(
SegChannelSelectionTransform(params.get("selected_seg_channels")))
# don't do color augmentations while in 2d mode with 3d data because the color channel is overloaded!!
if params.get("dummy_2D") is not None and params.get("dummy_2D"):
ignore_axes = (0, )
tr_transforms.append(Convert3DTo2DTransform())
else:
ignore_axes = None
tr_transforms.append(
SpatialTransform(patch_size,
patch_center_dist_from_border=None,
do_elastic_deform=params.get("do_elastic"),
alpha=params.get("elastic_deform_alpha"),
sigma=params.get("elastic_deform_sigma"),
do_rotation=params.get("do_rotation"),
angle_x=params.get("rotation_x"),
angle_y=params.get("rotation_y"),
angle_z=params.get("rotation_z"),
do_scale=params.get("do_scaling"),
scale=params.get("scale_range"),
border_mode_data=params.get("border_mode_data"),
border_cval_data=0,
order_data=order_data,
border_mode_seg="constant",
border_cval_seg=border_val_seg,
order_seg=order_seg,
random_crop=params.get("random_crop"),
p_el_per_sample=params.get("p_eldef"),
p_scale_per_sample=params.get("p_scale"),
p_rot_per_sample=params.get("p_rot"),
independent_scale_for_each_axis=params.get(
"independent_scale_factor_for_each_axis")))
if params.get("dummy_2D"):
tr_transforms.append(Convert2DTo3DTransform())
# we need to put the color augmentations after the dummy 2d part (if applicable). Otherwise the overloaded color
# channel gets in the way
tr_transforms.append(GaussianNoiseTransform(p_per_sample=0.15))
tr_transforms.append(
GaussianBlurTransform((0.5, 1.5),
different_sigma_per_channel=True,
p_per_sample=0.2,
p_per_channel=0.5))
tr_transforms.append(
BrightnessMultiplicativeTransform(multiplier_range=(0.70, 1.3),
p_per_sample=0.15))
tr_transforms.append(
ContrastAugmentationTransform(contrast_range=(0.65, 1.5),
p_per_sample=0.15))
tr_transforms.append(
SimulateLowResolutionTransform(zoom_range=(0.5, 1),
per_channel=True,
p_per_channel=0.5,
order_downsample=0,
order_upsample=3,
p_per_sample=0.25,
ignore_axes=ignore_axes))
tr_transforms.append(
GammaTransform(params.get("gamma_range"),
True,
True,
retain_stats=params.get("gamma_retain_stats"),
p_per_sample=0.15)) # inverted gamma
if params.get("do_gamma"):
tr_transforms.append(
GammaTransform(params.get("gamma_range"),
False,
True,
retain_stats=params.get("gamma_retain_stats"),
p_per_sample=params["p_gamma"]))
if params.get("do_mirror") or params.get("mirror"):
tr_transforms.append(MirrorTransform(params.get("mirror_axes")))
if params.get("mask_was_used_for_normalization") is not None:
mask_was_used_for_normalization = params.get(
"mask_was_used_for_normalization")
tr_transforms.append(
MaskTransform(mask_was_used_for_normalization,
mask_idx_in_seg=0,
set_outside_to=0))
tr_transforms.append(RemoveLabelTransform(-1, 0))
if params.get("move_last_seg_chanel_to_data") is not None and params.get(
"move_last_seg_chanel_to_data"):
tr_transforms.append(
MoveSegAsOneHotToData(1, params.get("all_segmentation_labels"),
'seg', 'data'))
if params.get("cascade_do_cascade_augmentations"
) and not None and params.get(
"cascade_do_cascade_augmentations"):
if params.get("cascade_random_binary_transform_p") > 0:
tr_transforms.append(
ApplyRandomBinaryOperatorTransform(
channel_idx=list(
range(-len(params.get("all_segmentation_labels")),
0)),
p_per_sample=params.get(
"cascade_random_binary_transform_p"),
key="data",
strel_size=params.get(
"cascade_random_binary_transform_size")))
if params.get("cascade_remove_conn_comp_p") > 0:
tr_transforms.append(
RemoveRandomConnectedComponentFromOneHotEncodingTransform(
channel_idx=list(
range(-len(params.get("all_segmentation_labels")),
0)),
key="data",
p_per_sample=params.get("cascade_remove_conn_comp_p"),
fill_with_other_class_p=params.get(
"cascade_remove_conn_comp_max_size_percent_threshold"
),
dont_do_if_covers_more_than_X_percent=params.get(
"cascade_remove_conn_comp_fill_with_other_class_p")
))
tr_transforms.append(RenameTransform('seg', 'target', True))
if deep_supervision_scales is not None:
if soft_ds:
assert classes is not None
tr_transforms.append(
DownsampleSegForDSTransform3(deep_supervision_scales, 'target',
'target', classes))
else:
tr_transforms.append(
DownsampleSegForDSTransform2(deep_supervision_scales,
0,
0,
input_key='target',
output_key='target'))
tr_transforms.append(NumpyToTensor(['data', 'target'], 'float'))
tr_transforms = Compose(tr_transforms)
batchgenerator_train = MultiThreadedAugmenter(
dataloader_train,
tr_transforms,
params.get('num_threads'),
params.get("num_cached_per_thread"),
seeds=seeds_train,
pin_memory=pin_memory)
val_transforms = []
val_transforms.append(RemoveLabelTransform(-1, 0))
if params.get("selected_data_channels") is not None:
val_transforms.append(
DataChannelSelectionTransform(
params.get("selected_data_channels")))
if params.get("selected_seg_channels") is not None:
val_transforms.append(
SegChannelSelectionTransform(params.get("selected_seg_channels")))
if params.get("move_last_seg_chanel_to_data") is not None and params.get(
"move_last_seg_chanel_to_data"):
val_transforms.append(
MoveSegAsOneHotToData(1, params.get("all_segmentation_labels"),
'seg', 'data'))
val_transforms.append(RenameTransform('seg', 'target', True))
if deep_supervision_scales is not None:
if soft_ds:
assert classes is not None
val_transforms.append(
DownsampleSegForDSTransform3(deep_supervision_scales, 'target',
'target', classes))
else:
val_transforms.append(
DownsampleSegForDSTransform2(deep_supervision_scales,
0,
0,
input_key='target',
output_key='target'))
val_transforms.append(NumpyToTensor(['data', 'target'], 'float'))
val_transforms = Compose(val_transforms)
batchgenerator_val = MultiThreadedAugmenter(
dataloader_val,
val_transforms,
max(params.get('num_threads') // 2, 1),
params.get("num_cached_per_thread"),
seeds=seeds_val,
pin_memory=pin_memory)
return batchgenerator_train, batchgenerator_val
def get_training_transforms(self):
assert self.params.get(
'mirror'
) is None, "old version of params, use new keyword do_mirror"
tr_transforms = []
if self.params.get("selected_data_channels"):
tr_transforms.append(
DataChannelSelectionTransform(
self.params.get("selected_data_channels")))
if self.params.get("selected_seg_channels"):
tr_transforms.append(
SegChannelSelectionTransform(
self.params.get("selected_seg_channels")))
if self.params.get("dummy_2D", False):
# don't do color augmentations while in 2d mode with 3d data because the color channel is overloaded!!
tr_transforms.append(Convert3DTo2DTransform())
tr_transforms.append(
SpatialTransform(
self._spatial_transform_patch_size,
patch_center_dist_from_border=None,
do_elastic_deform=self.params.get("do_elastic"),
alpha=self.params.get("elastic_deform_alpha"),
sigma=self.params.get("elastic_deform_sigma"),
do_rotation=self.params.get("do_rotation"),
angle_x=self.params.get("rotation_x"),
angle_y=self.params.get("rotation_y"),
angle_z=self.params.get("rotation_z"),
do_scale=self.params.get("do_scaling"),
scale=self.params.get("scale_range"),
order_data=self.params.get("order_data"),
border_mode_data=self.params.get("border_mode_data"),
border_cval_data=self.params.get("border_cval_data"),
order_seg=self.params.get("order_seg"),
border_mode_seg=self.params.get("border_mode_seg"),
border_cval_seg=self.params.get("border_cval_seg"),
random_crop=self.params.get("random_crop"),
p_el_per_sample=self.params.get("p_eldef"),
p_scale_per_sample=self.params.get("p_scale"),
p_rot_per_sample=self.params.get("p_rot"),
independent_scale_for_each_axis=self.params.get(
"independent_scale_factor_for_each_axis"),
))
if self.params.get("dummy_2D", False):
tr_transforms.append(Convert2DTo3DTransform())
if self.params.get("do_gamma", False):
tr_transforms.append(
GammaTransform(
self.params.get("gamma_range"),
False,
True,
retain_stats=self.params.get("gamma_retain_stats"),
p_per_sample=self.params["p_gamma"]))
if self.params.get("do_mirror", False):
tr_transforms.append(
MirrorTransform(self.params.get("mirror_axes")))
if self.params.get("use_mask_for_norm"):
use_mask_for_norm = self.params.get("use_mask_for_norm")
tr_transforms.append(
MaskTransform(use_mask_for_norm,
mask_idx_in_seg=0,
set_outside_to=0))
tr_transforms.append(RemoveLabelTransform(-1, 0))
tr_transforms.append(RenameTransform('seg', 'target', True))
tr_transforms.append(NumpyToTensor(['data', 'target'], 'float'))
return Compose(tr_transforms)
def get_arteries_augmentation(dataloader_train,
dataloader_val,
patch_size,
params=default_3D_augmentation_params,
border_val_seg=-1,
seeds_train=None,
seeds_val=None,
order_seg=1,
order_data=3,
deep_supervision_scales=None,
soft_ds=False,
classes=None,
pin_memory=True,
regions=None,
use_nondetMultiThreadedAugmenter: bool = False):
assert params.get(
'mirror') is None, "old version of params, use new keyword do_mirror"
tr_transforms = []
if params.get("selected_data_channels") is not None:
tr_transforms.append(
DataChannelSelectionTransform(
params.get("selected_data_channels")))
if params.get("selected_seg_channels") is not None:
tr_transforms.append(
SegChannelSelectionTransform(params.get("selected_seg_channels")))
# don't do color augmentations while in 2d mode with 3d data because the color channel is overloaded!!
# if params.get("dummy_2D") is not None and params.get("dummy_2D"):
# ignore_axes = (0,)
# tr_transforms.append(Convert3DTo2DTransform())
# else:
# ignore_axes = None
tr_transforms.append(
SpatialTransform(patch_size,
patch_center_dist_from_border=None,
do_elastic_deform=False,
do_rotation=False,
do_scale=params.get("do_scaling"),
scale=params.get("scale_range"),
border_mode_data=params.get("border_mode_data"),
border_cval_data=0,
order_data=order_data,
border_mode_seg="constant",
border_cval_seg=border_val_seg,
order_seg=order_seg,
random_crop=False,
p_el_per_sample=params.get("p_eldef"),
p_scale_per_sample=params.get("p_scale"),
p_rot_per_sample=params.get("p_rot"),
independent_scale_for_each_axis=params.get(
"independent_scale_factor_for_each_axis")))
if params.get("dummy_2D"):
tr_transforms.append(Convert2DTo3DTransform())
if params.get("do_mirror") or params.get("mirror"):
tr_transforms.append(MirrorTransform(params.get("mirror_axes")))
tr_transforms.append(RemoveLabelTransform(-1, 0))
# if params.get("move_last_seg_chanel_to_data") is not None and params.get("move_last_seg_chanel_to_data"):
# tr_transforms.append(MoveSegAsOneHotToData(1, params.get("all_segmentation_labels"), 'seg', 'data'))
# if params.get("cascade_do_cascade_augmentations") is not None and params.get(
# "cascade_do_cascade_augmentations"):
# if params.get("cascade_random_binary_transform_p") > 0:
# tr_transforms.append(ApplyRandomBinaryOperatorTransform(
# channel_idx=list(range(-len(params.get("all_segmentation_labels")), 0)),
# p_per_sample=params.get("cascade_random_binary_transform_p"),
# key="data",
# strel_size=params.get("cascade_random_binary_transform_size"),
# p_per_label=params.get("cascade_random_binary_transform_p_per_label")))
# if params.get("cascade_remove_conn_comp_p") > 0:
# tr_transforms.append(
# RemoveRandomConnectedComponentFromOneHotEncodingTransform(
# channel_idx=list(range(-len(params.get("all_segmentation_labels")), 0)),
# key="data",
# p_per_sample=params.get("cascade_remove_conn_comp_p"),
# fill_with_other_class_p=params.get("cascade_remove_conn_comp_max_size_percent_threshold"),
# dont_do_if_covers_more_than_X_percent=params.get(
# "cascade_remove_conn_comp_fill_with_other_class_p")))
tr_transforms.append(RenameTransform('seg', 'target', True))
if regions is not None:
tr_transforms.append(
ConvertSegmentationToRegionsTransform(regions, 'target', 'target'))
# if deep_supervision_scales is not None:
# if soft_ds:
# assert classes is not None
# tr_transforms.append(DownsampleSegForDSTransform3(deep_supervision_scales, 'target', 'target', classes))
# else:
# tr_transforms.append(DownsampleSegForDSTransform2(deep_supervision_scales, 0, 0, input_key='target',
# output_key='target'))
tr_transforms.append(NumpyToTensor(['data', 'target'], 'float'))
tr_transforms = Compose(tr_transforms)
batchgenerator_train = MultiThreadedAugmenter(
dataloader_train,
tr_transforms,
params.get('num_threads'),
params.get("num_cached_per_thread"),
seeds=seeds_train,
pin_memory=pin_memory)
# batchgenerator_train = SingleThreadedAugmenter(dataloader_train, tr_transforms)
# import IPython;IPython.embed()
batchgenerator_train.restart()
val_transforms = []
val_transforms.append(RemoveLabelTransform(-1, 0))
if params.get("selected_data_channels") is not None:
val_transforms.append(
DataChannelSelectionTransform(
params.get("selected_data_channels")))
if params.get("selected_seg_channels") is not None:
val_transforms.append(
SegChannelSelectionTransform(params.get("selected_seg_channels")))
# if params.get("move_last_seg_chanel_to_data") is not None and params.get("move_last_seg_chanel_to_data"):
# val_transforms.append(MoveSegAsOneHotToData(1, params.get("all_segmentation_labels"), 'seg', 'data'))
val_transforms.append(RenameTransform('seg', 'target', True))
if regions is not None:
val_transforms.append(
ConvertSegmentationToRegionsTransform(regions, 'target', 'target'))
# if deep_supervision_scales is not None:
# if soft_ds:
# assert classes is not None
# val_transforms.append(DownsampleSegForDSTransform3(deep_supervision_scales, 'target', 'target', classes))
# else:
# val_transforms.append(DownsampleSegForDSTransform2(deep_supervision_scales, 0, 0, input_key='target',
# output_key='target'))
val_transforms.append(NumpyToTensor(['data', 'target'], 'float'))
val_transforms = Compose(val_transforms)
batchgenerator_val = MultiThreadedAugmenter(
dataloader_val,
val_transforms,
max(params.get('num_threads') // 2, 1),
params.get("num_cached_per_thread"),
seeds=seeds_val,
pin_memory=pin_memory)
# batchgenerator_val = SingleThreadedAugmenter(dataloader_val, val_transforms)
batchgenerator_val.restart()
return batchgenerator_train, batchgenerator_val
def get_train_transforms(self) -> List[AbstractTransform]:
# used for transpost and rot90
matching_axes = np.array(
[sum([i == j for j in self.patch_size]) for i in self.patch_size])
valid_axes = list(np.where(matching_axes == np.max(matching_axes))[0])
tr_transforms = []
if self.data_aug_params['selected_seg_channels'] is not None:
tr_transforms.append(
SegChannelSelectionTransform(
self.data_aug_params['selected_seg_channels']))
if self.do_dummy_2D_aug:
ignore_axes = (0, )
tr_transforms.append(Convert3DTo2DTransform())
patch_size_spatial = self.patch_size[1:]
else:
patch_size_spatial = self.patch_size
ignore_axes = None
tr_transforms.append(
SpatialTransform(
patch_size_spatial,
patch_center_dist_from_border=None,
do_elastic_deform=False,
do_rotation=True,
angle_x=self.data_aug_params["rotation_x"],
angle_y=self.data_aug_params["rotation_y"],
angle_z=self.data_aug_params["rotation_z"],
p_rot_per_axis=0.5,
do_scale=True,
scale=self.data_aug_params['scale_range'],
border_mode_data="constant",
border_cval_data=0,
order_data=3,
border_mode_seg="constant",
border_cval_seg=-1,
order_seg=1,
random_crop=False,
p_el_per_sample=0.2,
p_scale_per_sample=0.2,
p_rot_per_sample=0.4,
independent_scale_for_each_axis=True,
))
if self.do_dummy_2D_aug:
tr_transforms.append(Convert2DTo3DTransform())
if np.any(matching_axes > 1):
tr_transforms.append(
Rot90Transform((0, 1, 2, 3),
axes=valid_axes,
data_key='data',
label_key='seg',
p_per_sample=0.5), )
if np.any(matching_axes > 1):
tr_transforms.append(
TransposeAxesTransform(valid_axes,
data_key='data',
label_key='seg',
p_per_sample=0.5))
tr_transforms.append(
OneOfTransform([
MedianFilterTransform((2, 8),
same_for_each_channel=False,
p_per_sample=0.2,
p_per_channel=0.5),
GaussianBlurTransform((0.3, 1.5),
different_sigma_per_channel=True,
p_per_sample=0.2,
p_per_channel=0.5)
]))
tr_transforms.append(GaussianNoiseTransform(p_per_sample=0.1))
tr_transforms.append(
BrightnessTransform(0,
0.5,
per_channel=True,
p_per_sample=0.1,
p_per_channel=0.5))
tr_transforms.append(
OneOfTransform([
ContrastAugmentationTransform(contrast_range=(0.5, 2),
preserve_range=True,
per_channel=True,
data_key='data',
p_per_sample=0.2,
p_per_channel=0.5),
ContrastAugmentationTransform(contrast_range=(0.5, 2),
preserve_range=False,
per_channel=True,
data_key='data',
p_per_sample=0.2,
p_per_channel=0.5),
]))
tr_transforms.append(
SimulateLowResolutionTransform(zoom_range=(0.25, 1),
per_channel=True,
p_per_channel=0.5,
order_downsample=0,
order_upsample=3,
p_per_sample=0.15,
ignore_axes=ignore_axes))
tr_transforms.append(
GammaTransform((0.7, 1.5),
invert_image=True,
per_channel=True,
retain_stats=True,
p_per_sample=0.1))
tr_transforms.append(
GammaTransform((0.7, 1.5),
invert_image=True,
per_channel=True,
retain_stats=True,
p_per_sample=0.1))
if self.do_mirroring:
tr_transforms.append(MirrorTransform(self.mirror_axes))
tr_transforms.append(
BlankRectangleTransform([[max(1, p // 10), p // 3]
for p in self.patch_size],
rectangle_value=np.mean,
num_rectangles=(1, 5),
force_square=False,
p_per_sample=0.4,
p_per_channel=0.5))
tr_transforms.append(
BrightnessGradientAdditiveTransform(
lambda x, y: np.exp(
np.random.uniform(np.log(x[y] // 6), np.log(x[y]))),
(-0.5, 1.5),
max_strength=lambda x, y: np.random.uniform(-5, -1)
if np.random.uniform() < 0.5 else np.random.uniform(1, 5),
mean_centered=False,
same_for_all_channels=False,
p_per_sample=0.3,
p_per_channel=0.5))
tr_transforms.append(
LocalGammaTransform(
lambda x, y: np.exp(
np.random.uniform(np.log(x[y] // 6), np.log(x[y]))),
(-0.5, 1.5),
lambda: np.random.uniform(0.01, 0.8)
if np.random.uniform() < 0.5 else np.random.uniform(1.5, 4),
same_for_all_channels=False,
p_per_sample=0.3,
p_per_channel=0.5))
tr_transforms.append(
SharpeningTransform(strength=(0.1, 1),
same_for_each_channel=False,
p_per_sample=0.2,
p_per_channel=0.5))
if any(self.use_mask_for_norm.values()):
tr_transforms.append(
MaskTransform(self.use_mask_for_norm,
mask_idx_in_seg=0,
set_outside_to=0))
tr_transforms.append(RemoveLabelTransform(-1, 0))
if self.data_aug_params["move_last_seg_chanel_to_data"]:
all_class_labels = np.arange(1, self.num_classes)
tr_transforms.append(
MoveSegAsOneHotToData(1, all_class_labels, 'seg', 'data'))
if self.data_aug_params["cascade_do_cascade_augmentations"]:
tr_transforms.append(
ApplyRandomBinaryOperatorTransform(channel_idx=list(
range(-len(all_class_labels), 0)),
p_per_sample=0.4,
key="data",
strel_size=(1, 8),
p_per_label=1))
tr_transforms.append(
RemoveRandomConnectedComponentFromOneHotEncodingTransform(
channel_idx=list(range(-len(all_class_labels), 0)),
key="data",
p_per_sample=0.2,
fill_with_other_class_p=0.15,
dont_do_if_covers_more_than_X_percent=0))
tr_transforms.append(RenameTransform('seg', 'target', True))
if self.regions is not None:
tr_transforms.append(
ConvertSegmentationToRegionsTransform(self.regions, 'target',
'target'))
if self.deep_supervision_scales is not None:
tr_transforms.append(
DownsampleSegForDSTransform2(self.deep_supervision_scales,
0,
input_key='target',
output_key='target'))
tr_transforms.append(NumpyToTensor(['data', 'target'], 'float'))
return tr_transforms
def get_default_augmentation(dataloader_train, dataloader_val=None, params=None,
patch_size=None, border_val_seg=-1, pin_memory=True,
seeds_train=None, seeds_val=None, regions=None):
assert params.get('mirror') is None, "old version of params, use new keyword do_mirror"
tr_transforms = []
assert params is not None, "augmentation params expect to be not None"
if params.get("selected_data_channels") is not None:
tr_transforms.append(DataChannelSelectionTransform(params.get("selected_data_channels")))
if params.get("selected_seg_channels") is not None:
tr_transforms.append(SegChannelSelectionTransform(params.get("selected_seg_channels")))
# don't do color augmentations while in 2d mode with 3d data because the color channel is overloaded!!
if params.get("dummy_2D") is not None and params.get("dummy_2D"):
tr_transforms.append(Convert3DTo2DTransform())
tr_transforms.append(SpatialTransform(
patch_size, patch_center_dist_from_border=None, do_elastic_deform=params.get("do_elastic"),
alpha=params.get("elastic_deform_alpha"), sigma=params.get("elastic_deform_sigma"),
do_rotation=params.get("do_rotation"), angle_x=params.get("rotation_x"), angle_y=params.get("rotation_y"),
angle_z=params.get("rotation_z"), do_scale=params.get("do_scaling"), scale=params.get("scale_range"),
border_mode_data=params.get("border_mode_data"), border_cval_data=0, order_data=3, border_mode_seg="constant",
border_cval_seg=border_val_seg,
order_seg=1, random_crop=params.get("random_crop"), p_el_per_sample=params.get("p_eldef"),
p_scale_per_sample=params.get("p_scale"), p_rot_per_sample=params.get("p_rot"),
independent_scale_for_each_axis=params.get("independent_scale_factor_for_each_axis")
))
if params.get("dummy_2D") is not None and params.get("dummy_2D"):
tr_transforms.append(Convert2DTo3DTransform())
if params.get("do_gamma"):
tr_transforms.append(
GammaTransform(params.get("gamma_range"), False, True, retain_stats=params.get("gamma_retain_stats"),
p_per_sample=params["p_gamma"]))
if params.get("do_mirror"):
tr_transforms.append(MirrorTransform(params.get("mirror_axes")))
tr_transforms.append(RemoveLabelTransform(-1, 0))
tr_transforms.append(RenameTransform('seg', 'target', True))
if regions is not None:
tr_transforms.append(ConvertSegmentationToRegionsTransform(regions, 'target', 'target'))
tr_transforms.append(NumpyToTensor(['data', 'target'], 'float'))
tr_transforms = Compose(tr_transforms)
batchgenerator_train = MultiThreadedAugmenter(dataloader_train, tr_transforms, params.get('num_threads'),
params.get("num_cached_per_thread"), seeds=seeds_train,
pin_memory=pin_memory)
batchgenerator_train.restart()
if dataloader_val is None:
return batchgenerator_train, None
val_transforms = []
val_transforms.append(RemoveLabelTransform(-1, 0))
if params.get("selected_data_channels") is not None:
val_transforms.append(DataChannelSelectionTransform(params.get("selected_data_channels")))
if params.get("selected_seg_channels") is not None:
val_transforms.append(SegChannelSelectionTransform(params.get("selected_seg_channels")))
val_transforms.append(RenameTransform('seg', 'target', True))
if regions is not None:
val_transforms.append(ConvertSegmentationToRegionsTransform(regions, 'target', 'target'))
val_transforms.append(NumpyToTensor(['data', 'target'], 'float'))
val_transforms = Compose(val_transforms)
batchgenerator_val = MultiThreadedAugmenter(dataloader_val, val_transforms, max(params.get('num_threads') // 2, 1),
params.get("num_cached_per_thread"), seeds=seeds_val,
pin_memory=pin_memory)
batchgenerator_val.restart()
return batchgenerator_train, batchgenerator_val
def get_insaneDA_augmentation(dataloader_train,
dataloader_val,
patch_size,
params=default_3D_augmentation_params,
border_val_seg=-1,
seeds_train=None,
seeds_val=None,
order_seg=1,
order_data=3,
deep_supervision_scales=None,
soft_ds=False,
classes=None,
pin_memory=True,
regions=None):
assert params.get(
'mirror') is None, "old version of params, use new keyword do_mirror"
tr_transforms = []
# 'patch_size': array([288, 320]),
# 'border_val_seg': -1,
# 'seeds_train': None,
# 'seeds_val': None,
# 'order_seg': 1,
# 'order_data': 3,
# 'deep_supervision_scales': [[1, 1, 1],
# [1.0, 0.5, 0.5],
# [1.0, 0.25, 0.25],
# [0.5, 0.125, 0.125],
# [0.5, 0.0625, 0.0625]],
# 'soft_ds': False,
# 'classes': None,
# 'pin_memory': True,
# 'regions': None
# params
# {'selected_data_channels': None,
# 'selected_seg_channels': [0],
# 'do_elastic': True,
# 'elastic_deform_alpha': (0.0, 300.0),
# 'elastic_deform_sigma': (9.0, 15.0),
# 'p_eldef': 0.1,
# 'do_scaling': True,
# 'scale_range': (0.65, 1.6),
# 'independent_scale_factor_for_each_axis': True,
# 'p_independent_scale_per_axis': 0.3,
# 'p_scale': 0.3,
# 'do_rotation': True,
# 'rotation_x': (-3.141592653589793, 3.141592653589793),
# 'rotation_y': (-0.5235987755982988, 0.5235987755982988),
# 'rotation_z': (-0.5235987755982988, 0.5235987755982988),
# 'rotation_p_per_axis': 1,
# 'p_rot': 0.7,
# 'random_crop': False,
# 'random_crop_dist_to_border': None,
# 'do_gamma': True,
# 'gamma_retain_stats': True,
# 'gamma_range': (0.5, 1.6),
# 'p_gamma': 0.3,
# 'do_mirror': True,
# 'mirror_axes': (0, 1, 2),
# 'dummy_2D': True,
# 'mask_was_used_for_normalization': OrderedDict([(0, False)]),
# 'border_mode_data': 'constant',
# 'all_segmentation_labels': None,
# 'move_last_seg_chanel_to_data': False,
# 'cascade_do_cascade_augmentations': False,
# 'cascade_random_binary_transform_p': 0.4,
# 'cascade_random_binary_transform_p_per_label': 1,
# 'cascade_random_binary_transform_size': (1, 8),
# 'cascade_remove_conn_comp_p': 0.2,
# 'cascade_remove_conn_comp_max_size_percent_threshold': 0.15,
# 'cascade_remove_conn_comp_fill_with_other_class_p': 0.0,
# 'do_additive_brightness': True,
# 'additive_brightness_p_per_sample': 0.3,
# 'additive_brightness_p_per_channel': 1,
# 'additive_brightness_mu': 0,
# 'additive_brightness_sigma': 0.2,
# 'num_threads': 12,
# 'num_cached_per_thread': 1,
# 'patch_size_for_spatialtransform': array([288, 320])}
# selected_data_channels is None
if params.get("selected_data_channels") is not None:
tr_transforms.append(
DataChannelSelectionTransform(
params.get("selected_data_channels")))
# selected_seg_channels is [0]
if params.get("selected_seg_channels") is not None:
tr_transforms.append(
SegChannelSelectionTransform(params.get("selected_seg_channels")))
# don't do color augmentations while in 2d mode with 3d data because the color channel is overloaded!!
# dummy_2D is True
if params.get("dummy_2D") is not None and params.get("dummy_2D"):
ignore_axes = (0, )
tr_transforms.append(Convert3DTo2DTransform())
else:
ignore_axes = None
tr_transforms.append(
SpatialTransform(patch_size,
patch_center_dist_from_border=None,
do_elastic_deform=params.get("do_elastic"),
alpha=params.get("elastic_deform_alpha"),
sigma=params.get("elastic_deform_sigma"),
do_rotation=params.get("do_rotation"),
angle_x=params.get("rotation_x"),
angle_y=params.get("rotation_y"),
angle_z=params.get("rotation_z"),
do_scale=params.get("do_scaling"),
scale=params.get("scale_range"),
border_mode_data=params.get("border_mode_data"),
border_cval_data=0,
order_data=order_data,
border_mode_seg="constant",
border_cval_seg=border_val_seg,
order_seg=order_seg,
random_crop=params.get("random_crop"),
p_el_per_sample=params.get("p_eldef"),
p_scale_per_sample=params.get("p_scale"),
p_rot_per_sample=params.get("p_rot"),
independent_scale_for_each_axis=params.get(
"independent_scale_factor_for_each_axis"),
p_independent_scale_per_axis=params.get(
"p_independent_scale_per_axis")))
if params.get("dummy_2D"):
tr_transforms.append(Convert2DTo3DTransform())
# we need to put the color augmentations after the dummy 2d part (if applicable). Otherwise the overloaded color
# channel gets in the way
tr_transforms.append(GaussianNoiseTransform(p_per_sample=0.15))
tr_transforms.append(
GaussianBlurTransform((0.5, 1.5),
different_sigma_per_channel=True,
p_per_sample=0.2,
p_per_channel=0.5))
tr_transforms.append(
BrightnessMultiplicativeTransform(multiplier_range=(0.70, 1.3),
p_per_sample=0.15))
tr_transforms.append(
ContrastAugmentationTransform(contrast_range=(0.65, 1.5),
p_per_sample=0.15))
tr_transforms.append(
SimulateLowResolutionTransform(zoom_range=(0.5, 1),
per_channel=True,
p_per_channel=0.5,
order_downsample=0,
order_upsample=3,
p_per_sample=0.25,
ignore_axes=ignore_axes))
tr_transforms.append(
GammaTransform(params.get("gamma_range"),
True,
True,
retain_stats=params.get("gamma_retain_stats"),
p_per_sample=0.15)) # inverted gamma
# do_additive_brightness is True
if params.get("do_additive_brightness"):
tr_transforms.append(
BrightnessTransform(
params.get("additive_brightness_mu"),
params.get("additive_brightness_sigma"),
True,
p_per_sample=params.get("additive_brightness_p_per_sample"),
p_per_channel=params.get("additive_brightness_p_per_channel")))
# do_gamma is True
if params.get("do_gamma"):
tr_transforms.append(
GammaTransform(params.get("gamma_range"),
False,
True,
retain_stats=params.get("gamma_retain_stats"),
p_per_sample=params["p_gamma"]))
# do_mirror is True
if params.get("do_mirror") or params.get("mirror"):
tr_transforms.append(MirrorTransform(params.get("mirror_axes")))
# mask_was_used_for_normalization is OrderedDict([(0, False)]),
if params.get("mask_was_used_for_normalization") is not None:
mask_was_used_for_normalization = params.get(
"mask_was_used_for_normalization")
tr_transforms.append(
MaskTransform(mask_was_used_for_normalization,
mask_idx_in_seg=0,
set_outside_to=0))
tr_transforms.append(RemoveLabelTransform(-1, 0))
# move_last_seg_chanel_to_data is False
if params.get("move_last_seg_chanel_to_data") is not None and params.get(
"move_last_seg_chanel_to_data"):
tr_transforms.append(
MoveSegAsOneHotToData(1, params.get("all_segmentation_labels"),
'seg', 'data'))
if params.get("cascade_do_cascade_augmentations"
) and not None and params.get(
"cascade_do_cascade_augmentations"):
if params.get("cascade_random_binary_transform_p") > 0:
tr_transforms.append(
ApplyRandomBinaryOperatorTransform(
channel_idx=list(
range(-len(params.get("all_segmentation_labels")),
0)),
p_per_sample=params.get(
"cascade_random_binary_transform_p"),
key="data",
strel_size=params.get(
"cascade_random_binary_transform_size")))
if params.get("cascade_remove_conn_comp_p") > 0:
tr_transforms.append(
RemoveRandomConnectedComponentFromOneHotEncodingTransform(
channel_idx=list(
range(-len(params.get("all_segmentation_labels")),
0)),
key="data",
p_per_sample=params.get("cascade_remove_conn_comp_p"),
fill_with_other_class_p=params.get(
"cascade_remove_conn_comp_max_size_percent_threshold"
),
dont_do_if_covers_more_than_X_percent=params.get(
"cascade_remove_conn_comp_fill_with_other_class_p")
))
tr_transforms.append(RenameTransform('seg', 'target', True))
# regions is None
if regions is not None:
tr_transforms.append(
ConvertSegmentationToRegionsTransform(regions, 'target', 'target'))
# deep_supervision_scales is a not None
if deep_supervision_scales is not None:
# soft_ds is False
if soft_ds:
assert classes is not None
tr_transforms.append(
DownsampleSegForDSTransform3(deep_supervision_scales, 'target',
'target', classes))
else:
tr_transforms.append(
DownsampleSegForDSTransform2(deep_supervision_scales,
0,
0,
input_key='target',
output_key='target'))
tr_transforms.append(NumpyToTensor(['data', 'target'], 'float'))
tr_transforms = Compose(tr_transforms)
batchgenerator_train = MultiThreadedAugmenter(
dataloader_train,
tr_transforms,
params.get('num_threads'),
params.get("num_cached_per_thread"),
seeds=seeds_train,
pin_memory=pin_memory)
# ========================================================
val_transforms = []
val_transforms.append(RemoveLabelTransform(-1, 0))
# selected_data_channels is None
if params.get("selected_data_channels") is not None:
val_transforms.append(
DataChannelSelectionTransform(
params.get("selected_data_channels")))
# selected_seg_channels is [0]
if params.get("selected_seg_channels") is not None:
val_transforms.append(
SegChannelSelectionTransform(params.get("selected_seg_channels")))
# move_last_seg_chanel_to_data is False
if params.get("move_last_seg_chanel_to_data") is not None and params.get(
"move_last_seg_chanel_to_data"):
val_transforms.append(
MoveSegAsOneHotToData(1, params.get("all_segmentation_labels"),
'seg', 'data'))
val_transforms.append(RenameTransform('seg', 'target', True))
# regions is None
if regions is not None:
val_transforms.append(
ConvertSegmentationToRegionsTransform(regions, 'target', 'target'))
# deep_supervision_scales is not None
if deep_supervision_scales is not None:
# soft_ds is False
if soft_ds:
assert classes is not None
val_transforms.append(
DownsampleSegForDSTransform3(deep_supervision_scales, 'target',
'target', classes))
else:
val_transforms.append(
DownsampleSegForDSTransform2(deep_supervision_scales,
0,
0,
input_key='target',
output_key='target'))
val_transforms.append(NumpyToTensor(['data', 'target'], 'float'))
val_transforms = Compose(val_transforms)
batchgenerator_val = MultiThreadedAugmenter(
dataloader_val,
val_transforms,
max(params.get('num_threads') // 2, 1),
params.get("num_cached_per_thread"),
seeds=seeds_val,
pin_memory=pin_memory)
return batchgenerator_train, batchgenerator_val
def Transforms(patch_size,
params=default_3D_augmentation_params,
border_val_seg=-1):
tr_transforms = []
if params.get("selected_data_channels") is not None:
tr_transforms.append(
DataChannelSelectionTransform(params.get("selected_data_channels"),
data_key="data"))
if params.get("selected_seg_channels") is not None:
tr_transforms.append(
SegChannelSelectionTransform(params.get("selected_seg_channels")))
# don't do color augmentations while in 2d mode with 3d data because the color channel is overloaded!!
if params.get("dummy_2D") is not None and params.get("dummy_2D"):
tr_transforms.append(Convert3DTo2DTransform())
tr_transforms.append(
SpatialTransform(patch_size,
patch_center_dist_from_border=None,
do_elastic_deform=params.get("do_elastic"),
alpha=params.get("elastic_deform_alpha"),
sigma=params.get("elastic_deform_sigma"),
do_rotation=params.get("do_rotation"),
angle_x=params.get("rotation_x"),
angle_y=params.get("rotation_y"),
angle_z=params.get("rotation_z"),
do_scale=params.get("do_scaling"),
scale=params.get("scale_range"),
border_mode_data=params.get("border_mode_data"),
border_cval_data=0,
order_data=3,
border_mode_seg="constant",
border_cval_seg=border_val_seg,
order_seg=1,
random_crop=params.get("random_crop"),
p_el_per_sample=params.get("p_eldef"),
p_scale_per_sample=params.get("p_scale"),
p_rot_per_sample=params.get("p_rot")))
if params.get("dummy_2D") is not None and params.get("dummy_2D"):
tr_transforms.append(Convert2DTo3DTransform())
if params.get("do_gamma"):
tr_transforms.append(
GammaTransform(params.get("gamma_range"),
False,
True,
retain_stats=params.get("gamma_retain_stats"),
p_per_sample=params["p_gamma"]))
tr_transforms.append(MirrorTransform(params.get("mirror_axes")))
if params.get("mask_was_used_for_normalization") is not None:
mask_was_used_for_normalization = params.get(
"mask_was_used_for_normalization")
tr_transforms.append(
MaskTransform(mask_was_used_for_normalization,
mask_idx_in_seg=0,
set_outside_to=0))
tr_transforms.append(RemoveLabelTransform(-1, 0))
if params.get("move_last_seg_chanel_to_data") is not None and params.get(
"move_last_seg_chanel_to_data"):
tr_transforms.append(
MoveSegAsOneHotToData(1, params.get("all_segmentation_labels"),
'seg', 'data'))
if params.get(
"advanced_pyramid_augmentations") and not None and params.get(
"advanced_pyramid_augmentations"):
tr_transforms.append(
ApplyRandomBinaryOperatorTransform(channel_idx=list(
range(-len(params.get("all_segmentation_labels")), 0)),
p_per_sample=0.4,
key="data",
strel_size=(1, 8)))
tr_transforms.append(
RemoveRandomConnectedComponentFromOneHotEncodingTransform(
channel_idx=list(
range(-len(params.get("all_segmentation_labels")), 0)),
key="data",
p_per_sample=0.2,
fill_with_other_class_p=0.0,
dont_do_if_covers_more_than_X_percent=0.15))
tr_transforms.append(RenameTransform('seg', 'target', True))
tr_transforms.append(NumpyToTensor(['data', 'target'], 'float'))
tr_transforms = Compose(tr_transforms)
return tr_transforms
