README.md

---
license: other
license_name: license-pending-robocasa-derived
license_link: https://huggingface.co/datasets/ChangChrisLiu/GWAM_Data/blob/main/LICENSE_PENDING.md
size_categories:
- 10K<n<100K
task_categories:
- robotics
tags:
- robotics
- robocasa
- graph-world-model
- graph-wam
- manipulation
- scene-graph
- sparse-graph
- segmentation
- visible-only-features
pretty_name: GWAM_Data
---

# GWAM_Data v1.2 sparse-v2

`GWAM_Data` is a RoboCasa-derived graph annotation and sparse visual-feature export for Graph-WAM / graph world-model research.


## Complete workflow: offline data, online graph, RGB alignment, and verification

Use this checklist when handing the package to another team member for joint training, evaluation, or real-time inference.

### A. If you only want to train/evaluate on already-generated HF episode ZIPs

You do **not** need RoboCasa, MuJoCo, SAM2, or CLIP at runtime. Download episode ZIPs and use the public loader:

```bash
python loaders/gwam_graph_dataloader.py \
  --zip gwam_v12_sparse_v2/episodes/target/TurnOnSinkFaucet/episode_000505.zip \
  --t 0 \
  --family-encoding onehot \
  --include-visual \
  --include-view-evidence \
  --include-type-clip32
```

This returns the model graph:

```text
x          [N_real,342]
edge_index [2,E]
edge_attr  [E,8]
slot_ids   [N_real]  # maps graph rows back to padded node slots 0..255
```

### B. If you need the graph online from a live RoboCasa environment

Install runtime dependencies and assets, then run the included verifier:

```bash
bash scripts/setup_realtime_final_graph_env.sh robocasa
conda activate robocasa

MUJOCO_GL=egl PYOPENGL_PLATFORM=egl \
python scripts/verify_realtime_final_graph.py \
  --visual-backend sam2 \
  --device cuda
```

The full online graph is produced by:

```python
snapshot = extractor.extract_final_graph(visual_backend=visual_backend)
graph = snapshot["gnn_graph"]
rgb_frames = snapshot["rgb_frames"]
rgb_frame_cameras = snapshot["rgb_frame_cameras"]
```

One snapshot is one current simulator state:

```text
current qpos/qvel/contact state
+ current segmentation from 3 views
+ current RGB frames from the same 3 views
+ current visible RLE masks
+ SAM2 masked pooling on rgb_frames[v] with mask(n,v)
+ CLIP type_clip32
= x [N_real,342], edge_attr [E,8], aligned RGB images
```

Canonical view ids:

```text
v=0 robot0_agentview_right
v=1 robot0_agentview_left
v=2 robot0_eye_in_hand
```

The same `v` is used everywhere: `rgb_frames[v]`, `rgb_frame_cameras[v]`, `view_visible[n,v]`, `rle_masks[*]["v"]`, and `visual_features_sparse["v"]`.

### C. If you want to save graph + aligned RGB for debugging or joint training

```python
from realtime.gwam_realtime_env_graph import save_realtime_graph_snapshot
save_realtime_graph_snapshot(snapshot, "debug_step_000000")
```

This writes graph files first, plus lossless aligned RGB files:

```text
debug_step_000000/graph/node_state.npz
debug_step_000000/graph/view_evidence.npz
debug_step_000000/graph/visible_masks_rle.jsonl.gz
debug_step_000000/graph/visual_features_sparse.npz
debug_step_000000/rgb/view_0_robot0_agentview_right.npy
debug_step_000000/rgb/view_1_robot0_agentview_left.npy
debug_step_000000/rgb/view_2_robot0_eye_in_hand.npy
debug_step_000000/rgb_manifest.json
```

### D. Verification commands team members should run

Graph/RGB/mask alignment without needing real SAM2:

```bash
MUJOCO_GL=egl PYOPENGL_PLATFORM=egl \
python scripts/verify_rgb_graph_alignment.py
```

Real SAM2/CLIP final graph:

```bash
MUJOCO_GL=egl PYOPENGL_PLATFORM=egl \
python scripts/verify_realtime_final_graph.py --visual-backend sam2 --device cuda
```

Expected invariants:

```text
D_node = 342
D_edge = 8
rgb_view_count = 3
rgb_shapes[v] = [256,256,3]
rgb_aligned_with_view_ids = true
```

### E. Verified match to already-generated data

I verified the online visual path against an existing generated episode:

```text
gwam_v12_sparse_v2/episodes/target/TurnOnSinkFaucet/episode_000505.zip
```

Using the corresponding prior RoboCasa RGB videos and the stored RLE masks at `t=0`, recomputing `visual_features_sparse` with the current online SAM2/CLIP backend gave:

```text
existing graph: D_node=342, D_edge=8
RGB videos: three uint8 [256,256,3] views
visible rows at t=0: 50
recomputed SAM2 rows: 50 / 50 exact fp16 matches
SAM2 cosine min: 1.0
type_clip32 cosine min: 0.99999988
```

So the current RGB+mask -> SAM2 feature path matches the previously generated graph features. A newly sampled live scene will not be pixel-identical to a prior episode unless you replay the exact saved simulator state/trajectory, but the schema and feature-generation policy are compatible and verified.


## Matching GWAM graph ZIPs to original RoboCasa RGB videos

The released `gwam_v12_sparse_v2/episodes/.../episode_XXXXXX.zip` files contain graph/state/mask/view-evidence/SAM2-feature annotations, but they intentionally do **not** bundle the original RoboCasa RGB videos. To compare or recompute image features exactly, keep a local copy of the source RoboCasa LeRobot dataset and use the shared `split/task/episode_id` key.

For a graph ZIP path:

```text
gwam_v12_sparse_v2/episodes/<split>/<TaskName>/episode_XXXXXX.zip
```

match it to source RoboCasa videos under the local RoboCasa dataset root:

```text
<ROBOCASA_DATASET_ROOT>/v1.0/<split>/atomic/<TaskName>/<snapshot_date>/lerobot/videos/chunk-000/observation.images.robot0_agentview_right/episode_XXXXXX.mp4
<ROBOCASA_DATASET_ROOT>/v1.0/<split>/atomic/<TaskName>/<snapshot_date>/lerobot/videos/chunk-000/observation.images.robot0_agentview_left/episode_XXXXXX.mp4
<ROBOCASA_DATASET_ROOT>/v1.0/<split>/atomic/<TaskName>/<snapshot_date>/lerobot/videos/chunk-000/observation.images.robot0_eye_in_hand/episode_XXXXXX.mp4
```

On this machine the root is:

```text
/home/chris/robocasa_datasets
```

Example verified match:

```text
Graph ZIP:
  gwam_v12_sparse_v2/episodes/target/TurnOnSinkFaucet/episode_000505.zip

Source RGB videos:
  /home/chris/robocasa_datasets/v1.0/target/atomic/TurnOnSinkFaucet/20250812/lerobot/videos/chunk-000/observation.images.robot0_agentview_right/episode_000505.mp4
  /home/chris/robocasa_datasets/v1.0/target/atomic/TurnOnSinkFaucet/20250812/lerobot/videos/chunk-000/observation.images.robot0_agentview_left/episode_000505.mp4
  /home/chris/robocasa_datasets/v1.0/target/atomic/TurnOnSinkFaucet/20250812/lerobot/videos/chunk-000/observation.images.robot0_eye_in_hand/episode_000505.mp4
```

Using those three RGB videos plus the stored `visible_masks_rle.jsonl.gz` masks at `t=0`, the current online SAM2/CLIP backend recomputed all stored `visual_features_sparse` rows exactly for the verified example:

```text
visible rows at t=0: 50
recomputed SAM2 rows: 50 / 50 exact fp16 matches
SAM2 cosine min: 1.0
type_clip32 cosine min: 0.99999988
```

Important notes:

- The HF graph ZIP is sufficient for graph-only or graph-feature training/evaluation through `loaders/gwam_graph_dataloader.py`.
- Original RGB videos are needed only if you want pixel-level image/graph pairing, feature recomputation, or joint RGB+graph training from the original demonstrations.
- Snapshot dates differ by task; if multiple dated source folders exist, choose the one containing the matching `episode_XXXXXX.mp4` and corresponding `data/chunk-000/episode_XXXXXX.parquet`.
- Online realtime snapshots saved by `save_realtime_graph_snapshot()` are different: they do include lossless `rgb/view_<v>_<camera>.npy` files plus `rgb_manifest.json`.

## Start here: get the full final graph in real time for inference/evaluation

Most users will use `GWAM_Data` in one of two ways:

| Goal | Start with | Requires simulator/SAM2? | Output graph |
|---|---|---:|---|
| Load an already exported HF episode ZIP | `loaders/gwam_graph_dataloader.py` | no | one timestep from `gwam_v12_sparse_v2/episodes/.../episode_XXXXXX.zip` |
| Get the final graph directly from a live environment every simulation move | `realtime/gwam_realtime_env_graph.py` or `extractors/gwam_realtime_env_graph.py` | yes | current-scene final graph with Phase 1 + Phase 2 features |

This section is for the second case: **online final-graph extraction for inference/evaluation**.

### What problem this solves

During policy evaluation or world-model inference, you often have a live RoboCasa / robosuite environment and need the graph corresponding to the **current scene after each move**. The online final-graph extractor performs the same conceptual two-phase pipeline used locally for the full data export:

```text
Phase 1 from current environment state
  current MuJoCo sim state
  + current segmentation renders
  -> node inventory, node_state [256,32]
  -> static/prior edges, current contact edges
  -> view_evidence and visible_masks_rle

Phase 2 from current RGB + Phase-1 masks
  current RGB frames for the three canonical cameras
  + visible_masks_rle
  + SAM2.1 Hiera-B+ image embeddings
  + CLIP ViT-B/32 type text features projected to 32-D
  -> visual_features_sparse-compatible sparse features

Final graph for model input
  -> x [N_real,342]
  -> edge_index [2,E]
  -> edge_attr [E,8]
  -> slot_ids [N_real]
```

Local production source-of-truth:

```text
agent_workspace/scripts/export_gwam_v12_phase1.py
agent_workspace/scripts/fill_gwam_v12_phase2_sparse.py
```

Public HF online implementation:

```text
realtime/gwam_realtime_env_graph.py        # implementation
extractors/gwam_realtime_env_graph.py      # compatibility wrapper
examples/realtime_env_graph_eval_loop.py   # runnable evaluation-loop template
docs/REALTIME_ENV_GRAPH_PIPELINE.md        # full guide
```

The official online final-graph API is:

```python
snapshot = extractor.extract_final_graph(visual_backend=visual_backend)
graph = snapshot["gnn_graph"]
```

`extract_current_graph()` still exists only as a 33-D Phase-1 debug path. For final inference/evaluation graphs, use `extract_final_graph()`.

### Full online final-graph code sample

```python
import robocasa  # registers RoboCasa environments
import robosuite
from realtime.gwam_realtime_env_graph import (
    RealtimeGWAMGraphExtractor,
    Sam2ClipRealtimeFeatureBackend,
)

env = robosuite.make(
    "OpenDrawer",
    robots="PandaOmron",
    has_renderer=False,
    has_offscreen_renderer=True,
    use_object_obs=True,
    use_camera_obs=True,
    camera_names=[
        "robot0_agentview_right",
        "robot0_agentview_left",
        "robot0_eye_in_hand",
    ],
    camera_heights=256,
    camera_widths=256,
    camera_depths=False,
    reward_shaping=False,
    ignore_done=True,
)

obs = env.reset()
extractor = RealtimeGWAMGraphExtractor(env, ep_meta=None)
visual_backend = Sam2ClipRealtimeFeatureBackend(
    device="cuda",
)

snapshot = extractor.extract_final_graph(visual_backend=visual_backend)
graph = snapshot["gnn_graph"]

for step in range(100):
    action = policy(obs, graph)
    obs, reward, done, info = env.step(action)
    snapshot = extractor.extract_final_graph(visual_backend=visual_backend)
    graph = snapshot["gnn_graph"]
    if done:
        break
```

Final graph tensors:

```python
x = graph["x"]                    # float32 [N_real,342]
edge_index = graph["edge_index"]  # int64   [2,E]
edge_attr = graph["edge_attr"]    # float32 [E,8]
slot_ids = graph["slot_ids"]      # original 0..255 storage slots
```

Feature layout:

```text
20 state dims + 10 family dims + 256 SAM2 visual dims + 32 type_clip32 dims + 24 view-evidence dims = 342
```

Run the included final-graph example:

```bash
MUJOCO_GL=egl PYOPENGL_PLATFORM=egl \
python examples/realtime_env_graph_eval_loop.py \
  --task OpenDrawer \
  --robots PandaOmron \
  --steps 2 \
  --visual-backend sam2 \
  --device cuda \
  --json-output /tmp/gwam_realtime_final_graph.json
```

Expected invariants:

```text
N_real > 1
D_node = 342
D_edge = 8
final_graph = true
visual_features_written >= 0
invalid_visible_pairs >= 0
```


Bundled model weights for direct HF-checkout runs:

```text
models/sam2/checkpoints/sam2.1_hiera_base_plus.pt
models/clip/ViT-B-32.pt
models/MODEL_MANIFEST.json
```

Install runtime dependencies, then run the verifier:

```bash
bash scripts/setup_realtime_final_graph_env.sh robocasa
conda activate robocasa
MUJOCO_GL=egl PYOPENGL_PLATFORM=egl python scripts/verify_realtime_final_graph.py --visual-backend sam2 --device cuda
```

This requires your own working RoboCasa/robosuite installation plus SAM2/CLIP runtime dependencies. The model checkpoints above are included to make the reference extraction path directly runnable from an HF checkout. The HF dataset does not redistribute RoboCasa itself or MuJoCo/RoboCasa assets. Third-party SAM2/CLIP checkpoints under `models/` are included under their own upstream licenses; see `models/README.md`.

