code: def conv(
      name,
      x,
      output_channels,
      filter_size=None,
      stride=None,
      logscale_factor=3.0,
      apply_actnorm=True,
      conv_init="default",
      dilations=None,
  ):
      """Convolutional layer with edge bias padding and optional actnorm.
  
      If x is 5-dimensional, actnorm is applied independently across every
      time-step.
  
      Args:
        name: variable scope.
        x: 4-D Tensor or 5-D Tensor of shape NHWC or NTHWC
        output_channels: Number of output channels.
        filter_size: list of ints, if None [3, 3] and [2, 3, 3] are defaults for
                     4-D and 5-D input tensors respectively.
        stride: list of ints, default stride: 1
        logscale_factor: see actnorm for parameter meaning.
        apply_actnorm: if apply_actnorm the activations of the first minibatch
                       have zero mean and unit variance. Else, there is no scaling
                       applied.
        conv_init: default or zeros. default is a normal distribution with 0.05 std.
        dilations: List of integers, apply dilations.
      Returns:
        x: actnorm(conv2d(x))
      Raises:
        ValueError: if init is set to "zeros" and apply_actnorm is set to True.
      """
      if conv_init == "zeros" and apply_actnorm:
          raise ValueError(
              "apply_actnorm is unstable when init is set to zeros."
          )
  
      x_shape = common_layers.shape_list(x)
      is_2d = len(x_shape) == 4
      num_steps = x_shape[1]
  
      # set filter_size, stride and in_channels
      if is_2d:
          if filter_size is None:
              filter_size = [3, 3]
          if stride is None:
              stride = [1, 1]
          if dilations is None:
              dilations = [1, 1, 1, 1]
          actnorm_func = actnorm
          x = add_edge_bias(x, filter_size=filter_size)
          conv_filter = tf.nn.conv2d
      else:
          if filter_size is None:
              if num_steps == 1:
                  filter_size = [1, 3, 3]
              else:
                  filter_size = [2, 3, 3]
          if stride is None:
              stride = [1, 1, 1]
          if dilations is None:
              dilations = [1, 1, 1, 1, 1]
          actnorm_func = actnorm_3d
          x = time_pad(x, filter_size=filter_size, dilations=dilations)
          conv_filter = tf.nn.conv3d
  
      in_channels = common_layers.shape_list(x)[-1]
      filter_shape = filter_size + [in_channels, output_channels]
      stride_shape = [1] + stride + [1]
  
      with tf.variable_scope(name, reuse=tf.AUTO_REUSE):
          if conv_init == "default":
              initializer = default_initializer()
          elif conv_init == "zeros":
              initializer = tf.zeros_initializer()
  
          w = tf.get_variable(
              "W", filter_shape, tf.float32, initializer=initializer
          )
          x = conv_filter(
              x, w, stride_shape, padding="VALID", dilations=dilations
          )
          if apply_actnorm:
              x, _ = actnorm_func(
                  "actnorm", x, logscale_factor=logscale_factor
              )
          else:
              x += tf.get_variable(
                  "b",
                  [1, 1, 1, output_channels],
                  initializer=tf.zeros_initializer(),
              )
              logs = tf.get_variable(
                  "logs",
                  [1, output_channels],
                  initializer=tf.zeros_initializer(),
              )
              x *= tf.exp(logs * logscale_factor)
          return x
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import functools
  import numpy
  import scipy
  from tensor2tensor.layers import common_layers
  from tensor2tensor.layers import common_video
  from tensor2tensor.utils import contrib
  import tensorflow.compat.v1
  from tensorflow.compat.v1 import estimator
  import tensorflow_probability
label_desc: Use image node_id 19 for calling a global function with example usage: conv(name, x, output_channels, filter_size, stride, logscale_factor, apply_actnorm, conv_init, dilations) and returns: x