class_docstr: Natural Policy Optimization with Task Embeddings.
  
  See https://karolhausman.github.io/pdf/hausman17nips-ws2.pdf for algorithm
  reference.
  
  Args:
      env_spec (EnvSpec): Environment specification.
      policy (garage.tf.policies.TaskEmbeddingPolicy): Policy.
      baseline (garage.tf.baselines.Baseline): The baseline.
      sampler (garage.sampler.Sampler): Sampler.
      scope (str): Scope for identifying the algorithm.
          Must be specified if running multiple algorithms
          simultaneously, each using different environments
          and policies.
      discount (float): Discount.
      gae_lambda (float): Lambda used for generalized advantage
          estimation.
      center_adv (bool): Whether to rescale the advantages
          so that they have mean 0 and standard deviation 1.
      positive_adv (bool): Whether to shift the advantages
          so that they are always positive. When used in
          conjunction with center_adv the advantages will be
          standardized before shifting.
      fixed_horizon (bool): Whether to fix horizon.
      lr_clip_range (float): The limit on the likelihood ratio between
          policies, as in PPO.
      max_kl_step (float): The maximum KL divergence between old and new
          policies, as in TRPO.
      optimizer (object): The optimizer of the algorithm. Should be the
          optimizers in garage.tf.optimizers.
      optimizer_args (dict): The arguments of the optimizer.
      policy_ent_coeff (float): The coefficient of the policy entropy.
          Setting it to zero would mean no entropy regularization.
      encoder_ent_coeff (float): The coefficient of the policy encoder
          entropy. Setting it to zero would mean no entropy regularization.
      use_softplus_entropy (bool): Whether to estimate the softmax
          distribution of the entropy to prevent the entropy from being
          negative.
      stop_ce_gradient (bool): Whether to stop the cross entropy gradient.
      inference (garage.tf.embeddings.StochasticEncoder): A encoder
          that infers the task embedding from state trajectory.
      inference_optimizer (object): The optimizer of the inference. Should be
          an optimizer in garage.tf.optimizers.
      inference_optimizer_args (dict): The arguments of the inference
          optimizer.
      inference_ce_coeff (float): The coefficient of the cross entropy of
          task embeddings inferred from task one-hot and state trajectory.
          This is effectively the coefficient of log-prob of inference.
      name (str): The name of the algorithm.
docstr: Build input variables.
  
  Returns:
      namedtuple: Collection of variables to compute policy loss.
      namedtuple: Collection of variables to do policy optimization.
      namedtuple: Collection of variables to compute inference loss.
      namedtuple: Collection of variables to do inference optimization.