Leakage rule: extract `final_graph_t` only from the current state/RGB/masks available at evaluation step `t`. Do not feed `final_graph_{t+1}` while predicting `t+1` unless the experiment is explicitly labeled oracle/teacher-forced.

Offline packaged data users should still start with:

```text
loaders/gwam_graph_dataloader.py
```

That loader reads released `episode_XXXXXX.zip` files and converts stored padded arrays into variable-size GNN graphs without needing RoboCasa/SAM2 at evaluation time.

This repository does **not** claim ownership of the original RoboCasa demonstrations, environments, assets, actions, or state trajectories. The original demonstrations are from RoboCasa. This release extends them with generated scene-graph state tensors, graph/event annotations, view evidence, visible masks, sparse visual features, audits, and per-episode packaging for our internal research use.


## Repository layout note: single source of truth

To avoid confusing duplicated files, this HF repo now uses a clean split:

```text
# Canonical package/docs/tools/model weights at repository root
README.md
SCHEMA.md
docs/
examples/
extractors/
loaders/
models/
realtime/
scripts/
tests/

# Data-release namespace only
gwam_v12_sparse_v2/README.md              # short release index, not a full duplicate
gwam_v12_sparse_v2/MANIFEST.jsonl
gwam_v12_sparse_v2/*VALIDATION*.json
gwam_v12_sparse_v2/episodes/**/*.zip
gwam_v12_sparse_v2/docs/GWAM_v12_sparse_v2_graph_design.pptx
gwam_v12_sparse_v2/examples/load_gwam_v12_episode.py
```

Large checkpoints and runnable code are root-only. Do not look for duplicate `.pt`, `scripts/`, `realtime/`, or `loaders/` copies under `gwam_v12_sparse_v2/`; use the root paths instead. When downloading episode ZIPs and also wanting online realtime extraction, include both the release data prefix and the root code/model paths:

```bash
hf download ChangChrisLiu/GWAM_Data --repo-type dataset \
  --include "gwam_v12_sparse_v2/**" \
  --include "README.md" --include "SCHEMA.md" --include "docs/**" \
  --include "loaders/**" --include "realtime/**" --include "scripts/**" \
  --include "models/**" \
  --local-dir gwam_data
```

## Current release status

```text
Release line: GWAM_Data v1.2 sparse-v2
HF repo: ChangChrisLiu/GWAM_Data
Release prefix: gwam_v12_sparse_v2/
Original source: RoboCasa datasets v1.0 (robocasa_version 1.0.1), per-task snapshots 2025-08-11 .. 2025-08-22, LeRobot conversion
Production root: gwam_v12_phase1_full_rle_v2
Nominal source total: 10,565 episodes
Known excluded source episode: target/OpenDrawer/episode_000459
Effective v1.2 total: 10,564 episodes
Phase 1 graph export: 10,564 / 10,564 effective episodes complete
Phase 2 sparse visual export: 10,564 / 10,564 effective episodes complete
Packaging: one ZIP per episode under gwam_v12_sparse_v2/episodes/
License/status: license pending; RoboCasa-derived; internal research use only while redistribution terms are reviewed
Total release size: ~71.9 GB (10,564 episode ZIPs)
Episode length: 57–858 frames, mean 251.8 frames, at 20 Hz
```

Every packaged episode has completed both Phase 1 and Phase 2 and is listed in `gwam_v12_sparse_v2/MANIFEST.jsonl`.

The manifest has one row per episode ZIP. `zip_path` is **relative to the `gwam_v12_sparse_v2/` prefix** (prepend it when composing HF download paths). Rows carry enough per-episode statistics to select subsets before downloading the full release:

| Field | Meaning |
|---|---|
| `episode` | `<split>/<task>/episode_XXXXXX` |
| `episode_id` | `episode_XXXXXX` |
| `split`, `task` | tier and task name |
| `schema` | `GWAM_Data_v1.2_phase1_sparse_v2` |
| `ok`, `errors` | per-episode validation status; final release rows are all `ok=true` with empty errors |
| `frames_processed` | episode length `T` |
| `visible_pairs_from_phase1` | Phase-1 visible `(t,n,v)` count |
| `features_written` | Phase-2 valid sparse feature count |
| `invalid_visible_pairs` | Phase-2 visible pairs that could not be pooled on the SAM2 grid |
| `zip_path` | path relative to the release prefix, e.g. `episodes/target/OpenDrawer/episode_000000.zip` |
| `zip_size` | ZIP size in bytes |
| `zip_sha256` | ZIP SHA-256 |

Release scale from `MANIFEST.jsonl`:

```text
manifest_rows: 10,564
total_zip_size: 71,917,066,323 bytes (~71.9 GB)
zip_size_min/max/mean: 932,571 / 41,312,194 / 6,807,749 bytes
split_counts: pretrain=1,939, target=8,625
episode_length_frames: 57–858, mean 251.8, 20 Hz
```


Validation artifacts:

```text
gwam_v12_sparse_v2/FULL_RELEASE_VALIDATION.json
gwam_v12_sparse_v2/FULL_PHASE2_VALIDATION_SUMMARY.json
gwam_v12_sparse_v2/FINAL_COMPREHENSIVE_VALIDATION.json
```
### Release history on this prefix

| Date | Content | Validation file |
|---|---|---|
| 2026-07-04 | Partial Phase-2 snapshot: 3,155 episodes under `gwam_v12_sparse_v2/episodes/` | `PARTIAL_PHASE2_VALIDATION.json` (superseded) |
| 2026-07-06 | Full release: 10,564 episodes; manifest and all validation files regenerated | `FULL_RELEASE_VALIDATION.json`, `FULL_PHASE2_VALIDATION_SUMMARY.json`, `FINAL_COMPREHENSIVE_VALIDATION.json` |

The full release supersedes the partial snapshot in place (same prefix; already-uploaded episode ZIPs are unchanged and were reused byte-identically). If `PARTIAL_PHASE2_VALIDATION.json` is still present under the prefix, ignore it; `FINAL_COMPREHENSIVE_VALIDATION.json` is the authoritative final summary. Remote completeness can be re-verified by comparing the HF file listing against `MANIFEST.jsonl` (10,564 rows).


Final validation summary:

```text
episodes_considered: 10,564
phase1_done: 10,564
phase2_done: 10,564
fail_count: 0
error_count: 0
total_frames: 2,659,774
total_valid_sparse_visual_features: 113,650,752
total_invalid_visible_pairs: 89,183
total_phase1_visible_pairs: 113,739,935
schema: GWAM_Data_v1.2_phase1_sparse_v2 for all episodes
rule_versions_unique: 1
max_nodes_observed: 255 / N_MAX=256
known_drop: target/OpenDrawer/episode_000459
```

## Provenance and use notice

This data is derived from RoboCasa source demonstrations:

```text
RoboCasa datasets v1.0, robocasa_version 1.0.1
task soup: target_atomic_seen (our registry snapshot) + pretrain/atomic PickPlace
per-task snapshot dates: 2025-08-11 through 2025-08-22
  (the exact per-episode source path, including its snapshot date, is recorded in
   graph_static.json/dataset_path, e.g. .../target/atomic/OpenDrawer/20250816/lerobot)
conversion: LeRobot
demo filter: 500_demos filter key, human-sourced demonstrations
source tiers used: target/atomic and pretrain/atomic
```

The generated GWAM files include graph/mask/feature annotations over RoboCasa episodes. They may also include absolute source-path strings inside `graph/graph_static.json`, `_PHASE1_DONE.json`, `audit/*.json`, and validation files as provenance metadata. These local paths are not needed by loaders.

Use status:

```text
Internal research use only while RoboCasa-derived redistribution terms are reviewed.
Do not treat this as an independently owned replacement for RoboCasa.
Do not redistribute repackaged copies while license review is pending.
Users must comply with RoboCasa and upstream asset licenses.
```

See `LICENSE` and `LICENSE_PENDING.md` for the current license-pending notice.

## Selected RoboCasa tasks

The release covers 17 of the 18 tasks in the RoboCasa v1.0 target atomic seen task set as snapshotted in our source registry (`dataset_soup: target_atomic_seen`) plus 18 pretrain atomic PickPlace tasks. `NavigateKitchen` is intentionally excluded because it is navigation-only rather than manipulation scene-graph dynamics.

### Target atomic manipulation tasks

| Tier | Task | Episodes |
|---|---:|---:|
| target | `CloseBlenderLid` | 502 |
| target | `CloseFridge` | 513 |
| target | `CloseToasterOvenDoor` | 505 |
| target | `CoffeeSetupMug` | 502 |
| target | `OpenCabinet` | 500 |
| target | `OpenDrawer` | 513 |
| target | `OpenStandMixerHead` | 502 |
| target | `PickPlaceCounterToCabinet` | 502 |
| target | `PickPlaceCounterToStove` | 501 |
| target | `PickPlaceDrawerToCounter` | 501 |
| target | `PickPlaceSinkToCounter` | 501 |
| target | `PickPlaceToasterToCounter` | 512 |
| target | `SlideDishwasherRack` | 502 |
| target | `TurnOffStove` | 500 |
| target | `TurnOnElectricKettle` | 520 |
| target | `TurnOnMicrowave` | 543 |
| target | `TurnOnSinkFaucet` | 506 |

Target total: 8,625 episodes.

### Pretrain atomic PickPlace tasks

| Tier | Task | Episodes |
|---|---:|---:|
| pretrain | `PickPlaceCabinetToCounter` | 106 |
| pretrain | `PickPlaceCounterToBlender` | 106 |
| pretrain | `PickPlaceCounterToCabinet` | 108 |
| pretrain | `PickPlaceCounterToDrawer` | 107 |
| pretrain | `PickPlaceCounterToMicrowave` | 110 |
| pretrain | `PickPlaceCounterToOven` | 111 |
| pretrain | `PickPlaceCounterToSink` | 108 |
| pretrain | `PickPlaceCounterToStandMixer` | 107 |
| pretrain | `PickPlaceCounterToStove` | 108 |
| pretrain | `PickPlaceCounterToToasterOven` | 108 |
| pretrain | `PickPlaceDrawerToCounter` | 103 |
| pretrain | `PickPlaceFridgeDrawerToShelf` | 106 |
| pretrain | `PickPlaceFridgeShelfToDrawer` | 111 |
| pretrain | `PickPlaceMicrowaveToCounter` | 112 |
| pretrain | `PickPlaceSinkToCounter` | 108 |
| pretrain | `PickPlaceStoveToCounter` | 109 |
| pretrain | `PickPlaceToasterOvenToCounter` | 106 |
| pretrain | `PickPlaceToasterToCounter` | 105 |

Pretrain total: 1,939 episodes.

### Known excluded source episode

```text
target/OpenDrawer/episode_000459
```

This source episode repeatedly failed RoboCasa `_load_model()` initialization and is excluded. Empty residue directories are not packaged.

## Hugging Face layout

```text
README.md                                      # root copy of this dataset card
SCHEMA.md                                      # root copy of v1.2 sparse-v2 schema
LICENSE
LICENSE_PENDING.md
VERSION
CHANGELOG.md

gwam_v12_sparse_v2/
  README.md                                    # release-prefix copy of this card
  SCHEMA.md                                    # normative v1.2 sparse-v2 schema
  MANIFEST.jsonl                               # 10,564 rows, one per episode ZIP
  FULL_RELEASE_VALIDATION.json                 # packaging summary
  FULL_PHASE2_VALIDATION_SUMMARY.json          # pipeline validate-only summary
  FINAL_COMPREHENSIVE_VALIDATION.json          # comprehensive final validation summary
  docs/
    QA_AND_LEAKAGE.md
    SANITY_CHECKS_AND_LEAKAGE_GUARDS.md
    REALTIME_ENV_GRAPH_PIPELINE.md
  examples/
    load_gwam_v12_episode.py
    realtime_env_graph_eval_loop.py
    REALTIME_ENV_GRAPH_README.md
  episodes/
    target/<Task>/episode_XXXXXX.zip
    pretrain/<Task>/episode_XXXXXX.zip
```

Each episode ZIP preserves the internal path prefix:

```text
<split>/<task>/episode_000123/
  _PHASE1_DONE.json
  graph/
    frames.jsonl
    graph_static.json
    node_state.npz
    view_evidence.npz
    dynamic_edges.jsonl
    visible_masks_rle.jsonl.gz
    visual_features_sparse.npz
  audit/
    summary.json
    phase2_summary.json
```

## Episode graph design overview

Each episode is a fixed-cap sparse scene graph sequence. The graph has:

1. a static per-episode node inventory in `graph/graph_static.json`;
2. a dense-per-node, sparse-over-time state tensor in `graph/node_state.npz`;
3. static/prior structural edges in `graph_static.json/prior_edges`;
4. dynamic per-frame event edges in `graph/dynamic_edges.jsonl`;
5. per-frame/per-node/per-view visibility evidence in `graph/view_evidence.npz`;
6. visible node masks in `graph/visible_masks_rle.jsonl.gz`;
7. sparse visible-only Phase-2 features in `graph/visual_features_sparse.npz`.

Important model-input rule: `goal_grounding_supervision_only`, natural-language instructions, fixture references, object role labels, node id strings, source paths, and raw alignment fields are metadata/supervision. Do not use them as model inputs unless your experiment explicitly allows that information.

### Graph construction design in detail

The graph is built as a temporally indexed attributed scene graph:

```text
G_t = (V, E_prior, E_dynamic_t, X_t, O_t, A_t)

V             fixed node inventory for the episode, padded to N_MAX=256
E_prior       static structural relations such as part_of and controls
E_dynamic_t   per-frame event relations such as contact and visibility_change
X_t           node_state[t] with 32 scalar channels per node
O_t           per-view observation evidence: masks, bboxes, centroids, sparse visual features
A_t           optional 12-D source action/alignment stream from frames.jsonl
```

