def __init__(self, offset_creator_class, weight_basis, filters, kernel_size, strides=(1, 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(RProjLocallyConnected2D, self).__init__(offset_creator_class, weight_basis, **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) if self.padding != 'valid': raise ValueError('Invalid border mode for LocallyConnected2D ' '(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=4)
def __init__(self, padding=(1, 1), data_format=None, **kwargs): super(ReflectionPadding2D, self).__init__(**kwargs) self.data_format = conv_utils.normalize_data_format(data_format) if isinstance(padding, int): self.padding = ((padding, padding), (padding, padding)) elif hasattr(padding, '__len__'): if len(padding) != 2: raise ValueError('`padding` should have two elements. ' 'Found: ' + str(padding)) height_padding = conv_utils.normalize_tuple(padding[0], 2, '1st entry of padding') width_padding = conv_utils.normalize_tuple(padding[1], 2, '2nd entry of padding') self.padding = (height_padding, width_padding) else: raise ValueError('`padding` should be either an int, ' 'a tuple of 2 ints ' '(symmetric_height_pad, symmetric_width_pad), ' 'or a tuple of 2 tuples of 2 ints ' '((top_pad, bottom_pad), (left_pad, right_pad)). ' 'Found: ' + str(padding)) self.input_spec = InputSpec(ndim=4)
def __init__(self, filters, kernel_size,strides=1,padding='same',dilation_rate=1, bias_initializer='zeros',kernel_initializer='glorot_uniform', activation='linear', weights=None, border_mode='valid', subsample_length=1, kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None, use_bias=True, input_dim=None, input_length=None, tied_to=None,data_format='channels_last',rank=1,learnedKernel=None,layer_inner=None, **kwargs): if border_mode not in {'valid', 'same'}: raise Exception('Invalid border mode for Convolution1D:', border_mode) self.input_spec = [InputSpec(ndim=3)] self.input_dim = input_dim self.input_length = input_length self.tied_to = tied_to self.learnedKernel = np.array(learnedKernel) #self.tied_to.set_weights([weights, bias]) self.strides = conv_utils.normalize_tuple(strides, rank, 'strides') self.padding = conv_utils.normalize_padding(padding) self.dilation_rate = conv_utils.normalize_tuple(dilation_rate, rank, 'dilation_rate') self.data_format = data_format self.filters = filters if self.tied_to is not None: self.kernel_size = self.tied_to.kernel_size else: self.kernel_size = kernel_size self.kernel_initializer = initializers.get(kernel_initializer) self.bias_initializer = initializers.get(bias_initializer) self.activation = activations.get(activation) assert border_mode in {'valid', 'same'}, 'border_mode must be in {valid, same}' self.border_mode = border_mode self.subsample_length = subsample_length self.subsample = (subsample_length, 1) 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.use_bias = use_bias self.rank = 1 self.layer_inner = layer_inner if self.input_dim: kwargs['input_shape'] = (self.input_length, self.input_dim) #self.layer_inner = kwargs.pop('layer_inner') super(Convolution1D_tied, self).__init__(**kwargs)
def __init__(self, upsampling=(2, 2), output_size=None, data_format=None, **kwargs): super(BilinearUpsampling, self).__init__(**kwargs) self.data_format = K.normalize_data_format(data_format) self.input_spec = InputSpec(ndim=4) if output_size: self.output_size = conv_utils.normalize_tuple( output_size, 2, 'output_size') self.upsampling = None else: self.output_size = None self.upsampling = conv_utils.normalize_tuple( upsampling, 2, 'upsampling')
def __init__(self, kernel_size = (7, 7), init_normal = 1.0, **kwargs): """ init_normal: initial value of (normal_dev+normal_mag) weight +/- uniform random shift of max. 0.05 """ super(LocalNormalization, self).__init__(**kwargs) self.kernel_size = normalize_tuple(kernel_size, 2, 'kernel_size') self.init_normal = init_normal # initial value of (normal_dev+normal_mag), +/- random shift of max. 0.05 self.seed = None
def test_normalize_tuple(): assert conv_utils.normalize_tuple(5, 2, 'kernel_size') == (5, 5) assert conv_utils.normalize_tuple([7, 9], 2, 'kernel_size') == (7, 9) with pytest.raises(ValueError): conv_utils.normalize_tuple(None, 2, 'kernel_size') with pytest.raises(ValueError): conv_utils.normalize_tuple([2, 3, 4], 2, 'kernel_size') with pytest.raises(ValueError): conv_utils.normalize_tuple(['str', 'impossible'], 2, 'kernel_size')
def __init__(self, size=(2, 2), data_format=None, **kwargs): super(BicubicUpSampling2D, self).__init__(**kwargs) self.data_format = K.normalize_data_format(data_format) self.size = conv_utils.normalize_tuple(size, 2, 'size') self.input_spec = InputSpec(ndim=4)
def __init__(self, filters=1, kernel_size=80, rank=1, strides=1, padding='valid', data_format='channels_last', dilation_rate=1, activation=None, use_bias=True, fsHz=1000., fc_initializer=initializers.RandomUniform(minval=10, maxval=4000), n_order_initializer=initializers.constant(4.), amp_initializer=initializers.constant(10**5), beta_initializer=initializers.RandomNormal(mean=30, stddev=6), bias_initializer='zeros', **kwargs): super(Conv1D_gammatone, self).__init__(**kwargs) self.rank = rank self.filters = filters self.kernel_size_ = kernel_size 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 = 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.bias_initializer = initializers.get(bias_initializer) self.fc_initializer = initializers.get(fc_initializer) self.n_order_initializer = initializers.get(n_order_initializer) self.amp_initializer = initializers.get(amp_initializer) self.beta_initializer = initializers.get(beta_initializer) self.input_spec = InputSpec(ndim=self.rank + 2) self.fsHz = fsHz self.t = tf.range(start=0, limit=kernel_size / float(fsHz), delta=1 / float(fsHz), dtype=K.floatx()) self.t = tf.expand_dims(input=self.t, axis=-1)
def __init__(self, filters, kernel_size, strides=1, padding='valid', 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, input_dim=None, input_length=None, **kwargs): if padding not in {'valid', 'same', 'causal'}: raise Exception('Invalid padding mode for Convolution1D:', padding) super(Conv1D_local, self).__init__(**kwargs) self.rank = 1 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('channels_last') 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) self.input_spec = InputSpec(ndim=self.rank + 2) self.input_dim = input_dim self.input_length = input_length if self.input_dim: kwargs['input_shape'] = (self.input_length, self.input_dim)
def __init__(self, filters, kernel_size, rank=2, sparsity=0.9, strides=(1, 1), padding='same', data_format=None, dilation_rate=(1, 1), activation=None, use_bias=False, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None, trainable=False, **kwargs): self.rank = rank self.sparsity = sparsity 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 = K.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.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=self.rank + 2) self.trainable = trainable super(LBC, self).__init__(filters=filters, kernel_size=kernel_size, **kwargs)
def __init__(self, filters, kernel_size, rank=1, strides=1, padding='valid', data_format='channels_last', 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, **kwargs): super(Conv1D_linearphase, self).__init__(**kwargs) self.rank = rank self.filters = filters self.kernel_size_ = kernel_size if kernel_size % 2: self.kernel_size = conv_utils.normalize_tuple( kernel_size // 2 + 1, rank, 'kernel_size') else: self.kernel_size = conv_utils.normalize_tuple( kernel_size // 2, 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.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=self.rank + 2)
def __init__(self, filters, 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, conv_select_activation=None, select_weight_init_value=0, **kwargs): super(ConvBank, self).__init__(**kwargs) rank = 2 self.rank = 2 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 = 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.activity_regularizer = regularizers.get(activity_regularizer) self.kernel_constraint = constraints.get(kernel_constraint) self.bias_constraint = constraints.get(bias_constraint) self.select_activation = None if conv_select_activation == None else activations.get( conv_select_activation) self.select_weight_init = initializers.Constant( select_weight_init_value)
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, implementation=1, **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', allow_zero=True) self.padding = conv_utils.normalize_padding(padding) if self.padding != 'valid' and implementation == 1: raise ValueError( 'Invalid border mode for LocallyConnected1D ' '(only "valid" is supported if implementation is 1): ' + 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.implementation = implementation self.input_spec = InputSpec(ndim=3)
def __init__(self, rank, filters, 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, minmax_kernel_regularizer=None, bias_regularizer=None, minmax_bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None, **kwargs): super(_Conv, 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 = K.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.minmax_kernel_regularizer = regularizers.get( minmax_kernel_regularizer) self.bias_regularizer = regularizers.get(bias_regularizer) self.minmax_bias_regularizer = regularizers.get( minmax_bias_regularizer) self.activity_regularizer = regularizers.get(activity_regularizer) self.kernel_constraint = constraints.get(kernel_constraint) self.bias_constraint = constraints.get(bias_constraint)
def __init__(self, num_capsule, dim_capsule, kernel_size, strides=1, padding='valid', dilation_rate=1, transpose=False, routings=3): self.out_num_capsule = num_capsule self.out_dim_capsule = dim_capsule 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.dilation_rate = conv_utils.normalize_tuple( dilation_rate, 2, 'dilation_rate') self.conv_layer = layers.Conv2DTranspose if transpose else layers.Conv2D self.routings = routings
def __init__(self, size=(2, 2), data_format=None, interpolation='nearest', **kwargs): super(UpSampling2D, self).__init__(**kwargs) self.data_format = conv_utils.normalize_data_format(data_format) self.interpolation = interpolation self.size = conv_utils.normalize_tuple(size, 2, 'size') self.input_spec = InputSpec(ndim=4)
def __init__(self, pool_function, pool_size, strides, padding='valid', data_format='channels_last', name=None, **kwargs): super(Pooling3D, 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, 3, 'pool_size') self.strides = conv_utils.normalize_tuple(strides, 3, 'strides') self.padding = conv_utils.normalize_padding(padding) self.data_format = conv_utils.normalize_data_format(data_format) self.input_spec = InputSpec(ndim=5)
def __init__(self, filters, kernel_size, strides=(1, 1), padding='valid', group=1, 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): super(GroupConv2D, self).__init__( filters=filters, kernel_size=kernel_size, strides=strides, padding=padding, data_format=data_format, dilation_rate=dilation_rate, activation=activation, use_bias=use_bias, kernel_initializer=kernel_initializer, bias_initializer=bias_initializer, kernel_regularizer=kernel_regularizer, bias_regularizer=bias_regularizer, activity_regularizer=activity_regularizer, kernel_constraint=kernel_constraint, bias_constraint=bias_constraint, **kwargs) 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.dilation_rate = conv_utils.normalize_tuple(dilation_rate, 2, 'dilation_rate') self.channel_axis = None self.group = group
def __init__(self, filters, kernel_size, strides=1, padding='valid', 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, function=None, arguments=None, normalized_position=True, **kwargs): super(SemiConv2D, 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.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) self.input_spec = InputSpec(ndim=self.rank + 2) self.function = function self.arguments = arguments if arguments else {} self.normalized_position = normalized_position
def __init__(self, rank, filters, 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, Masked=False, kernel_mask_val=None, **kwargs): super(MaskedConv, 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 = K.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.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=self.rank + 2) self.Masked = Masked self.kernel_mask_val = kernel_mask_val
def __init__(self, filters, 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, tied_to=None, **kwargs): super().__init__(filters, kernel_size, **kwargs) self.bias_constraint = constraints.get(bias_constraint) self.supports_masking = True self.tied_to = tied_to 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 = K.normalize_data_format(data_format) self.dilation_rate = conv_utils.normalize_tuple( dilation_rate, 2, '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) self.input_spec = InputSpec(ndim=4)
def __init__(self, rank, filters, kernel_size, strides=1, padding='valid', data_format=None, dilation_rate=1, activation=None, use_bias=True, kernel_initializer='he_complex', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None, seed=None, spectral_parametrization=False, **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 = K.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 = cinitializers.get(kernel_initializer) self.bias_initializer = cinitializers.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=self.rank + 2) self.spectral_parametrization = spectral_parametrization self.seed = seed if seed is not None else np.random.randint(1, 1e6)
def __init__( self, strides=1, strides_test=None, dilation_rate=1, dilation_rate_test=None, bottomright_stride=False, bottomright_stride_test=False): self.strides_test = conv_utils.normalize_tuple( strides if strides_test is None else strides_test, 2, 'strides_test') self.dilation_rate_test = conv_utils.normalize_tuple( dilation_rate if dilation_rate_test is None else dilation_rate_test, 2, 'dilation_rate_test') self.strides = conv_utils.normalize_tuple(strides, 2, 'strides') self.dilation_rate = conv_utils.normalize_tuple(dilation_rate, 2, 'dilation_rate') self.bottomright_stride = bottomright_stride self.bottomright_stride_test = bottomright_stride_test if self.bottomright_stride: assert self.strides == (2, 2) if self.bottomright_stride_test: assert self.strides_test == (2, 2)
def __init__(self, upsampling=(2, 2), data_format=None, **kwargs): """ During its instantiation, it require two up sampling parameter. :param upsampling: :param data_format: :param kwargs: """ super(BilinearUpsampling, self).__init__(**kwargs) self.data_format = normalize_data_format(data_format) self.upsampling = conv_utils.normalize_tuple(upsampling, 2, "size") self.input_spec = InputSpec(ndim=4)
def __init__(self, padding=(1, 1), data_formater=None, **kwargs): super(ReflectionPadding2D, self).__init__(**kwargs) self.data_formater = conv_utils.normalize_data_format(data_formater) if isinstance(padding, int): self.padding = ((padding, padding), (padding, padding)) elif hasattr(padding,"__len__"): if len(padding) != 2: raise ValueError('`padding` should have two elements. ' 'Found: ' + str(padding)) height_padding = conv_utils.normalize_tuple(padding[0], 2, "1st entry of padding") width_padding = conv_utils.normalize_tuple(padding[1], 2, "2nd entry of padding") self.padding = (height_padding, width_padding) else: raise ValueError('`padding` should be either an int, ' 'a tuple of 2 ints ' '(symmetric_height_pad, symmetric_width_pad), ' 'or a tuple of 2 tuples of 2 ints ' '((top_pad, bottom_pad), (left_pad, right_pad)). ' 'Found: ' + str(padding)) self.input_spec = InputSpec(ndim=4)
def recurrent_conv(self, x, w): strides = conv_utils.normalize_tuple(1, self.rank, 'strides', allow_zero=True) conv_out = self._conv_func(x, w, strides=strides, padding='same', data_format=self.data_format) return conv_out
def __init__(self, filters, 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, num_bits=8, **kwargs): super(QuantizedConv2D, 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) self.num_bits = num_bits self.quantization = _Quantization(num_bits=self.num_bits) self.input_spec = InputSpec(ndim=self.rank + 2)
def __init__(self, filters, kernel_size, strides=(1, 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, template_tensor=None, clusterid=None, **kwargs): super(ModifiedConv2D, self).__init__(**kwargs) self.rank = 2 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.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=self.rank + 2) self.template_tensor = template_tensor self.clusterid = clusterid
def __init__(self, **kwargs): #default channel last super(MySegNetLayer, self).__init__(**kwargs) self.filters = 1 self.encodeORdecode = 'encode' self.rank = 2 self.kernel_size = conv_utils.normalize_tuple((3, 3), self.rank, 'kernel_size') self.strides = conv_utils.normalize_tuple((1, 1), self.rank, 'strides') self.padding = 'same' self.dilation_rate = conv_utils.normalize_tuple((1, 1), self.rank, 'dilation_rate') self.activation = activations.get('relu') self.use_bias = True self.kernel_initializer = initializers.get('glorot_uniform') self.bias_initializer = initializers.get('zeros') self.kernel_regularizer = None self.bias_regularizer = None self.activity_regularizer = None self.kernel_constraint = None self.bias_constraint = None self.input_spec = InputSpec(ndim=self.rank + 2)
def __init__(self, filters, kernel_size, kernel_initializer='glorot_uniform', bias_initializer='zeros', **kwargs): super(myConv2d, self).__init__(**kwargs) # Initialize the corresponding class variables self.filters = filters self.kernel_size = conv_utils.normalize_tuple(kernel_size, 2, 'kernel_size') self.strides = conv_utils.normalize_tuple((1, 1), 2, 'strides') self.data_format = "channels_last" self.dilation_rate = conv_utils.normalize_tuple((1, 1), 2, 'dilation_rate') self.activation = activations.get('relu') self.kernel_initializer = initializers.get(kernel_initializer) self.bias_initializer = initializers.get(bias_initializer)
def __init__(self, size=(2, 2), data_format=None, interpolation='nearest', **kwargs): normalized_size = conv_utils.normalize_tuple(size, 2, 'size') super(UpSampling2D, self).__init__(normalized_size, data_format, **kwargs) if interpolation not in ['nearest', 'bilinear']: raise ValueError('interpolation should be one ' 'of "nearest" or "bilinear".') self.interpolation = interpolation
def __init__( self, filters=1, kernel_size=(3, 3), activation=None, kernel_initializer="glorot_uniform", padding="valid", strides=1, dilation_rate=(1, 1), bias=True, **kwargs, ): self.filters = filters self.kernel_initializer = initializers.get(kernel_initializer) self.padding = padding self.strides = conv_utils.normalize_tuple(strides, 2, "strides") self.activation = activations.get(activation) self.dilation_rate = dilation_rate self.kernel_size = conv_utils.normalize_tuple(kernel_size, 2, "kernel_size") self.bias = bias super(myConvolution2D, self).__init__(**kwargs)
def __init__(self, rank, filters, kernel_size, time_distributed, strides=1, padding='valid', data_format=None, dilation_rate=1, activation=None, #dynamic_activation = 'softmax', use_bias=False, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None, **kwargs): super(adaptive_conv, self).__init__(**kwargs) self.rank = rank self.filters = filters self.kernel_size = conv_utils.normalize_tuple(kernel_size, rank, 'kernel_size') self.time_distributed = time_distributed self.strides = conv_utils.normalize_tuple(strides, 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, rank, 'dilation_rate') self.activation = activations.get(activation) #self.dynamic_activation = activations.relu(alpha=0.2) 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)
def __init__(self, filters, 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, kl_lambda = 1e-6, drop_prob = 0.20, batch_size = 8, **kwargs): super(Conv2D_wd, self).__init__(**kwargs) self.rank = 2 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.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.kl_lambda = kl_lambda self.drop_prob = drop_prob self.batch_size = batch_size
def __init__(self, shape, batch_size, transform_function='rotate_and_flip', intensity_threshold=0.0, area_ratio_threshold=0.0, scale_factor=1): def rotate_and_flip(x, y, dim): if dim == 2: k = np.random.randint(0, 4) x, y = [np.rot90(v, k=k) for v in (x, y)] if np.random.random() < 0.5: x, y = [np.fliplr(v) for v in (x, y)] return x, y elif dim == 3: k = np.random.randint(0, 4) x, y = [np.rot90(v, k=k, axes=(1, 2)) for v in (x, y)] if np.random.random() < 0.5: x, y = [np.flip(v, axis=1) for v in (x, y)] if np.random.random() < 0.5: x, y = [np.flip(v, axis=0) for v in (x, y)] return x, y else: raise ValueError('Unsupported dimension') self._shape = tuple(shape) self._batch_size = batch_size dim = len(self._shape) if transform_function == 'rotate_and_flip': if shape[-2] != shape[-1]: raise ValueError( 'Patch shape must be square when using `rotate_and_flip`; ' f'Received shape: {shape}') self._transform_function = lambda x, y: rotate_and_flip(x, y, dim) elif callable(transform_function): self._transform_function = transform_function elif transform_function is None: self._transform_function = lambda x, y: (x, y) else: raise ValueError('Invalid transform function') self._intensity_threshold = intensity_threshold if not 0 <= area_ratio_threshold <= 1: raise ValueError('"area_ratio_threshold" must be between 0 and 1') self._area_threshold = area_ratio_threshold * np.prod(shape) self._scale_factor = normalize_tuple(scale_factor, dim, 'scale_factor') if any(not isinstance(f, int) or f == 0 for f in self._scale_factor): raise ValueError('"scale_factor" must be nonzero integer')
def __init__(self, fwh_projector, rank, filters, 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, **kwargs): # embed() super(_RProjFWHConv, self).__init__(**kwargs) self.fwh_projector = fwh_projector 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 = 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.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=self.rank + 2)
def __init__(self, cropping=(1, 1), **kwargs): super(Cropping1D, self).__init__(**kwargs) self.cropping = conv_utils.normalize_tuple(cropping, 2, 'cropping') self.input_spec = InputSpec(ndim=3)
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')