code: def dqn_pong(
      ctxt=None, seed=1, buffer_size=int(5e4), max_episode_length=500
  ):
      """Train DQN on PongNoFrameskip-v4 environment.
  
      Args:
          ctxt (garage.experiment.ExperimentContext): The experiment
              configuration used by Trainer to create the snapshotter.
          seed (int): Used to seed the random number generator to produce
              determinism.
          buffer_size (int): Number of timesteps to store in replay buffer.
          max_episode_length (int): Maximum length of an episode, after which an
              episode is considered complete. This is used during testing to
              minimize the memory required to store a single episode.
  
      """
      set_seed(seed)
      with TFTrainer(ctxt) as trainer:
          n_epochs = 100
          steps_per_epoch = 20
          sampler_batch_size = 500
          num_timesteps = (
              n_epochs * steps_per_epoch * sampler_batch_size
          )
  
          env = gym.make("PongNoFrameskip-v4")
          env = env.unwrapped
          env = Noop(env, noop_max=30)
          env = MaxAndSkip(env, skip=4)
          env = EpisodicLife(env)
          if "FIRE" in env.unwrapped.get_action_meanings():
              env = FireReset(env)
          env = Grayscale(env)
          env = Resize(env, 84, 84)
          env = ClipReward(env)
          env = StackFrames(env, 4)
  
          env = GymEnv(
              env, is_image=True, max_episode_length=max_episode_length
          )
  
          replay_buffer = PathBuffer(
              capacity_in_transitions=buffer_size
          )
  
          qf = DiscreteCNNQFunction(
              env_spec=env.spec,
              filters=(
                  (32, (8, 8)),
                  (64, (4, 4)),
                  (64, (3, 3)),
              ),
              strides=(4, 2, 1),
              dueling=False,
          )  # yapf: disable
  
          policy = DiscreteQFArgmaxPolicy(env_spec=env.spec, qf=qf)
          exploration_policy = EpsilonGreedyPolicy(
              env_spec=env.spec,
              policy=policy,
              total_timesteps=num_timesteps,
              max_epsilon=1.0,
              min_epsilon=0.02,
              decay_ratio=0.1,
          )
  
          sampler = LocalSampler(
              agents=exploration_policy,
              envs=env,
              max_episode_length=env.spec.max_episode_length,
              is_tf_worker=True,
              worker_class=FragmentWorker,
          )
  
          algo = DQN(
              env_spec=env.spec,
              policy=policy,
              qf=qf,
              exploration_policy=exploration_policy,
              replay_buffer=replay_buffer,
              sampler=sampler,
              qf_lr=1e-4,
              discount=0.99,
              min_buffer_size=int(1e4),
              double_q=False,
              n_train_steps=500,
              steps_per_epoch=steps_per_epoch,
              target_network_update_freq=2,
              buffer_batch_size=32,
          )
  
          trainer.setup(algo, env)
          trainer.train(
              n_epochs=n_epochs, batch_size=sampler_batch_size
          )
  
imports: import click
  import gym
  from garage import wrap_experiment
  from garage.envs import GymEnv
  from garage.envs.wrappers.clip_reward import ClipReward
  from garage.envs.wrappers.episodic_life import EpisodicLife
  from garage.envs.wrappers.fire_reset import FireReset
  from garage.envs.wrappers.grayscale import Grayscale
  from garage.envs.wrappers.max_and_skip import MaxAndSkip
  from garage.envs.wrappers.noop import Noop
  from garage.envs.wrappers.resize import Resize
  from garage.envs.wrappers.stack_frames import StackFrames
  from garage.experiment.deterministic import set_seed
  from garage.np.exploration_policies import EpsilonGreedyPolicy
  from garage.replay_buffer import PathBuffer
  from garage.sampler import FragmentWorker, LocalSampler
  from garage.tf.algos import DQN
  from garage.tf.policies import DiscreteQFArgmaxPolicy
  from garage.tf.q_functions import DiscreteCNNQFunction
  from garage.trainer import TFTrainer
label_desc: Use image node_id 1 for calling a global function with example usage: dqn_pong(ctxt, seed, buffer_size, max_episode_length) without return types