class_docstr: Recurrent implicit quantile network-based Q-function.
  
  Args:
      psi (torch.nn.Module): Module that implements
          `pfrl.nn.Recurrent`.
          (batch_size, obs_size) -> (batch_size, hidden_size).
      phi (torch.nn.Module): Callable module
          (batch_size, n_taus) -> (batch_size, n_taus, hidden_size).
      f (torch.nn.Module): Callable module
          (batch_size * n_taus, hidden_size)
          -> (batch_size * n_taus, n_actions).
  
  Returns:
      ImplicitQuantileDiscreteActionValue: Action values.
docstr: Evaluate given observations.
  
  Args:
      x (object): Batched sequences of observations.
      recurrent_state (object): Batched recurrent states.
  
  Returns:
      callable: (batch_size, taus) -> (batch_size, taus, n_actions)
      object: new recurrent states
docstr_tok: ["Evaluate","given","observations",".","Args",":","x","(","object",")",":","Batched","sequences","of","observations",".","recurrent_state","(","object",")",":","Batched","recurrent","states",".","Returns",":","callable",":","(","batch_size",",","taus",")","-",">","(","batch_size",",","taus",",","n_actions",")","object",":","new","recurrent","states"]
code: def forward(self, x, recurrent_state):
      """Evaluate given observations.
  
      Args:
          x (object): Batched sequences of observations.
          recurrent_state (object): Batched recurrent states.
  
      Returns:
          callable: (batch_size, taus) -> (batch_size, taus, n_actions)
          object: new recurrent states
      """
      psi_x, recurrent_state = self.psi(x, recurrent_state)
      # unwrap PackedSequence
      assert isinstance(psi_x, nn.utils.rnn.PackedSequence)
      psi_x = psi_x.data
      assert psi_x.ndim == 2
  
      def evaluate_with_quantile_thresholds(taus):
          return _evaluate_psi_x_with_quantile_thresholds(
              psi_x, self.phi, self.f, taus
          )
  
      return evaluate_with_quantile_thresholds, recurrent_state
  
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 2 for calling the RecurrentImplicitQuantileQFunction obj's underlying member method code with example usage: obj.forward(x, recurrent_state) and returns: evaluate_with_quantile_thresholds,  recurrent_state, _evaluate_psi_x_with_quantile_thresholds