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 _run_svdf_conv_calculation(
      self,
      inputs,
      feature_kernel,
      time_kernel,
      memory_size,
      units,
      cnn_bias,
  ):
      # padded_inputs: [batch_size, time_steps+mem_size-1, feature_size]
      padded_inputs = tf.keras.backend.temporal_padding(
          inputs, padding=(memory_size - 1, 0)
      )
      # feature_conv_kernel: [1, feature_size, num_filters]
      feature_conv_kernel = tf.expand_dims(feature_kernel, 0)
      # svdf_feature_activations: [batch_size, time_steps+padsize, num_filters]
      svdf_feature_activations = tf.keras.backend.conv1d(
          padded_inputs, feature_conv_kernel, padding="valid"
      )
  
      # time_conv_kernel: [memory_size, 1, num_filters, 1]
      time_conv_kernel = tf.expand_dims(
          tf.expand_dims(time_kernel, 1), -1
      )
      # svdf_time_activations: [batch_size, time_steps, 1, num_filters]
      svdf_time_activations = tf.nn.depthwise_conv2d(
          tf.expand_dims(svdf_feature_activations, -2),
          time_conv_kernel,
          strides=[1, 1, 1, 1],
          padding="VALID",
      )
      # svdf_time_activations: [batch_size, time_steps, num_filters]
      svdf_time_activations = tf.keras.backend.squeeze(
          svdf_time_activations, -2
      )
      new_shape = [
          -1,
          tf.shape(svdf_time_activations)[1],
          units,
          self.rank,
      ]
      svdf_time_activations = tf.reshape(
          svdf_time_activations, new_shape
      )
      # time_activations_t: [batch_size, time_steps, units]
      svdf_activations = tf.keras.backend.sum(
          svdf_time_activations, axis=-1
      )
  
      if cnn_bias is not None:
          svdf_activations = tf.add(svdf_activations, cnn_bias)
  
      if self.use_batch_norm:
          svdf_activations = tf.keras.layers.BatchNormalization(
              scale=self.bn_scale
          )(svdf_activations)
  
      # svdf_output: [batch_size, time_steps, units]
      svdf_output = self.activation(svdf_activations)
      return svdf_output, svdf_activations
  
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 5 for calling the SvdfConvLayer obj's underlying member method code with example usage: obj._run_svdf_conv_calculation(inputs, feature_kernel, time_kernel, memory_size, units, cnn_bias) and returns: svdf_output,  svdf_activations