def __init__(self, rank,
filters,
kernel_size,
strides=1,
padding='valid',
data_format='channels_last',
dilation_rate=1,
activation=None,
use_bias=True,
kernel_initializer=None,
bias_initializer=init_ops.zeros_initializer(),
kernel_regularizer=None,
bias_regularizer=None,
activity_regularizer=None,
trainable=True,
name=None,
**kwargs):
super(_Conv, self).__init__(trainable=trainable,
name=name, **kwargs)
self.rank = rank
self.filters = filters
self.kernel_size = utils.normalize_tuple(kernel_size, rank, 'kernel_size')
self.strides = utils.normalize_tuple(strides, rank, 'strides')
self.padding = utils.normalize_padding(padding)
self.data_format = utils.normalize_data_format(data_format)
self.dilation_rate = utils.normalize_tuple(
dilation_rate, rank, 'dilation_rate')
self.activation = activation
self.use_bias = use_bias
self.kernel_initializer = kernel_initializer
self.bias_initializer = bias_initializer
self.kernel_regularizer = kernel_regularizer
self.bias_regularizer = bias_regularizer
self.activity_regularizer = activity_regularizer
def __init__(self,
kernel_size,
filters,
dilation_rate=1,
strides=1,
padding="same",
kernel_initializer=None,
add_bias=True,
use_wn=False,
trainable=True,
name=None,
**kwargs):
super(Conv1d, self).__init__(trainable=trainable,
name=name,
activity_regularizer=None,
**kwargs)
self.rank = 1
self.filters = filters
self.kernel_size = utils.normalize_tuple(kernel_size, self.rank,
"kernel_size")
self.dilation_rate = utils.normalize_tuple(dilation_rate, self.rank,
"dilation_rate")
self.strides = utils.normalize_tuple(strides, self.rank, "strides")
self.padding = utils.normalize_padding(padding)
self.kernel_initializer = kernel_initializer
self.add_bias = add_bias
self.use_wn = use_wn
def __init__(self, pool_function, pool_size, strides,
padding='valid', data_format='channels_last',
name=None, **kwargs):
super(_Pooling1D, self).__init__(name=name, **kwargs)
self.pool_function = pool_function
self.pool_size = utils.normalize_tuple(pool_size, 1, 'pool_size')
self.strides = utils.normalize_tuple(strides, 1, 'strides')
self.padding = utils.normalize_padding(padding)
self.data_format = utils.normalize_data_format(data_format)
def __init__(self, pool_function, pool_size, strides,
padding='valid', data_format='channels_last',
name=None, **kwargs):
super(_Pooling1D, self).__init__(name=name, **kwargs)
self.pool_function = pool_function
self.pool_size = utils.normalize_tuple(pool_size, 1, 'pool_size')
self.strides = utils.normalize_tuple(strides, 1, 'strides')
self.padding = utils.normalize_padding(padding)
self.data_format = utils.normalize_data_format(data_format)
def __init__(self,
rank,
filters,
kernel_size,
strides=1,
padding='valid',
data_format='channels_last',
dilation_rate=1,
activation=None,
use_scale=True,
use_bias=True,
kernel_initializer=None,
scale_initializer=None,
bias_initializer=init_ops.zeros_initializer(),
scale_regularizer=None,
kernel_regularizer=None,
bias_regularizer=None,
activity_regularizer=None,
kernel_constraint=None,
scale_constraint=None,
bias_constraint=None,
trainable=True,
name=None,
**kwargs):
super(_ConvWNorm,
self).__init__(trainable=trainable,
name=name,
activity_regularizer=activity_regularizer,
**kwargs)
self.rank = rank
self.filters = filters
self.kernel_size = utils.normalize_tuple(kernel_size, rank,
'kernel_size')
self.strides = utils.normalize_tuple(strides, rank, 'strides')
self.padding = utils.normalize_padding(padding)
self.data_format = utils.normalize_data_format(data_format)
self.dilation_rate = utils.normalize_tuple(dilation_rate, rank,
'dilation_rate')
self.activation = activation
self.use_scale = use_scale
self.use_bias = use_bias
self.kernel_initializer = kernel_initializer
self.scale_initializer = scale_initializer
self.bias_initializer = bias_initializer
self.kernel_regularizer = kernel_regularizer
self.scale_regularizer = scale_regularizer
self.bias_regularizer = bias_regularizer
self.kernel_constraint = kernel_constraint
self.scale_constraint = scale_constraint
self.bias_constraint = bias_constraint
self.input_spec = base.InputSpec(ndim=self.rank + 2)
def __init__(
self,
rank,
filters,
kernel_size,
is_mc,
strides=1,
padding="valid",
data_format="channels_last",
dilation_rate=1,
activation=None,
activity_regularizer=None,
kernel_posterior_fn=tfp_layers_util.default_mean_field_normal_fn(),
kernel_posterior_tensor_fn=lambda d: d.sample(),
kernel_prior_fn=tfp_layers_util.default_multivariate_normal_fn,
kernel_divergence_fn=(lambda q, p, ignore: kl_lib.kl_divergence(q, p)),
bias_posterior_fn=tfp_layers_util.default_mean_field_normal_fn(
is_singular=True
),
bias_posterior_tensor_fn=lambda d: d.sample(),
bias_prior_fn=None,
bias_divergence_fn=lambda q, p, ignore: kl_lib.kl_divergence(q, p),
**kwargs
):
super(_ConvVariational, self).__init__(
activity_regularizer=activity_regularizer, **kwargs
)
self.rank = rank
self.is_mc = is_mc
self.filters = filters
self.kernel_size = tf_layers_util.normalize_tuple(
kernel_size, rank, "kernel_size"
)
self.strides = tf_layers_util.normalize_tuple(strides, rank, "strides")
self.padding = tf_layers_util.normalize_padding(padding)
self.data_format = tf_layers_util.normalize_data_format(data_format)
self.dilation_rate = tf_layers_util.normalize_tuple(
dilation_rate, rank, "dilation_rate"
)
self.activation = tf.keras.activations.get(activation)
self.input_spec = tf.keras.layers.InputSpec(ndim=self.rank + 2)
self.kernel_posterior_fn = kernel_posterior_fn
self.kernel_posterior_tensor_fn = kernel_posterior_tensor_fn
self.kernel_prior_fn = kernel_prior_fn
self.kernel_divergence_fn = kernel_divergence_fn
self.bias_posterior_fn = bias_posterior_fn
self.bias_posterior_tensor_fn = bias_posterior_tensor_fn
self.bias_prior_fn = bias_prior_fn
self.bias_divergence_fn = bias_divergence_fn
def __init__(self,
pool_function,
pool_size,
strides,
padding='valid',
data_format='channels_last',
name=None,
quantizer=None,
**kwargs):
super(_Pooling2D, self).__init__(name=name, **kwargs)
self.pool_function = pool_function
self.pool_size = utils.normalize_tuple(pool_size, 2, 'pool_size')
self.strides = utils.normalize_tuple(strides, 2, 'strides')
self.padding = utils.normalize_padding(padding)
self.data_format = utils.normalize_data_format(data_format)
self.input_spec = base.InputSpec(ndim=4)
self.quantizer = quantizer
def __init__(self,
rank,
filters,
kernel_size,
strides=1,
padding="valid",
data_format="channels_last",
dilation_rate=1,
activation=None,
use_bias=True,
dropout_rate=0.5,
temperature=0.6,
gamma=-0.1,
zeta=1.1,
kernel_initializer=init.random_normal_initializer(0., 1e-2),
bias_initializer=init.zeros_initializer(),
trainable=True,
name=None,
**kwargs):
super(_L0NormConv, self).__init__(trainable=trainable,
name=name,
**kwargs)
self.rank = rank
self.filters = filters
self.kernel_size = utils.normalize_tuple(kernel_size, rank,
"kernel_size")
self.strides = utils.normalize_tuple(strides, rank, "strides")
self.padding = utils.normalize_padding(padding)
self.data_format = utils.normalize_data_format(data_format)
self.dilation_rate = utils.normalize_tuple(dilation_rate, rank,
"dilation_rate")
self.activation = activation
self.use_bias = use_bias
self.dropout_rate = dropout_rate
self.temperature = temperature
self.gamma = gamma
self.zeta = zeta
self.kernel_initializer = kernel_initializer
self.bias_initializer = bias_initializer
# Construct log_alpha initializer.
alpha = dropout_rate / (1. - dropout_rate)
self.log_alpha_initializer = init.random_normal_initializer(
alpha, 0.01)
def __init__(self,
rank,
filters,
kernel_size,
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,
trainable=True,
name=None,
**kwargs):
super(_MaskedConv, self).__init__(
trainable=trainable,
name=name,
activity_regularizer=activity_regularizer,
**kwargs)
self.rank = rank
self.filters = filters
self.kernel_size = utils.normalize_tuple(kernel_size, rank, 'kernel_size')
self.strides = utils.normalize_tuple(strides, rank, 'strides')
self.padding = utils.normalize_padding(padding)
self.data_format = utils.normalize_data_format(data_format)
self.dilation_rate = utils.normalize_tuple(dilation_rate, rank,
'dilation_rate')
self.activation = activation
self.use_bias = use_bias
self.ones_initializer = initializers.get('ones')
self.zeros_initializer = initializers.get('zeros')
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 __init__(self,
rank,
filters,
kernel_size,
strides=1,
padding="valid",
data_format="channels_last",
dilation_rate=1,
activation=None,
use_bias=True,
trainable=True,
local_reparametrization=False,
flipout=False,
seed=None,
name=None,
**kwargs):
super(_ConvVariational, self).__init__(trainable=trainable,
name=name,
**kwargs)
if local_reparametrization and flipout:
raise ValueError('Cannot apply both flipout and local '
'reparametrizations for variance reduction.')
self.rank = rank
self.filters = filters
self.kernel_size = utils.normalize_tuple(kernel_size, rank,
"kernel_size")
self.strides = utils.normalize_tuple(strides, rank, "strides")
self.padding = utils.normalize_padding(padding)
self.data_format = utils.normalize_data_format(data_format)
self.dilation_rate = utils.normalize_tuple(dilation_rate, rank,
"dilation_rate")
self.activation = activation
self.use_bias = use_bias
self.local_reparametrization = local_reparametrization
self.flipout = flipout
self.seed = seed
def testNormalizePadding(self):
self.assertEqual(utils.normalize_padding('SAME'), 'same')
self.assertEqual(utils.normalize_padding('VALID'), 'valid')
with self.assertRaises(ValueError):
utils.normalize_padding('invalid')
def testNormalizePadding(self):
self.assertEqual('same', utils.normalize_padding('SAME'))
self.assertEqual('valid', utils.normalize_padding('VALID'))
with self.assertRaises(ValueError):
utils.normalize_padding('invalid')
