"""Held-out evaluation for strict local-wrist RGB-D Stereo-ACT-cross_relbias.""" from __future__ import annotations import argparse import hashlib import json import multiprocessing as mp import os import random from pathlib import Path import gymnasium as gym import numpy as np import torch import robofactory # noqa: F401 from train_stereo_act import StereoACT from two_three_task_manifest import TASKS, get_task def reset_reproducibly(env, seed): random.seed(seed); np.random.seed(seed); torch.manual_seed(seed); torch.cuda.manual_seed_all(seed) return env.reset(seed=seed) def load(checkpoint, device): saved = torch.load(checkpoint, map_location=device, weights_only=False) cfg, raw_stats = saved["config"], saved["stats"] # The first 10k preflight checkpoints predate explicit evaluator metadata; # infer only architecture defaults, never an observation input or label. common = dict(horizon=cfg.get("horizon", 100), d_model=cfg.get("d_model", 384), enc_layers=cfg.get("enc_layers", 4), dec_layers=cfg.get("dec_layers", 7), dino_model=cfg.get("dino_model", "facebook/dinov3-vitb16-pretrain-lvd1689m"), defm_model=cfg.get("defm_model", "defm_vit_s14")) # A missing policy_variant denotes the original Stereo-ACT checkpoint. # Only historical checkpoints explicitly tagged mode=sync may infer the # Sync-ARCA variant; never default a vanilla Stereo checkpoint to ARCA. variant = cfg.get("policy_variant") or ("stereo_sync_arca" if cfg.get("mode") == "sync" else "stereo") state_dim, action_dim = cfg.get("state_dim", len(raw_stats["q_mean"])), cfg.get("action_dim", len(raw_stats["a_mean"])) if variant == "stereo_ffn_moe": from stereo_decoder_variants import StereoFFNMoE model = StereoFFNMoE(state_dim, action_dim, experts=cfg.get("experts", 4), **common) elif variant == "stereo_arca": from stereo_decoder_variants import StereoARCA model = StereoARCA(state_dim, action_dim, roles=cfg.get("experts", 4), role_rank=cfg.get("role_rank", 32), **common) elif variant == "stereo_sync_arca": from stereo_decoder_variants import StereoSyncARCA model = StereoSyncARCA(state_dim, action_dim, roles=cfg.get("experts", 4), role_rank=cfg.get("role_rank", 32), phases=cfg.get("clusters", 8), **common) else: model = StereoACT(state_dim, action_dim, **common) model = model.to(device); model.load_state_dict(saved["model"]); model.eval() return model, {key: torch.as_tensor(value, device=device) for key, value in raw_stats.items()}, cfg @torch.no_grad() def predict_all(model, stats, obs, arms, device): rgb, depth, qposes = [], [], [] for arm in arms: sensor = obs["sensor_data"][f"head_camera_agent{arm}"] image, metric_depth = np.asarray(sensor["rgb"]), np.asarray(sensor["depth"]) qpos = np.asarray(obs["agent"][f"panda-{arm}"]["qpos"]) rgb.append(image[0] if image.ndim == 4 else image) depth.append(metric_depth[0] if metric_depth.ndim == 4 else metric_depth) qposes.append(qpos[0] if qpos.ndim == 2 else qpos) rgb = torch.as_tensor(np.stack(rgb)).permute(0, 3, 1, 2).float().div_(255).to(device) depth = torch.as_tensor(np.stack(depth)).permute(0, 3, 1, 2).to(device) qpos = (torch.as_tensor(np.stack(qposes)).float().to(device) - stats["q_mean"]) / stats["q_std"] chunks = model(rgb, depth, qpos)[0] return (chunks * stats["a_std"] + stats["a_mean"]).float().cpu().numpy() def evaluate_slice(checkpoint, task_name, seeds, device_name, max_steps): torch.set_num_threads(12); device = torch.device(device_name) model, stats, cfg = load(checkpoint, device) os.environ["ROBOFACTORY_WRIST_WIDTH"], os.environ["ROBOFACTORY_WRIST_HEIGHT"] = "640", "480" import wrist_camera_patch # noqa: F401 spec, arms = get_task(task_name), get_task(task_name)["agents"] env = gym.make(spec["env_id"], config=f"/workspace/RoboFactory/{spec['config']}", obs_mode="rgbd", control_mode="pd_joint_pos", render_mode="sensors", reward_mode="dense", sim_backend="cpu", sensor_configs=dict(shader_pack="default"), human_render_camera_configs=dict(shader_pack="default"), viewer_camera_configs=dict(shader_pack="default")) rows = [] for seed in seeds: obs, _ = reset_reproducibly(env, seed); histories = [[] for _ in arms]; success = False for step in range(max_steps): chunks = predict_all(model, stats, obs, arms, device); actions = {} for local, arm in enumerate(arms): histories[local].append(chunks[local]) candidates = [chunk[step - start] for start, chunk in enumerate(histories[local]) if step - start < len(chunk)] weights = np.exp(-0.01 * np.arange(len(candidates) - 1, -1, -1)); weights /= weights.sum() actions[f"panda-{arm}"] = np.sum(np.asarray(candidates) * weights[:, None], axis=0) obs, _, terminated, truncated, info = env.step(actions) success = bool(np.asarray(info.get("success", False)).all()) if bool(np.asarray(terminated).all()) or bool(np.asarray(truncated).all()): break rows.append({"seed": seed, "success": success, "steps": step + 1}) print(json.dumps({"task": task_name, **rows[-1]}), flush=True) env.close(); return rows def main(): parser = argparse.ArgumentParser() parser.add_argument("--checkpoint", required=True); parser.add_argument("--task", choices=sorted(TASKS), required=True) parser.add_argument("--seed-file", required=True); parser.add_argument("--episodes", type=int, default=100) parser.add_argument("--max-steps", type=int, default=1500); parser.add_argument("--workers", type=int, default=2) parser.add_argument("--devices", default="0"); parser.add_argument("--output", required=True) args = parser.parse_args(); raw = Path(args.seed_file).read_bytes(); seed_manifest = json.loads(raw) seeds = [int(seed) for seed in seed_manifest["seeds"]] if len(seeds) != args.episodes or len(set(seeds)) != len(seeds): raise ValueError("seed file must contain exactly the requested unique seeds") device_ids = [int(item) for item in args.devices.split(",") if item] workers = min(max(args.workers, 1), len(seeds)) if workers == 1: rows = evaluate_slice(args.checkpoint, args.task, seeds, f"cuda:{device_ids[0]}", args.max_steps) else: parts = [seeds[index::workers] for index in range(workers)] payload = [(args.checkpoint, args.task, part, f"cuda:{device_ids[index % len(device_ids)]}", args.max_steps) for index, part in enumerate(parts)] mp.set_start_method("spawn", force=True) with mp.Pool(workers) as pool: rows = [row for part in pool.starmap(evaluate_slice, payload) for row in part] rows.sort(key=lambda row: row["seed"]) successes = sum(row["success"] for row in rows) cfg = torch.load(args.checkpoint, map_location="cpu", weights_only=False)["config"] model_contract = {key: cfg.get(key) for key in ( "vision_backbone", "dino_model", "defm_model", "horizon", "enc_layers", "dec_layers", "d_model", "camera_width", "camera_height", "patch_grid", "fusion_layers", "depth_storage_unit", "arms", )} result = {"task": args.task, "env_id": get_task(args.task)["env_id"], "checkpoint": str(Path(args.checkpoint).resolve()), "model_contract": model_contract, "episodes": len(rows), "successes": successes, "success_rate": successes / len(rows), "rows": rows, "camera": "strictly local single wrist RGB-D on matching panda_hand; no global/peer/right-camera input", "seed_protocol": {"method": seed_manifest["selection_method"], "source": args.seed_file, "sha256": hashlib.sha256(raw).hexdigest(), "training_seed_overlap": seed_manifest["training_seed_overlap"]}} out = Path(args.output); out.parent.mkdir(parents=True, exist_ok=True); out.write_text(json.dumps(result, indent=2)) print(json.dumps(result | {"rows": "saved"}), flush=True) if __name__ == "__main__": main()