Datasets:

ChangChrisLiu
/

GWAM_Data

#!/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())

	#!/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())