code: def conv_latent_tower(
      images,
      time_axis,
      latent_channels=1,
      min_logvar=-5,
      is_training=False,
      random_latent=False,
      tiny_mode=False,
      small_mode=False,
  ):
      """Builds convolutional latent tower for stochastic model.
  
      At training time this tower generates a latent distribution (mean and std)
      conditioned on the entire video. This latent variable will be fed to the
      main tower as an extra variable to be used for future frames prediction.
      At inference time, the tower is disabled and only returns latents sampled
      from N(0,1).
      If the multi_latent flag is on, a different latent for every timestep would
      be generated.
  
      Args:
        images: tensor of ground truth image sequences
        time_axis: the time axis  in images tensor
        latent_channels: number of latent channels
        min_logvar: minimum value for log_var
        is_training: whether or not it is training mode
        random_latent: whether or not generate random latents
        tiny_mode: whether or not it is tiny_mode. tiny_mode sets the number
            of conv channels to 1 at each layer. useful for testing the
            integration tests.
        small_mode: whether or not it is small_mode. small mode is the same model
            with less conv and lstm layers and also lower number of channels.
            suitable for videos with less complexity and testing.
      Returns:
        latent_mean: predicted latent mean
        latent_logvar: predicted latent log variance
      """
      conv_size = tinyify([32, 64, 64], tiny_mode, small_mode)
      with tf.variable_scope("latent", reuse=tf.AUTO_REUSE):
          images = tf.to_float(images)
          images = tf.unstack(images, axis=time_axis)
          images = tf.concat(images, axis=3)
  
          x = images
          x = common_layers.make_even_size(x)
          x = tfl.conv2d(
              x,
              conv_size[0],
              [3, 3],
              strides=(2, 2),
              padding="SAME",
              activation=tf.nn.relu,
              name="latent_conv1",
          )
          x = contrib.layers().layer_norm(x)
          if not small_mode:
              x = tfl.conv2d(
                  x,
                  conv_size[1],
                  [3, 3],
                  strides=(2, 2),
                  padding="SAME",
                  activation=tf.nn.relu,
                  name="latent_conv2",
              )
              x = contrib.layers().layer_norm(x)
          x = tfl.conv2d(
              x,
              conv_size[2],
              [3, 3],
              strides=(1, 1),
              padding="SAME",
              activation=tf.nn.relu,
              name="latent_conv3",
          )
          x = contrib.layers().layer_norm(x)
  
          nc = latent_channels
          mean = tfl.conv2d(
              x,
              nc,
              [3, 3],
              strides=(2, 2),
              padding="SAME",
              activation=None,
              name="latent_mean",
          )
          logv = tfl.conv2d(
              x,
              nc,
              [3, 3],
              strides=(2, 2),
              padding="SAME",
              activation=tf.nn.relu,
              name="latent_std",
          )
          logvar = logv + min_logvar
  
          # No latent tower at inference time, just standard gaussian.
          if not is_training:
              return tf.zeros_like(mean), tf.zeros_like(logvar)
  
          # No latent in the first phase
          ret_mean, ret_logvar = tf.cond(
              random_latent,
              lambda: (tf.zeros_like(mean), tf.zeros_like(logvar)),
              lambda: (mean, logvar),
          )
  
          return ret_mean, ret_logvar
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import numpy
  from tensor2tensor.layers import common_layers
  from tensor2tensor.utils import contrib
  import tensorflow.compat.v1
  from tensorflow.python.ops import summary_op_util
label_desc: Use image node_id 20 for calling a global function with example usage: conv_latent_tower(images, time_axis, latent_channels, min_logvar, is_training, random_latent, tiny_mode, small_mode) and returns: ret_mean,  ret_logvar, tf,  tf