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: Return processed sample data based on the collected paths.
  
  Args:
      episodes (EpisodeBatch): Batch of episodes.
  
  Returns:
      np.ndarray: Embedding episodes.
      dict: Embedding distribution information.
          * mean (list[numpy.ndarray]): Means of the distribution.
          * log_std (list[numpy.ndarray]): Log standard deviations of the
              distribution.
docstr_tok: ["Return","processed","sample","data","based","on","the","collected","paths",".","Args",":","episodes","(","EpisodeBatch",")",":","Batch","of","episodes",".","Returns",":","np.ndarray",":","Embedding","episodes",".","dict",":","Embedding","distribution","information",".","*","mean","(","list","[","numpy.ndarray","]",")",":","Means","of","the","distribution",".","*","log_std","(","list","[","numpy.ndarray","]",")",":","Log","standard","deviations","of","the","distribution","."]
code: def _process_episodes(self, episodes):
      # pylint: disable=too-many-statements
      """Return processed sample data based on the collected paths.
  
      Args:
          episodes (EpisodeBatch): Batch of episodes.
  
      Returns:
          np.ndarray: Embedding episodes.
          dict: Embedding distribution information.
              * mean (list[numpy.ndarray]): Means of the distribution.
              * log_std (list[numpy.ndarray]): Log standard deviations of the
                  distribution.
  
      """
      max_episode_length = self.max_episode_length
  
      trajectories = []
      trajectory_infos = []
  
      for obs in episodes.padded_observations:
          # - Calculate a forward-looking sliding window.
          # - If step_space has shape (n, d), then trajs will have shape
          #   (n, window, d)
          # - The length of the sliding window is determined by the
          #   trajectory inference spec. We smear the last few elements to
          #   preserve the time dimension.
          # - Only observation is used for a single step.
          #   Alternatively, stacked [observation, action] can be used for
          #   in harder tasks.
          obs_flat = self._env_spec.observation_space.flatten_n(obs)
          steps = obs_flat
          window = self._inference.spec.input_space.shape[0]
          traj = sliding_window(steps, window, smear=True)
          traj_flat = self._inference.spec.input_space.flatten_n(traj)
          trajectories.append(traj_flat)
  
          _, traj_info = self._inference.get_latents(traj_flat)
          trajectory_infos.append(traj_info)
  
      trajectories = np.stack(trajectories)
      trajectory_infos = stack_tensor_dict_list(
          [
              pad_tensor_dict(p, max_episode_length)
              for p in trajectory_infos
          ]
      )
  
      return trajectories, trajectory_infos
  
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 6 for calling the TENPO obj's underlying member method code with example usage: obj._process_episodes(episodes) and returns: trajectories,  trajectory_infos