The design goal is not to reproduce the full simulator XML as a dense object graph. Instead, it extracts a compact manipulation-relevant graph from RoboCasa state, metadata, segmentation renders, and contacts. The graph keeps enough structure for graph-conditioned world-model experiments while avoiding target-role leakage in model-facing tensors.

#### Is the robot part of the graph?

Yes. The robot is explicitly represented as a node. Each packaged episode contains exactly one robot node:

```json
{
  "node_id": "robot",
  "family": "robot",
  "category_text": "robot arm and gripper",
  "root_bodies": ["robot0_right_hand", "gripper0_right_right_gripper", "robot0_base"],
  "source": "sim_robot",
  "free_movable": 1,
  "articulated": 0
}
```

In the current export this robot node is generated first by the inventory builder, so it is slot 0 in the packaged episodes. Loaders should still use `graph_static.json/nodes` rather than assuming semantic meaning from slot numbers. The robot node participates in:

```text
node_state[t, robot_slot, :]       pose, velocity, family, visibility channels
view_evidence[t, robot_slot, ...]  robot visibility evidence where rendered/segmented
dynamic_edges                      contact edges between robot geoms and scene nodes
visual_features_sparse            visible-only visual features for robot masks when visible
```

Robot state uses the first available robot root body from the root list for pose/velocity state, while mask attribution can map geoms descending from any listed robot root body to the robot node. Thus the robot is a graph node, not just an external action stream. The 12-D action vector in `frames.jsonl` is a separate optional action/robot stream.

Compatibility note: older GWAM/GNN notes discussed product-only or robot-global designs where the robot was kept outside the object/constraint graph, and some Hanoi/Desktop validation docs use separate `side_robot/` or optional robot-node ablations. Those notes do **not** describe this RoboCasa `GWAM_Data v1.2 sparse-v2` export. In the current uploaded RoboCasa v1.2 data, the robot is a real graph node in every episode: 10,564 / 10,564 episodes have exactly one `family=robot` node, at slot 0 in the current deterministic inventory.

#### Robot-as-node leakage and WAM joint-training guidance

Robot-as-node is not a data-leakage problem by itself. In v1.2 sparse-v2, the robot node contains only the current-frame robot body pose/velocity, family id, visibility, and visual evidence, all aligned to the same timestep as the rest of the graph. This is analogous to providing robot proprioception or robot pose as part of the observed state. It becomes leakage only if a loader or training objective uses information from the future, from held-out labels, or from goal/role metadata as if it were an observed causal input.

For WAM / world-action-model joint training, use the robot node under one of these causal protocols:

| Protocol | Inputs at prediction time | Safe? | Notes |
|---|---|---:|---|
| one-step dynamics | `G_t`, robot node state at `t`, action `a_t`, image/frame at `t` | yes | Predict `G_{t+1}` / frame `t+1`; robot pose at `t` is observed context. |
| rollout with known action plan | initial `G_0`, initial robot node, action sequence `a_0...a_{H-1}` | yes | Update or predict robot state causally; do not feed ground-truth robot node from future frames. |
| rollout without action plan | initial graph only; model predicts future robot/action state | yes if designed | Treat future robot node/action as predicted latent/output, not input. |
| teacher forcing | ground-truth `G_t` including robot node at each step during training | training-only | OK for supervised training if evaluation does not feed future GT robot nodes. Report teacher-forced vs autoregressive separately. |
| future robot state as input for video prediction | `G_{t+k}` robot node or future contact edges while predicting frame `t+k` | no | This leaks future trajectory/outcome. Use only for oracle/upper-bound experiments and label clearly. |

Recommended default for joint WAM training:

```text
Input at t:
  RGB/image/token state at t
  graph node_state at t, including robot node
  prior_edges
  dynamic_edges at t if they are observed at t
  action a_t or action chunk starting at t, if the WAM condition includes actions

Targets:
  next frame / latent / video tokens
  next graph state or graph delta
  next dynamic edges / contacts if supervised

Never feed as default input:
  node_state from t+1...t+H
  future robot node states
  future contact edges
  future visibility changes
  goal_grounding_supervision_only
  object_roles task/distractor labels
  instruction-derived target-node ids
```

Robot-target edge connections are allowed and useful when they are causal/observed. For example, a `contact` edge between the robot node and a target object at frame `t` is a valid observed physical event at `t`; it can help a WAM learn manipulation dynamics. But a future robot-target contact edge at `t+1` or a goal-derived semantic edge such as `robot_should_grasp_target` would leak the plan/outcome unless it is explicitly part of an action plan or oracle condition.

Practical leakage checklist for loaders:

```text
[ ] Split train/val/test by episodes or tasks before any normalization/probing.
[ ] For prediction from t -> t+1, only feed robot node/action/contact information available at t.
[ ] For H-step rollout, do not feed ground-truth robot nodes from future frames unless labeled teacher-forcing/oracle.
[ ] Treat `goal_grounding_supervision_only`, instructions, object_roles, node_id strings, and source paths as metadata/supervision-only.
[ ] If using dynamic_edges, define whether contact/visibility at t is input and contact/visibility at t+1 is target.
[ ] If constructing robot-target edges beyond observed contacts, document whether they come from actions, perception, or goal metadata. Goal-derived robot-target edges are not default-safe inputs.
[ ] Report ablations: robot node included vs robot node masked vs action-only/global robot state.
```

Recommended ablations for WAM papers:

| Ablation | Purpose |
|---|---|
| robot node + observed contact edges | default embodied graph setting |
| robot node, no robot-target edges | tests whether robot pose alone helps |
| object graph only + action stream | compares against older product-only design |
| robot global token instead of node | tests node vs global placement |
| masked future contacts | checks contact-edge leakage |
| shuffled/wrong robot node | sanity check for shortcut reliance |

So the current design is acceptable for joint WAM training if the loader is causal. The graph should be understood as an observed embodied scene graph at time `t`, not as an oracle future graph.

#### Node inventory construction

For each episode, the exporter resets the RoboCasa environment to the source XML/state and builds a deterministic node inventory. The inventory order is:

1. robot node;
2. all configured RoboCasa objects from `ep_meta.object_cfgs`;
3. salient fixtures from `ep_meta.fixtures`;
4. candidate subparts of salient fixtures, such as doors, handles, drawers, trays, and buttons, when corresponding simulator bodies exist.

Object nodes:

```text
source: sim_object_cfg
family: object
free_movable: 1
articulated: 0
category_text: source object category with underscores replaced by spaces
```

Important leakage fix: task objects and distractor objects are both assigned `family=object` in `node_state`. Their role labels are preserved only under `goal_grounding_supervision_only.object_roles`, not in model-facing state tensors.

Fixture nodes:

```text
source: sim_fixture_salient
family: fixture or surface
free_movable: 0
articulated: 0
```

Counters are represented as `surface`; other salient appliances/cabinets/accessories are usually `fixture`.

Subpart candidate nodes:

```text
source: sim_fixture_subpart_candidate
possible families: articulated_part, handle, receptacle, control
articulated: 1 for articulated_part / handle / control / receptacle candidates
```

The current emitted data includes `articulated_part`, `handle`, and `receptacle`; `control` and `region` ids are reserved/defined but unpopulated in this release.

Structural fixture classes such as walls/floors may be counted in `inventory_info.fixture_class_counts` but skipped as graph nodes unless they are salient to the manipulation graph. Unknown/nonstructural fixture classes are recorded in `inventory_info.unknown_nonstructural_classes` rather than silently becoming model inputs.

#### Geometry-to-node attribution

Rendered segmentation and contact geoms are mapped back to graph nodes using nearest-ancestor body attribution:

```text
geom -> geom body -> nearest ancestor body that matches a node root body -> node index
```

This is why a handle/door/drawer subpart can receive its own masks and contacts instead of being shadowed by its parent fixture. The rule version is:

```text
geom_attribution: nearest_ancestor_v2
```

#### State extraction per node

For each timestep, the exporter restores the source simulator state, renders masks, computes visibility, and writes a 32-channel state vector for every real node. For each node, the primary body is `root_bodies[0]`; pose and velocity are read from that body:

```text
body_xpos      -> pos_x, pos_y, pos_z
body_xquat     -> quat_x, quat_y, quat_z, quat_w
body velocity  -> lin_x, lin_y, lin_z, ang_x, ang_y, ang_z
scalar joint   -> qpos, qvel for non-free joints only
visibility     -> vis_right, vis_left, vis_wrist from rendered masks
```

Free-joint coordinates are not duplicated into qpos/qvel because world pose/velocity already occupy the pose/velocity channels. qpos/qvel are reserved for scalar articulation coordinates. This is one reason six appliance/switch tasks are documented as state-blind in the current `node_state`: their task success can depend on fixture-internal switch/appliance state not represented by the current scalar channels.

#### Static edge design

`prior_edges` are deterministic structural relations inferred from node naming and fixture/subpart structure. They are not frame-dependent and are not dense. They currently include:

```text
part_of:  subpart -> parent fixture or subpart
controls: handle/control-like node -> articulated part it actuates
```

Examples:

```json
{"src": 6, "dst": 5, "rel": "part_of"}
{"src": 6, "dst": 5, "rel": "controls"}
```

Use these edges as structural priors. They are separate from dynamic contacts/visibility events and should not be interpreted as all possible physical relations.

#### Dynamic edge design

`dynamic_edges.jsonl` is a sparse event stream. For each timestep:

1. simulator contacts are mapped through geom-to-node attribution;
2. same-node contacts are dropped;
3. duplicated unordered contacts are collapsed;
4. contact edges are written as `src=min(node_i,node_j)`, `dst=max(node_i,node_j)`, `rel=contact`;
5. visibility changes relative to the previous frame are added as self-edges with `rel=visibility_change` and a `view` id.

This means contact edges are undirected in meaning but stored canonically as sorted directed records. Visibility-change edges are self-events whose `view` field identifies the camera.

Semantics notes:

```text
contact edges are instantaneous per-frame relations: a persisting contact is re-emitted at every frame while it holds (not only at transition).
visibility_change edges are transition events relative to the previous frame and therefore never occur at t=0.
every frame has exactly one dynamic_edges.jsonl row; the edges list may be empty.
contacts carry no force, normal, or penetration depth and no contact-pair filtering beyond same-node dropping and per-frame deduplication; robot-to-scene contacts are included.
```

#### Observation graph design

The graph deliberately separates state from observation:

```text
node_state.npz                  low-dimensional simulator-derived state channels
view_evidence.npz               per-view visibility / bbox / centroid / area
visible_masks_rle.jsonl.gz      binary segmentation masks for visible node-view pairs
visual_features_sparse.npz      pooled visual features only for visible pairs
```

Phase 2 never fabricates visual features for invisible pairs. If a dense tensor is needed, users should initialize zeros and scatter `feat` at `(t,n,v)` indices from `visual_features_sparse.npz`. Invalid visible pairs are separately listed as `invalid_t/n/v`, so the visible-pair partition remains auditable.

#### What the graph is not

The v1.2 sparse-v2 graph is not:

```text
a dense all-pairs relation tensor;
a full MuJoCo XML graph;
a privileged task-role graph with target/distractor bits in node_state;
a complete symbolic state for every appliance/switch task;
a dense visual feature tensor for every t,n,view slot.
```

It is a compact, validated, sparse manipulation graph aligned to RoboCasa frames/actions and designed for graph world-model experiments.


## Structured graph representation for model loaders

This section gives the most explicit model-facing representation of the graph. The on-disk files are intentionally sparse and JSON/NPZ based, but a loader can convert each episode into the following typed tensors.

### Per-episode graph object

For an episode with `T` frames, `N_real` real nodes, and padded cap `N_MAX=256`:

```text
G_episode = {
  nodes_static:      list[N_real] records from graph_static.json/nodes,
  node_state:        float32[T, 256, 32],
  active_mask:       bool[T, 256]              = node_state[..., 0] == 1,
  prior_edge_index:  int64[2, E_prior],
  prior_edge_attr:   int64[E_prior] or onehot[E_prior, R_prior],
  dyn_edge_index[t]: int64[2, E_dyn_t],
  dyn_edge_attr[t]:  typed records / encoded features for events at t,
  view_evidence:     bool/float16 tensors over [T, 256, 3, ...],
  visual_sparse:     COO rows (t,n,v,feat[256]) for visible valid pairs,
  action:            optional float32[T, 12] from frames.jsonl
}
```

Recommended graph convention for GNNs:

```text
node dimension: slot n in [0,255]
real-node mask: node_state[t,n,active] == 1
padding policy: ignore/mask every tensor row where active == 0
static edges:   prior_edge_index is fixed for the episode
dynamic edges:  dyn_edge_index[t] varies by timestep and can be empty
```

### Node feature representation

There are three different node-related feature groups. Keep them conceptually separate:

| Feature group | File/key | Shape | Time-varying? | Model-facing? | Meaning |
|---|---|---:|---:|---:|---|
| physical/state node features `X_t` | `graph/node_state.npz/node_state` | `[T,256,32]` | yes | yes, if privileged sim state is allowed | low-dimensional state, visibility flags, family id, pose/velocity/articulation |
| static node records | `graph/graph_static.json/nodes` | `N_real` JSON records | no | metadata; selected fields can be encoded | node id, family, category text, root bodies, source, flags |
| category text feature | `graph/visual_features_sparse.npz/type_clip32` | `[256,32]` | no | optional; category-label ablation recommended | CLIP text embedding projected to 32-D; padded slots are non-zero and must be active-gated |

The exact 32-D `node_state` layout is:

