code: def main():
      import logging
  
      logging.basicConfig(level=logging.DEBUG)
  
      parser = argparse.ArgumentParser()
      parser.add_argument(
          "--outdir",
          type=str,
          default="results",
          help="Directory path to save output files."
          " If it does not exist, it will be created.",
      )
      parser.add_argument("--env", type=str, default="Humanoid-v2")
      parser.add_argument(
          "--seed", type=int, default=0, help="Random seed [0, 2 ** 32)"
      )
      parser.add_argument("--gpu", type=int, default=0)
      parser.add_argument(
          "--final-exploration-steps", type=int, default=10**6
      )
      parser.add_argument("--actor-lr", type=float, default=1e-4)
      parser.add_argument("--critic-lr", type=float, default=1e-3)
      parser.add_argument("--load", type=str, default="")
      parser.add_argument("--steps", type=int, default=10**7)
      parser.add_argument("--n-hidden-channels", type=int, default=300)
      parser.add_argument("--n-hidden-layers", type=int, default=3)
      parser.add_argument("--replay-start-size", type=int, default=5000)
      parser.add_argument("--n-update-times", type=int, default=1)
      parser.add_argument(
          "--target-update-interval", type=int, default=1
      )
      parser.add_argument(
          "--target-update-method",
          type=str,
          default="soft",
          choices=["hard", "soft"],
      )
      parser.add_argument("--soft-update-tau", type=float, default=1e-2)
      parser.add_argument("--update-interval", type=int, default=4)
      parser.add_argument("--eval-n-runs", type=int, default=100)
      parser.add_argument("--eval-interval", type=int, default=10**5)
      parser.add_argument("--gamma", type=float, default=0.995)
      parser.add_argument("--minibatch-size", type=int, default=200)
      parser.add_argument("--render", action="store_true")
      parser.add_argument("--demo", action="store_true")
      parser.add_argument(
          "--use-bn", action="store_true", default=False
      )
      parser.add_argument("--monitor", action="store_true")
      parser.add_argument(
          "--reward-scale-factor", type=float, default=1e-2
      )
      parser.add_argument("--num-envs", type=int, default=1)
      args = parser.parse_args()
  
      args.outdir = experiments.prepare_output_dir(
          args, args.outdir, argv=sys.argv
      )
      print("Output files are saved in {}".format(args.outdir))
  
      # Set a random seed used in ChainerRL
      misc.set_random_seed(args.seed, gpus=(args.gpu,))
  
      def clip_action_filter(a):
          return np.clip(a, action_space.low, action_space.high)
  
      def reward_filter(r):
          return r * args.reward_scale_factor
  
      # Set different random seeds for different subprocesses.
      # If seed=0 and processes=4, subprocess seeds are [0, 1, 2, 3].
      # If seed=1 and processes=4, subprocess seeds are [4, 5, 6, 7].
      process_seeds = (
          np.arange(args.num_envs) + args.seed * args.num_envs
      )
      assert process_seeds.max() < 2**32
  
      def make_env(idx, test):
          env = gym.make(args.env)
          # Use different random seeds for train and test envs
          process_seed = int(process_seeds[idx])
          env_seed = (
              2**32 - 1 - process_seed if test else process_seed
          )
          env.seed(env_seed)
          # Cast observations to float32 because our model uses float32
          env = chainerrl.wrappers.CastObservationToFloat32(env)
          if args.monitor:
              env = chainerrl.wrappers.Monitor(env, args.outdir)
          if isinstance(env.action_space, spaces.Box):
              misc.env_modifiers.make_action_filtered(
                  env, clip_action_filter
              )
          if not test:
              # Scale rewards (and thus returns) to a reasonable range so that
              # training is easier
              env = chainerrl.wrappers.ScaleReward(
                  env, args.reward_scale_factor
              )
          if args.render and not test:
              env = chainerrl.wrappers.Render(env)
          return env
  
      def make_batch_env(test):
          return chainerrl.envs.MultiprocessVectorEnv(
              [
                  functools.partial(make_env, idx, test)
                  for idx, env in enumerate(range(args.num_envs))
              ]
          )
  
      sample_env = make_env(0, test=False)
      timestep_limit = sample_env.spec.max_episode_steps
  
      obs_size = np.asarray(sample_env.observation_space.shape).prod()
      action_space = sample_env.action_space
  
      action_size = np.asarray(action_space.shape).prod()
      if args.use_bn:
          q_func = q_functions.FCBNLateActionSAQFunction(
              obs_size,
              action_size,
              n_hidden_channels=args.n_hidden_channels,
              n_hidden_layers=args.n_hidden_layers,
              normalize_input=True,
          )
          pi = policy.FCBNDeterministicPolicy(
              obs_size,
              action_size=action_size,
              n_hidden_channels=args.n_hidden_channels,
              n_hidden_layers=args.n_hidden_layers,
              min_action=action_space.low,
              max_action=action_space.high,
              bound_action=True,
              normalize_input=True,
          )
      else:
          q_func = q_functions.FCSAQFunction(
              obs_size,
              action_size,
              n_hidden_channels=args.n_hidden_channels,
              n_hidden_layers=args.n_hidden_layers,
          )
          pi = policy.FCDeterministicPolicy(
              obs_size,
              action_size=action_size,
              n_hidden_channels=args.n_hidden_channels,
              n_hidden_layers=args.n_hidden_layers,
              min_action=action_space.low,
              max_action=action_space.high,
              bound_action=True,
          )
      model = DDPGModel(q_func=q_func, policy=pi)
      opt_a = optimizers.Adam(alpha=args.actor_lr)
      opt_c = optimizers.Adam(alpha=args.critic_lr)
      opt_a.setup(model["policy"])
      opt_c.setup(model["q_function"])
      opt_a.add_hook(chainer.optimizer.GradientClipping(1.0), "hook_a")
      opt_c.add_hook(chainer.optimizer.GradientClipping(1.0), "hook_c")
  
      rbuf = replay_buffer.ReplayBuffer(5 * 10**5)
  
      def random_action():
          a = action_space.sample()
          if isinstance(a, np.ndarray):
              a = a.astype(np.float32)
          return a
  
      ou_sigma = (action_space.high - action_space.low) * 0.2
      explorer = explorers.AdditiveOU(sigma=ou_sigma)
      agent = DDPG(
          model,
          opt_a,
          opt_c,
          rbuf,
          gamma=args.gamma,
          explorer=explorer,
          replay_start_size=args.replay_start_size,
          target_update_method=args.target_update_method,
          target_update_interval=args.target_update_interval,
          update_interval=args.update_interval,
          soft_update_tau=args.soft_update_tau,
          n_times_update=args.n_update_times,
          gpu=args.gpu,
          minibatch_size=args.minibatch_size,
      )
  
      if len(args.load) > 0:
          agent.load(args.load)
  
      if args.demo:
          eval_stats = experiments.eval_performance(
              env=make_batch_env(test=True),
              agent=agent,
              n_steps=None,
              n_episodes=args.eval_n_runs,
              max_episode_len=timestep_limit,
          )
          print(
              "n_runs: {} mean: {} median: {} stdev {}".format(
                  args.eval_n_runs,
                  eval_stats["mean"],
                  eval_stats["median"],
                  eval_stats["stdev"],
              )
          )
      else:
          experiments.train_agent_batch_with_evaluation(
              agent=agent,
              env=make_batch_env(test=False),
              steps=args.steps,
              eval_env=make_batch_env(test=True),
              eval_n_steps=None,
              eval_n_episodes=args.eval_n_runs,
              eval_interval=args.eval_interval,
              outdir=args.outdir,
              max_episode_len=timestep_limit,
          )
  
file_path: chainerrl/examples/mujoco/train_ddpg_batch_gym.py
imports: import argparse
  import functools
  import sys
  import chainer
  from chainer import optimizers
  import gym
  from gym import spaces
  import numpy
  import chainerrl
  from chainerrl.agents.ddpg import DDPG
  from chainerrl.agents.ddpg import DDPGModel
  from chainerrl import experiments
  from chainerrl import explorers
  from chainerrl import misc
  from chainerrl import policy
  from chainerrl import q_functions
  from chainerrl import replay_buffer
label_desc: Use image node_id 1 for calling a global function with example usage: main() and returns: np, unknown, env, chainerrl, a