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)