class_docstr: Implicit Quantile Networks.
  
  See https://arxiv.org/abs/1806.06923.
  
  Args:
      quantile_thresholds_N (int): Number of quantile thresholds used in
          quantile regression.
      quantile_thresholds_N_prime (int): Number of quantile thresholds used
          to sample from the return distribution at the next state.
      quantile_thresholds_K (int): Number of quantile thresholds used to
          compute greedy actions.
      act_deterministically (bool): IQN's action selection is by default
          stochastic as it samples quantile thresholds every time it acts,
          even for evaluation. If this option is set to True, it uses
          equally spaced quantile thresholds instead of randomly sampled ones
          for evaluation, making its action selection deterministic.
  
  For other arguments, see pfrl.agents.DQN.
docstr: Compute a batch of predicted return distributions.
  
  Returns:
      torch.Tensor: Predicted return distributions.
          (batch_size, N).
docstr_tok: ["Compute","a","batch","of","predicted","return","distributions",".","Returns",":","torch.Tensor",":","Predicted","return","distributions",".","(","batch_size",",","N",")","."]
code: def _compute_y_and_taus(self, exp_batch):
      """Compute a batch of predicted return distributions.
  
      Returns:
          torch.Tensor: Predicted return distributions.
              (batch_size, N).
      """
  
      batch_size = exp_batch["reward"].shape[0]
  
      # Compute Q-values for current states
      batch_state = exp_batch["state"]
  
      # (batch_size, n_actions, n_atoms)
      if self.recurrent:
          tau2av, _ = pack_and_forward(
              self.model,
              batch_state,
              exp_batch["recurrent_state"],
          )
      else:
          tau2av = self.model(batch_state)
      taus = torch.rand(
          batch_size,
          self.quantile_thresholds_N,
          device=self.device,
          dtype=torch.float,
      )
      av = tau2av(taus)
      batch_actions = exp_batch["action"]
      y = av.evaluate_actions_as_quantiles(batch_actions)
  
      self.q_record.extend(av.q_values.detach().cpu().numpy().ravel())
  
      return y, taus
  
imports: import numpy
  import torch
  from torch import nn
  from pfrl.action_value import QuantileDiscreteActionValue
  from pfrl.agents import dqn
  from pfrl.nn import Recurrent
  from pfrl.utils.recurrent import one_step_forward, pack_and_forward
label_desc: Use image node_id 3 for calling the IQN obj's underlying member method code with example usage: obj._compute_y_and_taus(exp_batch) and returns: y,  taus