def __init__(self,
filters,
kernel_support,
corr=False,
strides_down=1,
strides_up=1,
padding="valid",
extra_pad_end=True,
channel_separable=False,
data_format="channels_last",
activation=None,
use_bias=False,
kernel_initializer=tf.initializers.variance_scaling(),
bias_initializer=tf.initializers.zeros(),
kernel_regularizer=None,
bias_regularizer=None,
kernel_parameterizer=parameterizers.RDFTParameterizer(),
bias_parameterizer=None,
**kwargs):
super(_SignalConv, self).__init__(**kwargs)
self._filters = int(filters)
self._kernel_support = self._normalized_tuple(kernel_support,
"kernel_support")
self._corr = bool(corr)
self._strides_down = self._normalized_tuple(strides_down,
"strides_down")
self._strides_up = self._normalized_tuple(strides_up, "strides_up")
self._padding = str(padding).lower()
try:
self._pad_mode = {
"valid": None,
"same_zeros": "CONSTANT",
"same_reflect": "REFLECT",
}[self.padding]
except KeyError:
raise ValueError("Unsupported padding mode: '{}'".format(padding))
self._extra_pad_end = bool(extra_pad_end)
self._channel_separable = bool(channel_separable)
self._data_format = str(data_format)
self._activation = activation
self._use_bias = bool(use_bias)
self._kernel_initializer = kernel_initializer
self._bias_initializer = bias_initializer
self._kernel_regularizer = kernel_regularizer
self._bias_regularizer = bias_regularizer
self._kernel_parameterizer = kernel_parameterizer
self._bias_parameterizer = bias_parameterizer
if self.data_format not in ("channels_first", "channels_last"):
raise ValueError("Unknown data format: '{}'.".format(
self.data_format))
self.input_spec = tf.keras.layers.InputSpec(ndim=self._rank + 2)
def __init__(self,
rank,
filters,
kernel_support,
corr=False,
strides_down=1,
strides_up=1,
padding="valid",
extra_pad_end=True,
channel_separable=False,
data_format="channels_last",
activation=None,
use_bias=False,
kernel_initializer=init_ops.VarianceScaling(),
bias_initializer=init_ops.Zeros(),
kernel_regularizer=None,
bias_regularizer=None,
kernel_parameterization=parameterizers.RDFTParameterizer(),
bias_parameterization=None,
**kwargs):
super(_SignalConv, self).__init__(**kwargs)
self._rank = int(rank)
self._filters = int(filters)
self._kernel_support = utils.normalize_tuple(kernel_support,
self._rank,
"kernel_support")
self._corr = bool(corr)
self._strides_down = utils.normalize_tuple(strides_down, self._rank,
"strides_down")
self._strides_up = utils.normalize_tuple(strides_up, self._rank,
"strides_up")
self._padding = str(padding).lower()
try:
self._pad_mode = {
"valid": None,
"same_zeros": "CONSTANT",
"same_reflect": "REFLECT",
}[self.padding]
except KeyError:
raise ValueError("Unsupported padding mode: '{}'".format(padding))
self._extra_pad_end = bool(extra_pad_end)
self._channel_separable = bool(channel_separable)
self._data_format = utils.normalize_data_format(data_format)
self._activation = activation
self._use_bias = bool(use_bias)
self._kernel_initializer = kernel_initializer
self._bias_initializer = bias_initializer
self._kernel_regularizer = kernel_regularizer
self._bias_regularizer = bias_regularizer
self._kernel_parameterization = kernel_parameterization
self._bias_parameterization = bias_parameterization
self.input_spec = base.InputSpec(ndim=self._rank + 2)
def __init__(self,
filters,
kernel_support,
corr=False,
strides_down=1,
strides_up=1,
padding="valid",
extra_pad_end=True,
channel_separable=False,
data_format="channels_last",
activation=None,
use_bias=False,
use_explicit=True,
kernel_initializer=tf.initializers.variance_scaling(),
bias_initializer=tf.initializers.zeros(),
kernel_regularizer=None,
bias_regularizer=None,
kernel_parameterizer=parameterizers.RDFTParameterizer(),
bias_parameterizer=None,
**kwargs):
"""Initializer.
Args:
filters: Integer. If `not channel_separable`, specifies the total number
of filters, which is equal to the number of output channels. Otherwise,
specifies the number of filters per channel, which makes the number of
output channels equal to `filters` times the number of input channels.
kernel_support: An integer or iterable of {rank} integers, specifying the
length of the convolution/correlation window in each dimension.
corr: Boolean. If True, compute cross correlation. If False, convolution.
strides_down: An integer or iterable of {rank} integers, specifying an
optional downsampling stride after the convolution/correlation.
strides_up: An integer or iterable of {rank} integers, specifying an
optional upsampling stride before the convolution/correlation.
padding: String. One of the supported padding modes (see above).
extra_pad_end: Boolean. When upsampling, use extra skipped samples at the
end of each dimension (default). For examples, refer to the discussion
of padding modes above.
channel_separable: Boolean. If `False` (default), each output channel is
computed by summing over all filtered input channels. If `True`, each
output channel is computed from only one input channel, and `filters`
specifies the number of filters per channel. The output channels are
ordered such that the first block of `filters` channels is computed from
the first input channel, the second block from the second input channel,
etc.
data_format: String, one of `channels_last` (default) or `channels_first`.
The ordering of the input dimensions. `channels_last` corresponds to
input tensors with shape `(batch, ..., channels)`, while
`channels_first` corresponds to input tensors with shape `(batch,
channels, ...)`.
activation: Activation function or `None`.
use_bias: Boolean, whether an additive constant will be applied to each
output channel.
use_explicit: Boolean, whether to use `EXPLICIT` padding mode (supported
in TensorFlow >1.14).
kernel_initializer: An initializer for the filter kernel.
bias_initializer: An initializer for the bias vector.
kernel_regularizer: Optional regularizer for the filter kernel.
bias_regularizer: Optional regularizer for the bias vector.
kernel_parameterizer: Reparameterization applied to filter kernel. If not
`None`, must be a `Parameterizer` object. Defaults to
`RDFTParameterizer`.
bias_parameterizer: Reparameterization applied to bias. If not `None`,
must be a `Parameterizer` object. Defaults to `None`.
**kwargs: Other keyword arguments passed to superclass (`Layer`).
"""
super(_SignalConv, self).__init__(**kwargs)
self._filters = int(filters)
self._kernel_support = self._normalized_tuple(kernel_support,
"kernel_support")
self._corr = bool(corr)
self._strides_down = self._normalized_tuple(strides_down,
"strides_down")
self._strides_up = self._normalized_tuple(strides_up, "strides_up")
self._padding = str(padding).lower()
try:
self._pad_mode = {
"valid": None,
"same_zeros": "CONSTANT",
"same_reflect": "REFLECT",
}[self.padding]
except KeyError:
raise ValueError("Unsupported padding mode: '{}'".format(padding))
self._extra_pad_end = bool(extra_pad_end)
self._channel_separable = bool(channel_separable)
self._data_format = str(data_format)
self._activation = activation
self._use_bias = bool(use_bias)
self._use_explicit = bool(use_explicit)
self._kernel_initializer = kernel_initializer
self._bias_initializer = bias_initializer
self._kernel_regularizer = kernel_regularizer
self._bias_regularizer = bias_regularizer
self._kernel_parameterizer = kernel_parameterizer
self._bias_parameterizer = bias_parameterizer
if self.data_format not in ("channels_first", "channels_last"):
raise ValueError("Unknown data format: '{}'.".format(
self.data_format))
self.input_spec = tf.keras.layers.InputSpec(ndim=self._rank + 2)
def test_rdft_parameterizer(self):
shape = (3, 4, 2, 1)
var = self._test_parameterizer(parameterizers.RDFTParameterizer(),
tf.initializers.ones(), shape)
self.assertEqual(var.shape, shape)
self.assertAllClose(var, np.ones(shape), rtol=0, atol=1e-6)
