def __init__(self, filters, kernel_size, strides=1, padding='valid', data_format=None, activation=None, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None, **kwargs): super(LocallyConnected1D, self).__init__(**kwargs) self.filters = filters self.kernel_size = conv_utils.normalize_tuple(kernel_size, 1, 'kernel_size') self.strides = conv_utils.normalize_tuple(strides, 1, 'strides') self.padding = conv_utils.normalize_padding(padding) if self.padding != 'valid': raise ValueError('Invalid border mode for LocallyConnected1D ' '(only "valid" is supported): ' + padding) self.data_format = conv_utils.normalize_data_format(data_format) self.activation = activations.get(activation) self.use_bias = use_bias self.kernel_initializer = initializers.get(kernel_initializer) self.bias_initializer = initializers.get(bias_initializer) self.kernel_regularizer = regularizers.get(kernel_regularizer) self.bias_regularizer = regularizers.get(bias_regularizer) self.activity_regularizer = regularizers.get(activity_regularizer) self.kernel_constraint = constraints.get(kernel_constraint) self.bias_constraint = constraints.get(bias_constraint) self.input_spec = InputSpec(ndim=3)
def __init__(self, filters, kernel_size, strides=(1, 1), padding='valid', data_format=None, dilation_rate=(1, 1), activation='tanh', recurrent_activation='hard_sigmoid', use_bias=True, kernel_initializer='glorot_uniform', recurrent_initializer='orthogonal', bias_initializer='zeros', unit_forget_bias=True, kernel_regularizer=None, recurrent_regularizer=None, bias_regularizer=None, kernel_constraint=None, recurrent_constraint=None, bias_constraint=None, dropout=0., recurrent_dropout=0., **kwargs): super(ConvLSTM2DCell, self).__init__(**kwargs) self.filters = filters self.kernel_size = conv_utils.normalize_tuple(kernel_size, 2, 'kernel_size') self.strides = conv_utils.normalize_tuple(strides, 2, 'strides') self.padding = conv_utils.normalize_padding(padding) self.data_format = conv_utils.normalize_data_format(data_format) self.dilation_rate = conv_utils.normalize_tuple(dilation_rate, 2, 'dilation_rate') self.activation = activations.get(activation) self.recurrent_activation = activations.get(recurrent_activation) self.use_bias = use_bias self.kernel_initializer = initializers.get(kernel_initializer) self.recurrent_initializer = initializers.get(recurrent_initializer) self.bias_initializer = initializers.get(bias_initializer) self.unit_forget_bias = unit_forget_bias self.kernel_regularizer = regularizers.get(kernel_regularizer) self.recurrent_regularizer = regularizers.get(recurrent_regularizer) self.bias_regularizer = regularizers.get(bias_regularizer) self.kernel_constraint = constraints.get(kernel_constraint) self.recurrent_constraint = constraints.get(recurrent_constraint) self.bias_constraint = constraints.get(bias_constraint) self.dropout = min(1., max(0., dropout)) self.recurrent_dropout = min(1., max(0., recurrent_dropout)) self.state_size = (self.filters, self.filters) self._dropout_mask = None self._recurrent_dropout_mask = None
def __init__(self, pool_function, pool_size, strides, padding='valid', data_format='channels_last', name=None, **kwargs): super(Pooling1D, self).__init__(name=name, **kwargs) if data_format is None: data_format = backend.image_data_format() if strides is None: strides = pool_size self.pool_function = pool_function self.pool_size = conv_utils.normalize_tuple(pool_size, 1, 'pool_size') self.strides = conv_utils.normalize_tuple(strides, 1, 'strides') self.padding = conv_utils.normalize_padding(padding) self.data_format = conv_utils.normalize_data_format(data_format) self.input_spec = InputSpec(ndim=3)
def test_normalize_tuple(self): self.assertEqual((2, 2, 2), conv_utils.normalize_tuple(2, n=3, name='strides')) self.assertEqual((2, 1, 2), conv_utils.normalize_tuple((2, 1, 2), n=3, name='strides')) with self.assertRaises(ValueError): conv_utils.normalize_tuple((2, 1), n=3, name='strides') with self.assertRaises(ValueError): conv_utils.normalize_tuple(None, n=3, name='strides')
def init_layers(self, input_shape): conv_layer_type = self.get_conv_layer_type() for i in range(self.depth): strides = self.strides if (i == 0) else 1 kernel_initializer = self.kernel_initializer if (i == 0) else tf.zeros_initializer conv_layer = conv_layer_type(filters=self.filters, kernel_size=self.kernel_size, strides=strides, padding="same", data_format=self.data_format, dilation_rate=self.dilation_rate, use_bias=False, kernel_initializer=kernel_initializer, kernel_regularizer=self.kernel_regularizer, activity_regularizer=self.activity_regularizer, kernel_constraint=self.kernel_constraint, bias_constraint=self.bias_constraint) self.conv_layers.append(conv_layer) if self.use_projection(input_shape): projection_kernel_size = conv_utils.normalize_tuple(1, self.rank, "projection_kernel_size") projection_kernel_initializer = VarianceScaling() self.projection_layer = conv_layer_type(filters=self.filters, kernel_size=projection_kernel_size, strides=self.strides, padding="same", data_format=self.data_format, dilation_rate=self.dilation_rate, use_bias=False, kernel_initializer=projection_kernel_initializer, kernel_regularizer=self.kernel_regularizer, activity_regularizer=self.activity_regularizer, kernel_constraint=self.kernel_constraint, bias_constraint=self.bias_constraint) self._layers = copy(self.conv_layers) if self.projection_layer is not None: self._layers.append(self.projection_layer)
def __init__(self, filter_size=3, strides=2, padding='valid', **kwargs): rank = 2 self.filter_size = filter_size self.strides = conv_utils.normalize_tuple(strides, rank, 'strides') self.padding = conv_utils.normalize_padding(padding) if self.filter_size == 1: self.a = np.array([ 1., ]) elif self.filter_size == 2: self.a = np.array([1., 1.]) elif self.filter_size == 3: self.a = np.array([1., 2., 1.]) elif self.filter_size == 4: self.a = np.array([1., 3., 3., 1.]) elif self.filter_size == 5: self.a = np.array([1., 4., 6., 4., 1.]) elif self.filter_size == 6: self.a = np.array([1., 5., 10., 10., 5., 1.]) elif self.filter_size == 7: self.a = np.array([1., 6., 15., 20., 15., 6., 1.]) super(Blur2D, self).__init__(**kwargs)
def sample_label_matrix(y, window_size=(30, 30), padding='valid', max_training_examples=1e7, data_format=None): """Sample a 4D Tensor, creating many small images of shape `window_size`. Args: y: label masks with the same shape as `X` data window_size: size of window around each pixel to sample padding: padding type `valid` or `same` max_training_examples: max number of samples per class data_format: `channels_first` or `channels_last` Returns: 4 arrays of coordinates of each sampled pixel """ data_format = conv_utils.normalize_data_format(data_format) is_channels_first = data_format == 'channels_first' if is_channels_first: num_dirs, num_features, image_size_x, image_size_y = y.shape else: num_dirs, image_size_x, image_size_y, num_features = y.shape window_size = conv_utils.normalize_tuple(window_size, 2, 'window_size') window_size_x, window_size_y = window_size feature_rows, feature_cols, feature_batch, feature_label = [], [], [], [] for direc in range(num_dirs): for k in range(num_features): if is_channels_first: feature_rows_temp, feature_cols_temp = np.where(y[direc, k, :, :] == 1) else: feature_rows_temp, feature_cols_temp = np.where(y[direc, :, :, k] == 1) # Check to make sure the features are actually present if not feature_rows_temp.size > 0: continue # Randomly permute index vector non_rand_ind = np.arange(len(feature_rows_temp)) rand_ind = np.random.choice(non_rand_ind, size=len(feature_rows_temp), replace=False) for i in rand_ind: condition = padding == 'valid' and \ feature_rows_temp[i] - window_size_x > 0 and \ feature_rows_temp[i] + window_size_x < image_size_x and \ feature_cols_temp[i] - window_size_y > 0 and \ feature_cols_temp[i] + window_size_y < image_size_y if padding == 'same' or condition: feature_rows.append(feature_rows_temp[i]) feature_cols.append(feature_cols_temp[i]) feature_batch.append(direc) feature_label.append(k) # Randomize non_rand_ind = np.arange(len(feature_rows), dtype='int32') if not max_training_examples: max_training_examples = non_rand_ind.size else: max_training_examples = int(max_training_examples) limit = min(non_rand_ind.size, max_training_examples) rand_ind = np.random.choice(non_rand_ind, size=limit, replace=False) feature_rows = np.array(feature_rows, dtype='int32')[rand_ind] feature_cols = np.array(feature_cols, dtype='int32')[rand_ind] feature_batch = np.array(feature_batch, dtype='int32')[rand_ind] feature_label = np.array(feature_label, dtype='int32')[rand_ind] return feature_rows, feature_cols, feature_batch, feature_label
def __init__(self, size=(2, 2), **kwargs): super(MaxUnpooling2D, self).__init__(**kwargs) self.size = conv_utils.normalize_tuple(size, 2, 'size')
def __init__(self, filters, kernel_size, cov_kernel_size=(3, 1), strides=(1, 1), padding='valid', data_format=None, dilation_rate=(1, 1), activation='tanh', recurrent_activation='hard_sigmoid', use_bias=True, kernel_initializer='glorot_uniform', recurrent_initializer='orthogonal', bias_initializer='zeros', unit_forget_bias=True, kernel_regularizer=None, recurrent_regularizer=None, bias_regularizer=None, kernel_constraint=None, recurrent_constraint=None, bias_constraint=None, dropout=0., recurrent_dropout=0., **kwargs): super(ConvLSTM2DCell_2, self).__init__(**kwargs) self.filters = filters self.kernel_size = conv_utils.normalize_tuple(kernel_size, 2, 'kernel_size') ############################# self.cov_kernel_size = cov_kernel_size self.kernel_size_1 = conv_utils.normalize_tuple( cov_kernel_size, 2, 'kernel_size') ################################## self.strides = conv_utils.normalize_tuple(strides, 2, 'strides') self.padding = conv_utils.normalize_padding(padding) self.data_format = conv_utils.normalize_data_format(data_format) self.dilation_rate = conv_utils.normalize_tuple( dilation_rate, 2, 'dilation_rate') self.activation = activations.get(activation) self.recurrent_activation = activations.get(recurrent_activation) self.use_bias = use_bias self.kernel_initializer = initializers.get(kernel_initializer) ############################### self.cov_kernel_initializer = initializers.get(kernel_initializer) ########################## self.recurrent_initializer = initializers.get(recurrent_initializer) self.bias_initializer = initializers.get(bias_initializer) self.unit_forget_bias = unit_forget_bias self.kernel_regularizer = regularizers.get(kernel_regularizer) self.recurrent_regularizer = regularizers.get(recurrent_regularizer) self.bias_regularizer = regularizers.get(bias_regularizer) self.kernel_constraint = constraints.get(kernel_constraint) self.recurrent_constraint = constraints.get(recurrent_constraint) self.bias_constraint = constraints.get(bias_constraint) self.dropout = min(1., max(0., dropout)) self.recurrent_dropout = min(1., max(0., recurrent_dropout)) self.state_size = (self.filters, self.filters)
def __init__(self, dilations, filters, kernel_size, activation=None, attention_kernel_size=(3, 3, 3), attention_filters=None, attention_activation=tf.nn.relu, use_bn=True, **kwargs): """ dilations : (list of ints, list of 2-tuples of ints) List of dilation rates to process on the input in parallel filters: (int) Number of filters of the dilated convolutions kernel_size: (int, 2-tuple of intes) Kernel dim in dilated convolution layers activation: (string, func) Activation function to apply to final Autofocus layer output attention_kernel_size : (int, 2-tuple of intes) Kernel dim in attention conv layer 1 attention_filters : (int, None) Number of filters in attention conv layer 1, uses 'filters' // 2 if not specified attention_activation: (func) TF activation function to apply after attention conv layer 1 use_bn : (bool) Apply batch normalization after dilated convolutions kwargs : (dict) Passed to tf.keras.layers.Conv3D, for instance... - kernel_initializer='glorot_uniform' - bias_initializer='zeros' - kernel_regularizer=None - bias_regularizer=None - activity_regularizer=None - kernel_constraint=None - bias_constraint=None NOTE: These passed parameters are currently used for all convolutions across the layer - both in the dilated network and attention layer """ # Assert parameters passed are compatible if kwargs.get("padding") and kwargs["padding"].upper() != "SAME": raise NotImplementedError("Only implemented for padding 'SAME'") if kwargs.get("dilation_rate"): raise ValueError("Should not pass arguments to 'dilation_rate'. " "Pass a list to 'dilations' instead.") kwargs["dilation_rate"] = (1, 1, 1) kwargs["padding"] = "SAME" # Init base tf 3D Conv class super(Autofocus3D, self).__init__(filters=filters, kernel_size=kernel_size, activation=activation, **kwargs) # Use batch norm in dilation network? self.use_bn = use_bn # Attributes for attention network self.attention_filters = attention_filters or self.filters // 2 self.attention_kernel_size = conv_utils.normalize_tuple( attention_kernel_size, self.rank, 'kernel_size') self.attention_activation = attention_activation # Dilations self.dilations = [ conv_utils.normalize_tuple(d, self.rank, 'dilation_rate') for d in dilations ] self.conv_ops = [] self.attention_ops = []
def call(self, inputs): if self.data_format == 'channels_first': inputs = K.permute_dimensions(inputs, pattern=[0, 2, 3, 4, 1]) padding_input = self.padding.upper() dilation_rate = conv_utils.normalize_tuple( self.dilation_rate, 3, 'dilation_rate') if self.padding == 'valid': outputs = tf.nn.pool(inputs, window_shape=self.pool_size, pooling_type='MAX', padding=padding_input, dilation_rate=dilation_rate, strides=self.strides, data_format='NDHWC') elif self.padding == 'same': input_shape = K.int_shape(inputs) times = input_shape[1] rows = input_shape[2] cols = input_shape[3] times_unpadded = conv_utils.conv_output_length( times, self.pool_size[0], padding='valid', stride=self.strides[0], dilation=self.dilation_rate) rows_unpadded = conv_utils.conv_output_length( rows, self.pool_size[1], padding='valid', stride=self.strides[0], dilation=self.dilation_rate) cols_unpadded = conv_utils.conv_output_length( cols, self.pool_size[2], padding='valid', stride=self.strides[1], dilation=self.dilation_rate) t_pad = (times - times_unpadded) // 2 w_pad = (rows - rows_unpadded) // 2 h_pad = (cols - cols_unpadded) // 2 t_pad = (t_pad, t_pad) w_pad = (w_pad, w_pad) h_pad = (h_pad, h_pad) pattern = [[0, 0], list(t_pad), list(w_pad), list(h_pad), [0, 0]] # Pad the image outputs = tf.pad(inputs, pattern, mode='REFLECT') # Perform pooling outputs = tf.nn.pool(inputs, window_shape=self.pool_size, pooling_type='MAX', padding='VALID', dilation_rate=dilation_rate, strides=self.strides, data_format='NDHWC') if self.data_format == 'channels_first': outputs = K.permute_dimensions(outputs, pattern=[0, 4, 1, 2, 3]) return outputs
def __init__(self, rank, kernel_size, growth_rate, depth, output_filters=None, use_bottleneck=True, bottleneck_filters_multiplier=4, use_batch_normalization=True, data_format=None, activation="relu", use_bias=True, kernel_initializer="he_normal", bias_initializer="zeros", kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None, **kwargs): if rank not in [1, 2, 3]: raise ValueError( "`rank` must be in [1, 2, 3]. Got {}".format(rank)) super(DenseBlockND, self).__init__(**kwargs) self.rank = rank self.kernel_size = conv_utils.normalize_tuple(kernel_size, rank, "kernel_size") self.output_filters = output_filters self.growth_rate = growth_rate if use_bottleneck: if (depth % 2) != 0: raise ValueError( "Depth must be a multiple of 2 when using bottlenecks. Got {}." .format(depth)) self._depth = depth // 2 if use_bottleneck else depth self.use_bottleneck = use_bottleneck self.bottleneck_filters_multiplier = bottleneck_filters_multiplier self.use_batch_normalization = use_batch_normalization self.data_format = conv_utils.normalize_data_format(data_format) self.channel_axis = -1 if self.data_format == "channels_last" else 1 self.activation = activations.get(activation) self.use_bias = use_bias self.kernel_initializer = initializers.get(kernel_initializer) self.bias_initializer = initializers.get(bias_initializer) self.kernel_regularizer = regularizers.get(kernel_regularizer) self.bias_regularizer = regularizers.get(bias_regularizer) self.activity_regularizer = regularizers.get(activity_regularizer) self.kernel_constraint = constraints.get(kernel_constraint) self.bias_constraint = constraints.get(bias_constraint) self.composite_function_blocks: Optional[ List[CompositeFunctionBlock]] = None self.transition_layer = None self.input_spec = InputSpec(ndim=self.rank + 2)
def call(self, inputs, argmax, spatial_output_shape): # standardize spatial_output_shape spatial_output_shape = conv_utils.normalize_tuple( spatial_output_shape, 2, 'spatial_output_shape') # getting input shape # input_shape = tf.shape(inputs) # input_shape = inputs.get_shape().as_list() input_shape = tf.shape(inputs) # checking if spatial shape is ok if self.data_format == 'channels_last': output_shape = (input_shape[0],) + \ spatial_output_shape + (input_shape[3],) # assert output_shape[1] * output_shape[2] * output_shape[ # 3] > tf.math.reduce_max(argmax).numpy(), "HxWxC <= Max(argmax)" else: output_shape = (input_shape[0], input_shape[1]) + spatial_output_shape # assert output_shape[1] * output_shape[2] * output_shape[ # 3] > tf.math.reduce_max(argmax).numpy(), "CxHxW <= Max(argmax)" # N * H_in * W_in * C # flat_input_size = tf.reduce_prod(input_shape) flat_input_size = tf.reduce_prod(input_shape) # flat output_shape = [N, H_out * W_out * C] flat_output_shape = [ output_shape[0], output_shape[1] * output_shape[2] * output_shape[3] ] # flatten input tensor for the use in tf.scatter_nd inputs_ = tf.reshape(inputs, [flat_input_size]) # create the tensor [ [[[0]]], [[[1]]], ..., [[[N-1]]] ] # corresponding to the batch size but transposed in 4D batch_range = tf.reshape(tf.range(tf.cast(output_shape[0], tf.int64), dtype=argmax.dtype), shape=[input_shape[0], 1, 1, 1]) # b is a tensor of size (N, H, W, C) or (N, C, H, W) whose # first element of the batch are 3D-array full of 0, ... # second element of the batch are 3D-array full of 1, ... b = tf.ones_like(argmax) * batch_range b = tf.reshape(b, [flat_input_size, 1]) # argmax_ = [ [0, argmax_1], [0, argmax_2], ... [0, argmax_k], ..., # [N-1, argmax_{N*H*W*C}], [N-1, argmax_{N*H*W*C-1}] ] argmax_ = tf.reshape(argmax, [flat_input_size, 1]) argmax_ = tf.concat([b, argmax_], axis=-1) # reshaping output tensor ret = tf.scatter_nd(argmax_, inputs_, shape=tf.cast(flat_output_shape, tf.int64)) ret = tf.reshape(ret, output_shape) return ret
def __init__(self, size=(2, 2), data_format=None, **kwargs): super(PixelShuffler, self).__init__(**kwargs) self.data_format = conv_utils.normalize_data_format(data_format) self.size = conv_utils.normalize_tuple(size, 2, 'size')
def __init__(self, rank, filters, kernel_size, param_reduction=0.5, form='diagonal', strides=1, padding='valid', data_format=None, dilation_rate=1, groups=1, activation=None, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None, trainable=True, name=None, conv_op=None, **kwargs): super(SzConv, self).__init__( trainable=trainable, name=name, activity_regularizer=regularizers.get(activity_regularizer), **kwargs) self.rank = rank if isinstance(filters, float): filters = int(filters) self.filters = filters self.groups = groups or 1 self.kernel_size = conv_utils.normalize_tuple(kernel_size, rank, 'kernel_size') self.strides = conv_utils.normalize_tuple(strides, rank, 'strides') self.padding = conv_utils.normalize_padding(padding) self.data_format = conv_utils.normalize_data_format(data_format) self.dilation_rate = conv_utils.normalize_tuple( dilation_rate, rank, 'dilation_rate') self.activation = activations.get(activation) self.use_bias = use_bias self.kernel_initializer = initializers.get(kernel_initializer) self.bias_initializer = initializers.get(bias_initializer) self.kernel_regularizer = regularizers.get(kernel_regularizer) self.bias_regularizer = regularizers.get(bias_regularizer) self.kernel_constraint = constraints.get(kernel_constraint) self.bias_constraint = constraints.get(bias_constraint) self.input_spec = InputSpec(min_ndim=self.rank + 2) self._validate_init() self._is_causal = self.padding == 'causal' self._channels_first = self.data_format == 'channels_first' self._tf_data_format = conv_utils.convert_data_format( self.data_format, self.rank + 2) self.reduction_sv = param_reduction self.form = form self.num_ones = 0 self.num_weights = 0 self.reduced_ratio = 0 self.halfbandwidth = 0
def build(self, input_shape, **kwargs): if self.data_format == 'channels_first': channel_axis = 1 space = input_shape[2:] new_space = [] for i in range(len(space)): new_dim = conv_utils.conv_output_length( space[i], self.kernel_size[i], padding=self.padding, stride=self.strides[i], dilation=self.dilation_rate[i]) new_space.append(new_dim) self.output_size = tensor_shape.TensorShape( [input_shape[0], self.filters] + new_space) else: channel_axis = -1 space = input_shape[2:-1] new_space = [] for i in range(len(space)): new_dim = conv_utils.conv_output_length( space[i], self.kernel_size[i], padding=self.padding, stride=self.strides[i], dilation=self.dilation_rate[i]) new_space.append(new_dim) self.output_size = tensor_shape.TensorShape([input_shape[0]] + new_space + [self.filters]) if input_shape[channel_axis] is None: raise ValueError('The channel dimension of the inputs ' 'should be defined. Found `None`.') input_dim = input_shape[channel_axis] shape_x = self.kernel_size + (input_dim, self.filters * 7) shape_m = self.kernel_size + (self.filters, self.filters * 4) shape_h = self.kernel_size + (self.filters, self.filters * 4) shape_c = self.kernel_size + (self.filters, self.filters) shape_1by1 = conv_utils.normalize_tuple(1, 2, 'kernel_size') +\ (self.filters * 2, self.filters) self.kernel_shape = shape_x self.kernel_x = self.add_weight(shape=shape_x, initializer=self.kernel_initializer, name='kernel_x', regularizer=self.kernel_regularizer, constraint=self.kernel_constraint) self.kernel_m = self.add_weight(shape=shape_m, initializer=self.recurrent_initializer, name='kernel_m', regularizer=self.recurrent_regularizer, constraint=self.recurrent_constraint) self.kernel_h = self.add_weight(shape=shape_h, initializer=self.recurrent_initializer, name='kernel_h', regularizer=self.recurrent_regularizer, constraint=self.recurrent_constraint) self.kernel_c = self.add_weight(shape=shape_c, initializer=self.recurrent_initializer, name='kernel_c', regularizer=self.recurrent_regularizer, constraint=self.recurrent_constraint) self.kernel_1by1 = self.add_weight(shape=shape_1by1, initializer=self.kernel_initializer, name='kernel_1by1', regularizer=self.kernel_regularizer, constraint=self.kernel_constraint) if self.use_bias: if self.unit_forget_bias: def bias_initializer(_, *args, **kwargs): return K.concatenate([ self.bias_initializer((self.filters, ), *args, **kwargs), initializers.Ones()((self.filters, ), *args, **kwargs), self.bias_initializer((self.filters * 2, ), *args, **kwargs), initializers.Ones()((self.filters, ), *args, **kwargs), self.bias_initializer((self.filters * 2, ), *args, **kwargs) ]) else: bias_initializer = self.bias_initializer self.bias = self.add_weight(shape=(self.filters * 7, ), name='bias', initializer=bias_initializer, regularizer=self.bias_regularizer, constraint=self.bias_constraint) else: self.bias = None self.kernel_xi = self.kernel_x[:, :, :, :self.filters] self.kernel_xf = self.kernel_x[:, :, :, self.filters:self.filters * 2] self.kernel_xc = self.kernel_x[:, :, :, self.filters * 2:self.filters * 3] self.kernel_hi = self.kernel_h[:, :, :, :self.filters] self.kernel_hf = self.kernel_h[:, :, :, self.filters:self.filters * 2] self.kernel_hc = self.kernel_h[:, :, :, self.filters * 2:self.filters * 3] self.kernel_xip = self.kernel_x[:, :, :, self.filters * 3:self.filters * 4] self.kernel_xfp = self.kernel_x[:, :, :, self.filters * 4:self.filters * 5] self.kernel_xm = self.kernel_x[:, :, :, self.filters * 5:self.filters * 6] self.kernel_mi = self.kernel_m[:, :, :, :self.filters] self.kernel_mf = self.kernel_m[:, :, :, self.filters:self.filters * 2] self.kernel_mm = self.kernel_m[:, :, :, self.filters * 2:self.filters * 3] self.kernel_xo = self.kernel_x[:, :, :, self.filters * 6:] self.kernel_ho = self.kernel_h[:, :, :, self.filters * 3:] self.kernel_co = self.kernel_c self.kernel_mo = self.kernel_m[:, :, :, self.filters * 3:] if self.use_bias: self.bias_i = self.bias[:self.filters] self.bias_f = self.bias[self.filters:self.filters * 2] self.bias_c = self.bias[self.filters * 2:self.filters * 3] self.bias_ip = self.bias[self.filters * 3:self.filters * 4] self.bias_fp = self.bias[self.filters * 4:self.filters * 5] self.bias_m = self.bias[self.filters * 5:self.filters * 6] self.bias_o = self.bias[self.filters * 6:] else: self.bias_i = None self.bias_f = None self.bias_c = None self.bias_ip = None self.bias_fp = None self.bias_m = None self.bias_o = None self.built = True
def __init__(self, train_dict, movie_data_generator, batch_size=32, shuffle=False, transform=None, transform_kwargs={}, balance_classes=False, max_class_samples=None, window_size=(30, 30, 5), seed=None, data_format='channels_last', save_to_dir=None, save_prefix='', save_format='png'): X, y = train_dict['X'], train_dict['y'] if y is not None and X.shape[0] != y.shape[0]: raise ValueError('`X` (movie data) and `y` (labels) ' 'should have the same size. Found ' 'Found x.shape = {}, y.shape = {}'.format( X.shape, y.shape)) self.channel_axis = 4 if data_format == 'channels_last' else 1 self.time_axis = 1 if data_format == 'channels_last' else 2 self.x = np.asarray(X, dtype=K.floatx()) y = _transform_masks(y, transform, data_format=data_format, **transform_kwargs) if self.x.ndim != 5: raise ValueError( 'Input data in `SampleMovieArrayIterator` ' 'should have rank 5. You passed an array ' 'with shape', self.x.shape) window_size = conv_utils.normalize_tuple(window_size, 3, 'window_size') pixels_z, pixels_x, pixels_y, batch, y = sample_label_movie( y=y, padding='valid', window_size=window_size, max_training_examples=None, data_format=data_format) self.y = y self.win_x = window_size[0] self.win_y = window_size[1] self.win_z = window_size[2] self.pixels_x = pixels_x self.pixels_y = pixels_y self.pixels_z = pixels_z self.batch = batch self.movie_data_generator = movie_data_generator self.data_format = data_format self.save_to_dir = save_to_dir self.save_prefix = save_prefix self.save_format = save_format self.class_balance(max_class_samples, balance_classes, seed=seed) self.y = to_categorical(self.y).astype('int32') super(SampleMovieArrayIterator, self).__init__(len(self.y), batch_size, shuffle, seed)
def dilation_rate(self) -> Tuple: if not isinstance(self._dilation_rate, (tuple, list)): self._dilation_rate = conv_utils.normalize_tuple(self._dilation_rate, self.rank, "dilation_rate") return self._dilation_rate
def strides(self) -> Tuple: if not isinstance(self._strides, (tuple, list)): self._strides = conv_utils.normalize_tuple(self._strides, self.rank, "strides") return self._strides
def kernel_size(self) -> Tuple: if not isinstance(self._kernel_size, (tuple, list)): self._kernel_size = conv_utils.normalize_tuple(self._kernel_size, self.rank, "kernel_size") return self._kernel_size
def projection_kernel_size(self): return conv_utils.normalize_tuple(1, self.rank, "projection_kernel_size")
def __init__( self, rank, filters, kernel_size, strides=1, padding="valid", data_format=None, dilation_rate=1, activation=None, use_bias=True, normalize_weight=False, kernel_initializer="complex", bias_initializer="zeros", gamma_diag_initializer=sqrt_init, gamma_off_initializer="zeros", kernel_regularizer=None, bias_regularizer=None, gamma_diag_regularizer=None, gamma_off_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None, gamma_diag_constraint=None, gamma_off_constraint=None, init_criterion="he", seed=None, spectral_parametrization=False, transposed=False, epsilon=1e-7, **kwargs): super(ComplexConv, self).__init__(**kwargs) self.rank = rank self.filters = filters self.kernel_size = conv_utils.normalize_tuple( kernel_size, rank, "kernel_size" ) self.strides = conv_utils.normalize_tuple(strides, rank, "strides") self.padding = conv_utils.normalize_padding(padding) self.data_format = "channels_last" \ if rank == 1 else conv_utils.normalize_data_format(data_format) self.dilation_rate = conv_utils.normalize_tuple( dilation_rate, rank, "dilation_rate" ) self.activation = activations.get(activation) self.use_bias = use_bias self.normalize_weight = normalize_weight self.init_criterion = init_criterion self.spectral_parametrization = spectral_parametrization self.transposed = transposed self.epsilon = epsilon self.kernel_initializer = sanitizedInitGet(kernel_initializer) self.bias_initializer = sanitizedInitGet(bias_initializer) self.gamma_diag_initializer = sanitizedInitGet(gamma_diag_initializer) self.gamma_off_initializer = sanitizedInitGet(gamma_off_initializer) self.kernel_regularizer = regularizers.get(kernel_regularizer) self.bias_regularizer = regularizers.get(bias_regularizer) self.gamma_diag_regularizer = regularizers.get(gamma_diag_regularizer) self.gamma_off_regularizer = regularizers.get(gamma_off_regularizer) self.activity_regularizer = regularizers.get(activity_regularizer) self.kernel_constraint = constraints.get(kernel_constraint) self.bias_constraint = constraints.get(bias_constraint) self.gamma_diag_constraint = constraints.get(gamma_diag_constraint) self.gamma_off_constraint = constraints.get(gamma_off_constraint) if seed is None: self.seed = np.random.randint(1, 10e6) else: self.seed = seed self.input_spec = InputSpec(ndim=self.rank + 2) # The following are initialized later self.kernel_shape = None self.kernel = None self.gamma_rr = None self.gamma_ii = None self.gamma_ri = None self.bias = None
def __init__( self, filters, kernel_size, feature_number, # ????feature strides=(1, 1), padding='valid', data_format=None, dilation_rate=(1, 1), activation='tanh', recurrent_activation='hard_sigmoid', conv_activation='hard_sigmoid', convolutional_type="early", use_bias=True, kernel_initializer='glorot_uniform', recurrent_initializer='orthogonal', bias_initializer='zeros', unit_forget_bias=True, kernel_regularizer=None, recurrent_regularizer=None, bias_regularizer=None, kernel_constraint=None, recurrent_constraint=None, bias_constraint=None, dropout=0., recurrent_dropout=0., **kwargs): """ filters : A list , Specifies the number of filters in each layer, e.g. [10,10] kernel_size : A List , Same length as filters, Window size for 1D convolution e.g. [3,3] # ????feature feature_number: int , Number of multiple time series e.g 28 sensors --> 28 recurrent_activation : A str List, Specifies the tupe of activation functions """ super(ConvLSTM1DCell, self).__init__(**kwargs) self.number_of_layer = len(filters) self.out_feature_number = feature_number self.convolutional_type = convolutional_type # ============= Each layer has different parameters ====================== self.filters = filters self.conv_layer_number = len(filters) self.kernel_size = [] for index, size in enumerate(kernel_size): if self.convolutional_type[index] == "hybrid": self.kernel_size.append( conv_utils.normalize_tuple((size, 1), 2, 'kernel_size')) if self.convolutional_type[index] == "early": self.kernel_size.append( conv_utils.normalize_tuple((size, feature_number), 2, 'kernel_size')) self.out_feature_number = 1 feature_number = 1 self.recurrent_activation = [] for acti in recurrent_activation: self.recurrent_activation.append(activations.get(acti)) self.conv_activation = [] for acti in conv_activation: self.conv_activation.append(activations.get(acti)) self.state_size = (self.filters[-1], self.filters[-1]) # ============= Each layer has the same parameter ====================== self.strides = conv_utils.normalize_tuple(strides, 2, 'strides') # (1,1) self.padding = conv_utils.normalize_padding(padding) # valid self.data_format = conv_utils.normalize_data_format( data_format) # None --- -1 self.dilation_rate = conv_utils.normalize_tuple( dilation_rate, 2, 'dilation_rate') self.activation = activations.get(activation) # tanh default self.use_bias = use_bias # True self.kernel_initializer = initializers.get( kernel_initializer) # glorot_uniform self.recurrent_initializer = initializers.get( recurrent_initializer) # orthogonal self.bias_initializer = initializers.get(bias_initializer) # zeros self.unit_forget_bias = unit_forget_bias # True self.kernel_regularizer = regularizers.get(kernel_regularizer) self.recurrent_regularizer = regularizers.get(recurrent_regularizer) self.bias_regularizer = regularizers.get(bias_regularizer) self.kernel_constraint = constraints.get(kernel_constraint) self.recurrent_constraint = constraints.get(recurrent_constraint) self.bias_constraint = constraints.get(bias_constraint) self.dropout = min(1., max(0., dropout)) self.recurrent_dropout = min(1., max(0., recurrent_dropout))
def __init__(self, kernel_size, strides=(1, 1), padding='valid', depth_multiplier=1, data_format=None, activation=None, use_bias=True, depthwise_initializer='glorot_uniform', bias_initializer='zeros', depthwise_regularizer=None, bias_regularizer=None, activity_regularizer=None, depthwise_constraint=None, bias_constraint=None, **kwargs): super(DepthwiseConv2D, self).__init__(filters=None, kernel_size=kernel_size, strides=strides, padding=padding, data_format=data_format, activation=activation, use_bias=use_bias, bias_regularizer=bias_regularizer, activity_regularizer=activity_regularizer, bias_constraint=bias_constraint, **kwargs) self.rank = 2 self.kernel_size = conv_utils.normalize_tuple(kernel_size, self.rank, 'kernel_size') if self.kernel_size[0] != self.kernel_size[1]: raise NotImplementedError( "TF Encrypted currently only supports same " "stride along the height and the width." "You gave: {}".format(self.kernel_size)) self.strides = conv_utils.normalize_tuple(strides, self.rank, 'strides') self.padding = conv_utils.normalize_padding(padding).upper() self.depth_multiplier = depth_multiplier self.data_format = conv_utils.normalize_data_format(data_format) if activation is not None: logger.info( "Performing an activation before a pooling layer can result " "in unnecessary performance loss. Check model definition in " "case of missed optimization.") self.activation = activations.get(activation) self.use_bias = use_bias self.depthwise_initializer = initializers.get(depthwise_initializer) self.bias_initializer = initializers.get(bias_initializer) # Not implemented arguments default_args_check(depthwise_regularizer, "depthwise_regularizer", "DepthwiseConv2D") default_args_check(bias_regularizer, "bias_regularizer", "DepthwiseConv2D") default_args_check(activity_regularizer, "activity_regularizer", "DepthwiseConv2D") default_args_check(depthwise_constraint, "depthwise_constraint", "DepthwiseConv2D") default_args_check(bias_constraint, "bias_constraint", "DepthwiseConv2D")
def __init__( self, rank: int, head_size: int, head_count: int, kernel_size: Union[int, Tuple, List], strides: Union[int, Tuple, List], # data_format: Optional[AnyStr], dilation_rate: Union[int, Tuple, List], activation: Optional[Union[AnyStr, Callable]], use_bias: bool, kernel_initializer: Optional[Union[Dict, AnyStr, Callable]], bias_initializer: Optional[Union[Dict, AnyStr, Callable]], embeddings_initializer: Optional[Union[Dict, AnyStr, Callable]], kernel_regularizer: Optional[Union[Dict, AnyStr, Callable]], bias_regularizer: Optional[Union[Dict, AnyStr, Callable]], activity_regularizer: Optional[Union[Dict, AnyStr, Callable]], kernel_constraint: Optional[Union[Dict, AnyStr, Callable]], bias_constraint: Optional[Union[Dict, AnyStr, Callable]], trainable=True, name=None, **kwargs): activity_regularizer = regularizers.get(activity_regularizer) super(StandAloneSelfAttention, self).__init__(trainable=trainable, name=name, activity_regularizer=activity_regularizer, **kwargs) # region Utils (normalizing tuples, data format and getting initializers/regularizers/constraints) kernel_size = conv_utils.normalize_tuple(kernel_size, rank, "kernel_size") strides = conv_utils.normalize_tuple(strides, rank, "strides") # data_format = conv_utils.normalize_data_format(data_format) dilation_rate = conv_utils.normalize_tuple(dilation_rate, rank, "dilation_rate") activation = activations.get(activation) kernel_initializer = initializers.get(kernel_initializer) bias_initializer = initializers.get(bias_initializer) if embeddings_initializer == "random_normal": embeddings_initializer = initializers.initializers_v2.RandomNormal( stddev=1.0) embeddings_initializer = initializers.get(embeddings_initializer) kernel_regularizer = regularizers.get(kernel_regularizer) bias_regularizer = regularizers.get(bias_regularizer) kernel_constraint = constraints.get(kernel_constraint) bias_constraint = constraints.get(bias_constraint) # endregion # region Base attributes self.rank = rank self.head_size = head_size self.head_count = head_count self.kernel_size = kernel_size self.strides = strides # self.data_format = data_format self.dilation_rate = dilation_rate self.activation = activation self.use_bias = use_bias self.kernel_initializer = kernel_initializer self.bias_initializer = bias_initializer self.embeddings_initializer = embeddings_initializer self.kernel_regularizer = kernel_regularizer self.bias_regularizer = bias_regularizer self.kernel_constraint = kernel_constraint self.bias_constraint = bias_constraint # endregion # region Queries/Keys/Values conv layers common_parameters = { "rank": self.rank, "filters": self.filters, "kernel_size": 1, "use_bias": self.use_bias, "kernel_initializer": self.kernel_initializer, "bias_initializer": self.bias_initializer, "kernel_regularizer": self.kernel_regularizer, "activity_regularizer": self.activity_regularizer, "kernel_constraint": self.kernel_constraint, "bias_constraint": self.bias_constraint, } self.queries_layer = Conv(name="Conv_Queries{}".format(self.name), **common_parameters) self.keys_layer = Conv(name="Conv_Keys{}".format(self.name), **common_parameters) self.values_layer = Conv(name="Conv_Values{}".format(self.name), **common_parameters) # endregion # region Queries/Keys/Values unfold layers self.queries_unfold = Unfold(kernel_size=1, strides=strides, name="Unfold_Queries_{}".format( self.name)) self.keys_unfold = Unfold(kernel_size=kernel_size, strides=strides, dilation_rate=dilation_rate, padding="SAME", name="Unfold_Keys_{}".format(self.name)) self.values_unfold = Unfold(kernel_size=kernel_size, strides=strides, dilation_rate=dilation_rate, padding="SAME", name="Unfold_Values_{}".format(self.name)) # endregion # region Time/Height/Width embeddings conv_embeddings = [] for i in range(rank): dim_embeddings_size = self.filters // rank if i == 0: dim_embeddings_size += self.filters % rank dim_embeddings_shape = (dim_embeddings_size, *[1] * i, kernel_size[i], *[1] * (rank - i - 1)) dim_embeddings = self.add_weight( name="dim_{}_embeddings".format(i + 1), shape=dim_embeddings_shape, dtype=tf.float32, initializer=self.embeddings_initializer) conv_embeddings.append(dim_embeddings) self.conv_embeddings = conv_embeddings
def __init__(self, filters, kernel_size, strides=1, rank=1, padding='valid', data_format=None, dilation_rate=1, init_sigma=0.1, groups=1, norm=2, activation=None, trainSigmas=True, trainWeights=True, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, sigma_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None, trainable=True, name=None, conv_op=None, **kwargs): super(Conv1DAdaptive, self).__init__( trainable=trainable, name=name, activity_regularizer=regularizers.get(activity_regularizer), **kwargs) self.initsigma = None self.rank = rank if isinstance(filters, float): filters = int(filters) self.filters = filters self.groups = groups or 1 self.kernel_size = conv_utils.normalize_tuple( kernel_size, rank, 'kernel_size') self.strides = conv_utils.normalize_tuple(strides, rank, 'strides') self.padding = conv_utils.normalize_padding(padding) self.data_format = conv_utils.normalize_data_format(data_format) self.dilation_rate = conv_utils.normalize_tuple( dilation_rate, rank, 'dilation_rate') self.activation = activations.get(activation) self.use_bias = use_bias self.initsigma = init_sigma self.norm = norm self.sigma_regularizer = regularizers.get(sigma_regularizer) self.kernel_initializer = initializers.get(kernel_initializer) self.bias_initializer = initializers.get(bias_initializer) self.kernel_regularizer = regularizers.get(kernel_regularizer) self.bias_regularizer = regularizers.get(bias_regularizer) self.kernel_constraint = constraints.get(kernel_constraint) self.bias_constraint = constraints.get(bias_constraint) self.input_spec = InputSpec(min_ndim=self.rank + 2) self.trainSigmas = trainSigmas self.trainWeights = trainWeights self._is_causal = self.padding == 'causal' self._channels_first = self.data_format == 'channels_first' self._tf_data_format = conv_utils.convert_data_format( self.data_format, self.rank + 2)
def __init__(self, size=(1, 2, 2), interpolation='bilinear', **kwargs): self.size = conv_utils.normalize_tuple(size, 3, 'size') self.x = int(size[1]) self.y = int(size[2]) self.interpolation = interpolation super(self.__class__, self).__init__(**kwargs)
def __init__(self, filters, kernel_size, strides=(1, 1), padding='valid', data_format=None, dilation_rate=None, activation=None, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None, **kwargs): super(Conv2D, self).__init__(**kwargs) self.rank = 2 self.filters = filters self.kernel_size = conv_utils.normalize_tuple(kernel_size, self.rank, 'kernel_size') if self.kernel_size[0] != self.kernel_size[1]: raise NotImplementedError( "TF Encrypted currently only supports same " "stride along the height and the width." "You gave: {}".format(self.kernel_size)) self.strides = conv_utils.normalize_tuple(strides, self.rank, 'strides') self.padding = conv_utils.normalize_padding(padding).upper() self.data_format = conv_utils.normalize_data_format(data_format) if activation is not None: logger.info( "Performing an activation before a pooling layer can result " "in unnecessary performance loss. Check model definition in " "case of missed optimization.") self.activation = activations.get(activation) self.use_bias = use_bias self.kernel_initializer = initializers.get(kernel_initializer) self.bias_initializer = initializers.get(bias_initializer) if dilation_rate: raise NotImplementedError( arg_not_impl_msg.format("dilation_rate", "Conv2d"), ) if kernel_regularizer: raise NotImplementedError( arg_not_impl_msg.format("kernel_regularizer", "Conv2d"), ) if bias_regularizer: raise NotImplementedError( arg_not_impl_msg.format("bias_regularizer", "Conv2d"), ) if activity_regularizer: raise NotImplementedError( arg_not_impl_msg.format("activity_regularizer", "Conv2d"), ) if kernel_constraint: raise NotImplementedError( arg_not_impl_msg.format("kernel_constraint", "Conv2d"), ) if bias_constraint: raise NotImplementedError( arg_not_impl_msg.format("bias_constraint", "Conv2d"), )
def sample_label_movie(y, window_size=(30, 30, 5), padding='valid', max_training_examples=1e7, data_format=None): """Sample a 5D Tensor, creating many small voxels of shape window_size. Args: y (numpy.array): label masks with the same shape as X data window_size (tuple): size of window around each pixel to sample padding (str): padding type 'valid' or 'same' max_training_examples (int): max number of samples per class data_format (str): 'channels_first' or 'channels_last' Returns: tuple: 5 arrays of coordinates of each sampled pixel """ data_format = conv_utils.normalize_data_format(data_format) is_channels_first = data_format == 'channels_first' if is_channels_first: num_dirs, num_features, image_size_z, image_size_x, image_size_y = y.shape else: num_dirs, image_size_z, image_size_x, image_size_y, num_features = y.shape window_size = conv_utils.normalize_tuple(window_size, 3, 'window_size') window_size_x, window_size_y, window_size_z = window_size feature_rows, feature_cols, feature_frames, feature_batch, feature_label = [], [], [], [], [] for d in range(num_dirs): for k in range(num_features): if is_channels_first: frames_temp, rows_temp, cols_temp = np.where( y[d, k, :, :, :] == 1) else: frames_temp, rows_temp, cols_temp = np.where(y[d, :, :, :, k] == 1) # Check to make sure the features are actually present if not rows_temp.size > 0: continue # Randomly permute index vector non_rand_ind = np.arange(len(rows_temp)) rand_ind = np.random.choice(non_rand_ind, size=len(rows_temp), replace=False) for i in rand_ind: condition = padding == 'valid' and \ frames_temp[i] - window_size_z > 0 and \ frames_temp[i] + window_size_z < image_size_z and \ rows_temp[i] - window_size_x > 0 and \ rows_temp[i] + window_size_x < image_size_x and \ cols_temp[i] - window_size_y > 0 and \ cols_temp[i] + window_size_y < image_size_y if padding == 'same' or condition: feature_rows.append(rows_temp[i]) feature_cols.append(cols_temp[i]) feature_frames.append(frames_temp[i]) feature_batch.append(d) feature_label.append(k) # Randomize non_rand_ind = np.arange(len(feature_rows), dtype='int32') if not max_training_examples: max_training_examples = non_rand_ind.size else: max_training_examples = int(max_training_examples) limit = min(non_rand_ind.size, max_training_examples) rand_ind = np.random.choice(non_rand_ind, size=limit, replace=False) feature_frames = np.array(feature_frames, dtype='int32')[rand_ind] feature_rows = np.array(feature_rows, dtype='int32')[rand_ind] feature_cols = np.array(feature_cols, dtype='int32')[rand_ind] feature_batch = np.array(feature_batch, dtype='int32')[rand_ind] feature_label = np.array(feature_label, dtype='int32')[rand_ind] return feature_frames, feature_rows, feature_cols, feature_batch, feature_label
def __init__(self, up_sampling=(2, 2), data_format=None, **kwargs): super(bilinear_upsampling, self).__init__(**kwargs) self.data_format = conv_utils.normalize_data_format(data_format) self.up_sampling = conv_utils.normalize_tuple(up_sampling, 2, 'size') self.input_spec = InputSpec(ndim=4)
def __init__(self, size=(2, 2), data_format=None, **kwargs): super(BilinearUpSampling2D, self).__init__(**kwargs) self.data_format = conv_utils.normalize_data_format(data_format) self.size = conv_utils.normalize_tuple(size, 2, 'size') self.input_spec = InputSpec(ndim=4)
def sample_label_movie(y, window_size=(30, 30, 5), padding='valid', max_training_examples=1e7, data_format=None): """Create a list of the maximum pixels to sample from each feature in each data set. If output_mode is 'sample', then this will be set to the number of edge pixels. If not, it will be set to np.Inf, i.e. sampling everything. """ data_format = conv_utils.normalize_data_format(data_format) is_channels_first = data_format == 'channels_first' if is_channels_first: num_dirs, num_features, image_size_z, image_size_x, image_size_y = y.shape else: num_dirs, image_size_z, image_size_x, image_size_y, num_features = y.shape window_size = conv_utils.normalize_tuple(window_size, 3, 'window_size') window_size_x, window_size_y, window_size_z = window_size feature_rows, feature_cols, feature_frames, feature_batch, feature_label = [], [], [], [], [] for d in range(num_dirs): for k in range(num_features): if is_channels_first: frames_temp, rows_temp, cols_temp = np.where(y[d, k, :, :, :] == 1) else: frames_temp, rows_temp, cols_temp = np.where(y[d, :, :, :, k] == 1) # Check to make sure the features are actually present if not rows_temp.size > 0: continue # Randomly permute index vector non_rand_ind = np.arange(len(rows_temp)) rand_ind = np.random.choice(non_rand_ind, size=len(rows_temp), replace=False) for i in rand_ind: condition = padding == 'valid' and \ frames_temp[i] - window_size_z > 0 and \ frames_temp[i] + window_size_z < image_size_z and \ rows_temp[i] - window_size_x > 0 and \ rows_temp[i] + window_size_x < image_size_x and \ cols_temp[i] - window_size_y > 0 and \ cols_temp[i] + window_size_y < image_size_y if padding == 'same' or condition: feature_rows.append(rows_temp[i]) feature_cols.append(cols_temp[i]) feature_frames.append(frames_temp[i]) feature_batch.append(d) feature_label.append(k) # Randomize non_rand_ind = np.arange(len(feature_rows), dtype='int32') if not max_training_examples: max_training_examples = non_rand_ind.size else: max_training_examples = int(max_training_examples) limit = min(non_rand_ind.size, max_training_examples) rand_ind = np.random.choice(non_rand_ind, size=limit, replace=False) feature_frames = np.array(feature_frames, dtype='int32')[rand_ind] feature_rows = np.array(feature_rows, dtype='int32')[rand_ind] feature_cols = np.array(feature_cols, dtype='int32')[rand_ind] feature_batch = np.array(feature_batch, dtype='int32')[rand_ind] feature_label = np.array(feature_label, dtype='int32')[rand_ind] return feature_frames, feature_rows, feature_cols, feature_batch, feature_label
def __init__(self, output_dim=(1, 1), data_format=None, **kwargs): super(ResizeImages, self).__init__(**kwargs) data_format = conv_utils.normalize_data_format(data_format) self.output_dim = conv_utils.normalize_tuple(output_dim, 2, 'output_dim') self.data_format = conv_utils.normalize_data_format(data_format) self.input_spec = InputSpec(ndim=4)
def __init__(self, rank, lgroups, lfilters, kernel_size, strides=1, padding='valid', data_format=None, dilation_rate=1, activation=None, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None, trainable=True, name=None, **kwargs): super(_GroupConv, self).__init__( trainable=trainable, name=name, activity_regularizer=regularizers.get(activity_regularizer), **kwargs) self.rank = rank if rank > 2: raise ValueError( 'The quick group convolution does not support 3D or any higher dimension.' ) initRank = rank self.lgroups = lgroups self.lfilters = lfilters self.kernel_size = conv_utils.normalize_tuple(kernel_size, rank, 'kernel_size') self.strides = conv_utils.normalize_tuple(strides, rank, 'strides') self.padding = conv_utils.normalize_padding(padding) if (self.padding == 'causal' and not isinstance(self, (Conv1D, SeparableConv1D))): raise ValueError( 'Causal padding is only supported for `Conv1D` and ``SeparableConv1D`.' ) self.data_format = conv_utils.normalize_data_format(data_format) self.dilation_rate = conv_utils.normalize_tuple( dilation_rate, rank, 'dilation_rate') if rank == 1: # when rank=1, expand the tuples to 2D case. self.kernel_size = (1, *self.kernel_size) self.strides = (1, *self.strides) self.dilation_rate = (1, *self.dilation_rate) self.activation = activations.get(activation) self.use_bias = use_bias self.kernel_initializer = initializers.get(kernel_initializer) self.bias_initializer = initializers.get(bias_initializer) self.kernel_regularizer = regularizers.get(kernel_regularizer) self.bias_regularizer = regularizers.get(bias_regularizer) self.kernel_constraint = constraints.get(kernel_constraint) self.bias_constraint = constraints.get(bias_constraint) self.input_spec = InputSpec(ndim=self.rank + 2) self.group_input_dim = None self.exp_dim_pos = None