| Channel range | Dim | Name(s) | Dtype | Representation | Notes |
|---:|---:|---|---|---|---|
| 0 | 1 | `active` | float32 binary | 1 real node, 0 padding | mandatory mask |
| 1 | 1 | `family_idx` | float32 integer-coded | ids 0..9 | usually embed/cast to int for GNNs |
| 2 | 1 | `free_movable` | float32 binary | free object/robot mobility flag | static copied over time |
| 3 | 1 | `articulated` | float32 binary | scalar articulated part flag | static copied over time |
| 4:7 | 3 | `pos_x,pos_y,pos_z` | float32 | world/body position | primary root body |
| 7:11 | 4 | `quat_x,quat_y,quat_z,quat_w` | float32 | orientation quaternion | primary root body |
| 11:14 | 3 | `lin_x,lin_y,lin_z` | float32 | linear velocity | primary root body |
| 14:17 | 3 | `ang_x,ang_y,ang_z` | float32 | angular velocity | primary root body |
| 17 | 1 | `qpos` | float32 | scalar joint position | 0 if unavailable/non-scalar/free joint |
| 18 | 1 | `qvel` | float32 | scalar joint velocity | 0 if unavailable/non-scalar/free joint |
| 19:22 | 3 | `vis_right,vis_left,vis_wrist` | float32 binary | per-camera visible flag | same visibility as `view_visible[...,0:3]` |
| 22:32 | 10 | `reserved_22...reserved_31` | float32 | reserved zeros | do not assign semantics in v1.2 |

Suggested typed split for model code:

```python
x = node_state[t]                         # float32 [256,32]
active = x[:, 0].astype(bool)             # [256]
family = x[:, 1].astype(np.int64)         # [256], valid only where active
flags = x[:, 2:4]                         # [256,2]
pose = x[:, 4:11]                         # [256,7] = xyz + quat_xyzw
velocity = x[:, 11:17]                    # [256,6]
joint = x[:, 17:19]                       # [256,2]
visibility = x[:, 19:22]                  # [256,3]
reserved = x[:, 22:32]                    # [256,10], currently zeros
```

Do not treat `node_state` as a homogeneous 32-D semantic vector without masking/casting: `family_idx` is categorical, `active/free_movable/articulated/visibility` are binary, pose/quaternion/velocity/joint channels are continuous, and reserved channels are placeholders.


### Avoiding the two-`256` ambiguity: node slots vs SAM2 feature dimension

The release uses the number `256` in two different axes. They are unrelated and should not be confused. In `node_state`-style tensors, **256 = padded node slots**. In `visual_features_sparse.npz/feat`, 256 = SAM2 visual feature dimension.

| Tensor / slice | Shape | Meaning of `256` | Feature dimension |
|---|---:|---|---:|
| `node_state[t]` | `[256,32]` | padded node slots, `N_MAX=256` | 32 state channels per node |
| `node_state[t,:,11:17]` | `[256,6]` | padded node slots, `N_MAX=256` | 6 velocity channels per node |
| `view_visible[t]` | `[256,3]` | padded node slots, `N_MAX=256` | 3 camera visibility flags per node |
| `type_clip32` | `[256,32]` | padded node slots, `N_MAX=256` | 32 CLIP text/type channels per node slot |
| `visual_features_sparse.npz/feat` | `[P,256]` | **not node slots**; here `P` rows are visible `(t,n,v)` pairs | 256-D SAM2 pooled visual feature |

So **[256,6] is not a projection from 6D into 256D**. It means:

```text
256 rows = node slots
6 columns = velocity channels per node
```

The velocity slice is:

```python
velocity = node_state[t, :, 11:17]   # [256,6]
```

For node slot `n`:

```python
velocity_n = velocity[n]             # [6] = lin_x, lin_y, lin_z, ang_x, ang_y, ang_z
```

If an episode has only `N_real=123` real nodes, then the first 123 active rows are real and rows 123..255 are padding:

```python
active = node_state[t, :, 0].astype(bool)  # [256]
velocity_real = velocity[active]           # [N_real,6], e.g. [123,6]
```

The 256-D SAM2 visual feature is a different tensor:

```python
feat = phase2["feat"]                  # [P,256]
```

For sparse row `p`:

```python
t = phase2["t"][p]
n = phase2["n"][p]
v = phase2["v"][p]
visual_p = feat[p]                      # [256] SAM2 pooled visual feature for node n in view v at time t
```

A model may later project node features to a hidden dimension, but that is model-side processing, not dataset storage. For example:

```python
velocity = node_state[t, :, 11:17]      # [256,6]
hidden_velocity = Linear(6, 128)(velocity)  # [256,128]
```

Here the node axis remains 256 slots; only the per-node feature dimension changes from 6 to 128.





### Start here: how to use the graph and sample code

If you are new to this dataset, use this section first. The important idea is:

```text
The uploaded episode files store a padded graph table for convenience.
The sample dataloader converts that storage format into the variable-size graph that a GNN usually expects.
```

The sample code is here:

```text
loaders/gwam_graph_dataloader.py
```

It is also duplicated under the release folder:

```text
gwam_v12_sparse_v2/loaders/gwam_graph_dataloader.py
```

#### What the sample dataloader does

The loader reads one episode ZIP or one extracted episode directory and returns one graph at one timestep `t`.

It performs these steps for you:

```text
1. Reads graph/node_state.npz.
2. Uses node_state[t,:,0] as active_mask.
3. Removes inactive padded rows from the fixed 256 storage slots.
4. Converts the remaining storage slot ids into local GNN node ids 0..N_real-1.
5. Removes raw active and raw family_idx from the continuous feature block.
6. Encodes family_idx safely as one-hot, returns it for a learned embedding, or removes it.
7. Mean-pools sparse SAM2 visual features over visible camera views.
8. Adds a visual_feature_valid mask so missing visual features are explicit.
9. Optionally appends type_clip32 and view-evidence features.
10. Reads static and dynamic edge records.
11. Remaps edge src/dst from storage slot ids to local node ids.
12. Returns x, edge_index, edge_attr, slot_ids, schemas, and masks.
```

#### Command-line example

After downloading or extracting the dataset, run:

```bash
python loaders/gwam_graph_dataloader.py \
  --zip episodes/target/TurnOnSinkFaucet/episode_000505.zip \
  --t 0 \
  --family-encoding onehot \
  --include-visual \
  --include-view-evidence \
  --include-type-clip32
```

If you are running from the release subfolder, use:

```bash
python gwam_v12_sparse_v2/loaders/gwam_graph_dataloader.py \
  --zip gwam_v12_sparse_v2/episodes/target/TurnOnSinkFaucet/episode_000505.zip \
  --t 0 \
  --family-encoding onehot \
  --include-visual \
  --include-view-evidence \
  --include-type-clip32
```

The command prints a JSON summary. Important fields are:

| Output field | Meaning |
|---|---|
| `N_real` | number of active real nodes after dropping padded storage slots |
| `D_node` | number of columns in `x` after the selected feature blocks are assembled |
| `E` | number of remapped graph edges at timestep `t` |
| `D_edge` | number of columns in combined `edge_attr`; the verified loader uses 8 |
| `visual_valid_count` | number of active nodes that had at least one visible SAM2 feature row |
| `feature_schema` | names of every node-feature column in `x` |
| `edge_schema` | names of every edge-feature column in `edge_attr` |

A verified smoke test on a real staged episode produced:

```text
N_real = 136
D_node = 342
E = 87
D_edge = 8
visual_valid_count = 26
```

#### Python example: get a GNN-ready graph

```python
from loaders.gwam_graph_dataloader import load_gwam_graph_timestep

graph = load_gwam_graph_timestep(
    zip_path="episodes/target/TurnOnSinkFaucet/episode_000505.zip",
    t=0,
    family_encoding="onehot",
    include_visual=True,
    include_type_clip32=True,
    include_view_evidence=True,
)

x = graph["x"]                    # [N_real, D_node]
edge_index = graph["edge_index"]  # [2, E]
edge_attr = graph["edge_attr"]    # [E, 8]
slot_ids = graph["slot_ids"]      # original 0..255 storage node slots

print(x.shape)
print(edge_index.shape)
print(edge_attr.shape)
```

The returned graph follows the common PyG/DGL style:

```text
x          = node features for real active nodes only
edge_index = graph connectivity after remapping slot ids to local node ids
edge_attr  = numeric edge features
slot_ids   = mapping back to the original storage slots
```

#### What node features does this example include?

With this call:

```python
family_encoding="onehot"
include_visual=True
include_type_clip32=True
include_view_evidence=True
```

`x` contains:

| Block | Dimension | Explanation |
|---|---:|---|
| state features | 20 | `node_state` channels 2:22; flags, position, orientation, velocity, joint state, visibility |
| family one-hot | 10 | safe categorical encoding of `family_idx` |
| SAM2 visual feature | 256 | mean-pooled over visible camera views for the node at timestep `t` |
| type/category feature | 32 | optional `type_clip32`; useful but can be ablated if semantic labels are considered privileged |
| view evidence | 24 | three cameras × eight values: visible, center x/y, area, bounding box |
| **total** | **342** | verified example dimension |

Why this is 342 instead of the earlier source-block illustration of 344:

```text
The safe loader drops active, raw family_idx, and reserved zero channels.
It then adds a 10-D family one-hot encoding.
```

#### How to handle family_idx correctly

`family_idx` is categorical. Do not treat it as a continuous float.

Safe fixed encoding:

```python
graph = load_gwam_graph_timestep(
    zip_path="episode_000505.zip",
    t=0,
    family_encoding="onehot",
)

x = graph["x"]  # includes family_onehot_0 ... family_onehot_9
```

Recommended neural-network encoding:

```python
graph = load_gwam_graph_timestep(
    zip_path="episode_000505.zip",
    t=0,
    family_encoding="embedding_placeholder",
)

family_idx = graph["family_idx"]  # integer ids, shape [N_real]

# In PyTorch model code:
# family_idx_t = torch.as_tensor(family_idx, dtype=torch.long)
# family_feat = family_embedding(family_idx_t)
# x = torch.cat([continuous_features, family_feat, other_features], dim=-1)
```

Do not do this:

```python
bad_x = node_state[t, active, :32].astype("float32")
```

That incorrectly feeds `family_idx` as a raw float and creates a fake ordering such as `robot=9` being larger than `object=1`.

#### What edge features does this example include?

The loader returns a combined `edge_attr` with eight columns:

```text
[static_is_part_of,
 static_is_controls,
 dynamic_is_contact,
 dynamic_is_visibility_change,
 dynamic_view_right,
 dynamic_view_left,
 dynamic_view_wrist,
 dynamic_is_self_edge]
```

It also returns separated edge tensors:

```text
static_edge_attr  [E_static, 2] = [is_part_of, is_controls]
dynamic_edge_attr [E_dynamic, 6] = [is_contact, is_visibility_change, view_right, view_left, view_wrist, is_self_edge]
```

Examples:

```text
static part_of edge        = [1, 0]
static controls edge       = [0, 1]
dynamic contact edge       = [1, 0, 0, 0, 0, 0]
right visibility change    = [0, 1, 1, 0, 0, 1]
left visibility change     = [0, 1, 0, 1, 0, 1]
wrist visibility change    = [0, 1, 0, 0, 1, 1]
```

Static edges define scene structure. Dynamic edges define frame-level events. Contact edges do not include force, contact normal, contact point, penetration depth, distance, or material; regenerate those from the simulator if needed.

#### Minimal use in a training loop

```python
for t in range(num_frames):
    graph = load_gwam_graph_timestep(
        zip_path=episode_zip,
        t=t,
        family_encoding="onehot",
        include_visual=True,
        include_view_evidence=True,
    )

    x = graph["x"]
    edge_index = graph["edge_index"]
    edge_attr = graph["edge_attr"]

    # Feed x, edge_index, edge_attr to your GNN.
```

If you use PyTorch Geometric, convert arrays like this:

```python
import torch
from torch_geometric.data import Data

data = Data(
    x=torch.as_tensor(graph["x"], dtype=torch.float32),
    edge_index=torch.as_tensor(graph["edge_index"], dtype=torch.long),
    edge_attr=torch.as_tensor(graph["edge_attr"], dtype=torch.float32),
)
```

This section is the recommended starting point for students who want to use the graph data directly.

### Graph definition, node definition, and edge definition

This release represents each RoboCasa episode as a time-indexed scene graph.
The graph is not a separate hand-labeled abstraction; it is built from simulator state, object inventory, camera visibility, masks, and event records.

#### Graph definition

At frame `t`, the graph contains:

```text
G_t = active nodes at frame t + static/prior edges + dynamic/event edges at frame t
```

For storage, every episode uses up to 256 node slots. For model use, a loader should remove inactive padded slots and return a variable-size graph:

```text
x          [N_real, D_node]
edge_index [2, E]
edge_attr  [E, D_edge]
```

`N_real` is the number of real active nodes in that frame. It can change across episodes and tasks. The fixed `256` is only a storage/alignment capacity, not a GNN requirement.

#### Node definition

A node is one physical or semantic entity that can carry state, visibility, and optional visual evidence. The node inventory includes:

```text
robot node
movable object nodes
fixture nodes
articulated part nodes
handle / door / drawer nodes
surface / region nodes
```

The robot is included as a graph node so robot state can participate in message passing. Padded slots are not nodes; they are inactive storage rows and must be masked or dropped.

#### Edge definition

An edge is a directed or event-style relationship between two node slots. The release uses two edge groups:

```text
Static/prior edges: stable structural relations such as part_of and controls.
Dynamic/event edges: per-frame contact and visibility_change events.
```

Static edges explain how the scene is structured. Dynamic edges explain what is happening at a frame. Edge vectors used by the dataloader are numeric encodings constructed from relation strings; they are not stored as dense tensors in the raw episode files.

