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 policy entropy tensor.
  
  Args:
      i (namedtuple): Collection of variables to compute policy loss.
  
  Returns:
      tf.Tensor: Policy entropy.
docstr_tok: ["Build","policy","entropy","tensor",".","Args",":","i","(","namedtuple",")",":","Collection","of","variables","to","compute","policy","loss",".","Returns",":","tf.Tensor",":","Policy","entropy","."]
code: def _build_entropy_terms(self, i):
      """Build policy entropy tensor.
  
      Args:
          i (namedtuple): Collection of variables to compute policy loss.
  
      Returns:
          tf.Tensor: Policy entropy.
  
      """
      pol_dist = self._policy_network.dist
      infer_dist = self._infer_network.dist
      enc_dist = self._encoder_network.dist
      with tf.name_scope("entropy_terms"):
          # 1. Encoder distribution total entropy
          with tf.name_scope("encoder_entropy"):
              encoder_dist, _, _ = self.policy.encoder.build(
                  i.task_var, name="encoder_entropy"
              ).outputs
              encoder_all_task_entropies = -encoder_dist.log_prob(
                  i.latent_var
              )
  
              if self._use_softplus_entropy:
                  encoder_entropy = tf.nn.softplus(
                      encoder_all_task_entropies
                  )
  
              encoder_entropy = tf.reduce_mean(
                  encoder_entropy, name="encoder_entropy"
              )
              encoder_entropy = tf.stop_gradient(encoder_entropy)
  
          # 2. Infernece distribution cross-entropy (log-likelihood)
          with tf.name_scope("inference_ce"):
              # Build inference with trajectory windows
  
              traj_ll = infer_dist.log_prob(
                  enc_dist.sample(
                      seed=deterministic.get_tf_seed_stream()
                  ),
                  name="traj_ll",
              )
  
              inference_ce_raw = -traj_ll
              inference_ce = tf.clip_by_value(inference_ce_raw, -3, 3)
  
              if self._use_softplus_entropy:
                  inference_ce = tf.nn.softplus(inference_ce)
  
              if self._stop_ce_gradient:
                  inference_ce = tf.stop_gradient(inference_ce)
  
          # 3. Policy path entropies
          with tf.name_scope("policy_entropy"):
              policy_entropy = -pol_dist.log_prob(
                  i.action_var, name="policy_log_likeli"
              )
  
              # This prevents entropy from becoming negative
              # for small policy std
              if self._use_softplus_entropy:
                  policy_entropy = tf.nn.softplus(policy_entropy)
  
              policy_entropy = tf.stop_gradient(policy_entropy)
  
      # Diagnostic functions
      self._f_task_entropies = compile_function(
          flatten_inputs(self._policy_opt_inputs),
          encoder_all_task_entropies,
      )
      self._f_encoder_entropy = compile_function(
          flatten_inputs(self._policy_opt_inputs), encoder_entropy
      )
      self._f_inference_ce = compile_function(
          flatten_inputs(self._policy_opt_inputs),
          tf.reduce_mean(inference_ce * i.valid_var),
      )
      self._f_policy_entropy = compile_function(
          flatten_inputs(self._policy_opt_inputs), policy_entropy
      )
  
      return encoder_entropy, inference_ce, policy_entropy
  
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 9 for calling the TENPO obj's underlying member method code with example usage: obj._build_entropy_terms(i) and returns: encoder_entropy,  inference_ce,  policy_entropy