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.

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.

Current release status

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:

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:

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:

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:

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:

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

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

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
  examples/
    load_gwam_v12_episode.py
  episodes/
    target/<Task>/episode_XXXXXX.zip
    pretrain/<Task>/episode_XXXXXX.zip

Each episode ZIP preserves the internal path prefix:

<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:

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:

{
  "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:

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:

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:

[ ] 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:

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:

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:

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:

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:

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:

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:

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

Examples:

{"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:

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:

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:

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:

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:

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:

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:

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

The velocity slice is:

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

For node slot n:

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:

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:

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

For sparse row p:

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:

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:

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:

loaders/gwam_graph_dataloader.py

It is also duplicated under the release folder:

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:

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:

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:

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:

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

Python example: get a GNN-ready graph

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:

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:

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:

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:

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:

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:

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:

[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:

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:

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

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:

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:

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:

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:

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:

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:

loaders/gwam_graph_dataloader.py

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

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:

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:

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:

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:

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:

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:

[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:

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:

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:

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:

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:

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:

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:

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.

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.

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:

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:

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:

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:

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:

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:

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:

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

Model-ready tensorization:

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:

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:

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

Model-ready per-frame tensorization:

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:

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

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:

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:

GWAM_Data_v1.2_phase1_sparse_v2

Rule versions are uniform across the release:

{
  "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:

{
  "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:

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:

{"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:

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:

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:

{
  "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:

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:

{"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:

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:

{"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:

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:

features_written + invalid_visible_pairs == visible_pairs_from_phase1
invisible_features_injected == 0

Feature provenance:

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:

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:

{
  "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:

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:

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:

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:

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

Download an entire task:

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:

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

Verify a downloaded ZIP against the manifest:

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:

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:

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:

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:

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:

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:

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:

CloseFridge
OpenStandMixerHead
SlideDishwasherRack
TurnOffStove
TurnOnElectricKettle
TurnOnMicrowave

Scale:

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:

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:

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:

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