### Verified graph dataloader example

A verified example loader is included with this package:

```text
loaders/gwam_graph_dataloader.py
```

It converts the padded storage files for one episode timestep into a normal variable-size graph for GNN use:

```text
x          [N_real, D_node]   active nodes only, no padded rows
edge_index [2, E]             source/destination local node ids
edge_attr  [E, 8]             combined edge attributes for static and dynamic edges
slot_ids   [N_real]           original storage slot ids in 0..255
```

Run it on one episode ZIP:

```bash
python loaders/gwam_graph_dataloader.py   --zip episodes/target/TurnOnSinkFaucet/episode_000505.zip   --t 0   --family-encoding onehot   --include-visual   --include-view-evidence
```

The loader implements the recommended graph-data handling:

```text
1. Use node_state[t,:,0] as active_mask.
2. Drop inactive padded node slots before GNN computation.
3. Drop raw active and raw family_idx from continuous learned features.
4. Convert family_idx with --family-encoding onehot, or use embedding_placeholder and pass integer family ids to a learned embedding in your model.
5. Drop reserved node_state channels 22:32 by default.
6. Mean-pool SAM2 feat rows over visible camera views for each active node.
7. Keep visual_feature_valid so invisible/no-feature nodes are not confused with real zero visual features.
8. Remap edge src/dst from storage slot ids to local node ids after dropping padding.
```

Minimal Python usage:

```python
from loaders.gwam_graph_dataloader import load_gwam_graph_timestep

graph = load_gwam_graph_timestep(
    zip_path="episodes/target/TurnOnSinkFaucet/episode_000505.zip",
    t=0,
    family_encoding="onehot",      # safe fixed encoding
    include_visual=True,
    include_type_clip32=False,      # optional semantic feature; ablate if needed
    include_view_evidence=True,
)

x = graph["x"]                    # [N_real, D_node]
edge_index = graph["edge_index"]  # [2, E]
edge_attr = graph["edge_attr"]    # [E, 8]
slot_ids = graph["slot_ids"]      # original 0..255 node slots
```

If you prefer a learned family embedding, do not ask the numpy loader to append one-hot. Return integer family ids and embed them inside the model:

```python
graph = load_gwam_graph_timestep(
    zip_path="episode_000505.zip",
    t=0,
    family_encoding="embedding_placeholder",
    include_visual=True,
    include_view_evidence=True,
)

family_idx = graph["family_idx"]  # integer categorical ids, shape [N_real]
# In PyTorch model code:
# family_feat = family_embedding(torch.as_tensor(family_idx, dtype=torch.long))
# x = torch.cat([continuous_float_features, family_feat, visual_features], dim=-1)
```

Do not do this:

```python
bad_x = node_state[t, active, :32].astype("float32")
```

That feeds `family_idx` as a raw float and gives it a false ordinal meaning. `family_idx` is a category, not a continuous coordinate.

The combined `edge_attr` returned by the loader has eight columns:

```text
[static_is_part_of, static_is_controls,
 dynamic_is_contact, dynamic_is_visibility_change,
 dynamic_view_right, dynamic_view_left, dynamic_view_wrist, dynamic_is_self_edge]
```

The loader also returns the separated edge views:

```text
static_edge_attr  [E_static, 2] = [is_part_of, is_controls]
dynamic_edge_attr [E_dynamic, 6] = [is_contact, is_visibility_change, view_right, view_left, view_wrist, is_self_edge]
```

This example keeps the released data unchanged. It only shows how to assemble model inputs safely in the loader.

### Storage format vs. actual GNN graph

The fixed 256 node slots are a **storage and alignment format**, not a limitation of GNN models. Standard GNNs can handle graphs with different numbers of nodes. The dataset stores `node_state` as `[T,256,32]` so every episode has the same file shape and all node-indexed files agree on the same slot id `n`:

```text
graph_static.json/nodes[n]
node_state[t,n,:]
view_visible[t,n,v]
view_bbox[t,n,v,:]
visual_features_sparse rows with phase2["n"] == n
prior_edges / dynamic_edges with src or dst == n
```

This shared slot index makes the dataset easy to save, validate, zip, and join with masks/visual features. It does **not** mean the model must process 256 real nodes.

Conceptually, the actual graph at timestep `t` is:

```text
N_real active nodes + E_prior static edges + E_dyn_t dynamic edges
```

For a standard PyG/DGL-style GNN, convert from padded storage to a ragged graph:

```python
import numpy as np

x_padded = node_state[t]                 # [256,32], storage form
active = x_padded[:, 0].astype(bool)     # [256]

# Keep only real nodes for GNN input.
x = x_padded[active]                     # [N_real,32]

# Map storage slot id -> local GNN node id.
slot_to_local = {}
for local_id, slot_id in enumerate(np.where(active)[0]):
    slot_to_local[int(slot_id)] = int(local_id)
```

Then remap edge lists:

```python
def remap_edges(edge_records, rel_vocab):
    edge_index = []
    edge_type = []
    for e in edge_records:
        src_slot, dst_slot = int(e["src"]), int(e["dst"])
        if src_slot in slot_to_local and dst_slot in slot_to_local:
            edge_index.append([slot_to_local[src_slot], slot_to_local[dst_slot]])
            edge_type.append(rel_vocab[e["rel"]])
    if edge_index:
        edge_index = np.asarray(edge_index, dtype=np.int64).T  # [2,E]
    else:
        edge_index = np.zeros((2, 0), dtype=np.int64)
    edge_type = np.asarray(edge_type, dtype=np.int64)          # [E]
    return edge_index, edge_type

prior_edge_index, prior_edge_type = remap_edges(
    graph_static["prior_edges"],
    {"part_of": 0, "controls": 1},
)
```

So there are two valid model-loading styles:

| Loading style | Tensor shape seen by model | When to use |
|---|---:|---|
| Padded dense loader | `[256,F]` plus `active_mask` | transformer/dense batching; must mask inactive slots after every layer and during pooling |
| Ragged GNN loader | `[N_real,F]`, `edge_index=[2,E]` | standard GNN/PyG/DGL; drop padded slots and remap edge indices |

Recommended for a normal GNN:

```text
GNN can use [N_real,F] node features and [2,E] edge_index.
Use [N_real,F] nodes and [2,E] edge_index after active-mask filtering.
Keep 256-slot ids only as storage/source indices for joining node_state, masks, visual features, and edge records.
```

This is why the dataset uses `N_MAX=256`: it is a fixed storage capacity and cross-file alignment key. It is not a claim that GNNs need fixed node counts.


### Example fused node and edge feature dimensions for model input

The dataset stores node state, visual features, category/type features, and view evidence in separate files. A model loader may concatenate them into one fused node vector. The following is an **illustration of one full fused node feature design**, not an extra precomputed tensor in the release.

#### Example fused node feature: 344 dimensions per active node per frame

| Block order | Feature block | Dimension | Source file/key | Meaning |
|---:|---|---:|---|---|
| 1 | SAM2 visual feature | 256 | `visual_features_sparse.npz/feat` | pooled visual feature for this node in a selected or pooled camera view; use zeros/mask if unavailable |
| 2 | node state | 32 | `node_state.npz/node_state` | physical/state channels, listed below |
| 3 | category/type text feature | 32 | `visual_features_sparse.npz/type_clip32` | CLIP text feature for node category; optional and active-gated |
| 4 | view evidence | 24 | `view_evidence.npz` | per-camera 2D evidence: 3 cameras × 8 values per camera |
|  | **Total example fused node feature** | **344** |  | `256 + 32 + 32 + 24` |

The 32-D `node_state` block contains:

| Sub-block | Dimension | Channels | Meaning |
|---|---:|---|---|
| active flag | 1 | `active` | real node vs padding; normally used as mask, not learned content |
| node family | 1 | `family_idx` | categorical family id; can be embedded instead of used as scalar |
| static flags | 2 | `free_movable`, `articulated` | object/articulation properties |
| position | 3 | `pos_x,pos_y,pos_z` | world/body position |
| orientation | 4 | `quat_x,quat_y,quat_z,quat_w` | quaternion orientation |
| velocity | 6 | `lin_x,lin_y,lin_z,ang_x,ang_y,ang_z` | linear and angular velocity |
| joint state | 2 | `qpos,qvel` | scalar articulated joint state if available |
| visibility flags | 3 | `vis_right,vis_left,vis_wrist` | visible in each camera |
| reserved | 10 | `reserved_22...reserved_31` | zeros in v1.2; usually ignored |
| **Total node_state block** | **32** |  |  |

The 24-D view-evidence block is:

| Per-camera view-evidence values | Dimension per camera | For 3 cameras |
|---|---:|---:|
| visible flag | 1 | 3 |
| centroid `(x,y)` | 2 | 6 |
| visible area | 1 | 3 |
| bounding box `(x_min,y_min,x_max,y_max)` | 4 | 12 |
| **Total** | **8** | **24** |

Important notes:

```text
1. This 344-D fused vector is an example loader design, not a required format.
2. If you pool over multiple cameras, you may keep one 256-D SAM2 vector, concatenate all camera features, or create one node-view graph per camera.
3. If category labels are considered privileged, remove the 32-D type_clip32 block.
4. For a pure simulator-state GNN, use only the 32-D node_state block.
5. Always remove or mask inactive padded slots before GNN computation.
```


#### Exact fused feature index layout for the 344-D example node vector

If a student wants one flat node vector per active node, use the following explicit ordering. This is an implementation-ready convention for a model loader; the dataset still stores the source blocks separately.

```text
fused_node_feature[n] has length 344
```

| Fused index range | Dimension | Feature block | Exact content |
|---:|---:|---|---|
| `0:256` | 256 | SAM2 visual feature | `feat[p]` for the selected or view-pooled `(t,n,v)` visual row; use zeros plus a validity mask if unavailable |
| `256:288` | 32 | `node_state` block | copied from `node_state[t,n,0:32]`; detailed sub-layout below |
| `288:320` | 32 | `type_clip32` block | `type_clip32[n,0:32]`; optional category/type text vector; active-gate required |
| `320:344` | 24 | view-evidence block | three cameras × eight values per camera; detailed sub-layout below |
| **total** | **344** |  | `256 + 32 + 32 + 24` |

Inside the `node_state` block at fused indices `256:288`:

| Fused index range | Local node_state channels | Dimension | Feature |
|---:|---:|---:|---|
| `256:257` | `0` | 1 | active flag |
| `257:258` | `1` | 1 | family id; categorical id 0..9 |
| `258:260` | `2:4` | 2 | static flags: free_movable, articulated |
| `260:263` | `4:7` | 3 | position xyz |
| `263:267` | `7:11` | 4 | orientation quaternion xyzw |
| `267:273` | `11:17` | 6 | velocity: linear xyz and angular xyz |
| `273:275` | `17:19` | 2 | scalar joint state: qpos, qvel |
| `275:278` | `19:22` | 3 | visibility flags: right, left, wrist |
| `278:288` | `22:32` | 10 | reserved zeros in v1.2 |

Inside the 24-D view-evidence block at fused indices `320:344`:

| Fused index range | Camera | Dimension | Feature order |
|---:|---|---:|---|
| `320:328` | right agentview | 8 | visible, centroid_x, centroid_y, area, bbox_xmin, bbox_ymin, bbox_xmax, bbox_ymax |
| `328:336` | left agentview | 8 | same order |
| `336:344` | wrist camera | 8 | same order |

Recommended validity masks to keep with this fused node vector:

| Mask | Shape before dropping padding | Meaning |
|---|---:|---|
| `active_mask` | `[256]` | real node slot vs padding |
| `visual_feature_valid` | `[256]` or `[256,3]` | whether a SAM2 feature was available for the selected pooled view or per camera |
| `view_visible` | `[256,3]` | whether each node is visible in each camera |


#### How to read and encode each feature dimension

The exact index tables above define where every feature lives. This section explains how each value should be interpreted by a model loader.

```text
What is stored vs. what you assemble
```

The release stores separate source blocks: `node_state[T,256,32]`, sparse SAM2 features `feat[P,256]`, `type_clip32[256,32]`, view-evidence arrays, and edge records with relation strings. The 344-D node vector, 2-D static edge vector, and 6-D dynamic edge vector are **not separate files**. They are an example model-loader representation after concatenating blocks and numerically encoding relations.

Node feature interpretation:

| Feature | Stored encoding | Recommended model use |
|---|---|---|
| `active` | float 0/1 | mask only; drop padded rows before GNN computation; do not treat as learned content |
| `family_idx` | scalar categorical id 0..9 stored as float | cast to integer, then use learned embedding or one-hot; never feed raw scalar into a Linear/MLP |
| `free_movable`, `articulated` | binary 0/1 flags | use directly as binary features |
| position xyz | continuous floats | use directly; optionally normalize by scene/statistics |
| orientation quaternion | continuous 4-number quaternion | use directly; optionally canonicalize sign for temporal smoothness |
| linear/angular velocity | continuous floats | use directly; optionally normalize |
| `qpos`, `qvel` | continuous floats; zero if not meaningful | use with articulation mask/context; zeros do not always mean a real zero joint state |
| visibility flags | binary camera flags | use directly; these duplicate the visible bit in the view-evidence block by design |
| reserved channels | zeros in v1.2 | drop for a lean loader; keep only if preserving a fixed 32-D layout |
| SAM2 visual feature | 256-D pooled feature for visible node-view mask | mean-pool visible camera rows for the 344-D example; use zero vector plus validity mask if absent |
| `type_clip32` | 32-D category text feature | optional semantic/type feature; active-gate because padded rows are non-zero |
| view evidence | per-camera visible, center, area, bbox | use as geometric image evidence; values are normalized image coordinates/areas |

##### Why `family_idx` is not stored as one-hot

