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 chainerrl.agents.DQN.
docstr: Compute a batch of target return distributions.
  
  Returns:
      chainer.Variable: (batch_size, N_prime).
docstr_tok: ["Compute","a","batch","of","target","return","distributions",".","Returns",":","chainer.Variable",":","(","batch_size",",","N_prime",")","."]
code: def _compute_target_values(self, exp_batch):
      """Compute a batch of target return distributions.
  
      Returns:
          chainer.Variable: (batch_size, N_prime).
      """
      batch_next_state = exp_batch["next_state"]
      batch_size = len(exp_batch["reward"])
      taus_tilde = self.xp.random.uniform(
          0, 1, size=(batch_size, self.quantile_thresholds_K)
      ).astype("f")
  
      if self.recurrent:
          target_next_tau2av, _ = self.target_model.n_step_forward(
              batch_next_state,
              exp_batch["next_recurrent_state"],
              output_mode="concat",
          )
      else:
          target_next_tau2av = self.target_model(batch_next_state)
      greedy_actions = target_next_tau2av(taus_tilde).greedy_actions
      taus_prime = self.xp.random.uniform(
          0, 1, size=(batch_size, self.quantile_thresholds_N_prime)
      ).astype("f")
      target_next_maxz = target_next_tau2av(
          taus_prime
      ).evaluate_actions_as_quantiles(greedy_actions)
  
      batch_rewards = exp_batch["reward"]
      batch_terminal = exp_batch["is_state_terminal"]
      batch_discount = exp_batch["discount"]
      assert batch_rewards.shape == (batch_size,)
      assert batch_terminal.shape == (batch_size,)
      assert batch_discount.shape == (batch_size,)
      batch_rewards = F.broadcast_to(
          batch_rewards[..., None], target_next_maxz.shape
      )
      batch_terminal = F.broadcast_to(
          batch_terminal[..., None], target_next_maxz.shape
      )
      batch_discount = F.broadcast_to(
          batch_discount[..., None], target_next_maxz.shape
      )
  
      return (
          batch_rewards
          + batch_discount * (1.0 - batch_terminal) * target_next_maxz
      )
  
imports: import chainer
  from chainer import cuda
  import chainer.functions
  import chainer.links
  from chainerrl.action_value import QuantileDiscreteActionValue
  from chainerrl.agents import dqn
  from chainerrl.links import StatelessRecurrentChainList
label_desc: Use image node_id 2 for calling the IQN obj's underlying member method code with example usage: obj._compute_target_values(exp_batch) and returns: unknown