docstr_tok: ["Build","input","variables",".","Returns",":","namedtuple",":","Collection","of","variables","to","compute","policy","loss",".","namedtuple",":","Collection","of","variables","to","do","policy","optimization",".","namedtuple",":","Collection","of","variables","to","compute","inference","loss",".","namedtuple",":","Collection","of","variables","to","do","inference","optimization","."]
code: def _build_inputs(self):
      """Build input variables.
  
      Returns:
          namedtuple: Collection of variables to compute policy loss.
          namedtuple: Collection of variables to do policy optimization.
          namedtuple: Collection of variables to compute inference loss.
          namedtuple: Collection of variables to do inference optimization.
  
      """
      # pylint: disable=too-many-statements
      observation_space = self.policy.observation_space
      action_space = self.policy.action_space
      task_space = self.policy.task_space
      latent_space = self.policy.latent_space
      trajectory_space = self._inference.spec.input_space
  
      with tf.name_scope("inputs"):
          obs_var = observation_space.to_tf_placeholder(
              name="obs", batch_dims=2
          )
          task_var = tf.compat.v1.placeholder(
              tf.float32,
              shape=[None, None, task_space.flat_dim],
              name="task",
          )
          trajectory_var = tf.compat.v1.placeholder(
              tf.float32, shape=[None, None, trajectory_space.flat_dim]
          )
          latent_var = tf.compat.v1.placeholder(
              tf.float32, shape=[None, None, latent_space.flat_dim]
          )
  
          action_var = action_space.to_tf_placeholder(
              name="action", batch_dims=2
          )
          reward_var = tf.compat.v1.placeholder(
              tf.float32, shape=[None, None], name="reward"
          )
          baseline_var = tf.compat.v1.placeholder(
              tf.float32, shape=[None, None], name="baseline"
          )
  
          valid_var = tf.compat.v1.placeholder(
              tf.float32, shape=[None, None], name="valid"
          )
  
          # Policy state (for RNNs)
          policy_state_info_vars = {
              k: tf.compat.v1.placeholder(
                  tf.float32, shape=[None] * 2 + list(shape), name=k
              )
              for k, shape in self.policy.state_info_specs
          }
          policy_state_info_vars_list = [
              policy_state_info_vars[k]
              for k in self.policy.state_info_keys
          ]
  
          # Encoder state (for RNNs)
          embed_state_info_vars = {
              k: tf.compat.v1.placeholder(
                  tf.float32,
                  shape=[None] * 2 + list(shape),
                  name="embed_%s" % k,
              )
              for k, shape in self.policy.encoder.state_info_specs
          }
          embed_state_info_vars_list = [
              embed_state_info_vars[k]
              for k in self.policy.encoder.state_info_keys
          ]
  
          # Inference distribution state (for RNNs)
          infer_state_info_vars = {
              k: tf.compat.v1.placeholder(
                  tf.float32,
                  shape=[None] * 2 + list(shape),
                  name="infer_%s" % k,
              )
              for k, shape in self._inference.state_info_specs
          }
          infer_state_info_vars_list = [
              infer_state_info_vars[k]
              for k in self._inference.state_info_keys
          ]
  
      extra_obs_var = [
          tf.cast(v, tf.float32) for v in policy_state_info_vars_list
      ]
      # Pylint false alarm
      # pylint: disable=unexpected-keyword-arg, no-value-for-parameter
      augmented_obs_var = tf.concat([obs_var] + extra_obs_var, axis=-1)
      extra_traj_var = [
          tf.cast(v, tf.float32) for v in infer_state_info_vars_list
      ]
      augmented_traj_var = tf.concat(
          [trajectory_var] + extra_traj_var, -1
      )
  
      # Policy and encoder network loss and optimizer inputs
      policy_loss_inputs = graph_inputs(
          "PolicyLossInputs",
          augmented_obs_var=augmented_obs_var,
          augmented_traj_var=augmented_traj_var,
          task_var=task_var,
          latent_var=latent_var,
          action_var=action_var,
          reward_var=reward_var,
          baseline_var=baseline_var,
          valid_var=valid_var,
      )
      policy_opt_inputs = graph_inputs(
          "PolicyOptInputs",
          obs_var=obs_var,
          action_var=action_var,
          reward_var=reward_var,
          baseline_var=baseline_var,
          trajectory_var=trajectory_var,
          task_var=task_var,
          latent_var=latent_var,
          valid_var=valid_var,
          policy_state_info_vars_list=policy_state_info_vars_list,
          embed_state_info_vars_list=embed_state_info_vars_list,
      )
  
      # Inference network loss and optimizer inputs
      inference_loss_inputs = graph_inputs(
          "InferenceLossInputs",
          latent_var=latent_var,
          valid_var=valid_var,
      )
      inference_opt_inputs = graph_inputs(
          "InferenceOptInputs",
          latent_var=latent_var,
          trajectory_var=trajectory_var,
          valid_var=valid_var,
          infer_state_info_vars_list=infer_state_info_vars_list,
      )
  
      return (
          policy_loss_inputs,
          policy_opt_inputs,
          inference_loss_inputs,
          inference_opt_inputs,
      )
  
imports: import akro
  from dowel import Histogram, logger, tabular
  import numpy
  import scipy.stats
  import tensorflow
  from garage import InOutSpec, log_performance
  from garage.experiment import deterministic
  from garage.np import discount_cumsum, explained_variance_1d, pad_batch_array, rrse, sliding_window
  from garage.np.algos import RLAlgorithm
  from garage.tf import center_advs, compile_function, compute_advantages, concat_tensor_list, discounted_returns, flatten_inputs, graph_inputs, pad_tensor_dict, positive_advs, stack_tensor_dict_list
  from garage.tf.embeddings import StochasticEncoder
  from garage.tf.optimizers import LBFGSOptimizer
  from garage.tf.policies import TaskEmbeddingPolicy
label_desc: Use image node_id 7 for calling the TENPO obj's underlying member method code with example usage: obj._build_inputs() and returns: policy_loss_inputs,  policy_opt_inputs,  inference_loss_inputs,  inference_opt_inputs