`family_idx` is stored as a scalar categorical id, not as a one-hot vector and not as a learned embedding. This is a storage choice, not a recommendation to feed the raw number into a neural network.

Reasons:

1. A scalar id is the smallest lossless representation. A 10-way one-hot would spend 10 channels in the fixed 32-D `node_state` tensor to store one category.
2. The dataset stores raw reusable information; the model loader should choose the encoding.
3. A learned embedding is at least as expressive as one-hot followed by a linear layer: `one_hot(id) @ W` is equivalent to `Embedding(id)`.
4. Keeping it as one clearly labeled scalar makes ablations easy: remove or mask one column rather than finding ten one-hot columns.

Recommended encodings:

| Encoding | Width | Learnable | Recommendation |
|---|---:|---|---|
| raw scalar id into MLP | 1 | no | do not use; Never feed raw scalar into a Linear/MLP because it creates a false ordinal scale |
| one-hot family id | 10 | no | acceptable fixed encoding, but wider and includes reserved/unpopulated family ids |
| learned embedding | chosen by model | yes | recommended for GNNs |

Implementation sketch:

```python
active = node_state[t, :, 0].astype(bool)
x_state = node_state[t, active]
family_idx = x_state[:, 1].astype("int64")
family_emb = family_embedding(torch.from_numpy(family_idx))

# Recommended: concatenate continuous/binary state features with family_emb.
# Do not feed x_state[:, 1] as a raw float feature.
```

Default visual pooling for the 344-D example:

```text
For node n at frame t, mean-pool SAM2 feat[p] over visible camera rows with matching (t,n,v).
If no visible row exists, use a zero 256-D vector and set visual_feature_valid[n] = 0.
```

Lean-loader option:

```text
A lean GNN loader may drop active, reserved channels, duplicate visibility bits, and semantic type_clip32.
Then the node dimension is smaller than 344. The 344-D layout is only a fully explicit example.
```

#### Exact edge feature index layout

Static/prior edge feature vector:

```text
static_edge_attr[e] has length 2
```

| Static edge index | Feature | Value meaning |
|---:|---|---|
| `0` | `is_part_of` | 1 if relation is `part_of`, else 0 |
| `1` | `is_controls` | 1 if relation is `controls`, else 0 |

Dynamic/event edge feature vector:

```text
dynamic_edge_attr[e] has length 6
```

| Dynamic edge index | Feature | Value meaning |
|---:|---|---|
| `0` | `is_contact` | 1 for contact edge |
| `1` | `is_visibility_change` | 1 for visibility-change edge |
| `2` | `view_right` | 1 if visibility change occurs in right agentview; 0 for contact |
| `3` | `view_left` | 1 if visibility change occurs in left agentview; 0 for contact |
| `4` | `view_wrist` | 1 if visibility change occurs in wrist camera; 0 for contact |
| `5` | `is_self_edge` | 1 for visibility-change self-edge, 0 for contact |

Example encodings:

```text
static part_of edge:        [1, 0]
static controls edge:       [0, 1]
dynamic contact edge:       [1, 0, 0, 0, 0, 0]
right visibility change:    [0, 1, 1, 0, 0, 1]
left visibility change:     [0, 1, 0, 1, 0, 1]
wrist visibility change:    [0, 1, 0, 0, 1, 1]
```

Contact edges only say that two nodes are touching. They do not contain force, normal direction, contact point, penetration depth, distance, or material information.

#### Example edge feature dimensions

Static/prior edge feature:

| Edge feature block | Dimension | Meaning |
|---|---:|---|
| relation type one-hot | 2 | `part_of` or `controls` |
| **Total static edge feature** | **2** | used with `prior_edge_index` |

Dynamic/event edge feature:

| Edge feature block | Dimension | Meaning |
|---|---:|---|
| relation type one-hot | 2 | `contact` or `visibility_change` |
| camera/view one-hot | 3 | right, left, wrist; all zeros for contact edges |
| self-edge flag | 1 | 1 for visibility-change self-edge, 0 for contact |
| **Total dynamic edge feature** | **6** | used with per-frame `dyn_edge_index[t]` |

Contact edges do not include force, normal direction, contact point, penetration depth, distance, or material properties. If those are needed, they must be regenerated from the source simulator.

### Static node-record representation

Each `graph_static.json/nodes[i]` record defines the static identity of node slot `i`:

| Field | Type | Recommended encoding | Model-input caution |
|---|---|---|---|
| `node_id` | string | metadata/debug only | may leak task/source naming; do not use by default |
| `family` | string | equivalent to `family_idx`; embed as categorical if used | safe as node type |
| `category_text` | string | source prompt for `type_clip32` | category label; ablate if category labels are privileged |
| `root_bodies` | list[str] | metadata for geom attribution | source/sim metadata, not default model input |
| `source` | string | metadata/debug | not default model input |
| `free_movable` | int/bool | already in node_state channel 2 | static flag |
| `articulated` | int/bool | already in node_state channel 3 | static flag |

Current family id table:

| family_idx | family | Populated in v1.2? | Meaning |
|---:|---|---:|---|
| 0 | `object` | yes | movable task and distractor objects; target/distractor role not exposed here |
| 1 | `reserved` | no | old distractor id; forbidden in current model-facing tensors |
| 2 | `surface` | yes | counters/support surfaces |
| 3 | `receptacle` | yes | drawers/trays/containers where represented |
| 4 | `fixture` | yes | static appliances/cabinets/accessories |
| 5 | `articulated_part` | yes | doors/lids/racks/drawers/jointed parts |
| 6 | `handle` | yes | handles or handle-like actuators |
| 7 | `control` | no | reserved for future switches/knobs/buttons |
| 8 | `region` | no | reserved for future spatial/semantic regions |
| 9 | `robot` | yes | robot arm/gripper/base aggregate node |

### Static/prior edge representation

Static/prior edges are fixed for the episode and live in `graph_static.json/prior_edges`.

On disk:

```json
{"src": 31, "dst": 30, "rel": "controls"}
```

Model-ready tensorization:

```text
prior_edge_index: int64[2, E_prior]
  prior_edge_index[0, e] = src node slot
  prior_edge_index[1, e] = dst node slot

prior_edge_type: int64[E_prior]
  0 = part_of
  1 = controls

prior_edge_attr_onehot: float32[E_prior, 2] optional one-hot over relation type
```

Relation semantics:

| rel | Direction | Encoded id | Dim if one-hot | Meaning |
|---|---|---:|---:|---|
| `part_of` | child/subpart -> parent | 0 | `[1,0]` | structural inclusion, e.g. handle/drawer/door belongs to fixture |
| `controls` | actuator/handle -> articulated part | 1 | `[0,1]` | source node controls or actuates destination node |

Important details:

```text
E_prior varies by episode.
Prior edges are directed structural priors, not dynamic state.
The same (src,dst) pair may carry more than one relation, e.g. both part_of and controls.
There is no dense static adjacency tensor in the release; build one only if your model needs it.
If using undirected message passing, explicitly add reverse edges in the loader and mark/encode direction if needed.
```

### Dynamic/event edge representation

Dynamic edges are stored as one JSONL row per frame in `graph/dynamic_edges.jsonl`:

```json
{"t": 2, "edges": [{"src": 32, "dst": 32, "rel": "visibility_change", "view": 2}]}
```

Model-ready per-frame tensorization:

```text
dyn_edge_index[t]: int64[2, E_dyn_t]
dyn_edge_type[t]:  int64[E_dyn_t]
  0 = contact
  1 = visibility_change

dyn_edge_attr[t]: optional structured attributes
  relation_onehot: float32[E_dyn_t, 2]
  view_onehot:     float32[E_dyn_t, 3] or zeros for contact
  is_self_edge:    float32[E_dyn_t, 1]
```

Dynamic edge-feature schema:

| Edge rel | Direction/storage | Required fields | Optional encoded features | Semantics |
|---|---|---|---|---|
| `contact` | stored as `src=min(i,j)`, `dst=max(i,j)`; physically undirected | `src`, `dst`, `rel` | `rel_onehot=[1,0]`, `view_onehot=[0,0,0]`, `is_self_edge=0` | simulator contact relation at frame `t`; repeated every frame while contact persists |
| `visibility_change` | self-edge `src==dst`; transition event | `src`, `dst`, `rel`, `view` | `rel_onehot=[0,1]`, `view_onehot` for changed camera, `is_self_edge=1` | node visibility changed in camera `view` relative to previous frame; never at `t=0` |

Contact edges are stored as sorted node pairs (`src=min(i,j)`, `dst=max(i,j)`) and are physically undirected; add reverse edges explicitly for bidirectional message passing.

Dynamic edges do **not** include force, normal, penetration depth, contact point, distance, or material information. If a downstream model needs those, they must be regenerated from the source simulator state/XML, not read from this release.

### View/visual feature representation

View evidence can be treated as node-view attributes rather than graph edges:

| Feature | Shape | Suggested model use |
|---|---:|---|
| `view_visible` | bool `[T,256,3]` | observed node-view mask / visibility token |
| `view_centroid` | float16 `[T,256,3,2]` | normalized 2D location per camera |
| `view_area` | float16 `[T,256,3,1]` | normalized visible area fraction |
| `view_bbox` | float16 `[T,256,3,4]` | normalized 2D box per camera |
| `feat` sparse COO | float16 `[P,256]` at indices `(t,n,v)` | visual node-view feature when valid |
| `type_clip32` | float32 `[256,32]` | static category-text node feature; active-gate required |

A common model-ready node feature at time `t` is therefore a concatenation such as:

```text
x_model[t,n] = concat(
  node_state[t,n, selected continuous/binary channels],       # up to 32 dims
  embedding(family_idx[t,n]),                                # learned categorical embedding
  type_clip32[n] or ablated zero vector,                     # 32 dims, active-gated
  pooled/selected visual feat[t,n,v] if available,           # 256 dims per selected view or view-pooled
  view evidence summary[t,n]                                 # e.g. 3 vis + 3 area + 6 centroid/bbox stats
)
```

This concatenation is **not** precomputed in the release because different WAM/GNN experiments should decide whether category text, privileged simulator state, view-specific visual features, and dynamic contact edges are allowed inputs.

### Minimal loader conversion example

```python
import json, numpy as np
from pathlib import Path

REL_PRIOR = {"part_of": 0, "controls": 1}
REL_DYN = {"contact": 0, "visibility_change": 1}

def prior_edges_to_tensors(graph_static):
    edges = graph_static.get("prior_edges", [])
    edge_index = np.array([[e["src"], e["dst"]] for e in edges], dtype=np.int64).T
    if edge_index.size == 0:
        edge_index = np.zeros((2, 0), dtype=np.int64)
    edge_type = np.array([REL_PRIOR[e["rel"]] for e in edges], dtype=np.int64)
    edge_attr = np.eye(len(REL_PRIOR), dtype=np.float32)[edge_type] if len(edge_type) else np.zeros((0, len(REL_PRIOR)), dtype=np.float32)
    return edge_index, edge_type, edge_attr

def dynamic_edges_to_tensors(dynamic_row):
    edges = dynamic_row.get("edges", [])
    edge_index = np.array([[e["src"], e["dst"]] for e in edges], dtype=np.int64).T
    if edge_index.size == 0:
        edge_index = np.zeros((2, 0), dtype=np.int64)
    edge_type = np.array([REL_DYN[e["rel"]] for e in edges], dtype=np.int64)
    rel_onehot = np.eye(len(REL_DYN), dtype=np.float32)[edge_type] if len(edge_type) else np.zeros((0, len(REL_DYN)), dtype=np.float32)
    view_onehot = np.zeros((len(edges), 3), dtype=np.float32)
    is_self = np.zeros((len(edges), 1), dtype=np.float32)
    for i, e in enumerate(edges):
        if "view" in e:
            view_onehot[i, int(e["view"])] = 1.0
        is_self[i, 0] = float(e["src"] == e["dst"])
    edge_attr = np.concatenate([rel_onehot, view_onehot, is_self], axis=1)
    return edge_index, edge_type, edge_attr

# usage
with open(ep / "graph/graph_static.json") as f:
    graph_static = json.load(f)
prior_edge_index, prior_edge_type, prior_edge_attr = prior_edges_to_tensors(graph_static)

node_npz = np.load(ep / "graph/node_state.npz")
node_state = node_npz["node_state"]
active = node_state[..., 0].astype(bool)

with open(ep / "graph/dynamic_edges.jsonl") as f:
    first_dyn = json.loads(next(f))
dyn_edge_index, dyn_edge_type, dyn_edge_attr = dynamic_edges_to_tensors(first_dyn)
```

## Static graph: `graph/graph_static.json`

Top-level keys:

```text
schema
split
task
episode
dataset_path
episode_dir
n_max
num_nodes
num_frames
nodes
padded_node_count
prior_edges
rule_versions
inventory_info
goal_grounding_supervision_only
phase2_policy
```

Required schema stamp:

```text
GWAM_Data_v1.2_phase1_sparse_v2
```

Rule versions are uniform across the release:

```json
{
  "dynamic_edges": "contacts_visibility_nearest_ancestor_v2",
  "families": "object_distractor_merged_v2",
  "geom_attribution": "nearest_ancestor_v2",
  "mask_codec": "row_major_binary_rle_v2_vectorized",
  "min_visible_px": 20,
  "node_order": "deterministic_inventory_order_v1_metadata_not_model_input",
  "node_state_dtype": "float32_v2",
  "qpos_qvel": "articulated_scalar_only_v2"
}
```

### Static node records

`graph_static.json/nodes` is the complete node list for that episode. Node index in this list is the node slot used by `node_state[:, n, :]`, `view_evidence[:, n, ...]`, dynamic edges, and sparse visual feature indices.

Each node record has fields like:

