class_docstr: Old SV2P code. Only for legacy reasons.
class_docstr_tok: ["Old","SV2P","code",".","Only","for","legacy","reasons","."]
docstr: Build convolutional lstm video predictor using CDNA, or DNA.
  
  Args:
    images: list of tensors of ground truth image sequences
            there should be a 4D image ?xWxHxC for each timestep
    actions: list of action tensors
             each action should be in the shape ?x1xZ
    rewards: list of reward tensors
             each reward should be in the shape ?x1xZ
  Returns:
    gen_images: predicted future image frames
    gen_rewards: predicted future rewards
    latent_mean: mean of approximated posterior
    latent_std: std of approximated posterior
  
  Raises:
    ValueError: if more than 1 mask specified for DNA model.
docstr_tok: ["Build","convolutional","lstm","video","predictor","using","CDNA",",","or","DNA",".","Args",":","images",":","list","of","tensors","of","ground","truth","image","sequences","there","should","be","a","4D","image","?","xWxHxC","for","each","timestep","actions",":","list","of","action","tensors","each","action","should","be","in","the","shape","?","x1xZ","rewards",":","list","of","reward","tensors","each","reward","should","be","in","the","shape","?","x1xZ","Returns",":","gen_images",":","predicted","future","image","frames","gen_rewards",":","predicted","future","rewards","latent_mean",":","mean","of","approximated","posterior","latent_std",":","std","of","approximated","posterior","Raises",":","ValueError",":","if","more","than","1","mask","specified","for","DNA","model","."]
code: def construct_model(self, images, actions, rewards):
      """Build convolutional lstm video predictor using CDNA, or DNA.
  
      Args:
        images: list of tensors of ground truth image sequences
                there should be a 4D image ?xWxHxC for each timestep
        actions: list of action tensors
                 each action should be in the shape ?x1xZ
        rewards: list of reward tensors
                 each reward should be in the shape ?x1xZ
      Returns:
        gen_images: predicted future image frames
        gen_rewards: predicted future rewards
        latent_mean: mean of approximated posterior
        latent_std: std of approximated posterior
  
      Raises:
        ValueError: if more than 1 mask specified for DNA model.
      """
      context_frames = self.hparams.video_num_input_frames
      buffer_size = self.hparams.reward_prediction_buffer_size
      if buffer_size == 0:
          buffer_size = context_frames
      if buffer_size > context_frames:
          raise ValueError(
              "Buffer size is bigger than context frames %d %d."
              % (buffer_size, context_frames)
          )
  
      batch_size = common_layers.shape_list(images[0])[0]
      ss_func = self.get_scheduled_sample_func(batch_size)
  
      def process_single_frame(prev_outputs, inputs):
          """Process a single frame of the video."""
          cur_image, input_reward, action = inputs
          (
              time_step,
              prev_image,
              prev_reward,
              frame_buf,
              lstm_states,
          ) = prev_outputs
  
          # sample from softmax (by argmax). this is noop for non-softmax loss.
          prev_image = self.get_sampled_frame(prev_image)
  
          generated_items = [prev_image]
          groundtruth_items = [cur_image]
          done_warm_start = tf.greater(time_step, context_frames - 1)
          (input_image,) = self.get_scheduled_sample_inputs(
              done_warm_start,
              groundtruth_items,
              generated_items,
              ss_func,
          )
  
          # Prediction
          pred_image, lstm_states, _ = self.construct_predictive_tower(
              input_image, None, action, lstm_states, latent
          )
  
          if self.hparams.reward_prediction:
              reward_input_image = self.get_sampled_frame(pred_image)
              if self.hparams.reward_prediction_stop_gradient:
                  reward_input_image = tf.stop_gradient(
                      reward_input_image
                  )
              with tf.control_dependencies([time_step]):
                  frame_buf = [reward_input_image] + frame_buf[:-1]
              pred_reward = self.reward_prediction(
                  frame_buf, None, action, latent
              )
              pred_reward = common_video.decode_to_shape(
                  pred_reward,
                  common_layers.shape_list(input_reward),
                  "reward_dec",
              )
          else:
              pred_reward = prev_reward
  
          time_step += 1
          outputs = (
              time_step,
              pred_image,
              pred_reward,
              frame_buf,
              lstm_states,
          )
  
          return outputs
  
      # Latent tower
      latent = None
      if self.hparams.stochastic_model:
          latent_mean, latent_std = self.construct_latent_tower(
              images, time_axis=0
          )
          latent = common_video.get_gaussian_tensor(
              latent_mean, latent_std
          )
  
      # HACK: Do first step outside to initialize all the variables
  
      lstm_states = [None] * (5 if self.hparams.small_mode else 7)
      frame_buffer = [tf.zeros_like(images[0])] * buffer_size
      inputs = images[0], rewards[0], actions[0]
      init_image_shape = common_layers.shape_list(images[0])
      if self.is_per_pixel_softmax:
          init_image_shape[-1] *= 256
      init_image = tf.zeros(init_image_shape, dtype=images.dtype)
      prev_outputs = (
          tf.constant(0),
          init_image,
          tf.zeros_like(rewards[0]),
          frame_buffer,
          lstm_states,
      )
  
      initializers = process_single_frame(prev_outputs, inputs)
      first_gen_images = tf.expand_dims(initializers[1], axis=0)
      first_gen_rewards = tf.expand_dims(initializers[2], axis=0)
  
      inputs = (images[1:-1], rewards[1:-1], actions[1:-1])
  
      outputs = tf.scan(process_single_frame, inputs, initializers)
      gen_images, gen_rewards = outputs[1:3]
  
      gen_images = tf.concat((first_gen_images, gen_images), axis=0)
      gen_rewards = tf.concat((first_gen_rewards, gen_rewards), axis=0)
  
      if self.hparams.stochastic_model:
          return gen_images, gen_rewards, [latent_mean], [latent_std]
      else:
          return gen_images, gen_rewards, None, None
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  from tensor2tensor.layers import common_layers
  from tensor2tensor.layers import common_video
  from tensor2tensor.layers import discretization
  from tensor2tensor.models.video import base
  from tensor2tensor.models.video import base_vae
  from tensor2tensor.utils import contrib
  from tensor2tensor.utils import registry
  import tensorflow.compat.v1
label_desc: Use image node_id 3 for calling the NextFrameSv2pLegacy obj's underlying member method code with example usage: obj.construct_model(images, actions, rewards) and returns: outputs, gen_images,  gen_rewards,  list,  list, gen_images,  gen_rewards,  None,  None