# Copyright (c) 2022-2026, The Isaac Lab Project Developers (https://github.com/isaac-sim/IsaacLab/blob/main/CONTRIBUTORS.md). # All rights reserved. # # SPDX-License-Identifier: BSD-3-Clause """ Script to train RL agent with skrl. Visit the skrl documentation (https://skrl.readthedocs.io) to see the examples structured in a more user-friendly way. """ import warnings warnings.warn( "scripts/reinforcement_learning/skrl/train.py is deprecated. Use " "`./isaaclab.sh train --rl_library skrl --task ` instead. " "Example: `./isaaclab.sh train --rl_library skrl --task Isaac-Cartpole-v0`.", DeprecationWarning, stacklevel=1, ) import argparse import contextlib import logging import os import random import sys import time from datetime import datetime import gymnasium as gym import skrl from packaging import version from isaaclab.envs import DirectMARLEnvCfg, ManagerBasedRLEnvCfg from isaaclab.utils.assets import retrieve_file_path from isaaclab.utils.dict import print_dict from isaaclab.utils.io import dump_yaml from isaaclab.utils.seed import configure_seed from isaaclab_rl.skrl import SkrlVecEnvWrapper import isaaclab_tasks # noqa: F401 from isaaclab_tasks.utils import ( add_launcher_args, launch_simulation, resolve_task_config, setup_preset_cli, ) logger = logging.getLogger(__name__) # PLACEHOLDER: Extension template (do not remove this comment) with contextlib.suppress(ImportError): import isaaclab_tasks_experimental # noqa: F401 SKRL_VERSION = "2.1.0" # -- argparse ---------------------------------------------------------------- parser = argparse.ArgumentParser(description="Train an RL agent with skrl.") parser.add_argument("--video", action="store_true", default=False, help="Record videos during training.") parser.add_argument("--video_length", type=int, default=200, help="Length of the recorded video (in steps).") parser.add_argument("--video_interval", type=int, default=2000, help="Interval between video recordings (in steps).") parser.add_argument("--num_envs", type=int, default=None, help="Number of environments to simulate.") parser.add_argument("--task", type=str, default=None, help="Name of the task.") parser.add_argument( "--agent", type=str, default=None, help=( "Name of the RL agent configuration entry point. Defaults to None, in which case the argument " "--algorithm is used to determine the default agent configuration entry point." ), ) parser.add_argument("--seed", type=int, default=None, help="Seed used for the environment") parser.add_argument( "--distributed", action="store_true", default=False, help="Run training with multiple GPUs or nodes." ) parser.add_argument("--checkpoint", type=str, default=None, help="Path to model checkpoint to resume training.") parser.add_argument("--max_iterations", type=int, default=None, help="RL Policy training iterations.") parser.add_argument("--export_io_descriptors", action="store_true", default=False, help="Export IO descriptors.") parser.add_argument( "--ml_framework", type=str, default="torch", choices=["torch", "jax"], help="The ML framework used for training the skrl agent.", ) parser.add_argument( "--algorithm", type=str, default="PPO", choices=["AMP", "PPO", "IPPO", "MAPPO"], help="The RL algorithm used for training the skrl agent.", ) parser.add_argument( "--ray-proc-id", "-rid", type=int, default=None, help="Automatically configured by Ray integration, otherwise None." ) add_launcher_args(parser) args_cli, hydra_args = setup_preset_cli(parser) sys.argv = [sys.argv[0]] + hydra_args if args_cli.video: args_cli.enable_cameras = True # -- check skrl version ------------------------------------------------------ if version.parse(skrl.__version__) < version.parse(SKRL_VERSION): skrl.logger.error( f"Unsupported skrl version: {skrl.__version__}. " f"Install supported version using 'pip install skrl>={SKRL_VERSION}'" ) exit() # config shortcuts if args_cli.agent is None: algorithm = args_cli.algorithm.lower() agent_cfg_entry_point = "skrl_cfg_entry_point" if algorithm in ["ppo"] else f"skrl_{algorithm}_cfg_entry_point" else: agent_cfg_entry_point = args_cli.agent algorithm = agent_cfg_entry_point.split("_cfg")[0].split("skrl_")[-1].lower() def main(): """Train with skrl agent.""" env_cfg, agent_cfg = resolve_task_config(args_cli.task, agent_cfg_entry_point) with launch_simulation(env_cfg, args_cli): if args_cli.ml_framework.startswith("torch"): from skrl.utils.runner.torch import Runner elif args_cli.ml_framework.startswith("jax"): from skrl.utils.runner.jax import Runner # override configurations with non-hydra CLI arguments env_cfg.scene.num_envs = args_cli.num_envs if args_cli.num_envs is not None else env_cfg.scene.num_envs # For distributed training, launch_simulation() already resolved the # correct per-rank device; only apply a CLI --device override for # non-distributed runs (the default "cuda:0" would clobber the # per-rank device otherwise). if not args_cli.distributed: env_cfg.sim.device = args_cli.device if args_cli.device is not None else env_cfg.sim.device if args_cli.distributed and args_cli.device is not None and "cpu" in args_cli.device: raise ValueError( "Distributed training is not supported when using CPU device. " "Please use GPU device (e.g., --device cuda) for distributed training." ) # multi-gpu training config if args_cli.distributed: global_rank = int(os.getenv("RANK", "0")) # env_cfg.sim.device is resolved by launch_simulation() which # accounts for CUDA_VISIBLE_DEVICES restrictions. # max iterations for training if args_cli.max_iterations: agent_cfg["trainer"]["timesteps"] = args_cli.max_iterations * agent_cfg["agent"]["rollouts"] agent_cfg["trainer"]["close_environment_at_exit"] = False # configure the ML framework into the global skrl variable if args_cli.ml_framework.startswith("jax"): skrl.config.jax.backend = "jax" if args_cli.ml_framework == "jax" else "numpy" # randomly sample a seed if seed = -1 if args_cli.seed == -1: args_cli.seed = random.randint(0, 10000) # set the agent and environment seed from command line agent_cfg["seed"] = args_cli.seed if args_cli.seed is not None else agent_cfg["seed"] # use global rank for seed diversity across all nodes if args_cli.distributed: agent_cfg["seed"] = agent_cfg["seed"] + global_rank env_cfg.seed = agent_cfg["seed"] # specify directory for logging experiments log_root_path = os.path.join("logs", "skrl", agent_cfg["agent"]["experiment"]["directory"]) log_root_path = os.path.abspath(log_root_path) print(f"[INFO] Logging experiment in directory: {log_root_path}") log_dir = datetime.now().strftime("%Y-%m-%d_%H-%M-%S") + f"_{algorithm}_{args_cli.ml_framework}" print(f"Exact experiment name requested from command line: {log_dir}") if agent_cfg["agent"]["experiment"]["experiment_name"]: log_dir += f"_{agent_cfg['agent']['experiment']['experiment_name']}" agent_cfg["agent"]["experiment"]["directory"] = log_root_path agent_cfg["agent"]["experiment"]["experiment_name"] = log_dir log_dir = os.path.join(log_root_path, log_dir) # dump the configuration into log-directory dump_yaml(os.path.join(log_dir, "params", "env.yaml"), env_cfg) dump_yaml(os.path.join(log_dir, "params", "agent.yaml"), agent_cfg) # get checkpoint path (to resume training) resume_path = retrieve_file_path(args_cli.checkpoint) if args_cli.checkpoint else None # set the IO descriptors export flag if requested if isinstance(env_cfg, ManagerBasedRLEnvCfg): env_cfg.export_io_descriptors = args_cli.export_io_descriptors else: logger.warning( "IO descriptors are only supported for manager based RL environments." " No IO descriptors will be exported." ) # set the log directory for the environment env_cfg.log_dir = log_dir # create isaac environment env = gym.make(args_cli.task, cfg=env_cfg, render_mode="rgb_array" if args_cli.video else None) # convert to single-agent instance if required by the RL algorithm if isinstance(env.unwrapped.cfg, DirectMARLEnvCfg) and algorithm in ["ppo"]: from isaaclab.envs import multi_agent_to_single_agent env = multi_agent_to_single_agent(env) # wrap for video recording if args_cli.video: video_kwargs = { "video_folder": os.path.join(log_dir, "videos", "train"), "step_trigger": lambda step: step % args_cli.video_interval == 0, "video_length": args_cli.video_length, "disable_logger": True, } print("[INFO] Recording videos during training.") print_dict(video_kwargs, nesting=4) env = gym.wrappers.RecordVideo(env, **video_kwargs) start_time = time.time() # wrap around environment for skrl env = SkrlVecEnvWrapper(env, ml_framework=args_cli.ml_framework) # configure and instantiate the skrl runner runner = Runner(env, agent_cfg) # configure_seed must be called after Runner() so that PyTorch deterministic settings # do not interfere with Runner's internal initialization. if args_cli.deterministic: configure_seed(env_cfg.seed, True) # load checkpoint (if specified) if resume_path: print(f"[INFO] Loading model checkpoint from: {resume_path}") runner.agent.load(resume_path) # run training try: runner.run() print(f"Training time: {round(time.time() - start_time, 2)} seconds") # skrl only saves checkpoints at checkpoint_interval multiples during training, # so save a final checkpoint to ensure at least one always exists total_timesteps = agent_cfg["trainer"]["timesteps"] os.makedirs(os.path.join(log_dir, "checkpoints"), exist_ok=True) runner.agent.write_checkpoint(timestep=total_timesteps, timesteps=total_timesteps) print(f"[INFO] Saved final agent checkpoint to: {log_dir}/checkpoints") # close the simulator env.close() except KeyboardInterrupt: pass if __name__ == "__main__": main()