```json
{
  "node_id": "drawer_obj",
  "family": "object",
  "category_text": "pizza cutter",
  "root_bodies": ["drawer_obj_main"],
  "source": "sim_object_cfg",
  "free_movable": 1,
  "articulated": 0
}
```

Node families and family ids:

| family_idx | family | Meaning |
|---:|---|---|
| 0 | object | movable task and distractor objects; distractors are intentionally merged into object |
| 1 | reserved | old distractor family id, forbidden in v1.2 sparse-v2 |
| 2 | surface | counters and other support surfaces |
| 3 | receptacle | receptacles/containers such as drawers where applicable |
| 4 | fixture | static fixtures/appliances/cabinets/accessories |
| 5 | articulated_part | doors/drawers/lids/racks/joints represented as parts |
| 6 | handle | handles/controls that manipulate an articulated part |
| 7 | control | defined but currently unpopulated in emitted data |
| 8 | region | defined but currently unpopulated in emitted data |
| 9 | robot | robot arm and gripper |

Dataset-wide node family counts across all 10,564 episodes:

| Family | Node records |
|---|---:|
| robot | 10,564 |
| object | 19,359 |
| fixture | 694,056 |
| surface | 66,228 |
| articulated_part | 256,185 |
| handle | 212,302 |
| receptacle | 155,387 |

Node source counts:

| Source | Node records |
|---|---:|
| sim_robot | 10,564 |
| sim_object_cfg | 19,359 |
| sim_fixture_salient | 760,284 |
| sim_fixture_subpart_candidate | 623,874 |

Observed node count range:

```text
min num_nodes: 58
max num_nodes: 255
mean num_nodes: 133.86
N_MAX: 256
```

`N_MAX=256`; padded rows are all-zero and must be gated with the `active` channel.

### Static/prior edges

`graph_static.json/prior_edges` contains deterministic structural edges. Each record has:

```json
{"src": 31, "dst": 30, "rel": "controls"}
```

Fields:

| Field | Type | Meaning |
|---|---|---|
| `src` | int | source node index into `graph_static.json/nodes` |
| `dst` | int | destination node index into `graph_static.json/nodes` |
| `rel` | str | prior structural relation |

Current prior-edge relation vocabulary:

| rel | Meaning |
|---|---|
| `part_of` | source node is a structural subpart of destination node |
| `controls` | source node, usually a handle/control part, actuates or controls destination articulated part |

Prior edges are not a dense adjacency tensor. They are a static edge list. Use them as optional structural priors; dynamic per-frame events are separate.

## Node-state tensor: `graph/node_state.npz`

`node_state.npz` contains:

```text
node_state: float32[T, 256, 32]
node_state_schema: str[32]
```

Current `node_state_schema`:

| Channel | Name | Meaning |
|---:|---|---|
| 0 | active | 1 for real node slot, 0 for padded slot |
| 1 | family_idx | family id from the table above |
| 2 | free_movable | 1 if the source object/node is free movable |
| 3 | articulated | 1 if represented as articulated |
| 4 | pos_x | world/body position x |
| 5 | pos_y | world/body position y |
| 6 | pos_z | world/body position z |
| 7 | quat_x | orientation quaternion x |
| 8 | quat_y | orientation quaternion y |
| 9 | quat_z | orientation quaternion z |
| 10 | quat_w | orientation quaternion w |
| 11 | lin_x | linear velocity x |
| 12 | lin_y | linear velocity y |
| 13 | lin_z | linear velocity z |
| 14 | ang_x | angular velocity x |
| 15 | ang_y | angular velocity y |
| 16 | ang_z | angular velocity z |
| 17 | qpos | articulated scalar qpos where available, otherwise 0 |
| 18 | qvel | articulated scalar qvel where available, otherwise 0 |
| 19 | vis_right | visible in right-side camera |
| 20 | vis_left | visible in left-side camera |
| 21 | vis_wrist | visible in wrist camera |
| 22-31 | reserved_22 ... reserved_31 | reserved zeros in v1.2 sparse-v2 |

Loader discipline:

```python
node_npz = np.load(ep / "graph/node_state.npz")
node_state = node_npz["node_state"]
schema = [str(s) for s in node_npz["node_state_schema"]]
active = node_state[:, :, schema.index("active")] == 1
real_nodes_t0 = node_state[0, active[0]]
```

Do not use raw node slot position as a semantic shortcut. Node order is deterministic metadata order and can correlate with source/task object ordering.

## Per-frame alignment/actions: `graph/frames.jsonl`

Each row corresponds to a graph timestep `t` and source frame.

Example:

```json
{
  "t": 0,
  "source_frame": 0,
  "action": {
    "timestamp": 0.0,
    "action": [0.0, 0.0, 0.0, 0.0, -1.0, -0.014285714285714285, 0.0, 0.0, 0.0, -0.017142857142857144, 0.0, -1.0],
    "next.done": false,
    "index": 0
  }
}
```

Fields:

| Field | Meaning |
|---|---|
| `t` | graph timestep, 0-indexed |
| `source_frame` | source RoboCasa/LeRobot frame index |
| `action.timestamp` | source timestamp |
| `action.action` | 12-D source action vector |
| `action.next.done` | source done flag for the next transition |
| `action.index` | source action row index |

The 12-D action vector is preserved from the source conversion. Treat it as an action/robot stream, not as graph state.


Timing: rows step at 20 Hz (`action.timestamp` increases by 0.05 s per frame). Graph timesteps map 1:1 onto source frames with no subsampling (`t == source_frame`), so an episode of `num_frames` frames spans `num_frames / 20` seconds.

12-D action layout from the source RoboCasa LeRobot `meta/modality.json` for PandaOmron episodes:

```text
action[0:4]   base_motion
action[4:5]   control_mode
action[5:8]   end_effector_position
action[8:11]  end_effector_rotation
action[11:12] gripper_close
```

## Dynamic/event edges: `graph/dynamic_edges.jsonl`

Each line is a per-frame sparse edge list:

```json
{"t": 2, "edges": [{"src": 32, "dst": 32, "rel": "visibility_change", "view": 2}]}
```

Dynamic edge record fields:

| Field | Type | Meaning |
|---|---|---|
| `t` | int | frame index |
| `edges` | list | zero or more event edges for that frame |

Dynamic edge fields:

| Field | Type | Meaning |
|---|---|---|
| `src` | int | source node index |
| `dst` | int | destination node index |
| `rel` | str | event relation |
| `view` | int, optional | camera/view id for visibility-change events |

Current dynamic relation vocabulary:

| rel | Meaning |
|---|---|
| `contact` | simulator/contact-derived sparse contact relation between nodes |
| `visibility_change` | node visibility changed in a camera view |

Sampled dynamic-edge statistics across a 10% episode sample:

```text
sampled frame records: 265,935
sampled event edges: 1,694,008
avg event edges per sampled frame: 6.37
contact edges: 1,544,547
visibility_change edges: 149,461
```

There is no dense `rel_state[T,N,N,C]` tensor in v1.2 sparse-v2.

## View evidence and visible masks

### `graph/view_evidence.npz`

Keys:

| Key | Shape | Dtype | Meaning |
|---|---:|---|---|
| `view_visible` | `[T, 256, 3]` | bool | visible flag per frame/node/view |
| `view_centroid` | `[T, 256, 3, 2]` | float16 | visible mask centroid in image coordinates |
| `view_area` | `[T, 256, 3, 1]` | float16 | visible mask area |
| `view_bbox` | `[T, 256, 3, 4]` | float16 | visible mask bounding box |
| `cameras` | `[3]` | str | camera names |

Camera order:

| View id | Alias | Camera |
|---:|---|---|
| 0 | side_right | `robot0_agentview_right` |
| 1 | side_left | `robot0_agentview_left` |
| 2 | wrist | `robot0_eye_in_hand` |

Units and conventions: all image-space values are **normalized to [0,1]**, not pixels.

| Key | Convention |
|---|---|
| `view_centroid` | `(x, y) = (mean_col / 256, mean_row / 256)`, origin top-left of the upright image |
| `view_area` | foreground pixels / `(256*256)`, i.e. fraction of the image |
| `view_bbox` | `[x_min, y_min, x_max, y_max] / 256`, from inclusive pixel bounds |

Multiply by 256 to recover pixel coordinates in the 256x256 mask frame; float16 storage quantizes these to about quarter-pixel precision or better. Orientation matches the upright source video frames (row 0 = top). The integer-pixel `bbox` inside `visible_masks_rle.jsonl.gz` records the same box unnormalized.

Camera platform note: both agentview cameras are mounted on the mobile base and the wrist camera is hand-mounted, so **all three viewpoints move during an episode**. Camera intrinsics/extrinsics are not exported in v1.2; treat image-space evidence as per-view 2D observations, not calibrated 3D measurements.

### `graph/visible_masks_rle.jsonl.gz`

Row-major binary RLE v2 visible masks for visible `(t, n, v)` pairs, gzipped JSONL. One line is written per frame **that has at least one visible pair**; frames with zero visible pairs are omitted, so use `view_evidence.npz/view_visible` as the authoritative absence signal.

Per-line record:

```json
{"t": 0, "masks": [{"n": 0, "v": 0, "area_px": 12326, "bbox": [0, 54, 105, 255], "rle": [13892, 1, 248, 4]}]}
```

| Field | Meaning |
|---|---|
| `t` | frame index |
| `masks[].n` | node slot index |
| `masks[].v` | view id: 0=side/right agentview, 1=side/left agentview, 2=wrist |
| `masks[].area_px` | foreground pixel count, always at least `min_visible_px=20` |
| `masks[].bbox` | integer pixel bbox `[x_min, y_min, x_max, y_max]`, inclusive |
| `masks[].rle` | flat alternating run lengths over a 256x256 row-major mask |

Codec `row_major_binary_rle_v2_vectorized`: flatten the 256x256 binary mask in row-major order (row 0 = top of the upright image, matching source-video orientation). The RLE list starts with the background/zero run, possibly of length 0, then foreground/one run, then background, and so on. Run lengths always sum to 65,536.

Reference decoder:

```python
import gzip, json
import numpy as np

def decode_rle(runs, h=256, w=256):
    mask = np.zeros(h * w, dtype=bool)
    pos, val = 0, False
    for r in runs:
        if val:
            mask[pos:pos + r] = True
        pos += int(r)
        val = not val
    if pos != h * w:
        raise ValueError(f"bad RLE length: {pos} != {h*w}")
    return mask.reshape(h, w)

with gzip.open(ep / "graph/visible_masks_rle.jsonl.gz", "rt") as f:
    for line in f:
        rec = json.loads(line)
        for m in rec["masks"]:
            mask = decode_rle(m["rle"])
            assert int(mask.sum()) == int(m["area_px"])
```



## Phase-2 sparse visual features: `graph/visual_features_sparse.npz`

Phase 2 adds visible-only pooled visual features for node/view pairs that Phase 1 marked visible. It does **not** create a dense `[T,N,V,D]` tensor and does not fabricate features for invisible pairs.

NPZ keys:

| Key | Shape | Dtype | Meaning |
|---|---:|---|---|
| `t` | `[P]` | int32 | frame index for each valid feature row |
| `n` | `[P]` | int16 | node slot index for each valid feature row |
| `v` | `[P]` | int8 | view id for each valid feature row |
| `feat` | `[P,256]` | float16 | valid visible feature vector |
| `type_clip32` | `[256,32]` | float32 | category-text/node-type feature per node slot |
| `visual_computed` | `[T]` | bool | whether all camera frames for this timestep were processed |
| `invalid_t`, `invalid_n`, `invalid_v` | `[Q]` | int arrays | Phase-1-visible pairs that could not produce a pooled feature |
| `cameras` | `[3]` | str | camera names |
| `n_max` | `[1]` | int32 | 256 |

Accounting invariant:

```text
features_written + invalid_visible_pairs == visible_pairs_from_phase1
invisible_features_injected == 0
```

Feature provenance:

```text
feat (256-D):
  SAM2.1 image-encoder embedding, using sam2.1_hiera_base_plus checkpoint and
  configs/sam2.1/sam2.1_hiera_b+.yaml, computed on the source LeRobot RGB video
  frame for that camera. The embedding is mean-pooled under the Phase-1 visible RLE
  mask after downsampling to the embedding grid, then L2-normalized and stored as
  float16. Pooling id: sam2_image_embed_phase1_visible_rle_mask_pool.

invalid pairs:
  Phase-1-visible pairs whose mask has no support after downsampling to the SAM2
  embedding grid, typically tiny masks near min_visible_px. They are listed in
  invalid_t/n/v; no feature is fabricated. Dataset-wide: 89,183 pairs, about
  0.078% of visible pairs; 7,345 episodes contain at least one invalid pair.

type_clip32 (32-D per node slot):
  CLIP ViT-B/32 text embedding of the prompt
  "a photo of a {category_text} in a kitchen.", projected 512 -> 32 with a fixed
  seeded Gaussian random projection (seed 20260702, columns L2-normalized), then
  row L2-normalized. Recorded per episode in audit/phase2_summary.json under
  type_meta. This is a category-level text vector: nodes sharing category_text use
  the same prompt recipe and carry no instance appearance.

  WARNING: padded node slots are not zero in type_clip32; they hold the unit vector
  of the fixed prompt "a blank padded node in a kitchen.". Always gate on the
  node_state active channel before consuming type_clip32.
```

`type_clip32` is generated by a fixed recipe (fixed prompt template and projection seed 20260702) and is numerically reproducible to small tolerance; do not rely on bit-identical vectors across hardware/software versions.

To scatter sparse features into a dense tensor when needed:

```python
phase2 = np.load(ep / "graph/visual_features_sparse.npz")
T = node_state.shape[0]
dense = np.zeros((T, 256, 3, 256), dtype=np.float16)
dense[phase2["t"], phase2["n"], phase2["v"]] = phase2["feat"]
```

