def __call__(self, inputs, initial_state=None, constants=None, **kwargs): # inputs, initial_state, constants = _standardize_args( # inputs, initial_state, constants, self._num_constants) if initial_state is None and constants is None: return super(ConvRNN2D, self).__call__(inputs, **kwargs) # If any of `initial_state` or `constants` are specified and are Keras # tensors, then add them to the inputs and temporarily modify the # input_spec to include them. additional_inputs = [] additional_specs = [] if initial_state is not None: kwargs['initial_state'] = initial_state additional_inputs += initial_state self.state_spec = [] for state in initial_state: try: shape = K.int_shape(state) # Fix for Theano except TypeError: shape = tuple(None for _ in range(K.ndim(state))) self.state_spec.append(InputSpec(shape=shape)) additional_specs += self.state_spec if constants is not None: kwargs['constants'] = constants additional_inputs += constants self.constants_spec = [ InputSpec(shape=K.int_shape(constant)) for constant in constants ] self._num_constants = len(constants) additional_specs += self.constants_spec # at this point additional_inputs cannot be empty for tensor in additional_inputs: if K.is_keras_tensor(tensor) != K.is_keras_tensor( additional_inputs[0]): raise ValueError('The initial state or constants of an RNN' ' layer cannot be specified with a mix of' ' Keras tensors and non-Keras tensors') if K.is_keras_tensor(additional_inputs[0]): # Compute the full input spec, including state and constants full_input = [inputs] + additional_inputs full_input_spec = self.input_spec + additional_specs # Perform the call with temporarily replaced input_spec original_input_spec = self.input_spec self.input_spec = full_input_spec output = super(ConvRNN2D, self).__call__(full_input, **kwargs) self.input_spec = original_input_spec return output else: return super(ConvRNN2D, self).__call__(inputs, **kwargs)
def build(self, input_shape): """ Re-implement for free param kappa. For more info, see: https://elib.dlr.de/116408/1/WACV2018.pdf """ assert len(input_shape) >= 2 input_dim = input_shape[-1] self.kernel = self.add_weight(shape=(input_dim, self.units), initializer=self.kernel_initializer, name='kernel', regularizer=self.kernel_regularizer, constraint=self.kernel_constraint) self.kappa = self.add_weight( shape=(1, ), initializer=initializers.Constant(value=1.), name="kappa", regularizer=regularizers.l2(1e-1), constraint=constraints.NonNeg()) if self.use_bias: self.bias = self.add_weight(shape=(self.units, ), initializer=self.bias_initializer, name='bias', regularizer=self.bias_regularizer, constraint=self.bias_constraint) else: self.bias = None self.input_spec = InputSpec(min_ndim=2, axes={-1: input_dim}) self.built = True
def __init__(self, units, activation='tanh', use_bias=True, recurrent_activation='hard_sigmoid', kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None, **kwargs): if 'input_shape' not in kwargs and 'input_dim' in kwargs: kwargs['input_shape'] = (kwargs.pop('input_dim'),) super(GatedPCL, self).__init__(**kwargs) self.units = units 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.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(min_ndim=2) self.supports_masking = True self.mask =PCLMatrix.matrix128_256
def build(self, input_shape): assert len(input_shape) >= 2 input_dim = input_shape[-1] self.kernel = self.add_weight(shape=(input_dim, self.units * 4), initializer=self.kernel_initializer, name='kernel', regularizer=self.kernel_regularizer, constraint=self.kernel_constraint) if self.use_bias: self.bias = self.add_weight(shape=(self.units * 4,), initializer=self.bias_initializer, name='bias', regularizer=self.bias_regularizer, constraint=self.bias_constraint) else: self.bias = None self.input_spec = InputSpec(min_ndim=2, axes={-1: input_dim}) self.kernel_i = self.kernel[:, :self.units] * self.mask print(self.kernel_i) print('kernel_i', self.kernel_i.shape, self.mask.shape) self.kernel_c = self.kernel[:, self.units * 2: self.units * 3] * self.mask self.kernel_o = self.kernel[:, self.units * 3:] * self.mask if self.use_bias: self.bias_i = self.bias[:self.units] self.bias_c = self.bias[self.units * 2: self.units * 3] self.bias_o = self.bias[self.units * 3:] else: self.bias_i = None self.bias_c = None self.bias_o = None self.built = True
def __init__(self, units=14, name='rbmhidden', return_sequences=False, 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(RBMhidden, self).__init__( activity_regularizer=regularizers.get(activity_regularizer), **kwargs) self.units = int(units) if not isinstance(units, int) else units self.return_sequences = return_sequences 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(min_ndim=2) self.supports_masking = True
def build(self, input_shape): if self.data_format == 'channels_first': channel_axis = 1 else: channel_axis = -1 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] kernel_shape = self.kernel_size + (input_dim, self.filters) self.kernel = self.add_weight(shape=kernel_shape, initializer=self.kernel_initializer, name='kernel', regularizer=self.kernel_regularizer, constraint=self.kernel_constraint) if self.use_bias: self.bias = self.add_weight(shape=(self.filters,), initializer=self.bias_initializer, name='bias', regularizer=self.bias_regularizer, constraint=self.bias_constraint) else: self.bias = None kernel_norm = tf.reduce_sum(tf.square(self.kernel),axis=(0,1,2),keep_dims=False) self.gain = tf.Variable(tf.ones_like(kernel_norm),name='kernel_gain',trainable=False) self._non_trainable_weights.append(self.gain) self.kernel = self.gain*self.kernel/(tf.sqrt(kernel_norm)+1e-12) # Set input spec. self.input_spec = InputSpec(ndim=self.rank + 2, axes={channel_axis: input_dim}) self.built = True
def build(self, input_shape): if self.data_format == 'channels_first': channel_axis = 1 else: channel_axis = -1 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] binary_kernel_shape = self.kernel_size + (input_dim, input_dim) self.binary_kernel = make_binary_kernel(binary_kernel_shape, self.sparsity) self.kernel = self.add_weight(shape=(1, 1, input_dim, self.filters), initializer=self.kernel_initializer, name='kernel', regularizer=self.kernel_regularizer, constraint=self.kernel_constraint) if self.use_bias: raise NotImplementedError else: self.bias = None # Set input spec. self.input_spec = InputSpec(ndim=self.rank + 2, axes={channel_axis: input_dim}) self.built = True
def build(self, input_shape): assert len(input_shape) == 2 input_dim_1 = input_shape[-1] input_dim_2 = input_dim_1 * input_dim_1 self.kernel1 = self.add_weight(shape=(input_dim_1, self.units), initializer=self.kernel_initializer, name='kernel1', regularizer=self.kernel_regularizer, constraint=self.kernel_constraint) self.kernel2 = self.add_weight(shape=(input_dim_2, self.units), initializer=self.kernel_initializer, name='kernel2', regularizer=self.kernel_regularizer, constraint=self.kernel_constraint) if self.use_bias: self.bias = self.add_weight(shape=(self.units, ), initializer=self.bias_initializer, name='bias', regularizer=self.bias_regularizer, constraint=self.bias_constraint) else: self.bias = None self.input_spec = InputSpec(min_ndim=2, axes={-1: input_dim_1}) self.built = True
def build(self, input_shape): # If a singleton shape tuple is passed in, use the vanilla TimeDistributed if not isinstance(input_shape, list): super(TimeDistributedMultiInput, self).build(input_shape) return assert all([len(shape) >= 3 for shape in input_shape if shape is not None]) # We need to verify that the inputs have the same or broadcastable batch # and time dimensions batch_sizes = [shape[0] for shape in input_shape if shape is not None] batch_sizes = set(batch_sizes) batch_sizes -= set([None]) # Allow batch size of 1 if an input is to be broadcasted batch_sizes -= set([1]) if len(batch_sizes) > 1: raise ValueError('Receieved tensors with incompatible batch sizes. ' 'Got tensors with shapes : ' + str(input_shape)) timesteps = [shape[1] for shape in input_shape if shape is not None] timesteps = set(timesteps) timesteps -= set([None]) # Allow 1 timestep if an input is to be broadcasted timesteps -= set([1]) if len(timesteps) > 1: raise ValueError('Receieved tensors with incompatible number of timesteps. ' 'Got tensors with shapes : ' + str(input_shape)) self.timesteps = timesteps.pop() if len(timesteps) == 1 else None self.input_spec = [InputSpec(shape=s) for s in input_shape] child_input_shapes = [(shape[0],) + shape[2:] for shape in input_shape] if not self.layer.built: self.layer.build(child_input_shapes) self.layer.built = True Wrapper.build(self)
def build(self, input_shape): #Ordinary Conv2D kernel channel_axis = -1 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] kernel_shape = self.kernel_size + (input_dim, self.filters) self.kernel = self.add_weight(shape=kernel_shape, initializer=self.kernel_initializer, name='kernel', regularizer=self.kernel_regularizer, constraint=self.kernel_constraint) if self.use_bias: self.bias = self.add_weight(shape=(self.filters, ), initializer=self.bias_initializer, name='bias', regularizer=self.bias_regularizer, constraint=self.bias_constraint) else: self.bias = None # Set input spec. self.input_spec = InputSpec(ndim=self.rank + 2, axes={channel_axis: input_dim}) self.built = True
def __init__(self, units, 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, kernel_mask_val=None, Masked=False, **kwargs): if 'input_shape' not in kwargs and 'input_dim' in kwargs: kwargs['input_shape'] = (kwargs.pop('input_dim'), ) super(MaskedDense, self).__init__(**kwargs) self.units = units 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(min_ndim=2) self.supports_masking = True self.Masked = Masked self.kernel_mask_val = kernel_mask_val
def __init__(self, filters, kernel_size, strides=1, rank=2, padding='valid', data_format=None, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, **kwargs): super(Conv2D121, 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') # normalize_padding: 检查padding的值,只有['valid', 'same', 'causal']三个值合法 self.padding = conv_utils.normalize_padding(padding) # data_format: 检查 self.data_format = normalize_data_format(data_format) 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)
def build(self, input_shape): assert len(input_shape) >= 2 self.input_dim = input_shape[-1] #trainable parameters : mu_w,mu_b,sigma_w,sigma_b self.mu_w = self.add_weight(shape=(self.input_dim, self.units), initializer=self.kernel_initializer, name='mu_w', regularizer=None, constraint=None) self.mu_b = self.add_weight(shape=(self.units, ), initializer=self.bias_initializer, name='mu_b', regularizer=None, constraint=None) self.sigma_w = self.add_weight( shape=(self.input_dim, self.units), initializer=initializers.Constant(0.01), #constant initialization name='sigma_w', regularizer=None, constraint=None) self.sigma_b = self.add_weight( shape=(self.units, ), initializer=initializers.Constant(0.01), #constant initialization name='sigma_b', regularizer=None, constraint=None) self.input_spec = InputSpec(min_ndim=2, axes={-1: self.input_dim}) self.built = True
def build(self, input_shape): assert len(input_shape) >= 2 input_dim = input_shape[-1] ''' original for dense, too many dimensions so self.kernel = self.add_weight(shape=(input_dim, self.units), initializer=self.kernel_initializer, name='kernel', regularizer=self.kernel_regularizer, constraint=self.kernel_constraint) ''' self.kernel = self.add_weight(shape=(self.units, 1), initializer=self.kernel_initializer, name='kernel', regularizer=self.kernel_regularizer, constraint=self.kernel_constraint) if self.use_bias: self.bias = self.add_weight(shape=(self.units, ), initializer=self.bias_initializer, name='bias', regularizer=self.bias_regularizer, constraint=self.bias_constraint) else: self.bias = None self.input_spec = InputSpec(min_ndim=2, axes={-1: input_dim}) self.built = True
def __init__(self, size, data_format=None, **kwargs): # self.rank is 1 for UpSampling1D, 2 for UpSampling2D. self.rank = len(size) self.size = size self.data_format = K.normalize_data_format(data_format) self.input_spec = InputSpec(ndim=self.rank + 2) super(_UpSampling, self).__init__(**kwargs)
def build(self, input_shape): if self.data_format == 'channels_first': channel_axis = 1 else: channel_axis = -1 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] kernel_shape = self.kernel_size + (input_dim, self.filters) self.kernel_mask = tf.Variable(initial_value=self.kernel_mask_val, trainable=False) self.kernel = self.add_weight(shape=kernel_shape, initializer=self.kernel_initializer, name='kernel', regularizer=self.kernel_regularizer, constraint=self.kernel_constraint) if self.use_bias: self.bias = self.add_weight(shape=(self.filters, ), initializer=self.bias_initializer, name='bias', regularizer=self.bias_regularizer, constraint=self.bias_constraint) else: self.bias = None # Set input spec. self.input_spec = InputSpec(ndim=self.rank + 2, axes={channel_axis: input_dim}) self.built = True
def set_config(self, config_in): self.rank = 2 self.filters = config_in['filters'] self.kernel_size = conv_utils.normalize_tuple(config_in['kernel_size'], self.rank, 'kernel_size') self.strides = conv_utils.normalize_tuple(config_in['strides'], self.rank, 'strides') self.padding = conv_utils.normalize_padding(config_in['padding']) self.data_format = K.normalize_data_format(config_in['data_format']) self.dilation_rate = conv_utils.normalize_tuple( config_in['dilation_rate'], self.rank, 'dilation_rate') self.activation = activations.get(config_in['activation']) self.use_bias = config_in['use_bias'] self.kernel_initializer = initializers.get( config_in['kernel_initializer']) self.bias_initializer = initializers.get(config_in['bias_initializer']) self.kernel_regularizer = regularizers.get( config_in['kernel_regularizer']) self.bias_regularizer = regularizers.get(config_in['bias_regularizer']) self.activity_regularizer = regularizers.get( config_in['activity_regularizer']) self.kernel_constraint = constraints.get( config_in['kernel_constraint']) self.bias_constraint = constraints.get(config_in['bias_constraint']) self.input_spec = InputSpec(ndim=self.rank + 2)
def __init__(self, kernel_size=3, strides=1, padding='valid', dilation_rate=1, activation=None, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, kernel_constraint=None, bias_constraint=None, **kwargs): """ :param kernel_size: 奇数整数或奇数整数数组,数组的长度为2 :param strides: :param padding: :param dilation_rate: :param activation: :param kernel_initializer: :param bias_initializer: :param kernel_regularizer: :param bias_regularizer: :param kernel_constraint: :param bias_constraint: :param kwargs: """ super(DeformConv2d, self).__init__(**kwargs) # H_kernel = kernel_size[0] # W_kernel = kernel_size[1] self.kernel_size = conv_utils.normalize_tuple(kernel_size, 2, 'kernel_size') assert len(self.kernel_size) is 2, u'kernel_size 必须为2' assert self.kernel_size[0] & 1 is 1 and self.kernel_size[ 1] & 1 is 1, u"卷积和的高和宽必须为奇数" # N = H_kernel * W_kernel # 卷积输出通道为2 * N,即分别捕捉x轴与y轴的坐标偏移 self.filters = 2 * self.kernel_size[0] * self.kernel_size[1] self.strides = conv_utils.normalize_tuple(strides, 2, 'strides') self.padding = conv_utils.normalize_padding(padding) self.dilation_rate = conv_utils.normalize_tuple( dilation_rate, 2, 'dilation_rate') self.activation = activations.get(activation) 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=4) self.kernel = None self.bias = None
def build(self, input_shape): if self.data_format == 'channels_last': input_row, input_col = input_shape[1:-1] input_filter = input_shape[3] else: input_row, input_col = input_shape[2:] input_filter = input_shape[1] if input_row is None or input_col is None: raise ValueError('The spatial dimensions of the inputs to ' ' a LocallyConnected2D layer ' 'should be fully-defined, but layer received ' 'the inputs shape ' + str(input_shape)) output_row = conv_utils.conv_output_length(input_row, self.kernel_size[0], self.padding, self.strides[0]) output_col = conv_utils.conv_output_length(input_col, self.kernel_size[1], self.padding, self.strides[1]) self.output_row = output_row self.output_col = output_col self.kernel_shape = (output_row, self.kernel_size[0], self.kernel_size[1], input_filter, self.filters) self.kernel = self.add_weight(shape=self.kernel_shape, initializer=self.kernel_initializer, name='kernel', regularizer=self.kernel_regularizer, constraint=self.kernel_constraint) if self.use_bias: self.bias = self.add_weight(shape=(output_row, 1, self.filters), initializer=self.bias_initializer, name='bias', regularizer=self.bias_regularizer, constraint=self.bias_constraint) else: self.bias = None if self.data_format == 'channels_first': self.input_spec = InputSpec(ndim=4, axes={1: input_filter}) else: self.input_spec = InputSpec(ndim=4, axes={-1: input_filter}) self.built = True
def build(self, input_shape): assert len(input_shape) >= 2 input_dim = input_shape[-1] self.kernel = self.add_weight(shape=(input_dim, self.units), initializer=self.kernel_initializer, name='kernel', constraint=self.kernel_constraint) self.input_spec = InputSpec(min_ndim=2, axes={-1: input_dim}) super(Projection, self).build(input_shape)
def __init__(self, symmetric, input_is_revcomp_conv, smoothness_penalty=None, bias=False, **kwargs): super(WeightedSum1D, self).__init__(**kwargs) self.symmetric = symmetric self.input_is_revcomp_conv = input_is_revcomp_conv self.smoothness_penalty = smoothness_penalty self.bias = bias self.input_spec = [InputSpec(ndim=3)]
def build(self, input_shape): assert len(input_shape) >= 2 input_dim = input_shape[-1] self.bias = self.add_weight(shape=(input_dim, ), initializer=self.bias_initializer, name='bias', regularizer=self.bias_regularizer, constraint=self.bias_constraint) self.input_spec = InputSpec(min_ndim=2, axes={-1: input_dim}) self.built = True
def __init__(self, cell, return_sequences=False, return_state=False, go_backwards=False, stateful=False, unroll=False, **kwargs): super(ConvRNN3D, self).__init__(cell, return_sequences, return_state, go_backwards, stateful, unroll, **kwargs) self.input_spec = [InputSpec(ndim=6)]
def build(self, input_shape): assert len(input_shape) >= 2 input_dim = input_shape[-1] w = self.add_weight(shape=(input_dim, self.units), initializer=self.kernel_initializer, name='kernel', regularizer=self.kernel_regularizer, constraint=self.kernel_constraint) self.kernel = w / (K.epsilon() + K.sqrt(K.sum(K.square(w), axis=0, keepdims=True))) self.input_spec = InputSpec(min_ndim=2, axes={-1: input_dim}) self.built = True
def __init__(self, bias_initializer='zeros', bias_regularizer=None, bias_constraint=None, **kwargs): if 'input_shape' not in kwargs and 'input_dim' in kwargs: kwargs['input_shape'] = (kwargs.pop('input_dim'), ) super(Bias, self).__init__(**kwargs) self.bias_initializer = initializers.get(bias_initializer) self.bias_regularizer = regularizers.get(bias_regularizer) self.bias_constraint = constraints.get(bias_constraint) self.input_spec = InputSpec(min_ndim=2) self.supports_masking = True
def build(self, input_shape): assert len(input_shape) >= 2 self.input_dim = input_shape[-1] self.kernel = self.add_weight(shape=(self.dendrites, self.input_dim, self.units), initializer=self.kernel_initializer, name='kernel', regularizer=self.kernel_regularizer, constraint=self.kernel_constraint) self.alpha_L = 0.5 self.alpha_U = 0.5 self.b_U = 0 # Might make these trainable self.b_L = 1 # Might make these trainable self.a_d = 1 self.c_d = 0.5 self.b_d = 0.5 # self.b_d = self.add_weight(shape = 1, # initializer = self.bias_initializer, # name='b_d', # regularizer=self.bias_regularizer, # constraint=self.bias_constraint) # self.c_d = self.add_weight(shape = 1, # initializer = self.bias_initializer, # name='c_d', # regularizer=self.bias_regularizer, # constraint=self.bias_constraint) #self.dendriteInput = np.zeros((self.dendrites, hself.units)) self.dendriteInput = np.zeros((self.dendrites, self.units)) self.dendriteActivations = np.zeros(self.dendrites) self.preoutput = 0 if self.use_bias: self.dendriteBias = self.add_weight( shape=(self.units * self.dendrites, ), initializer=self.bias_initializer, name='bias', regularizer=self.bias_regularizer, constraint=self.bias_constraint) self.bias = self.add_weight(shape=(self.units, ), initializer=self.bias_initializer, name='bias', regularizer=self.bias_regularizer, constraint=self.bias_constraint) else: self.bias = None self.input_spec = InputSpec(min_ndim=2, axes={-1: self.input_dim}) # self.built = True super(Dendritic, self).build(input_shape)
def build(self, input_shape): """ Build the layer for the given input shape. Args: input_shape: the shape to build the layer with Returns: None """ # determine which axis contains channel data if self.data_format == 'channels_first': channel_axis = 1 else: channel_axis = -1 # if the channel dimension is not defined, raise an error if input_shape[channel_axis] is None: raise ValueError( 'The channel dimension of the inputs should be defined. ' 'Found `None`. ') # get the input channels from the input shape input_dim = input_shape[channel_axis] # create the shape for the 1 x 1 convolution kernels kernel_shape = (*self.kernel_size, input_dim, self.num_filters) # initialize the kernels and biases as empty lists self.kernels = len(self.bin_sizes) * [None] self.biases = len(self.bin_sizes) * [None] # iterate over the levels in the pyramid for (level, bin_size) in enumerate(self.bin_sizes): # create the kernel weights for this level self.kernels[level] = self.add_weight( shape=kernel_shape, initializer=self.kernel_initializer, name='kernel_{}'.format(bin_size), regularizer=self.kernel_regularizer, constraint=self.kernel_constraint) # if using bias, create the bias weights for this level if self.use_bias: self.biases[level] = self.add_weight( shape=(self.num_filters, ), initializer=self.bias_initializer, name='bias_{}'.format(bin_size), regularizer=self.bias_regularizer, constraint=self.bias_constraint) # set input specification for th layer self.input_spec = InputSpec(ndim=4, axes={channel_axis: input_dim}) self.built = True
def __init__(self, filters, kernel_size, conv_size, conv_first=True, strides=(1, 1), padding='valid', data_format=None, dilation_rate=(1, 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, **kwargs): # from _Conv super(PartialConv2D, self).__init__(**kwargs) self.rank = 2 self.filters = filters self.kernel_size = conv_utils.normalize_tuple(kernel_size, self.rank, 'kernel_size') self.strides = conv_utils.normalize_tuple(strides, self.rank, 'strides') self.padding = conv_utils.normalize_padding(padding) self.data_format = K.normalize_data_format(data_format) self.dilation_rate = conv_utils.normalize_tuple( dilation_rate, self.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.activity_regularizer = regularizers.get(activity_regularizer) self.kernel_constraint = constraints.get(kernel_constraint) self.bias_constraint = constraints.get(bias_constraint) # custom self.conv_size = tuple(conv_size) self.conv_first = conv_first self.num_conv_features = int(np.prod(self.conv_size)) self.input_spec = InputSpec(ndim=2) # defined in class methods self.kernel = None self.bias = None self.built = False
def __init__(self, units, kernel_initializer='glorot_uniform', kernel_constraint=None, **kwargs): if 'input_shape' not in kwargs and 'input_dim' in kwargs: kwargs['input_shape'] = (kwargs.pop('input_dim'), ) self.units = units self.activation = activations.linear self.kernel_initializer = initializers.get(kernel_initializer) self.kernel_constraint = constraints.get(kernel_constraint) self.input_spec = InputSpec(min_ndim=2) self.supports_masking = True super(Projection, self).__init__(**kwargs)
def __init__(self, size=(2, 2), num_pixels=(0, 0), data_format='channels_last', method_name='FgSegNet_M', **kwargs): super(MyUpSampling2D, 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) self.num_pixels = num_pixels self.method_name = method_name assert method_name in ['FgSegNet_M', 'FgSegNet_S', 'FgSegNet_v2' ], 'Provided method_name is incorrect.'