File size: 7,028 Bytes
f5d3e89 | 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 145 146 147 148 149 150 151 152 153 154 155 | #!/usr/bin/env python3
"""Verify online GWAM graph / multi-view RGB / mask alignment on a live RoboCasa env.
This is an integration smoke for the team-facing contract:
snapshot = extractor.extract_final_graph(...)
snapshot['gnn_graph'] is the fused graph from the current state
snapshot['rgb_frames'][v] is the current RGB image for view id v
snapshot['rle_masks'][*]['v'] and visual_features_sparse['v'] use the same v
The default backend is fake so this can run without SAM2/CLIP while still
checking state/RGB/mask/feature plumbing. Use scripts/verify_realtime_final_graph.py
for the real SAM2/CLIP backend gate.
"""
from __future__ import annotations
import argparse
import gzip
import hashlib
import json
import sys
import tempfile
from pathlib import Path
import numpy as np
PACKAGE_ROOT = Path(__file__).resolve().parents[1]
if str(PACKAGE_ROOT) not in sys.path:
sys.path.insert(0, str(PACKAGE_ROOT))
from examples.realtime_env_graph_eval_loop import FakeVisualBackend, make_env, zero_action # noqa: E402
from realtime.gwam_realtime_env_graph import ( # noqa: E402
RealtimeGWAMGraphExtractor,
build_online_visual_features,
render_rgb_frames,
render_visibility_and_masks,
save_realtime_graph_snapshot,
)
def state_digest(sim) -> str:
h = hashlib.sha256()
h.update(np.asarray(sim.data.qpos, dtype=np.float64).tobytes())
h.update(np.asarray(sim.data.qvel, dtype=np.float64).tobytes())
h.update(np.asarray([sim.data.time], dtype=np.float64).tobytes())
return h.hexdigest()
def rle_key(row: dict) -> tuple[int, int, str]:
return int(row["n"]), int(row["v"]), json.dumps(row["rle"], separators=(",", ":"))
def main() -> int:
ap = argparse.ArgumentParser()
ap.add_argument("--task", default="OpenDrawer")
ap.add_argument("--robots", default="PandaOmron")
args = ap.parse_args()
env = make_env(args.task, args.robots)
try:
env.reset()
extractor = RealtimeGWAMGraphExtractor(env)
backend = FakeVisualBackend()
before = state_digest(extractor.sim)
snapshot = extractor.extract_final_graph(visual_backend=backend, include_masks=True)
after = state_digest(extractor.sim)
assert before == after, "extract_final_graph advanced or mutated sim state"
graph = snapshot["gnn_graph"]
assert graph["x"].shape[1] == 342, graph["x"].shape
assert graph["edge_attr"].shape[1] == 8, graph["edge_attr"].shape
assert snapshot["rgb_frame_cameras"] == ["robot0_agentview_right", "robot0_agentview_left", "robot0_eye_in_hand"]
assert len(snapshot["rgb_frames"]) == 3
for v, frame in snapshot["rgb_frames"].items():
assert int(v) in (0, 1, 2)
assert frame.shape == (256, 256, 3), frame.shape
assert frame.dtype == np.uint8, frame.dtype
# Re-render from the still-current state; RGB and segmentation/masks must match.
rgb2 = render_rgb_frames(extractor.sim, cameras=extractor.cameras)
for v in snapshot["rgb_frames"]:
assert np.array_equal(snapshot["rgb_frames"][v], rgb2[v]), f"RGB view {v} changed without env.step"
visible2, centroid2, area2, bbox2, rle2 = render_visibility_and_masks(
extractor.sim, extractor.g2n, len(extractor.specs), cameras=extractor.cameras, include_rle=True
)
assert np.array_equal(snapshot["view_visible"], visible2)
assert np.allclose(snapshot["view_centroid"], centroid2, equal_nan=True)
assert np.allclose(snapshot["view_area"], area2, equal_nan=True)
assert np.allclose(snapshot["view_bbox"], bbox2, equal_nan=True)
assert sorted(map(rle_key, snapshot["rle_masks"])) == sorted(map(rle_key, rle2))
# Sparse feature provenance: recomputing with returned RGB/masks matches.
recomputed = build_online_visual_features(
rgb_frames=snapshot["rgb_frames"],
rle_rows=snapshot["rle_masks"],
nodes=snapshot["graph_static"]["nodes"],
visual_backend=backend,
t=0,
)
visual = snapshot["visual_features_sparse"]
for key in ["t", "n", "v", "feat", "type_clip32", "visual_computed", "invalid_t", "invalid_n", "invalid_v"]:
assert np.array_equal(visual[key], recomputed[key]), key
assert len(visual["n"]) + len(visual["invalid_n"]) == len(snapshot["rle_masks"])
# Node-state visibility flags match the view_visible matrix for active nodes.
active = snapshot["node_state"][:, 0] == 1
assert np.array_equal(snapshot["node_state"][active, 19:22].astype(bool), snapshot["view_visible"][active])
assert not any(e.get("rel") == "visibility_change" for e in snapshot["dynamic_edges"]), "first call should not have visibility_change edges"
# Persistence contract: saved RGB, masks, node_state, cameras round-trip.
with tempfile.TemporaryDirectory(prefix="gwam-rgb-align-") as td:
out = Path(td)
save_realtime_graph_snapshot(snapshot, out)
manifest = json.loads((out / "rgb_manifest.json").read_text())
assert [v["camera"] for v in manifest["views"]] == snapshot["rgb_frame_cameras"]
for rec in manifest["views"]:
arr = np.load(out / rec["path"])
assert np.array_equal(arr, snapshot["rgb_frames"][int(rec["view_id"])])
ve = np.load(out / "graph/view_evidence.npz")
assert list(ve["cameras"]) == snapshot["rgb_frame_cameras"]
assert np.array_equal(ve["view_visible"][0], snapshot["view_visible"])
ns = np.load(out / "graph/node_state.npz")
assert np.array_equal(ns["node_state"][0], snapshot["node_state"])
with gzip.open(out / "graph/visible_masks_rle.jsonl.gz", "rt") as f:
saved_masks = json.loads(f.readline())["masks"]
assert sorted(map(rle_key, saved_masks)) == sorted(map(rle_key, snapshot["rle_masks"]))
# Currency after one env step: t increments. RGB often changes even for zero action,
# but we only require the extractor not to reuse stale t/cache.
env.step(zero_action(env))
snapshot2 = extractor.extract_final_graph(visual_backend=backend, include_masks=True)
assert snapshot2["t"] == snapshot["t"] + 1
assert len(snapshot2["rgb_frames"]) == 3
result = {
"ok": True,
"N_real": int(graph["metadata"]["N_real"]),
"D_node": int(graph["x"].shape[1]),
"D_edge": int(graph["edge_attr"].shape[1]),
"n_visible_pairs": int(len(snapshot["rle_masks"])),
"n_feat_rows": int(len(visual["n"])),
"rgb_cameras": snapshot["rgb_frame_cameras"],
}
print("verify_rgb_graph_alignment_ok", json.dumps(result, sort_keys=True))
return 0
finally:
try:
env.close()
except Exception:
pass
if __name__ == "__main__":
raise SystemExit(main())
|