`audit/phase2_summary.json` records the Phase-2 policy and feature metadata, including:

```json
{
  "pooling": "sam2_image_embed_phase1_visible_rle_mask_pool",
  "policy": "sparse visible-only; absent pairs decode as zero",
  "type_meta": {
    "model": "ViT-B/32",
    "projection_seed": 20260702,
    "prompt_count": 256,
    "projection": "seeded_gaussian_column_normalized_v1"
  }
}
```

### `audit/summary.json`

Phase-1 audit summary:

| Field | Meaning |
|---|---|
| `ok` | Phase-1 episode export success |
| `split`, `task`, `episode` | episode identity |
| `num_frames` | graph timesteps |
| `num_nodes` | real nodes before padding |
| `visible_pairs` | Phase-1 visible `(t,n,v)` pair count |
| `dynamic_edge_records` | number of per-frame dynamic edge rows |
| `files` | local provenance paths from generation time |

### `audit/phase2_summary.json`

Phase-2 audit summary; see the sparse visual feature section above.

## Full loader example

Download one episode:

```bash
hf download ChangChrisLiu/GWAM_Data   gwam_v12_sparse_v2/episodes/target/OpenDrawer/episode_000000.zip   --repo-type dataset   --local-dir gwam_data
```

Run the bundled example:

```bash
python gwam_v12_sparse_v2/examples/load_gwam_v12_episode.py   --zip gwam_data/gwam_v12_sparse_v2/episodes/target/OpenDrawer/episode_000000.zip
```

Self-contained Python example:

```python
import json
import tempfile
import zipfile
from pathlib import Path

import numpy as np

zip_path = Path("gwam_data/gwam_v12_sparse_v2/episodes/target/OpenDrawer/episode_000000.zip")

with tempfile.TemporaryDirectory() as td:
    with zipfile.ZipFile(zip_path) as z:
        z.extractall(td)

    ep = Path(td) / "target" / "OpenDrawer" / "episode_000000"

    # Static graph / node inventory
    graph_static = json.loads((ep / "graph/graph_static.json").read_text())
    nodes = graph_static["nodes"]

    # Node state: [T, 256, 32]
    node_npz = np.load(ep / "graph/node_state.npz")
    node_state = node_npz["node_state"]
    schema = [str(s) for s in node_npz["node_state_schema"]]
    active = node_state[:, :, schema.index("active")] == 1
    family_idx = node_state[:, :, schema.index("family_idx")]

    # Per-frame dynamic edges
    with (ep / "graph/dynamic_edges.jsonl").open() as f:
        first_edges = json.loads(next(f))["edges"]

    # View evidence
    view_npz = np.load(ep / "graph/view_evidence.npz")
    visible = view_npz["view_visible"]          # bool [T, 256, 3]
    bbox = view_npz["view_bbox"]                # float16 [T, 256, 3, 4]
    cameras = [str(c) for c in view_npz["cameras"]]

    # Sparse visual features
    phase2 = np.load(ep / "graph/visual_features_sparse.npz")
    t = phase2["t"]                              # int32 [P]
    n = phase2["n"]                              # int16 [P]
    v = phase2["v"]                              # int8 [P]
    feat = phase2["feat"]                        # float16 [P, 256]
    type_clip32 = phase2["type_clip32"]          # float32 [256, 32]

    # Optional: build sparse lookup for valid visual features
    sparse_key_to_row = {(int(tt), int(nn), int(vv)): i for i, (tt, nn, vv) in enumerate(zip(t, n, v))}

    # Action/alignment stream
    with (ep / "graph/frames.jsonl").open() as f:
        first_frame = json.loads(next(f))
    action_12d = first_frame["action"]["action"]

    print("episode", graph_static["split"], graph_static["task"], graph_static["episode"])
    print("node_state", node_state.shape, node_state.dtype)
    print("real nodes", int(active[0].sum()), "of", node_state.shape[1])
    print("cameras", cameras)
    print("first dynamic edges", first_edges[:3])
    print("sparse visual features", feat.shape, feat.dtype)
    print("first action dim", len(action_12d))
```

## Downloading subsets

Download the full manifest:

```bash
hf download ChangChrisLiu/GWAM_Data   gwam_v12_sparse_v2/MANIFEST.jsonl   --repo-type dataset   --local-dir gwam_data
```

Download an entire task:

```bash
hf download ChangChrisLiu/GWAM_Data   --repo-type dataset   --include "gwam_v12_sparse_v2/episodes/target/OpenDrawer/*.zip"   --local-dir gwam_data
```

Download all v1.2 files:

```bash
hf download ChangChrisLiu/GWAM_Data   --repo-type dataset   --include "gwam_v12_sparse_v2/**"   --local-dir gwam_data
```

Verify a downloaded ZIP against the manifest:

```python
import hashlib, json
from pathlib import Path

manifest = Path("gwam_data/gwam_v12_sparse_v2/MANIFEST.jsonl")
zip_path = Path("gwam_data/gwam_v12_sparse_v2/episodes/target/OpenDrawer/episode_000000.zip")
rows = [json.loads(l) for l in manifest.read_text().splitlines()]
row = next(r for r in rows if r["zip_path"].endswith("target/OpenDrawer/episode_000000.zip"))
h = hashlib.sha256(zip_path.read_bytes()).hexdigest()
assert h == row["zip_sha256"]
assert zip_path.stat().st_size == row["zip_size"]
```


## Pairing episodes with source RoboCasa RGB / sim state

This release contains **no RGB frames and no depth**: it ships graphs, masks, evidence, pooled visual features, audits, and ZIP manifests. For WAM / video-model training, pair each episode with its source RoboCasa LeRobot conversion:

1. **Locate the source episode.** `graph_static.json/dataset_path` records the exact source root used at export time, for example `<robocasa_root>/v1.0/target/atomic/OpenDrawer/20250816/lerobot`. Episode numbering is identical: GWAM `episode_000123` is source episode 123 of that task.
2. **Frames.** `frames.jsonl` maps graph timestep `t` to `source_frame` 1:1 with no subsampling, at 20 Hz.
3. **Videos.** Per-camera MP4s live in the source conversion at `videos/chunk-000/observation.images.<camera>/episode_XXXXXX.mp4`, with camera names exactly as in `view_evidence.npz/cameras`: `robot0_agentview_right`, `robot0_agentview_left`, and `robot0_eye_in_hand`. Phase-2 features were pooled from these frames, so masks/evidence are pixel-aligned to them in upright orientation.
4. **Raw sim state.** Per-episode source `extras/episode_XXXXXX/` holds `states.npz` and `model.xml.gz`, the inputs for any custom re-rendering and the planned `fixture_state/` sidecar.

Obtain the RoboCasa data under its own terms; this repository does not redistribute source RGB/depth videos.

## Model-input discipline and leakage guard

Allowed default model inputs:

```text
node_state active rows
prior_edges if structural priors are part of your experiment
dynamic_edges sparse per-frame contacts/visibility changes
view_evidence and visible masks if visual grounding is part of your experiment
visual_features_sparse pair indices + features
robot/action streams if explicitly included by experiment
```

Metadata/supervision-only unless explicitly allowed:

```text
instruction
goal_grounding_supervision_only
fixture_refs
object_roles
node_id strings
category_text if your split/task setup treats labels as privileged
source path strings
frames.jsonl timestamp/index/next.done alignment fields
```

Important: `object_roles.task_object_like_node_ids` and `distractor_node_ids` are collapsed in model-facing `node_state` to family `object`. Do not use those metadata roles as model inputs for target-blind experiments.

Note: `type_clip32` is derived from `category_text`. Experiments that treat category labels as privileged information must exclude `type_clip32` from model inputs as well, or ablate with and without it. For other experiments it is a standard node-type feature.


## Recommended training and evaluation use

Intended framing for Graph-WAM / WAM experiments:

```text
graph  = an observed state modality and/or auxiliary prediction target
         (predict next graph state / graph delta / contact events alongside video)
graph conditioning of a video world model = an ablation condition, not the only default
```

Tier roles:

```text
pretrain/atomic PickPlace (1,939 eps): broad pick-place coverage for pretraining and cross-task transfer studies.
target/atomic (8,625 eps): the 17 evaluation task families; use for task-level training/evaluation and per-task reporting.
```

Splits: **no official train/val/test split ships with v1.2.** Recommended defaults, to be documented in each experiment:

```text
in-task split:   within each task, split by episode index (e.g. last 10% = val/test). Never split within an episode.
cross-task split: hold out entire tasks for generality claims, e.g. train on pretrain + subset of target tasks, evaluate on held-out target tasks.
```

Evaluation cautions:

```text
1. The six state-blind tasks (see L2) cannot be scored via node_state deltas alone; score them on contact/visibility/mask supervision or defer full-state scoring to the fixture_state sidecar.
2. Report teacher-forced and autoregressive rollout metrics separately.
3. Prefer per-task metrics over only pooled metrics because episode counts differ by task.
4. Contacts and node_state are privileged simulator state, not real-robot sensor streams; flag models consuming them accordingly.
```

## Known limitations

### L1. One excluded source episode

`target/OpenDrawer/episode_000459` is excluded due to repeated RoboCasa source environment initialization failure.

### L2. Six target tasks are state-blind in `node_state`

These target tasks have task-defining state changes that are not represented by current node pose/velocity/qpos fields:

```text
CloseFridge
OpenStandMixerHead
SlideDishwasherRack
TurnOffStove
TurnOnElectricKettle
TurnOnMicrowave
```

Scale:

```text
3,080 target episodes
35.7% of target tier
29.2% of full effective v1.2 dataset
```

These episodes are included and valid, but should be treated as geometric/contact/visibility-supervised rather than full `node_state` Delta-G tasks until an additive fixture-state sidecar is released.

Planned additive sidecar path:

```text
gwam_v12_sparse_v2/fixture_state/<split>/<task>/episode_XXXXXX.npz
```

The planned sidecar should parse appliance/joint/switch scalars from source `states.npz` and `model.xml.gz` without changing existing ZIPs.

### L3. License review pending

This upload is internal-research-only while RoboCasa-derived redistribution terms are reviewed.


### L4. No RGB, no depth, no camera calibration in this release

Episodes contain graphs, masks, evidence, and pooled features only. RGB comes from the source RoboCasa LeRobot conversion. Depth was not rendered (`camera_depths=False`), and camera intrinsics/extrinsics are not exported. All three cameras move during an episode: base-mounted agentviews and hand-mounted wrist.

### L5. `control` and `region` families are defined but unpopulated

Family ids 7 and 8 are reserved in the schema and appear in no packaged episode. This is one contributor to L2; for example, stove knobs / kettle switches do not yet have dedicated control nodes.

### L6. Node-cap headroom

`N_MAX=256` with a maximum observed inventory of 255 nodes. The v1.2 inventory builder never truncated a real node, but any future re-export with a richer inventory must re-verify this bound.

## Historical/stale formats not used here

Do not build v1.2 loaders using older v1/v1.1 notes that mention:

```text
317-D or 323-D node_feats
dense rel_state[T,N,N,C]
dense visual_views[T,N,V,D]
distractor family index 1 as active class
events.jsonl state_on/state_off
min_visible_px = 10
RLE v1
```

The current release is v1.2 sparse-v2:

```text
node_state: float32[T,256,32]
view evidence: sparse masks / evidence per visible pair
visual features: sparse visible-only visual_features_sparse.npz
dynamic relations: contact and visibility_change JSONL events
```

## Multi-view RGB / graph alignment contract

For joint training, evaluation, and real-time inference, the model-facing online call is:

```python
snapshot = extractor.extract_final_graph(visual_backend=visual_backend)
graph = snapshot["gnn_graph"]          # x [N_real,342], edge_attr [E,8]
rgb_frames = snapshot["rgb_frames"]             # dict: view_id -> uint8[256,256,3]
rgb_frame_cameras = snapshot["rgb_frame_cameras"]  # ordered camera names for those view ids
```

All fields in one `snapshot` are produced from the same current simulator state before the policy/env step advances:

```text
current qpos/qvel/contact state
+ current segmentation renders from the ordered camera list
+ current RGB renders from the same ordered camera list
+ current visible RLE masks indexed by (node slot n, view id v)
+ SAM2 masked pooling on rgb_frames[v] using that same mask
= final graph x [N_real,342]
```

The ordered multi-view camera contract is:

```text
v=0 robot0_agentview_right
v=1 robot0_agentview_left
v=2 robot0_eye_in_hand
```

Alignment rules for downstream integration:

- `view_visible[n,v]`, `view_centroid[n,v]`, `view_area[n,v]`, `view_bbox[n,v]`, `rle_masks[*]["v"]`, `visual_features_sparse["v"]`, and `rgb_frames[v]` use the same view id.
- `visual_features_sparse["n"]` uses the original padded node slot id; `gnn_graph["slot_ids"]` maps active GNN rows back to those padded slots.
- `rgb_frames[v]` is an upright `uint8[256,256,3]` RGB frame rendered with the same vertical flip convention as the segmentation/mask path.
- `save_realtime_graph_snapshot(snapshot, out_dir)` writes `rgb/view_<v>_<camera>.npy` plus `rgb_manifest.json`, so saved debug/eval snapshots contain graph data first and aligned RGB images alongside it.

Reusable alignment verifier:

```bash
MUJOCO_GL=egl PYOPENGL_PLATFORM=egl python scripts/verify_rgb_graph_alignment.py
```

This verifier checks that one `extract_final_graph()` call does not advance simulator state, that re-rendered current RGB and segmentation/masks match the snapshot, that sparse visual features are reproducible from returned `rgb_frames[v]` and masks, and that saved `rgb_manifest.json`/RGB files round-trip.