class_docstr: PCL (Path Consistency Learning).
  
  Not only the batch PCL algorithm proposed in the paper but also its
  asynchronous variant is implemented.
  
  See https://arxiv.org/abs/1702.08892
  
  Args:
      model (chainer.Link): Model to train. It must be a callable that
          accepts a batch of observations as input and return two values:
  
          - action distributions (Distribution)
          - state values (chainer.Variable)
      optimizer (chainer.Optimizer): optimizer used to train the model
      t_max (int or None): The model is updated after every t_max local
          steps. If set None, the model is updated after every episode.
      gamma (float): Discount factor [0,1]
      tau (float): Weight coefficient for the entropy regularizaiton term.
      phi (callable): Feature extractor function
      pi_loss_coef (float): Weight coefficient for the loss of the policy
      v_loss_coef (float): Weight coefficient for the loss of the value
          function
      rollout_len (int): Number of rollout steps
      batchsize (int): Number of episodes or sub-trajectories used for an
          update. The total number of transitions used will be
          (batchsize x t_max).
      disable_online_update (bool): If set true, disable online on-policy
          update and rely only on experience replay.
      n_times_replay (int): Number of times experience replay is repeated per
          one time of online update.
      replay_start_size (int): Experience replay is disabled if the number of
          transitions in the replay buffer is lower than this value.
      normalize_loss_by_steps (bool): If set true, losses are normalized by
          the number of steps taken to accumulate the losses
      act_deterministically (bool): If set true, choose most probable actions
          in act method.
      average_loss_decay (float): Decay rate of average loss. Used only
          to record statistics.
      average_entropy_decay (float): Decay rate of average entropy. Used only
          to record statistics.
      average_value_decay (float): Decay rate of average value. Used only
          to record statistics.
      explorer (Explorer or None): If not None, this explorer is used for
          selecting actions.
      logger (None or Logger): Logger to be used
      batch_states (callable): Method which makes a batch of observations.
          default is `chainerrl.misc.batch_states.batch_states`
      backprop_future_values (bool): If set True, value gradients are
          computed not only wrt V(s_t) but also V(s_{t+d}).
      train_async (bool): If set True, use a process-local model to compute
          gradients and update the globally shared model.
code: def stop_episode(self):
      if isinstance(self.model, Recurrent):
          self.model.reset_state()
  
imports: import copy
  from logging import getLogger
  import chainer
  from chainer import functions
  import chainerrl
  from chainerrl import agent
  from chainerrl.agents import a3c
  from chainerrl.misc import async_
  from chainerrl.misc.batch_states import batch_states
  from chainerrl.misc import copy_param
  from chainerrl.recurrent import Recurrent
  from chainerrl.recurrent import state_kept
  from chainerrl.recurrent import state_reset
  from chainerrl.replay_buffer import batch_experiences
label_desc: Use image node_id 11 for calling the PCL obj's underlying member method code with example usage: obj.stop_episode() without return types