strict640x480-v2/code/evaluate_stereo_act.py

"""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()