File size: 8,373 Bytes
096a426 4ddcfaa 096a426 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 | """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()
|