| |
| """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 ( |
| 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, |
| } |
| |
| |
| 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 |
| 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: |
| |
| |
| 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: |
| 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()) |
|
|
