class_docstr: Svdf implementations with conv layers.
  
  This is an equalivent implementation to class SvdfCell in svdf_cell.py.
  The difference is, training with SvdfConvLayer implementation is much faster,
  but SvdfCell is better during inference time as it is implemented in streaming
  way.
  
  # Attributes:
    units: Positive integer, dimensionality of the output space.
    memory_size: Dimension of feature vector.
    rank: int or long, the rank of the SVD approximation.
    activation: Activation function to use
      (see [activations](../activations.md)).
      Default: Rectified linear unit (`relu`).
      If you pass `None`, no activation is applied
      (ie. "linear" activation: `a(x) = x`).
    use_bias: Boolean, whether the layer uses a bias vector.
    kernel_initializer: Initializer for the `kernel` weights matrix,
      used for the linear transformation of the inputs
      (see [initializers](../initializers.md)).
    bias_initializer: Initializer for the bias vector
      (see [initializers](../initializers.md)).
    dropout: Float between 0 and 1.
      Fraction of the units to drop for
      the linear transformation of the inputs.
    use_batch_norm: whether to apply batch normalization
    bn_scale: whether to apply batch norm scaling. When the next layer is linear
      (e.g. nn.relu), this can be disabled since the scaling will be done by the
      next layer.
code: def __init__(
      self,
      units: int,
      memory_size: int = 0,
      rank: int = 1,
      activation: Text = "relu",
      use_bias: bool = True,
      kernel_initializer: CallOrText = "glorot_uniform",
      bias_initializer: CallOrText = "zeros",
      dropout: float = 0.0,
      use_batch_norm: bool = False,
      bn_scale: bool = False,
      name: Optional[str] = None,
      **kwargs,
  ):
      if memory_size <= 1:
          raise ValueError("memory_size must be > 1")
      if rank <= 0:
          raise ValueError("rank must be > 0")
  
      self.units = units
      self.memory_size = memory_size
      self.rank = rank
      self.activation = tf.keras.activations.get(activation)
      self.use_bias = use_bias
      self.use_batch_norm = use_batch_norm
      self.bn_scale = bn_scale
      self.dropout = min(1.0, max(0.0, dropout))
      self.num_filters = self.rank * self.units
      self._dropout_mask = None
      self.feature_kernel = []
      self.time_kernel = []
      self.bias = []
  
      self.kernel_initializer = tf.keras.initializers.get(
          kernel_initializer
      )
      self.bias_initializer = tf.keras.initializers.get(
          bias_initializer
      )
  
      self.input_spec = [tf.keras.layers.InputSpec(ndim=3)]
      self.output_size = self.units
  
      self._name = name or type(self).__name__
      super(SvdfConvLayer, self).__init__(name=self._name, **kwargs)
  
file_path: model_search/model_search/ops/svdf_conv.py
imports: from typing import Any, Callable, Dict, List, Optional, Text, Union
  from absl import logging
  from six.moves import range
  import tensorflow.compat.v1
label_desc: Use image node_id 1 to create a new SvdfConvLayer object from inherited base classes: tf.keras.layers with example: obj = SvdfConvLayer(units, memory_size, rank, activation, use_bias, kernel_initializer, bias_initializer, dropout, use_batch_norm, bn_scale, name)