# 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 benchmark RL agent with RSL-RL.""" """Launch Isaac Sim Simulator first.""" import argparse import contextlib import os import sys import time from isaaclab.app import AppLauncher from isaaclab_tasks.utils import setup_preset_cli from scripts.benchmarks.early_stop import ( RslRlEarlyStopWrapper, add_success_cli_args, build_success_kwargs, get_success_tracker, ) sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), "../..")) import scripts.reinforcement_learning.rsl_rl.cli_args as cli_args # isort: skip # add argparse arguments parser = argparse.ArgumentParser(description="Train an RL agent with RSL-RL.") 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=4096, help="Number of environments to simulate.") parser.add_argument("--task", type=str, default=None, help="Name of the task.") parser.add_argument("--seed", type=int, default=42, help="Seed used for the environment") parser.add_argument("--max_iterations", type=int, default=10, help="RL Policy training iterations.") parser.add_argument( "--distributed", action="store_true", default=False, help="Run training with multiple GPUs or nodes." ) parser.add_argument( "--benchmark_backend", type=str, default="omniperf", choices=[ "json", "osmo", "omniperf", "summary", "LocalLogMetrics", "JSONFileMetrics", "OsmoKPIFile", "OmniPerfKPIFile", ], help="Benchmarking backend options, defaults omniperf", ) parser.add_argument("--output_path", type=str, default=".", help="Path to output benchmark results.") parser.add_argument( "--reward_threshold", type=float, default=None, help="Reward threshold for convergence (overrides config)." ) parser.add_argument( "--check_convergence", action="store_true", help="Check reward convergence using thresholds from configs.yaml." ) parser.add_argument( "--convergence_config", type=str, default="full", help="Config mode for convergence thresholds (default: full)." ) add_success_cli_args(parser) # append RSL-RL cli arguments cli_args.add_rsl_rl_args(parser) # append AppLauncher cli args AppLauncher.add_app_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 imports_time_begin = time.perf_counter_ns() import importlib.metadata as metadata from datetime import datetime import gymnasium as gym import numpy as np import torch from rsl_rl.runners import OnPolicyRunner from isaaclab.envs import DirectMARLEnvCfg, DirectRLEnvCfg, ManagerBasedRLEnvCfg from isaaclab.utils.dict import print_dict from isaaclab.utils.io import dump_yaml from isaaclab_rl.rsl_rl import RslRlOnPolicyRunnerCfg, RslRlVecEnvWrapper, handle_deprecated_rsl_rl_cfg import isaaclab_tasks # noqa: F401 # PLACEHOLDER: Extension template (do not remove this comment) with contextlib.suppress(ImportError): import isaaclab_tasks_experimental # noqa: F401 from isaaclab_tasks.utils import get_checkpoint_path, launch_simulation, resolve_task_config imports_time_end = time.perf_counter_ns() from isaaclab.test.benchmark import BaseIsaacLabBenchmark, BenchmarkMonitor from isaaclab.utils.timer import Timer from scripts.benchmarks.utils import ( get_backend_type, get_preset_string, log_app_start_time, log_python_imports_time, log_rl_training_metrics, log_runtime_step_times, log_scene_creation_time, log_simulation_start_time, log_success, log_task_start_time, log_total_start_time, parse_tf_logs, ) torch.backends.cuda.matmul.allow_tf32 = True torch.backends.cudnn.allow_tf32 = True torch.backends.cudnn.deterministic = False torch.backends.cudnn.benchmark = False # Create the benchmark backend_type = get_backend_type(args_cli.benchmark_backend) benchmark = BaseIsaacLabBenchmark( benchmark_name="benchmark_rsl_rl_train", backend_type=backend_type, output_path=args_cli.output_path, use_recorders=True, frametime_recorders=backend_type in ("summary", "omniperf"), output_prefix=f"benchmark_rsl_rl_train_{args_cli.task}", workflow_metadata={ "metadata": [ {"name": "task", "data": args_cli.task}, {"name": "seed", "data": args_cli.seed}, {"name": "num_envs", "data": args_cli.num_envs}, {"name": "max_iterations", "data": args_cli.max_iterations}, {"name": "presets", "data": get_preset_string(hydra_args)}, ] }, ) def main( env_cfg: ManagerBasedRLEnvCfg | DirectRLEnvCfg | DirectMARLEnvCfg, agent_cfg: RslRlOnPolicyRunnerCfg, app_start_time_begin: int, app_start_time_end: int, ): """Train with RSL-RL agent.""" # parse configuration # override configurations with non-hydra CLI arguments agent_cfg = cli_args.update_rsl_rl_cfg(agent_cfg, args_cli) env_cfg.scene.num_envs = args_cli.num_envs if args_cli.num_envs is not None else env_cfg.scene.num_envs agent_cfg.max_iterations = ( args_cli.max_iterations if args_cli.max_iterations is not None else agent_cfg.max_iterations ) # set the environment seed # note: certain randomizations occur in the environment initialization so we set the seed here env_cfg.seed = agent_cfg.seed # 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 # check for invalid combination of CPU device with distributed training 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 configuration # env_cfg.sim.device is already resolved by launch_simulation(). world_rank = 0 world_size = 1 if args_cli.distributed: agent_cfg.device = env_cfg.sim.device # use global rank for seed diversity across all nodes world_rank = int(os.getenv("RANK", "0")) seed = agent_cfg.seed + world_rank env_cfg.seed = seed agent_cfg.seed = seed world_size = int(os.getenv("WORLD_SIZE", 1)) # specify directory for logging experiments log_root_path = os.path.join("logs", "rsl_rl", agent_cfg.experiment_name) log_root_path = os.path.abspath(log_root_path) print(f"[INFO] Logging experiment in directory: {log_root_path}") # specify directory for logging runs: {time-stamp}_{run_name} log_dir = datetime.now().strftime("%Y-%m-%d_%H-%M-%S") if agent_cfg.run_name: log_dir += f"_{agent_cfg.run_name}" log_dir = os.path.join(log_root_path, log_dir) # max iterations for training if args_cli.max_iterations: agent_cfg.max_iterations = args_cli.max_iterations task_startup_time_begin = time.perf_counter_ns() # create isaac environment env = gym.make(args_cli.task, cfg=env_cfg, render_mode="rgb_array" if args_cli.video else None) # wrap for video recording if args_cli.video: video_kwargs = { "video_folder": os.path.join(log_dir, "videos"), "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) # wrap around environment for rsl-rl env = RslRlVecEnvWrapper(env) task_startup_time_end = time.perf_counter_ns() # handle deprecated configurations (e.g. legacy policy -> actor/critic migration) agent_cfg = handle_deprecated_rsl_rl_cfg(agent_cfg, metadata.version("rsl-rl-lib")) # create runner from rsl-rl runner = OnPolicyRunner(env, agent_cfg.to_dict(), log_dir=log_dir, device=agent_cfg.device) # write git state to logs runner.add_git_repo_to_log(__file__) # save resume path before creating a new log_dir if agent_cfg.resume: # get path to previous checkpoint resume_path = get_checkpoint_path(log_root_path, agent_cfg.load_run, agent_cfg.load_checkpoint) print(f"[INFO]: Loading model checkpoint from: {resume_path}") # load previously trained model runner.load(resume_path) # set seed of the environment env.seed(agent_cfg.seed) # 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) # always track the success metric; early-stop only if --check_success early_stop_ctx = RslRlEarlyStopWrapper( env, runner, num_steps_per_env=agent_cfg.num_steps_per_env, **build_success_kwargs(args_cli) ) # run training with continuous benchmark monitoring with early_stop_ctx, BenchmarkMonitor(benchmark, interval=1.0): runner.learn(num_learning_iterations=agent_cfg.max_iterations, init_at_random_ep_len=True) if world_rank == 0: # Final update after training completes benchmark.update_manual_recorders() # parse tensorboard file stats log_data = parse_tf_logs(log_dir) # prepare RL timing dict collection_fps = ( 1 / (np.array(log_data["Perf/collection_time"])) * env.unwrapped.num_envs * agent_cfg.num_steps_per_env * world_size ) rl_training_times = { "Collection Time": (np.array(log_data["Perf/collection_time"]) / 1000).tolist(), "Learning Time": (np.array(log_data["Perf/learning_time"]) / 1000).tolist(), "Collection FPS": collection_fps.tolist(), "Total FPS": log_data["Perf/total_fps"] * world_size, } # log additional metrics to benchmark services log_app_start_time(benchmark, (app_start_time_end - app_start_time_begin) / 1e6) log_python_imports_time(benchmark, (imports_time_end - imports_time_begin) / 1e6) log_task_start_time(benchmark, (task_startup_time_end - task_startup_time_begin) / 1e6) log_scene_creation_time(benchmark, Timer.get_timer_info("scene_creation") * 1000) log_simulation_start_time(benchmark, Timer.get_timer_info("simulation_start") * 1000) log_total_start_time(benchmark, (task_startup_time_end - app_start_time_begin) / 1e6) log_runtime_step_times(benchmark, rl_training_times, compute_stats=True) log_rl_training_metrics( benchmark, log_data, reward_tag="Train/mean_reward", episode_length_tag="Train/mean_episode_length", task=args_cli.task, workflow="rsl_rl", should_check_convergence=args_cli.check_convergence, reward_threshold=args_cli.reward_threshold, convergence_config=args_cli.convergence_config, ) tracker = get_success_tracker(args_cli, early_stop_ctx.tracker, log_data) log_success(benchmark, tracker, framework_iteration_count=early_stop_ctx.framework_iteration_count) benchmark._finalize_impl() # close the simulator env.close() if __name__ == "__main__": env_cfg, agent_cfg = resolve_task_config(args_cli.task, "rsl_rl_cfg_entry_point") app_start_time_begin = time.perf_counter_ns() with launch_simulation(env_cfg, args_cli): app_start_time_end = time.perf_counter_ns() main(env_cfg, agent_cfg, app_start_time_begin, app_start_time_end)