#!/usr/bin/env python """Run the project-owned, headless π0.5 LIBERO-10 Task 0 evaluator. The model is loaded once per invocation. Each completed episode is written to an atomic JSON file so a later invocation can resume without changing prior results. Video is intentionally unsupported in this formal baseline runner; the protocol requires it to remain disabled. """ from __future__ import annotations import argparse import datetime as dt import hashlib import json import os import random import shlex import sys import time import traceback from pathlib import Path from typing import Any os.environ.setdefault("MUJOCO_GL", "egl") os.environ.setdefault("PYOPENGL_PLATFORM", "egl") os.environ.setdefault("LIBERO_TYPE", "standard") import numpy as np from omegaconf import DictConfig, OmegaConf SCRIPT_DIR = Path(__file__).resolve().parent PROJECT_ROOT = SCRIPT_DIR.parent for import_root in (PROJECT_ROOT / "third_party" / "RLinf", PROJECT_ROOT / "third_party" / "openpi" / "src"): if str(import_root) not in sys.path: sys.path.insert(0, str(import_root)) if str(SCRIPT_DIR) not in sys.path: sys.path.insert(0, str(SCRIPT_DIR)) from task0_baseline_common import ( # noqa: E402 RESULT_SCHEMA_VERSION, atomic_json_dump, episode_seed, expected_keys, load_config, load_episode_records, parse_int_spec, protocol_hash, require_project_path, sha256_file, validate_episode_record, write_resolved_config, ) RLLINF_COMMIT = "0505431899574619da86f551bad70b71e0ea2177" OPENPI_COMMIT = "c5dc4b9296a1a4739bf52828f28a579f12dce763" LIBERO_COMMIT = "0c5e40cc4ae63e09c14e7df6f74481e9ee8585f7" def _parse_args() -> argparse.Namespace: parser = argparse.ArgumentParser() parser.add_argument("--config", type=Path, required=True) parser.add_argument("--output-dir", type=Path, required=True) parser.add_argument("--seeds", default=None) parser.add_argument("--trial-ids", default=None) parser.add_argument("--max-episodes-per-invocation", type=int, default=None) parser.add_argument("--device", default="cuda") parser.add_argument("--resume", action="store_true") parser.add_argument("--overwrite", action="store_true") parser.add_argument("--dry-run", action="store_true") return parser.parse_args() def _model_option(model: DictConfig, key: str, default: Any) -> Any: """Read an option from model.openpi first, then model, preserving old configs.""" nested = model.get("openpi") if nested is not None and key in nested: return nested[key] return model.get(key, default) def _model_cfg(cfg: DictConfig, model_path: Path) -> DictConfig: model = cfg.model model_type = str(model.model_type) openpi_cfg = { "config_name": str(model.config_name), "num_images_in_input": 2, "noise_level": float(model.noise_level), "action_chunk": int(model.executed_action_chunk), "num_steps": int(model.denoise_steps), "train_expert_only": bool(_model_option(model, "train_expert_only", model_type != "cfg_model")), "action_env_dim": int(model.action_dim), "noise_method": str(model.noise_method), "add_value_head": False, "value_after_vlm": False, "value_vlm_mode": "mean_token", "detach_critic_input": None, } # CFG-only fields are ignored by the regular OpenPI builder and are kept # here so the same evaluator can load a project-owned cfg_model checkpoint. if model_type == "cfg_model": openpi_cfg.update( { "cfgrl_guidance_scale": float(_model_option(model, "cfgrl_guidance_scale", 1.0)), "unconditional_prob": float(_model_option(model, "unconditional_prob", 0.1)), "guidance_type": str(_model_option(model, "guidance_type", "positive")), "positive_only_conditional": bool(_model_option(model, "positive_only_conditional", True)), } ) return OmegaConf.create( { "model_type": model_type, "model_path": str(model_path), "precision": None, "load_to_device": False, "is_lora": False, "lora_rank": 32, "num_action_chunks": int(model.executed_action_chunk), "action_dim": int(model.action_dim), "use_proprio": bool(model.use_proprio), "num_steps": int(model.denoise_steps), "add_value_head": False, "openpi": openpi_cfg, } ) def _env_observation(raw: dict[str, Any], prompt: str, quat2axisangle) -> dict[str, Any]: main_image = np.asarray(raw["agentview_image"])[::-1, ::-1].copy() wrist_image = np.asarray(raw["robot0_eye_in_hand_image"])[::-1, ::-1].copy() state = np.concatenate( [ np.asarray(raw["robot0_eef_pos"]), quat2axisangle(np.asarray(raw["robot0_eef_quat"]).copy()), np.asarray(raw["robot0_gripper_qpos"]), ] ).astype(np.float32) import torch return { "main_images": torch.from_numpy(main_image[None]), "wrist_images": torch.from_numpy(wrist_image[None]), "extra_view_images": None, "states": torch.from_numpy(state[None]), "task_descriptions": [prompt], } def _step_result(result: tuple[Any, ...]) -> tuple[dict[str, Any], float, bool]: if len(result) == 4: obs, reward, done, _info = result return obs, float(reward), bool(done) obs, reward, terminated, truncated, _info = result return obs, float(reward), bool(terminated or truncated) def _seed_everything(value: int) -> None: random.seed(value) np.random.seed(value) os.environ["PYTHONHASHSEED"] = str(value) import torch torch.manual_seed(value) if torch.cuda.is_available(): torch.cuda.manual_seed_all(value) torch.backends.cudnn.benchmark = False def _gpu_memory() -> dict[str, int | None]: import torch if not torch.cuda.is_available(): return {"allocated": None, "reserved": None, "peak_allocated": None} return { "allocated": int(torch.cuda.memory_allocated()), "reserved": int(torch.cuda.memory_reserved()), "peak_allocated": int(torch.cuda.max_memory_allocated()), } def _observation_hash(observation: dict[str, Any]) -> str: digest = hashlib.sha256() for key in ("main_images", "wrist_images", "states"): value = observation.get(key) if value is None: continue digest.update(key.encode("utf-8")) digest.update(value.detach().cpu().contiguous().numpy().tobytes()) digest.update(json.dumps(observation.get("task_descriptions"), ensure_ascii=False).encode("utf-8")) return digest.hexdigest() def _make_env(cfg: DictConfig): from libero.libero.envs import OffScreenRenderEnv suite = _make_suite(cfg) bddl_file = suite.get_task_bddl_file_path(int(cfg.task_id)) env = OffScreenRenderEnv( bddl_file_name=bddl_file, camera_heights=int(cfg.environment.camera_height), camera_widths=int(cfg.environment.camera_width), camera_names=list(cfg.environment.camera_names), horizon=int(cfg.environment.max_episode_steps) + int(cfg.environment.reset_settle_steps) + 2, ) return suite, env def _make_suite(cfg: DictConfig): from libero.libero import benchmark return benchmark.get_benchmark_dict()[str(cfg.benchmark)]() def _reset_and_settle(env, init_state: Any, seed: int, cfg: DictConfig): if hasattr(env, "seed"): env.seed(seed) raw = env.reset() raw = env.set_init_state(init_state) zero_action = np.zeros(int(cfg.model.action_dim), dtype=np.float32) zero_action[-1] = float(cfg.environment.reset_gripper_action) for _ in range(int(cfg.environment.reset_settle_steps)): raw, _reward, _done = _step_result(env.step(zero_action)) return raw def _load_model(cfg: DictConfig, model_path: Path, device_name: str): import torch if not torch.cuda.is_available() and device_name.startswith("cuda"): raise RuntimeError("CUDA requested but torch.cuda.is_available() is false") from rlinf.models import get_model original_compile = torch.compile if not bool(cfg.model.torch_compile_enabled): torch.compile = lambda fn, *unused_args, **unused_kwargs: fn # type: ignore[assignment] try: model = get_model(_model_cfg(cfg, model_path)) finally: torch.compile = original_compile if model is None: raise RuntimeError("RLinf model registry returned no model") return model.to(torch.device(device_name)).eval() def _episode_path(root: Path, seed: int, trial_id: int) -> Path: return root / "episodes" / f"seed_{seed:03d}" / f"trial_{trial_id:02d}.json" def _record_error( *, cfg: DictConfig, cfg_hash: str, run_id: str, seed: int, trial_id: int, init_state_hash: str, retry_count: int, started: float, exc: BaseException, device_name: str, ) -> dict[str, Any]: finished = time.time() return { "schema_version": RESULT_SCHEMA_VERSION, "protocol_version": str(cfg.protocol_version), "protocol_sha256": cfg_hash, "run_id": run_id, "policy_role": str(cfg.get("policy_role", "baseline_sft")), "benchmark": str(cfg.benchmark), "task_id": int(cfg.task_id), "task_name": "unknown", "trial_id": int(trial_id), "init_state_sha256": init_state_hash, "policy_seed": int(seed), "episode_seed": episode_seed(seed, trial_id, int(cfg.runner.episode_seed_multiplier)), "checkpoint_repo": str(cfg.model.checkpoint_repo), "checkpoint_revision": str(cfg.model.checkpoint_revision), "checkpoint_weight_sha256": str(cfg.model.checkpoint_weight_sha256), "checkpoint_local_path_relative": str(Path(cfg.model.model_path).resolve().relative_to(PROJECT_ROOT)), "rlinf_commit": RLLINF_COMMIT, "openpi_commit": OPENPI_COMMIT, "libero_commit": LIBERO_COMMIT, "max_episode_steps": int(cfg.environment.max_episode_steps), "reset_settle_steps": int(cfg.environment.reset_settle_steps), "denoise_steps": int(cfg.model.denoise_steps), "noise_level": float(cfg.model.noise_level), "num_action_chunks_executed": 0, "torch_compile_enabled": bool(cfg.model.torch_compile_enabled), "success_once": False, "success_step": None, "env_steps": 0, "raw_env_return": None, "rlinf_return": None, "status": "error", "retry_count": int(retry_count), "started_at": dt.datetime.fromtimestamp(started, dt.timezone.utc).isoformat(), "finished_at": dt.datetime.fromtimestamp(finished, dt.timezone.utc).isoformat(), "elapsed_seconds": round(finished - started, 3), "gpu_logical_id": device_name, "gpu_physical_id_if_known": os.environ.get("BASELINE_PHYSICAL_GPU"), "error_type": type(exc).__name__, "error_message": str(exc)[:1000], "video_path": None, "first_observation_sha256": None, "first_action_chunk_sha256": None, } def _run_episode(model, env, init_state: Any, task_name: str, task_prompt: str, seed: int, trial_id: int, cfg: DictConfig, device_name: str, cfg_hash: str, run_id: str, retry_count: int) -> dict[str, Any]: import torch from rlinf.envs.libero.utils import quat2axisangle started = time.time() ep_seed = episode_seed(seed, trial_id, int(cfg.runner.episode_seed_multiplier)) init_state_hash = hashlib.sha256(np.asarray(init_state).tobytes()).hexdigest() _seed_everything(ep_seed) raw = _reset_and_settle(env, init_state, ep_seed, cfg) raw_return = 0.0 success_step: int | None = None env_steps = 0 chunks = 0 success = False done = False first_observation_hash: str | None = None first_action_hash: str | None = None while env_steps < int(cfg.environment.max_episode_steps) and not done and not success: _seed_everything(ep_seed + chunks) obs = _env_observation(raw, task_prompt, quat2axisangle) if first_observation_hash is None: first_observation_hash = _observation_hash(obs) with torch.inference_mode(): actions, _ = model.predict_action_batch(env_obs=obs, mode="eval", compute_values=False) if torch.is_tensor(actions): action_chunk = actions.detach().cpu().numpy()[0] else: # cfg_model's public sampler returns a NumPy array, while the # regular OpenPI path returns a torch Tensor. action_chunk = np.asarray(actions)[0] if first_action_hash is None: first_action_hash = hashlib.sha256( np.asarray(action_chunk[: int(cfg.model.executed_action_chunk)], dtype=np.float32).tobytes() ).hexdigest() chunks += 1 for action in action_chunk[: int(cfg.model.executed_action_chunk)]: if env_steps >= int(cfg.environment.max_episode_steps): break raw, reward, done = _step_result(env.step(action.astype(np.float32))) raw_return += reward env_steps += 1 if bool(env.check_success()): success = True success_step = env_steps break finished = time.time() memory = _gpu_memory() return { "schema_version": RESULT_SCHEMA_VERSION, "protocol_version": str(cfg.protocol_version), "protocol_sha256": cfg_hash, "run_id": run_id, "policy_role": str(cfg.get("policy_role", "baseline_sft")), "benchmark": str(cfg.benchmark), "task_id": int(cfg.task_id), "task_name": task_name, "trial_id": int(trial_id), "init_state_sha256": init_state_hash, "policy_seed": int(seed), "episode_seed": ep_seed, "checkpoint_repo": str(cfg.model.checkpoint_repo), "checkpoint_revision": str(cfg.model.checkpoint_revision), "checkpoint_weight_sha256": str(cfg.model.checkpoint_weight_sha256), "checkpoint_local_path_relative": str(Path(cfg.model.model_path).resolve().relative_to(PROJECT_ROOT)), "rlinf_commit": RLLINF_COMMIT, "openpi_commit": OPENPI_COMMIT, "libero_commit": LIBERO_COMMIT, "max_episode_steps": int(cfg.environment.max_episode_steps), "reset_settle_steps": int(cfg.environment.reset_settle_steps), "denoise_steps": int(cfg.model.denoise_steps), "noise_level": float(cfg.model.noise_level), "num_action_chunks_executed": chunks, "torch_compile_enabled": bool(cfg.model.torch_compile_enabled), "success_once": bool(success), "success_step": success_step, "env_steps": env_steps, "raw_env_return": raw_return, "rlinf_return": 5.0 if success else 0.0, "status": "completed", "retry_count": int(retry_count), "started_at": dt.datetime.fromtimestamp(started, dt.timezone.utc).isoformat(), "finished_at": dt.datetime.fromtimestamp(finished, dt.timezone.utc).isoformat(), "elapsed_seconds": round(finished - started, 3), "gpu_logical_id": device_name, "gpu_physical_id_if_known": os.environ.get("BASELINE_PHYSICAL_GPU"), "error_type": None, "error_message": None, "video_path": None, "first_observation_sha256": first_observation_hash, "first_action_chunk_sha256": first_action_hash, "gpu_memory_bytes": memory, } def _write_run_metadata(root: Path, cfg: DictConfig, cfg_hash: str, run_id: str, expected: list[tuple[int, int]]) -> None: root.mkdir(parents=True, exist_ok=True) protocol_path = root / "protocol.yaml" if protocol_path.exists(): existing_hash = (root / "protocol.sha256").read_text(encoding="utf-8").strip() if (root / "protocol.sha256").exists() else "" if existing_hash and existing_hash != cfg_hash: raise RuntimeError("existing result directory uses a different protocol hash") else: write_resolved_config(protocol_path, cfg) (root / "protocol.sha256").write_text(cfg_hash + "\n", encoding="utf-8") run_manifest = root / "run_manifest.json" if not run_manifest.exists(): atomic_json_dump( run_manifest, { "protocol_version": str(cfg.protocol_version), "protocol_sha256": cfg_hash, "first_run_id": run_id, "expected_episode_count": len(expected), "expected_keys": [list(key) for key in expected], "video_enabled": bool(cfg.video.enabled), }, ) def _write_status(root: Path, cfg: DictConfig, cfg_hash: str, expected: list[tuple[int, int]]) -> None: records = load_episode_records(root, expected_protocol_hash=cfg_hash) planned = expected_keys( [int(seed) for seed in cfg.policy_seeds], [int(trial) for trial in cfg.trial_ids], ) completed = { (int(item["policy_seed"]), int(item["trial_id"])) for item in records if item["status"] == "completed" } errors = {(int(item["policy_seed"]), int(item["trial_id"])) for item in records if item["status"] == "error"} atomic_json_dump( root / "status.json", { "protocol_version": str(cfg.protocol_version), "protocol_sha256": cfg_hash, "planned_episode_count": len(planned), "completed_episode_count": len(completed), "error_episode_count": len(errors), "pending_episode_count": len(set(planned) - completed), "updated_at": dt.datetime.now(dt.timezone.utc).isoformat(), }, ) def _checkpoint_weight_path(model_path: Path) -> Path: """Find a supported local checkpoint weight file without changing old paths.""" candidates = [ model_path / "model.safetensors", model_path / "model_state_dict" / "full_weights.pt", model_path / "actor" / "model_state_dict" / "full_weights.pt", ] candidates.extend(sorted(model_path.rglob("*.safetensors"))) candidates.extend(sorted(model_path.rglob("full_weights.pt"))) for candidate in candidates: if candidate.is_file(): return candidate raise FileNotFoundError(f"no supported checkpoint weight file found under {model_path}") def main() -> int: args = _parse_args() cfg = load_config(args.config) if str(cfg.benchmark) != "libero_10" or int(cfg.task_id) != 0: raise SystemExit("formal runner is restricted to libero_10 task_id=0") if bool(cfg.video.enabled): raise SystemExit("formal baseline runner requires video.enabled=false") root = require_project_path(args.output_dir, label="output directory") cfg_hash = protocol_hash(cfg) seeds = parse_int_spec(args.seeds, label="seeds") if args.seeds else [int(seed) for seed in cfg.policy_seeds] trials = parse_int_spec(args.trial_ids, label="trial ids") if args.trial_ids else [int(trial) for trial in cfg.trial_ids] expected = expected_keys(seeds, trials) if any(trial < 0 or trial >= 50 for trial in trials): raise SystemExit("Task 0 trial ids must be in 0..49") run_id = dt.datetime.now(dt.timezone.utc).strftime("%Y%m%dT%H%M%SZ") + "_" + cfg_hash[:12] _write_run_metadata(root, cfg, cfg_hash, run_id, expected) write_resolved_config(root / "resolved_config.yaml", cfg) with (root / "commands.txt").open("a", encoding="utf-8") as handle: handle.write( dt.datetime.now(dt.timezone.utc).isoformat() + " " + " ".join(shlex.quote(item) for item in sys.argv) + "\n" ) _write_status(root, cfg, cfg_hash, expected) model_path = require_project_path(cfg.model.model_path, label="checkpoint") if not model_path.is_dir(): raise SystemExit(f"checkpoint directory does not exist: {model_path}") if args.dry_run: records = load_episode_records(root, expected_protocol_hash=cfg_hash) completed = {(int(item["policy_seed"]), int(item["trial_id"])) for item in records if item["status"] == "completed"} pending = [key for key in expected if key not in completed] print(json.dumps({"protocol_sha256": cfg_hash, "expected_count": len(expected), "completed_count": len(completed), "pending_count": len(pending), "pending_keys": [list(key) for key in pending]}, ensure_ascii=False)) return 0 max_episodes = args.max_episodes_per_invocation or int(cfg.runner.default_max_episodes_per_invocation) if max_episodes < 1: raise SystemExit("--max-episodes-per-invocation must be positive") records = load_episode_records(root, expected_protocol_hash=cfg_hash) completed = set() if args.overwrite else { (int(item["policy_seed"]), int(item["trial_id"])) for item in records if item["status"] == "completed" } pending = [key for key in expected if key not in completed] pending = pending[:max_episodes] if not pending: _write_status(root, cfg, cfg_hash, expected) print("no pending episodes") return 0 import torch if args.device.startswith("cuda") and not torch.cuda.is_available(): raise SystemExit("CUDA requested but torch.cuda.is_available() is false; do not substitute a GPU run") actual_weight_sha = sha256_file(_checkpoint_weight_path(model_path)) if actual_weight_sha != str(cfg.model.checkpoint_weight_sha256): raise SystemExit(f"checkpoint SHA256 mismatch: expected {cfg.model.checkpoint_weight_sha256}, got {actual_weight_sha}") model = _load_model(cfg, model_path, args.device) suite, env = _make_env(cfg) task = suite.get_task(int(cfg.task_id)) init_states = suite.get_task_init_states(int(cfg.task_id)) if len(init_states) != 50: raise RuntimeError(f"expected 50 Task 0 init states, got {len(init_states)}") try: for seed, trial_id in pending: output_path = _episode_path(root, seed, trial_id) if output_path.exists() and not args.overwrite: existing = json.loads(output_path.read_text(encoding="utf-8")) if existing.get("status") == "completed": continue started = time.time() last_exc: BaseException | None = None record: dict[str, Any] | None = None for retry in range(int(cfg.runner.retry_limit) + 1): try: record = _run_episode( model, env, init_states[trial_id], str(task.name), str(task.language), seed, trial_id, cfg, args.device, cfg_hash, run_id, retry, ) last_exc = None break except Exception as exc: # record failure, then retry once last_exc = exc traceback.print_exc() try: env.close() except Exception: pass suite, env = _make_env(cfg) if record is None: assert last_exc is not None record = _record_error( cfg=cfg, cfg_hash=cfg_hash, run_id=run_id, seed=seed, trial_id=trial_id, init_state_hash=hashlib.sha256(np.asarray(init_states[trial_id]).tobytes()).hexdigest(), retry_count=int(cfg.runner.retry_limit), started=started, exc=last_exc, device_name=args.device, ) validate_episode_record(record, expected_protocol_hash=cfg_hash) if record["status"] == "error": atomic_json_dump(output_path, record) _write_status(root, cfg, cfg_hash, expected) raise RuntimeError(f"episode error for seed={seed} trial={trial_id}; see {output_path}") atomic_json_dump(output_path, record) _write_status(root, cfg, cfg_hash, expected) print(json.dumps({"seed": seed, "trial_id": trial_id, "success": record["success_once"], "env_steps": record["env_steps"], "elapsed_seconds": record["elapsed_seconds"]}, ensure_ascii=False)) finally: env.close() del model if torch.cuda.is_available(): torch.cuda.empty_cache() return 0 if __name__ == "__main__": raise SystemExit(main())