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,
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, 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')
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)
