def layer_op(self, input_tensor): spatial_rank = layer_util.infer_spatial_rank(input_tensor) look_up_operations(self.func, SUPPORTED_OP) kernel_size_all_dims = layer_util.expand_spatial_params( self.kernel_size, spatial_rank) stride_all_dims = layer_util.expand_spatial_params( self.stride, spatial_rank) if self.func == 'CONSTANT': full_kernel_size = kernel_size_all_dims + (1, 1) np_kernel = layer_util.trivial_kernel(full_kernel_size) kernel = tf.constant(np_kernel, dtype=tf.float32) output_tensor = [tf.expand_dims(x, -1) for x in tf.unstack(input_tensor, axis=-1)] output_tensor = [ tf.nn.convolution( input=inputs, filter=kernel, strides=stride_all_dims, padding=self.padding, name='conv') for inputs in output_tensor] output_tensor = tf.concat(output_tensor, axis=-1) else: output_tensor = tf.nn.pool( input=input_tensor, window_shape=kernel_size_all_dims, pooling_type=self.func, padding=self.padding, dilation_rate=[1] * spatial_rank, strides=stride_all_dims, name=self.layer_name) return output_tensor
def param_to_dict(input_data_param): """ Validate the user input ``input_data_param`` raise an error if it's invalid. :param input_data_param: :return: input data specifications as a nested dictionary """ error_msg = 'Unknown ``data_param`` type. ' \ 'It should be a nested dictionary: '\ '{"modality_name": {"input_property": value}} '\ 'or a dictionary of: {"modality_name": '\ 'niftynet.utilities.util_common.ParserNamespace}' data_param = deepcopy(input_data_param) if isinstance(data_param, (ParserNamespace, argparse.Namespace)): data_param = vars(data_param) if not isinstance(data_param, dict): raise ValueError(error_msg) for mod in data_param: mod_param = data_param[mod] if isinstance(mod_param, (ParserNamespace, argparse.Namespace)): dict_param = vars(mod_param) elif isinstance(mod_param, dict): dict_param = mod_param else: raise ValueError(error_msg) for data_key in dict_param: look_up_operations(data_key, SUPPORTED_DATA_SPEC) data_param[mod] = dict_param return data_param
def param_to_dict(input_data_param): """ Validate the user input ``input_data_param`` raise an error if it's invalid. :param input_data_param: :return: input data specifications as a nested dictionary """ error_msg = 'Unknown ``data_param`` type. ' \ 'It should be a nested dictionary: '\ '{"modality_name": {"input_property": value}} '\ 'or a dictionary of: {"modality_name": '\ 'niftynet.utilities.util_common.ParserNamespace}' data_param = deepcopy(input_data_param) if isinstance(data_param, (ParserNamespace, argparse.Namespace)): data_param = vars(data_param) if not isinstance(data_param, dict): raise ValueError(error_msg) for mod in data_param: mod_param = data_param[mod] if isinstance(mod_param, (ParserNamespace, argparse.Namespace)): dict_param = vars(mod_param) elif isinstance(mod_param, dict): dict_param = mod_param else: raise ValueError(error_msg) for data_key in dict_param: look_up_operations(data_key, SUPPORTED_DATA_SPEC) data_param[mod] = dict_param return data_param
def layer_op(self, input_tensor): spatial_rank = layer_util.infer_spatial_rank(input_tensor) look_up_operations(self.func, SUPPORTED_OP) kernel_size_all_dims = layer_util.expand_spatial_params( self.kernel_size, spatial_rank) stride_all_dims = layer_util.expand_spatial_params( self.stride, spatial_rank) if self.func == 'CONSTANT': full_kernel_size = kernel_size_all_dims + (1, 1) np_kernel = layer_util.trivial_kernel(full_kernel_size) kernel = tf.constant(np_kernel, dtype=tf.float32) output_tensor = [ tf.expand_dims(x, -1) for x in tf.unstack(input_tensor, axis=-1) ] output_tensor = [ tf.nn.convolution(input=inputs, filter=kernel, strides=stride_all_dims, padding=self.padding, name='conv') for inputs in output_tensor ] output_tensor = tf.concat(output_tensor, axis=-1) else: output_tensor = tf.nn.pool(input=input_tensor, window_shape=kernel_size_all_dims, pooling_type=self.func, padding=self.padding, dilation_rate=[1] * spatial_rank, strides=stride_all_dims, name=self.layer_name) return output_tensor
def get_file_list(self, phase=ALL, *section_names): """ get file names as a dataframe, by partitioning phase and section names set phase to ALL to load all subsets. :param phase: the label of the subset generated by self._partition_ids should be one of the SUPPORTED_PHASES :param section_names: one or multiple input section names :return: a pandas.dataframe of file names """ if self._file_list is None: tf.logging.warning('Empty file list, please initialise' 'ImageSetsPartitioner first.') return [] try: look_up_operations(phase, SUPPORTED_PHASES) except ValueError: tf.logging.fatal('Unknown phase argument.') raise for name in section_names: try: look_up_operations(name, set(self._file_list)) except ValueError: tf.logging.fatal( 'Requesting files under input section [%s],\n' 'however the section does not exist in the config.', name) raise if phase == ALL: self._file_list = self._file_list.sort_index() if section_names: section_names = [COLUMN_UNIQ_ID] + list(section_names) return self._file_list[section_names] return self._file_list if self._partition_ids is None: tf.logging.fatal('No partition ids available.') if self.new_partition: tf.logging.fatal( 'Unable to create new partitions,' 'splitting ratios: %s, writing file %s', self.ratios, self.data_split_file) elif os.path.isfile(self.data_split_file): tf.logging.fatal( 'Unable to load %s, initialise the' 'ImageSetsPartitioner with `new_partition=True`' 'to overwrite the file.', self.data_split_file) raise ValueError selector = self._partition_ids[COLUMN_PHASE] == phase selected = self._partition_ids[selector][[COLUMN_UNIQ_ID]] if selected.empty: tf.logging.warning( 'Empty subset for phase [%s], returning None as file list. ' 'Please adjust splitting fractions.', phase) return None subset = pandas.merge(self._file_list, selected, on=COLUMN_UNIQ_ID) if section_names: section_names = [COLUMN_UNIQ_ID] + list(section_names) return subset[list(section_names)] return subset
def __init__(self, func='AVG', reduction_ratio=16, name='channel_squeeze_excitation'): self.func = func.upper() self.reduction_ratio = reduction_ratio super(ChannelSELayer, self).__init__(name=name) look_up_operations(self.func, SUPPORTED_OP)
def __init__(self, interpolation="LINEAR", boundary="REPLICATE", name="resampler", implementation="Fast"): super(ResamplerLayer, self).__init__(name=name) self.boundary = boundary.upper() self.boundary_func = look_up_operations(self.boundary, SUPPORTED_BOUNDARY) self.interpolation = look_up_operations(interpolation.upper(), SUPPORTED_INTERPOLATION) if self.boundary == 'ZERO' and self.interpolation == 'BSPLINE': tf.logging.fatal('Zero padding is not supported for BSPLINE mode') raise NotImplementedError if self.boundary == 'ZERO' and self.interpolation == 'IDW': tf.logging.warning('Zero padding is not supported for IDW mode') # raise NotImplementedError self.FastResamplerLayer = None # if implementation.lower() in ['niftyreg', 'fast']: # check if niftyreg_resampling_layer is installed try: from niftyreg_image_resampling import NiftyregImageResamplingLayer import niftyreg_image_resampling as resampler_module except ImportError: tf.logging.warning(''' niftyreg_image_resampling is not installed; falling back onto niftynet.layer.resampler.ResamplerLayer. To allow fast resampling, please see installation instructions in niftynet/contrib/niftyreg_image_resampling/README.md ''') return # Passthrough of supported boundary types for resampling SUPPORTED_BOUNDARY_FAST = resampler_module.SUPPORTED_BOUNDARY # Passthrough of supported interpolation types for NiftyReg resampling SUPPORTED_INTERPOLATION_FAST = resampler_module.SUPPORTED_INTERPOLATION # check compatibility of the resampling options with niftyreg_image_resampling try: boundary_fast = look_up_operations(self.boundary, SUPPORTED_BOUNDARY_FAST) interp_fast = look_up_operations(self.interpolation, SUPPORTED_INTERPOLATION_FAST) self.FastResamplerLayer = NiftyregImageResamplingLayer( interp_fast, boundary_fast) tf.logging.info('''NiftyReg image resampling is used.''') except ValueError as e: tf.logging.warning(e) tf.logging.warning( '''Falling back onto niftynet.layer.resampler.ResamplerLayer.''' )
def __init__(self, type_str='otsu_plus', multimod_fusion='or', threshold=0.0): super(BinaryMaskingLayer, self).__init__(name='binary_masking') self.type_str = look_up_operations( type_str.lower(), SUPPORTED_MASK_TYPES) self.multimod_fusion = look_up_operations( multimod_fusion.lower(), SUPPORTED_MULTIMOD_MASK_TYPES) self.threshold = threshold
def __init__(self, func, kernel_size=3, stride=2, padding='SAME', name='pooling'): self.func = func.upper() self.layer_name = '{}_{}'.format(self.func.lower(), name) super(DownSampleLayer, self).__init__(name=self.layer_name) self.padding = padding.upper() look_up_operations(self.padding, SUPPORTED_PADDING) self.kernel_size = kernel_size self.stride = stride
def __init__(self, func, kernel_size=3, stride=2, padding='SAME', name='pooling'): self.func = func.upper() self.layer_name = '{}_{}'.format(self.func.lower(), name) super(DownSampleLayer, self).__init__(name=self.layer_name) self.padding = padding.upper() look_up_operations(self.padding, SUPPORTED_PADDING) self.kernel_size = kernel_size self.stride = stride
def initialise_dataset_loader(self, data_param=None, task_param=None, data_partitioner=None): self.data_param = data_param self.autoencoder_param = task_param if not self.is_training: self._infer_type = look_up_operations( self.autoencoder_param.inference_type, SUPPORTED_INFERENCE) else: self._infer_type = None file_lists = self.get_file_lists(data_partitioner) # read each line of csv files into an instance of Subject if self.is_evaluation: NotImplementedError('Evaluation is not yet ' 'supported in this application.') if self.is_training: self.readers = [] for file_list in file_lists: reader = ImageReader(['image']) reader.initialise(data_param, task_param, file_list) self.readers.append(reader) if self._infer_type in ('encode', 'encode-decode'): self.readers = [ImageReader(['image'])] self.readers[0].initialise(data_param, task_param, file_lists[0]) elif self._infer_type == 'sample': self.readers = [] elif self._infer_type == 'linear_interpolation': self.readers = [ImageReader(['feature'])] self.readers[0].initialise(data_param, task_param, [file_lists])
def __init__(self, n_output_chns, kernel_size=3, stride=1, dilation=1, padding='SAME', with_bias=False, w_initializer=None, w_regularizer=None, b_initializer=None, b_regularizer=None, padding_constant=0, name='conv'): """ :param padding_constant: a constant applied in padded convolution (see also tf.pad) """ super(ConvLayer, self).__init__(name=name) self.padding = look_up_operations(padding.upper(), SUPPORTED_PADDING) self.n_output_chns = int(n_output_chns) self.kernel_size = kernel_size self.stride = stride self.dilation = dilation self.with_bias = with_bias self.padding_constant = padding_constant self.initializers = { 'w': w_initializer if w_initializer else default_w_initializer(), 'b': b_initializer if b_initializer else default_b_initializer() } self.regularizers = {'w': w_regularizer, 'b': b_regularizer}
def initialise_dataset_loader( self, data_param=None, task_param=None, data_partitioner=None): self.data_param = data_param self.autoencoder_param = task_param if not self.is_training: self._infer_type = look_up_operations( self.autoencoder_param.inference_type, SUPPORTED_INFERENCE) else: self._infer_type = None file_lists = self.get_file_lists(data_partitioner) # read each line of csv files into an instance of Subject if self.is_evaluation: NotImplementedError('Evaluation is not yet ' 'supported in this application.') if self.is_training: self.readers = [] for file_list in file_lists: reader = ImageReader(['image']) reader.initialise(data_param, task_param, file_list) self.readers.append(reader) if self._infer_type in ('encode', 'encode-decode'): self.readers = [ImageReader(['image'])] self.readers[0].initialise(data_param, task_param, file_lists[0]) elif self._infer_type == 'sample': self.readers = [] elif self._infer_type == 'linear_interpolation': self.readers = [ImageReader(['feature'])] self.readers[0].initialise(data_param, task_param, [file_lists])
def interpret_output(self, batch_output): if self.is_training: return True else: infer_type = look_up_operations( self.autoencoder_param.inference_type, SUPPORTED_INFERENCE) if infer_type == 'encode': return self.output_decoder.decode_batch( {'window_embedded': batch_output['embedded']}, batch_output['location'][:, 0:1]) if infer_type == 'encode-decode': return self.output_decoder.decode_batch( { 'window_generated_image': batch_output['generated_image'] }, batch_output['location'][:, 0:1]) if infer_type == 'sample': return self.output_decoder.decode_batch( { 'window_generated_image': batch_output['generated_image'] }, None) if infer_type == 'linear_interpolation': return self.output_decoder.decode_batch( { 'window_generated_image': batch_output['generated_image'] }, batch_output['location'][:, :2])
def __init__(self, n_output_chns, kernel_size=3, stride=1, padding='SAME', with_bias=False, w_initializer=None, w_regularizer=None, b_initializer=None, b_regularizer=None, name='deconv'): super(DeconvLayer, self).__init__(name=name) self.padding = look_up_operations(padding.upper(), SUPPORTED_PADDING) self.n_output_chns = int(n_output_chns) self.kernel_size = kernel_size self.stride = stride self.with_bias = with_bias self.initializers = { 'w': w_initializer if w_initializer else default_w_initializer(), 'b': b_initializer if b_initializer else default_b_initializer()} self.regularizers = {'w': w_regularizer, 'b': b_regularizer}
def __init__(self, func, n_conv, n_feature_chns, n_output_chns, w_initializer=None, w_regularizer=None, b_regularizer=None, b_initializer=None, acti_func='relu', name='vnet_block'): """ :param func: string, defines final block operation (Downsampling, upsampling, same) :param n_conv: int, number of conv layers to apply :param n_feature_chns: int, number of feature channels (output channels) for each conv layer :param n_output_chns: int, number of output channels of the final block operation (func) :param w_initializer: weight initialisation of convolutional layers :param w_regularizer: weight regularisation of convolutional layers :param b_initializer: bias initialisation of convolutional layers :param b_regularizer: bias regularisation of convolutional layers :param acti_func: activation function to use :param name: layer name """ super(VNetBlock, self).__init__(name=name) self.func = look_up_operations(func.upper(), SUPPORTED_OP) self.n_conv = n_conv self.n_feature_chns = n_feature_chns self.n_output_chns = n_output_chns self.acti_func = acti_func self.initializers = {'w': w_initializer, 'b': b_initializer} self.regularizers = {'w': w_regularizer, 'b': b_regularizer}
def __init__(self, interpolation="LINEAR", boundary="REPLICATE", name="resampler"): super(ResamplerLayer, self).__init__(name=name) self.boundary = boundary.upper() self.boundary_func = look_up_operations( self.boundary, SUPPORTED_BOUNDARY) self.interpolation = look_up_operations( interpolation.upper(), SUPPORTED_INTERPOLATION) if self.boundary == 'ZERO' and self.interpolation == 'BSPLINE': tf.logging.fatal('Zero padding is not supported for BSPLINE mode') raise NotImplementedError if self.boundary == 'ZERO' and self.interpolation == 'IDW': tf.logging.warning('Zero padding is not supported for IDW mode')
def __init__(self, n_output_chns=1, kernel_size=3, dilation=1, acti_func='relu', w_initializer=None, w_regularizer=None, moving_decay=0.9, eps=1e-5, type_string='bn_acti_conv', name='res-downsample'): """ Implementation of residual unit presented in: [1] He et al., Identity mapping in deep residual networks, ECCV 2016 [2] He et al., Deep residual learning for image recognition, CVPR 2016 The possible types of connections are:: 'original': residual unit presented in [2] 'conv_bn_acti': ReLU before addition presented in [1] 'acti_conv_bn': ReLU-only pre-activation presented in [1] 'bn_acti_conv': full pre-activation presented in [1] [1] recommends 'bn_acti_conv' :param n_output_chns: number of output feature channels if this doesn't match the input, a 1x1 projection will be created. :param kernel_size: :param dilation: :param acti_func: :param w_initializer: :param w_regularizer: :param moving_decay: :param eps: :param type_string: :param name: """ super(TrainableLayer, self).__init__(name=name) self.type_string = look_up_operations(type_string.lower(), SUPPORTED_OP) self.acti_func = acti_func self.conv_param = { 'w_initializer': w_initializer, 'w_regularizer': w_regularizer, 'kernel_size': kernel_size, 'dilation': dilation, 'n_output_chns': n_output_chns } self.bn_param = { 'regularizer': w_regularizer, 'moving_decay': moving_decay, 'eps': eps }
def __init__(self, func, initializer=None, regularizer=None, name='residual'): self.func = look_up_operations(func.upper(), SUPPORTED_OP) self.layer_name = '{}_{}'.format(name, self.func.lower()) super(ElementwiseLayer, self).__init__(name=self.layer_name) self.initializers = {'w': initializer} self.regularizers = {'w': regularizer}
def __init__(self, func, initializer=None, regularizer=None, name='residual'): self.func = look_up_operations(func.upper(), SUPPORTED_OP) self.layer_name = '{}_{}'.format(name, self.func.lower()) super(ElementwiseLayer, self).__init__(name=self.layer_name) self.initializers = {'w': initializer} self.regularizers = {'w': regularizer}
def __init__(self, sigma=1, truncate=3.0, type_str='gaussian'): """ :param sigma: standard deviation :param truncate: Truncate the filter at this many standard deviations :param type_str: type of kernels """ Layer.__init__(self, name='approximated_smoothing') self.kernel_func = look_up_operations( type_str.lower(), SUPPORTED_KERNELS) self.sigma = sigma self.truncate = truncate
def __init__(self, func, n_layers=1, w_initializer=None, w_regularizer=None, acti_func='relu', name='scaleblock'): self.func = look_up_operations(func.upper(), SUPPORTED_OP) super(ScaleBlock, self).__init__(name=name) self.n_layers = n_layers self.acti_func = acti_func self.initializers = {'w': w_initializer} self.regularizers = {'w': w_regularizer}
def __init__(self, func, n_layers=1, w_initializer=None, w_regularizer=None, acti_func='relu', name='scaleblock'): self.func = look_up_operations(func.upper(), SUPPORTED_OP) super(ScaleBlock, self).__init__(name=name) self.n_layers = n_layers self.acti_func = acti_func self.initializers = {'w': w_initializer} self.regularizers = {'w': w_regularizer}
def __init__(self, n_output_chns=1, kernel_size=3, dilation=1, acti_func='relu', w_initializer=None, w_regularizer=None, moving_decay=0.9, eps=1e-5, type_string='bn_acti_conv', name='res-downsample'): """ Implementation of residual unit presented in: [1] He et al., Identity mapping in deep residual networks, ECCV 2016 [2] He et al., Deep residual learning for image recognition, CVPR 2016 The possible types of connections are:: 'original': residual unit presented in [2] 'conv_bn_acti': ReLU before addition presented in [1] 'acti_conv_bn': ReLU-only pre-activation presented in [1] 'bn_acti_conv': full pre-activation presented in [1] [1] recommends 'bn_acti_conv' :param n_output_chns: number of output feature channels if this doesn't match the input, a 1x1 projection will be created. :param kernel_size: :param dilation: :param acti_func: :param w_initializer: :param w_regularizer: :param moving_decay: :param eps: :param type_string: :param name: """ super(TrainableLayer, self).__init__(name=name) self.type_string = look_up_operations(type_string.lower(), SUPPORTED_OP) self.acti_func = acti_func self.conv_param = {'w_initializer': w_initializer, 'w_regularizer': w_regularizer, 'kernel_size': kernel_size, 'dilation': dilation, 'n_output_chns': n_output_chns} self.bn_param = {'regularizer': w_regularizer, 'moving_decay': moving_decay, 'eps': eps}
def number_of_subjects(self, phase=ALL): """ query number of images according to phase :param phase: :return: """ if self._file_list is None: return 0 phase = look_up_operations(phase, SUPPORTED_PHASES) if phase == ALL: return self._file_list[COLUMN_UNIQ_ID].count() if self._partition_ids is None: return 0 selector = self._partition_ids[COLUMN_PHASE] == phase return self._partition_ids[selector].count()[COLUMN_UNIQ_ID]
def layer_op(self, input_tensor, keep_prob=None): func_ = look_up_operations(self.func, SUPPORTED_OP) if self.func == 'prelu': alphas = tf.get_variable('alpha', input_tensor.shape[-1], initializer=self.initializers['alpha'], regularizer=self.regularizers['alpha']) output_tensor = func_(input_tensor, alphas) elif self.func == 'dropout': output_tensor = func_(input_tensor, keep_prob=keep_prob, name='dropout') else: output_tensor = func_(input_tensor, name='acti') return output_tensor
def number_of_subjects(self, phase=ALL): """ query number of images according to phase. :param phase: :return: """ if self._file_list is None: return 0 phase = look_up_operations(phase, SUPPORTED_PHASES) if phase == ALL: return self._file_list[COLUMN_UNIQ_ID].count() if self._partition_ids is None: return 0 selector = self._partition_ids[COLUMN_PHASE] == phase return self._partition_ids[selector].count()[COLUMN_UNIQ_ID]
def layer_op(self, input_tensor, keep_prob=None): func_ = look_up_operations(self.func, SUPPORTED_OP) if self.func == 'prelu': alphas = tf.get_variable( 'alpha', input_tensor.shape[-1], initializer=self.initializers['alpha'], regularizer=self.regularizers['alpha']) output_tensor = func_(input_tensor, alphas) elif self.func == 'dropout': assert keep_prob > 0.0 assert keep_prob <= 1.0 output_tensor = func_(input_tensor, keep_prob=keep_prob, name='dropout') else: output_tensor = func_(input_tensor, name='acti') return output_tensor
def initialise_dataset_loader(self, data_param=None, task_param=None): self.data_param = data_param self.autoencoder_param = task_param if not self.is_training: self._infer_type = look_up_operations( self.autoencoder_param.inference_type, SUPPORTED_INFERENCE) else: self._infer_type = None # read each line of csv files into an instance of Subject if self.is_training: self.reader = ImageReader(['image']) if self._infer_type in ('encode', 'encode-decode'): self.reader = ImageReader(['image']) elif self._infer_type == 'sample': self.reader = () elif self._infer_type == 'linear_interpolation': self.reader = ImageReader(['feature']) if self.reader: self.reader.initialise_reader(data_param, task_param) augmentation_layers = [] if self.is_training: if self.action_param.random_flipping_axes != -1: augmentation_layers.append( RandomFlipLayer( flip_axes=self.action_param.random_flipping_axes)) if self.action_param.scaling_percentage: augmentation_layers.append( RandomSpatialScalingLayer( min_percentage=self.action_param. scaling_percentage[0], max_percentage=self.action_param. scaling_percentage[1])) if self.action_param.rotation_angle: augmentation_layers.append( RandomRotationLayer( min_angle=self.action_param.rotation_angle[0], max_angle=self.action_param.rotation_angle[1])) self.reader.add_preprocessing_layers(augmentation_layers)
def __init__(self, func, kernel_size=3, stride=2, w_initializer=None, w_regularizer=None, with_bias=False, b_initializer=None, b_regularizer=None, name='upsample'): self.func = look_up_operations(func.upper(), SUPPORTED_OP) self.layer_name = '{}_{}'.format(self.func.lower(), name) super(UpSampleLayer, self).__init__(name=self.layer_name) self.kernel_size = kernel_size self.stride = stride self.with_bias = with_bias self.initializers = {'w': w_initializer, 'b': b_initializer} self.regularizers = {'w': w_regularizer, 'b': b_regularizer}
def __init__(self, func, kernel_size=3, stride=2, w_initializer=None, w_regularizer=None, with_bias=False, b_initializer=None, b_regularizer=None, name='upsample'): self.func = look_up_operations(func.upper(), SUPPORTED_OP) self.layer_name = '{}_{}'.format(self.func.lower(), name) super(UpSampleLayer, self).__init__(name=self.layer_name) self.kernel_size = kernel_size self.stride = stride self.with_bias = with_bias self.initializers = {'w': w_initializer, 'b': b_initializer} self.regularizers = {'w': w_regularizer, 'b': b_regularizer}
def __init__(self, func, n_chns, kernels, w_initializer=None, w_regularizer=None, with_downsample_branch=False, acti_func='relu', name='UNet_block'): super(UNetBlock, self).__init__(name=name) self.func = look_up_operations(func.upper(), SUPPORTED_OP) self.kernels = kernels self.n_chns = n_chns self.with_downsample_branch = with_downsample_branch self.acti_func = acti_func self.initializers = {'w': w_initializer} self.regularizers = {'w': w_regularizer}
def get_file_lists(self, data_partitioner): """This function pull the correct file_lists from the data partitioner depending on the phase :param data_partitioner: specifies train/valid/infer splitting if needed :return: list of file lists of length 2 if validation is needed otherwise 1""" if self.is_training: if self.action_param.validation_every_n > 0 and\ data_partitioner.has_validation: return [data_partitioner.train_files, data_partitioner.validation_files] else: return [data_partitioner.train_files] dataset = self.action_param.dataset_to_infer if dataset: dataset = look_up_operations(dataset, SUPPORTED_PHASES) return [data_partitioner.get_file_list(dataset)] return [data_partitioner.inference_files]
def initialise_dataset_loader(self, data_param=None, task_param=None): self.data_param = data_param self.autoencoder_param = task_param if not self.is_training: self._infer_type = look_up_operations( self.autoencoder_param.inference_type, SUPPORTED_INFERENCE) else: self._infer_type = None # read each line of csv files into an instance of Subject if self.is_training: self.reader = ImageReader(['image']) if self._infer_type in ('encode', 'encode-decode'): self.reader = ImageReader(['image']) elif self._infer_type == 'sample': self.reader = () elif self._infer_type == 'linear_interpolation': self.reader = ImageReader(['feature']) if self.reader: self.reader.initialise_reader(data_param, task_param)
def __init__(self, func, n_layers=1, w_initializer=None, w_regularizer=None, acti_func='relu', name='scaleblock'): """ :param func: merging function (SUPPORTED_OP: MAX, AVERAGE) :param n_layers: int, number of layers :param w_initializer: weight initialisation for network :param w_regularizer: weight regularisation for network :param acti_func: activation function to use :param name: layer name """ self.func = look_up_operations(func.upper(), SUPPORTED_OP) super(ScaleBlock, self).__init__(name=name) self.n_layers = n_layers self.acti_func = acti_func self.initializers = {'w': w_initializer} self.regularizers = {'w': w_regularizer}
def interpret_output(self, batch_output): if self.is_training: return True else: infer_type = look_up_operations( self.autoencoder_param.inference_type, SUPPORTED_INFERENCE) if infer_type == 'encode': return self.output_decoder.decode_batch( batch_output['embedded'], batch_output['location'][:, 0:1]) if infer_type == 'encode-decode': return self.output_decoder.decode_batch( batch_output['generated_image'], batch_output['location'][:, 0:1]) if infer_type == 'sample': return self.output_decoder.decode_batch( batch_output['generated_image'], None) if infer_type == 'linear_interpolation': return self.output_decoder.decode_batch( batch_output['generated_image'], batch_output['location'][:, :2])
def initialise_dataset_loader( self, data_param=None, task_param=None, data_partitioner=None): self.data_param = data_param self.autoencoder_param = task_param if not self.is_training: self._infer_type = look_up_operations( self.autoencoder_param.inference_type, SUPPORTED_INFERENCE) else: self._infer_type = None # read each line of csv files into an instance of Subject if self.is_training: file_lists = [] if self.action_param.validation_every_n > 0: file_lists.append(data_partitioner.train_files) file_lists.append(data_partitioner.validation_files) else: file_lists.append(data_partitioner.train_files) self.readers = [] for file_list in file_lists: reader = ImageReader(['image']) reader.initialise(data_param, task_param, file_list) self.readers.append(reader) if self._infer_type in ('encode', 'encode-decode'): self.readers = [ImageReader(['image'])] self.readers[0].initialise(data_param, task_param, data_partitioner.inference_files) elif self._infer_type == 'sample': self.readers = [] elif self._infer_type == 'linear_interpolation': self.readers = [ImageReader(['feature'])] self.readers[0].initialise(data_param, task_param, data_partitioner.inference_files)
def action(self, value): self._action = look_up_operations(value, self.SUPPORTED_ACTIONS)
def __init__(self, func='', num_classes=0, name='post_processing'): super(PostProcessingLayer, self).__init__(name=name) self.func = look_up_operations(func.upper(), SUPPORTED_OPS) self.num_classes = num_classes
def get_file_list(self, phase=ALL, *section_names): """ get file names as a dataframe, by partitioning phase and section names set phase to ALL to load all subsets. :param phase: the label of the subset generated by self._partition_ids should be one of the SUPPORTED_PHASES :param section_names: one or multiple input section names :return: a pandas.dataframe of file names """ if self._file_list is None: tf.logging.warning('Empty file list, please initialise' 'ImageSetsPartitioner first.') return [] try: look_up_operations(phase, SUPPORTED_PHASES) except ValueError: tf.logging.fatal('Unknown phase argument.') raise for name in section_names: try: look_up_operations(name, set(self._file_list)) except ValueError: tf.logging.fatal( 'Requesting files under input section [%s],\n' 'however the section does not exist in the config.', name) raise if phase == ALL: self._file_list = self._file_list.sort_index() if section_names: section_names = [COLUMN_UNIQ_ID] + list(section_names) return self._file_list[section_names] return self._file_list if self._partition_ids is None or self._partition_ids.empty: tf.logging.fatal('No partition ids available.') if self.new_partition: tf.logging.fatal('Unable to create new partitions,' 'splitting ratios: %s, writing file %s', self.ratios, self.data_split_file) elif os.path.isfile(self.data_split_file): tf.logging.fatal( 'Unable to load %s, initialise the' 'ImageSetsPartitioner with `new_partition=True`' 'to overwrite the file.', self.data_split_file) raise ValueError selector = self._partition_ids[COLUMN_PHASE] == phase selected = self._partition_ids[selector][[COLUMN_UNIQ_ID]] if selected.empty: tf.logging.warning( 'Empty subset for phase [%s], returning None as file list. ' 'Please adjust splitting fractions.', phase) return None subset = pandas.merge(self._file_list, selected, on=COLUMN_UNIQ_ID) if subset.empty: tf.logging.warning( 'No subject id matched in between file names and ' 'partition files.\nPlease check the partition files %s,\nor ' 'removing it to generate a new file automatically.', self.data_split_file) if section_names: section_names = [COLUMN_UNIQ_ID] + list(section_names) return subset[list(section_names)] return subset
def transform_by_mapping(img, mask, mapping, cutoff, type_hist='quartile'): """ Performs the standardisation of a given image. :param img: image to standardise :param mask: mask over which to determine the landmarks :param mapping: mapping landmarks to use for the piecewise linear transformations :param cutoff: cutoff points for the mapping :param type_hist: Type of landmarks scheme to use: choice between quartile percentile and median :return new_img: the standardised image """ image_shape = img.shape img = img.reshape(-1) mask = mask.reshape(-1) type_hist = look_up_operations(type_hist.lower(), SUPPORTED_CUTPOINTS) if type_hist == 'quartile': range_to_use = [0, 3, 6, 9, 12] elif type_hist == 'percentile': range_to_use = [0, 1, 2, 4, 5, 6, 7, 8, 10, 11, 12] elif type_hist == 'median': range_to_use = [0, 6, 12] else: raise ValueError('unknown cutting points type_str') assert len(mapping) >= len(range_to_use), \ "wrong mapping format, please check the histogram reference file" mapping = np.asarray(mapping) cutoff = __standardise_cutoff(cutoff, type_hist) perc = __compute_percentiles(img, mask, cutoff) # Apply linear histogram standardisation range_mapping = mapping[range_to_use] range_perc = perc[range_to_use] diff_mapping = range_mapping[1:] - range_mapping[:-1] diff_perc = range_perc[1:] - range_perc[:-1] # handling the case where two landmarks are the same # for a given input image. This usually happens when # image background are not removed from the image. diff_perc[diff_perc == 0] = np.inf affine_map = np.zeros([2, len(range_to_use) - 1]) # compute slopes of the linear models affine_map[0] = diff_mapping / diff_perc # compute intercepts of the linear models affine_map[1] = range_mapping[:-1] - affine_map[0] * range_perc[:-1] bin_id = np.digitize(img, range_perc[1:-1], right=False) lin_img = affine_map[0, bin_id] aff_img = affine_map[1, bin_id] # handling below cutoff[0] over cutoff[1] # values are mapped linearly and then smoothed new_img = lin_img * img + aff_img # Apply smooth thresholding (exponential) # below cutoff[0] and over cutoff[1] # this might not guarantee one to one mapping # lowest_values = img <= range_perc[0] # highest_values = img >= range_perc[-1] # new_img[lowest_values] = smooth_threshold( # new_img[lowest_values], mode='low') # new_img[highest_values] = smooth_threshold( # new_img[highest_values], mode='high') # Apply mask and set background to zero # new_img[mask == False] = 0. new_img = new_img.reshape(image_shape) return new_img
def phase(self, value): self._phase = look_up_operations(value, PHASES)