GWAM_Data

GWAM_Data is the documentation, schema, and handoff repository for a graph-augmented RoboCasa dataset for Graph-WAM research.

The first planned data release is RoboCasa target Atomic-Seen v1, covering all 18 target Atomic-Seen tasks from the RoboCasa target_atomic_seen dataset soup. This repository is currently docs-first: it contains the full graph schema, extraction contract, target task list, metadata templates, quality checks, and downstream training instructions. Processed graph data will be uploaded only after replayability, license, and extraction QA gates pass.

Current status

Status: documentation/schema package uploaded.
Processed data: pending.
Scope: RoboCasa target Atomic-Seen, target/human, 18 tasks.
Depth: not included in v1.
Canonical side camera: robot0_agentview_right.
Co-exported views: robot0_agentview_left and robot0_eye_in_hand.
Graph role: structured state / Delta-G supervision / optional joint modality; graph conditioning is only an ablation.

Core framing

Current job:

Extract and publish graph-augmented RoboCasa data.

Not current job:

Train Graph-WAM.

Downstream goal for the next student:

Train DreamZero-style Graph-WAM with joint vision + action flow matching.

Important correction: the graph is not assumed to be the main conditioning stream. The v1 dataset exposes graphs as structured state and relation-event supervision. Graph conditioning can be evaluated later as an ablation, but the dataset is intentionally architecture-neutral.

Recommended downstream graph uses, in order:

1. Structured scene-state modality aligned with RGB, action, and robot state.
2. Auxiliary target / Delta-G supervision for relation and event prediction.
3. Optional jointly modeled graph modality beside video and action.
4. Graph conditioning ablation, compared against no-graph and same-information baselines.

V1 design decisions

• RoboCasa split: target_atomic_seen.
• Source: target / human.
• Task count: 18.
• Primary side camera: robot0_agentview_right.
• Also export: robot0_agentview_left and robot0_eye_in_hand.
• No depth in v1.
• Use RGB, MuJoCo segmentation/masks, simulator state, contacts, qpos/qvel, object/body poses, robot state, actions, language, and graph records.
• One global graph per timestep; camera views are evidence attached to nodes, not separate graphs.
• Edge tiers are separated:
  • state: current physical/dynamic relations.
  • prior: static semantic/structural/vocabulary relations.
• Reasoning models are not required in sim v1. Vocabulary relations come from sim metadata and human-reviewed rule tables. LLMs may draft rule tables, but committed graph data must be deterministic and source-tagged.
• Component type encoding uses frozen CLIP text features: raw category text is authoritative, a 512D CLIP text table is stored once per type, and a frozen 32D projected vector is used in default tensors.

V1 data included and excluded

Included:

RGB from side_right, side_left, wrist
MuJoCo segmentation and masks for all three views
Simulator qpos/qvel
Body poses and orientations
MuJoCo contacts
Robot state / proprioception
Actions
Language instruction
Graph static records
Per-frame graph records
Delta-G event labels
Graph tensors
Audit metadata

Excluded from v1:

depth arrays
median_depth / depth_quantiles
point clouds from depth
RGB-D-derived geometry
depth-derived node features

Depth is deferred to v2 as an optional predicted-graph / real-lane rehearsal stream.

Target Atomic-Seen tasks

#	Task	Family	RoboCasa registry path	Horizon
1	CloseBlenderLid	articulation	v1.0/target/atomic/CloseBlenderLid/20250822/lerobot	900
2	CloseFridge	articulation	v1.0/target/atomic/CloseFridge/20250816/lerobot	900
3	CloseToasterOvenDoor	articulation	v1.0/target/atomic/CloseToasterOvenDoor/20250818/lerobot	450
4	CoffeeSetupMug	pick_place	v1.0/target/atomic/CoffeeSetupMug/20250813/lerobot	600
5	NavigateKitchen	navigation	v1.0/target/atomic/NavigateKitchen/20250821/lerobot	450
6	OpenCabinet	articulation	v1.0/target/atomic/OpenCabinet/20250813/lerobot	1050
7	OpenDrawer	articulation	v1.0/target/atomic/OpenDrawer/20250816/lerobot	750
8	OpenStandMixerHead	articulation	v1.0/target/atomic/OpenStandMixerHead/20250818/lerobot	450
9	PickPlaceCounterToCabinet	pick_place	v1.0/target/atomic/PickPlaceCounterToCabinet/20250811/lerobot	750
10	PickPlaceCounterToStove	pick_place	v1.0/target/atomic/PickPlaceCounterToStove/20250818/lerobot	600
11	PickPlaceDrawerToCounter	pick_place	v1.0/target/atomic/PickPlaceDrawerToCounter/20250820/lerobot	750
12	PickPlaceSinkToCounter	pick_place	v1.0/target/atomic/PickPlaceSinkToCounter/20250813/lerobot	900
13	PickPlaceToasterToCounter	pick_place	v1.0/target/atomic/PickPlaceToasterToCounter/20250817/lerobot	600
14	SlideDishwasherRack	articulation	v1.0/target/atomic/SlideDishwasherRack/20250820/lerobot	450
15	TurnOffStove	actuator	v1.0/target/atomic/TurnOffStove/20250812/lerobot	750
16	TurnOnElectricKettle	actuator	v1.0/target/atomic/TurnOnElectricKettle/20250817/lerobot	450
17	TurnOnMicrowave	actuator	v1.0/target/atomic/TurnOnMicrowave/20250813/lerobot	450
18	TurnOnSinkFaucet	actuator	v1.0/target/atomic/TurnOnSinkFaucet/20250812/lerobot	600

Task families are used for sanity checks:

• pick_place: grasp/release, support change, containment, source/target relation events.
• articulation: qpos/qvel, handle/part relation, open/close threshold events.
• actuator: knob/button/faucet control, binary on/off state events.
• navigation: moving-base negative/control case; base-mounted camera motion expected.

Camera convention

V1 camera aliases:

side_right -> robot0_agentview_right   # canonical side view
side_left  -> robot0_agentview_left    # secondary side view
wrist      -> robot0_eye_in_hand       # wrist / eye-in-hand view

All three are exported for every episode. side_right is canonical only for single-side experiments and report ordering.

RoboCasa camera facts:

• robot0_agentview_right, robot0_agentview_left, and robot0_agentview_center are mounted to mobilebase0_support.
• robot0_eye_in_hand is mounted to robot0_right_hand.
• Therefore, stock agent views are robot-base-mounted third-person views, not fixed world/table cameras.
• NavigateKitchen is special because the base and base-mounted cameras can move substantially.

Graph definition

Each timestep has one global graph:

G_t = (V_t, E_state_t, E_prior, globals_t)

Camera streams are evidence on nodes:

node.views.robot0_agentview_right
node.views.robot0_agentview_left
node.views.robot0_eye_in_hand

There is not a separate graph per camera.

Node inventory

Nodes are task-relevant components, not every MuJoCo geom.

Node families:

object
distractor
surface
receptacle
fixture
articulated_part
handle
appliance_part
robot_optional

Inventory is deterministic per episode from sim metadata, object configs, fixture refs, body/geom/joint structure, and node_grouping rules. Language does not decide which nodes exist.

Examples:

• Mug, beer can, food item -> object.
• Non-target movable object -> distractor.
• Countertop, stove surface -> surface.
• Cabinet, drawer cavity, sink basin, fridge interior -> receptacle.
• Fridge, stove, microwave, blender, kettle, faucet, toaster oven -> fixture.
• Door, drawer, lid, dishwasher rack, stand mixer head -> articulated_part.
• Door handle, drawer handle, knob, faucet handle, switch/button -> handle or appliance_part.

Node record schema

Each static node record contains:

{
  "node_id": "obj_000",
  "family": "object",
  "category_text": "mug",
  "instance_name": "mug_1",
  "body_names": ["mug_1_main"],
  "body_ids": [123],
  "geom_ids": [456, 457],
  "joint_ids": [],
  "movability": {
    "free_movable": true,
    "articulated": false,
    "static": false
  },
  "type_encoding": {
    "encoder": "openai/clip-vit-base-patch32-text",
    "raw_dim": 512,
    "stored_dim": 32,
    "projection": "seeded_gaussian_column_normalized_v1",
    "vector_ref": "type_encodings_v1.npz:clip32/category_id"
  },
  "source": "sim_metadata",
  "confidence": 1.0
}

Per-frame node state contains:

{
  "node_id": "obj_000",
  "position_world": [0.0, 0.0, 0.0],
  "orientation_world_xyzw": [0.0, 0.0, 0.0, 1.0],
  "linear_velocity": [0.0, 0.0, 0.0],
  "angular_velocity": [0.0, 0.0, 0.0],
  "qpos": null,
  "qvel": null,
  "visibility": {
    "side_right": {
      "visible": true,
      "mask_ref": "seg/side_right/frame_000123.npz:obj_000",
      "bbox_xyxy": [12, 34, 90, 110],
      "area_px": 1500,
      "centroid_xy": [50.2, 70.1]
    },
    "side_left": {"visible": false},
    "wrist": {"visible": true}
  }
}

No depth fields are allowed in v1 node records.

Node tensor view

Legacy/compatibility flat v1 tensor (superseded by v1.1 multi-stream tensors below):

node_feats: float32[T, N_max, 317]
node_mask: bool[N_max]

Published slicing map:

[0:256]   visual_256 from masked visual encoder / SAM2-on-oracle-mask using canonical side mask
[256:259] position_world xyz
[259:263] orientation quaternion xyzw
[263:266] linear velocity
[266:269] angular velocity
[269:270] qpos normalized or zero
[270:271] qvel normalized or zero
[271:272] binary appliance/control state or zero
[272:274] movability [free_movable, articulated]
[274:275] robot contact flag
[275:277] visibility [side_right, wrist]
[277:285] family one-hot, 8 slots
[285:317] type_clip_32

This 317D tensor is now a legacy compatibility view. The normative v1.1 representation below uses separated static/dynamic/per-view visual tensors to avoid single-view bias and feature-scale imbalance.

CLIP component type encoding

Use frozen CLIP text embeddings for component/category type.

Store three layers:

1. Raw text:

category_text
normalized_category_text
part_role_text
prompt_text

2. Full frozen type table:

encodings/type_encodings_v1.npz
  clip512: float32[num_types, 512]
  clip32:  float32[num_types, 32]
  projection_matrix or PCA basis

3. Metadata:

{
  "clip_model_id": "openai/clip-vit-base-patch32",
  "raw_dim": 512,
  "compressed_dim": 32,
  "prompt_template": "a photo of a {category_text} in a kitchen.",
  "projection": "seeded_gaussian_column_normalized_v1",
  "normalization": "l2"
}

Why frozen:

• Raw category strings are auditable.
• Full 512D vectors are reproducible.
• 32D projection keeps node tensors small.
• No trainable language shortcut is inserted into graph extraction.

Edge tiers

State-tier edges

State-tier edges are current physical/geometric state at timestep t.

Allowed state families:

support_contact
robot_contact
held_by_gripper
candidate_spatial
inside_current
articulation_state

Allowed state sources:

sim_contacts
sim_qpos
sim_pose_geometry
robot_state

Never source state-tier edges from a reasoning model.

Prior-tier edges

Prior-tier edges are static semantic, vocabulary, or structural relations.

Allowed prior families:

articulation_part
kinematic_part_of
precondition_affordance
category_compatibility

Allowed prior sources:

sim_kinematic_tree
sim_metadata
human_reviewed_rule_table

Reserved future sources:

llm_prior
vlm_caption
manual_annotation

In sim v1, reasoning models are not a dependency. If an LLM drafts a rule table, the committed source after review is human_reviewed_rule_table.

Edge record schema

{
  "src": "obj_000",
  "dst": "fixture_001",
  "tier": "state",
  "family": "support_contact",
  "relation_type": "resting_on",
  "active": true,
  "directed": true,
  "source": "sim_contacts",
  "confidence": 1.0,
  "attrs": {
    "num_contacts": 4,
    "min_contact_dist": -0.002,
    "relative_position": [0.1, 0.0, 0.2]
  }
}

Edge tensor view

State relation tensor:

rel_state: float32[T, N_max, N_max, 6]
channels: contact, support, near, inside, dist_norm, dz_norm

Prior relation tensor:

rel_prior: float32[N_max, N_max, 4]
channels: part_of, controls, can_contain, can_actuate

Goal/instruction-derived edges must not enter rel_state or rel_prior. Goal grounding is stored in globals/labels only.

Globals

Each episode includes:

{
  "dataset_version": "robocasa_target_atomic_seen_graph_v1",
  "schema_version": "gwam_robocasa_v1_no_depth",
  "task": "OpenDrawer",
  "split": "target_atomic_seen",
  "source": "human",
  "language_instruction": "Open the drawer.",
  "control_freq": 20,
  "primary_side_camera": "robot0_agentview_right",
  "exported_cameras": [
    "robot0_agentview_right",
    "robot0_agentview_left",
    "robot0_eye_in_hand"
  ],
  "graph_source": "oracle_sim_replay",
  "depth_included": false,
  "goal_grounding": {
    "supervision_only": true,
    "target_node_ids": [],
    "goal_relation_set": []
  }
}

Events / Delta-G

events.jsonl records graph changes:

{"frame": 123, "kind": "contact_make", "src": "obj_000", "dst": "surface_000", "from": false, "to": true}

Event kinds:

contact_make
contact_break
support_change
grasp
release
articulation_open_threshold
articulation_close_threshold
state_on
state_off
inside_make
inside_break
visibility_appeared
visibility_disappeared
goal_satisfied_eval_only

Target information policy: not inside graph inputs

Target/task-goal information is not stored inside the input graph tensors. It is stored only as supervision/evaluation metadata.

Allowed target-info locations:

globals.goal_grounding.supervision_only
labels
events goal_satisfied_eval_only
task metadata
audit/evaluation fields

Forbidden target-info locations:

node_feats
visual_views
rel_state
rel_prior
state_edges
prior_edges
node family
category_text edited per episode
target_relevance input bit
robot_to_target edge
object_to_goal_receptacle edge

Reason: the downstream model should learn task grounding by fusing the language stream with vision/robot/action/graph state, not by reading a target bit or target edge from the graph.

Bad/leaky examples:

{"src": "beer_can", "dst": "cabinet", "relation_type": "goal_place_in", "tier": "prior"}

{"node_id": "beer_can", "target_relevance": 1.0}

Good supervision-only metadata:

{
  "goal_grounding": {
    "supervision_only": true,
    "target_node_ids": ["beer_can"],
    "goal_relation_set": [
      {"predicate": "inside", "src": "beer_can", "dst": "cabinet"}
    ]
  }
}

Rule: if changing the instruction while keeping the simulator state fixed changes a graph input field, that field is leakage and must move to labels/supervision metadata.

Reasoning model / vocabulary relations

Final v1 policy:

No reasoning-model dependency in simulation v1.

Use:

sim metadata
sim kinematic tree
human-reviewed category/rule table
source tags

Do not use reasoning models for:

current contact
support state
held state
inside state
qpos/articulation state
future action
language-target edge
active physical relation

Reasoning models may later provide real-data vocabulary priors under reserved source tags such as llm_prior or vlm_caption, but that is not part of v1 oracle sim extraction.

Planned published data layout

The extraction/debug workspace may use per-frame PNG/NPZ files for inspection. The Hugging Face published data should avoid millions of files. Preferred layout:

data/v1_no_depth/
  meta/info.json
  meta/tasks.jsonl
  meta/episodes.jsonl
  meta/camera_conventions.json
  meta/type_vocab_clip_v1.parquet
  meta/relation_vocab_v1.json
  meta/processing_manifest.jsonl

  videos/chunk-000/observation.images.robot0_agentview_right/episode_000000.mp4
  videos/chunk-000/observation.images.robot0_agentview_left/episode_000000.mp4
  videos/chunk-000/observation.images.robot0_eye_in_hand/episode_000000.mp4

  graphs/chunk-000/episode_000000.graph.jsonl.zst
  masks/chunk-000/episode_000000.masks.npz
  masks/chunk-000/episode_000000.mask_index.jsonl.zst
  tensors/chunk-000/episode_000000.graph_tensors.npz
  audit/chunk-000/episode_000000_summary.json

Dataset scope v1.2: no navigation, add all atomic PickPlace tasks

Scope update from the user:

Exclude navigation-related tasks.
Add all pick-up / pick-place atomic tasks into the data.

Therefore NavigateKitchen is excluded from the Graph-WAM v1.2 processing set. It was downloaded for inspection, but it should not be part of the v1.2 training/export scope because it is primarily moving-base navigation rather than manipulation/contact-centric object transfer.

The v1.2 non-navigation target Atomic-Seen set has 17 tasks:

CloseBlenderLid
CloseFridge
CloseToasterOvenDoor
CoffeeSetupMug
OpenCabinet
OpenDrawer
OpenStandMixerHead
PickPlaceCounterToCabinet
PickPlaceCounterToStove
PickPlaceDrawerToCounter
PickPlaceSinkToCounter
PickPlaceToasterToCounter
SlideDishwasherRack
TurnOffStove
TurnOnElectricKettle
TurnOnMicrowave
TurnOnSinkFaucet

All target Atomic-Seen PickPlace tasks already downloaded:

PickPlaceCounterToCabinet
PickPlaceCounterToStove
PickPlaceDrawerToCounter
PickPlaceSinkToCounter
PickPlaceToasterToCounter

All 18 atomic PickPlace human/pretrain tasks to add:

PickPlaceCabinetToCounter
PickPlaceCounterToBlender
PickPlaceCounterToCabinet
PickPlaceCounterToDrawer
PickPlaceCounterToMicrowave
PickPlaceCounterToOven
PickPlaceCounterToSink
PickPlaceCounterToStandMixer
PickPlaceCounterToStove
PickPlaceCounterToToasterOven
PickPlaceDrawerToCounter
PickPlaceFridgeDrawerToShelf
PickPlaceFridgeShelfToDrawer
PickPlaceMicrowaveToCounter
PickPlaceSinkToCounter
PickPlaceStoveToCounter
PickPlaceToasterOvenToCounter
PickPlaceToasterToCounter

This means the final data scope is:

A. target/atomic/human, non-navigation target Atomic-Seen tasks: 17 tasks
B. pretrain/atomic/human, all PickPlace tasks: 18 tasks

Some PickPlace tasks appear in both A and B; keep their split provenance distinct. Do not merge target and pretrain splits silently.

Metadata file:

metadata/gwam_data_scope_v1_2.json

Should the graph include components that are invisible now but visible later?

Yes, for the simulator/oracle lane, the global graph should keep deterministic candidate nodes even when they are not currently visible in a camera. This can happen and is expected:

node exists globally
node may be invisible in side_right at t
node may become visible in side_right later
node may be visible in wrist but not side_right
node may be occluded by robot/fixture/object

The correct representation is:

node stays in the global graph
pose/qpos/contact/state fields remain simulator-derived
view_visible[t,n,v] = false for cameras where it is not visible
visual_views[t,n,v] = zero for cameras where it is not visible
view_centroid/view_area = zero for cameras where it is not visible

Do not delete the node just because it is invisible in the current image. Also do not hallucinate visual features for invisible views. The global graph is state; visual_views is camera evidence.

This is not target leakage if and only if node inventory is deterministic and target-blind. For RoboCasa sim v1.2, inventory comes from the restored model, object configs, fixture configs, and language-blind candidate rules. fixture_refs and instruction text are supervision-only and never decide which input nodes exist.

For a future real/predicted-graph lane, newly appearing components may be born as tracks when first observed, because there is no oracle model. That is a different setting. For this RoboCasa oracle dataset, keep the full candidate inventory from the beginning and use per-view visibility masks.

Verified local download: all atomic PickPlace pretrain human datasets

All 18 atomic PickPlace pretrain/human LeRobot exports have now been downloaded locally and verified for replay extras.

Local root:

/home/chris/robocasa_datasets/v1.0/pretrain/atomic

Manifest file in this HF package:

metadata/robocasa_pretrain_pickplace_download_manifest_20260702.json

Local working manifest:

/home/chris/gnn-world-model/agent_workspace/reports/robocasa_pretrain_pickplace_download_manifest_20260702.json

Totals:

tasks: 18
episodes: 1939
frames: 501419
size: 2.005 GB decimal
missing tasks: []
required replay extras missing: 0

Per-task counts:

PickPlaceCabinetToCounter            eps=106  frames= 20201  size_gb=0.087
PickPlaceCounterToBlender            eps=106  frames= 38892  size_gb=0.134
PickPlaceCounterToCabinet            eps=108  frames= 24225  size_gb=0.101
PickPlaceCounterToDrawer             eps=107  frames= 28225  size_gb=0.110
PickPlaceCounterToMicrowave          eps=110  frames= 42012  size_gb=0.191
PickPlaceCounterToOven               eps=111  frames= 32014  size_gb=0.129
PickPlaceCounterToSink               eps=108  frames= 22410  size_gb=0.088
PickPlaceCounterToStandMixer         eps=107  frames= 25467  size_gb=0.104
PickPlaceCounterToStove              eps=108  frames= 24039  size_gb=0.101
PickPlaceCounterToToasterOven        eps=108  frames= 24313  size_gb=0.106
PickPlaceDrawerToCounter             eps=103  frames= 31819  size_gb=0.135
PickPlaceFridgeDrawerToShelf         eps=106  frames= 26396  size_gb=0.079
PickPlaceFridgeShelfToDrawer         eps=111  frames= 27047  size_gb=0.085
PickPlaceMicrowaveToCounter          eps=112  frames= 38729  size_gb=0.167
PickPlaceSinkToCounter               eps=108  frames= 26397  size_gb=0.099
PickPlaceStoveToCounter              eps=109  frames= 23003  size_gb=0.096
PickPlaceToasterOvenToCounter        eps=106  frames= 19323  size_gb=0.086
PickPlaceToasterToCounter            eps=105  frames= 26907  size_gb=0.107

Required replay extras verified for every episode directory:

states.npz
model.xml.gz
ep_meta.json

These PickPlace datasets are pretrain split, not target split. Keep split provenance explicit in all exports and evaluations.

Local download and replayability verification status

Status recorded from the local lab machine after running the RoboCasa downloader.

Local dataset root:

/home/chris/robocasa_datasets/v1.0/target/atomic

Downloaded target Atomic-Seen human set:

18 / 18 tasks present
9126 episodes
2231347 frames
all episodes have required extras: True

Required replay extras verified per episode:

extras/episode_XXXXXX/states.npz
extras/episode_XXXXXX/model.xml.gz
extras/episode_XXXXXX/ep_meta.json

A replay smoke test was run on OpenDrawer/episode_000000: the saved XML + state restored successfully, and RGB plus MuJoCo segmentation rendered for:

robot0_agentview_right
robot0_agentview_left
robot0_eye_in_hand

Therefore the critical replayability gate for oracle graph extraction passed locally. This does not yet mean graph extraction is implemented; it means the downloaded data contains the simulator state/model metadata needed to implement it.

Per-task local manifest:

Task	Episodes	Frames	Required extras present
CloseBlenderLid	502	183099	yes
CloseFridge	513	155443	yes
CloseToasterOvenDoor	505	86401	yes
CoffeeSetupMug	502	117168	yes
NavigateKitchen	500	72786	yes
OpenCabinet	500	184024	yes
OpenDrawer	514	137431	yes
OpenStandMixerHead	502	58100	yes
PickPlaceCounterToCabinet	502	131904	yes
PickPlaceCounterToStove	501	129560	yes
PickPlaceDrawerToCounter	501	155749	yes
PickPlaceSinkToCounter	501	194952	yes
PickPlaceToasterToCounter	512	148353	yes
SlideDishwasherRack	502	83544	yes
TurnOffStove	500	114027	yes
TurnOnElectricKettle	520	84679	yes
TurnOnMicrowave	543	80439	yes
TurnOnSinkFaucet	506	113688	yes

Local manifest file:

/home/chris/gnn-world-model/agent_workspace/reports/robocasa_target_atomic_seen_download_manifest_20260702.json

Extraction plan

For each raw/replayable RoboCasa episode:

1. Load states, actions, model_file, and ep_meta.
2. Create RoboCasa environment from dataset metadata.
3. For each timestep t:
   • set simulator state to states[t];
   • call sim.forward();
   • render RGB for robot0_agentview_right, robot0_agentview_left, and robot0_eye_in_hand;
   • render MuJoCo segmentation for the same cameras;
   • map segmentation geom IDs to body IDs and graph node IDs;
   • read sim.data.qpos, qvel, xpos, xquat, and contacts;
   • read/reconstruct robot state and action;
   • assemble per-frame graph record;
   • compute Delta-G relative to previous frame.
4. After episode, write graph tensors and event labels.
5. Run sanity checks before accepting episode.

Download command shape

Manual download command for the 18 target Atomic-Seen tasks:

source /home/chris/anaconda3/bin/activate robocasa

python -m robocasa.scripts.download_datasets   --split target   --source human   --tasks   CloseBlenderLid CloseFridge CloseToasterOvenDoor CoffeeSetupMug NavigateKitchen   OpenCabinet OpenDrawer OpenStandMixerHead PickPlaceCounterToCabinet   PickPlaceCounterToStove PickPlaceDrawerToCounter PickPlaceSinkToCounter   PickPlaceToasterToCounter SlideDishwasherRack TurnOffStove   TurnOnElectricKettle TurnOnMicrowave TurnOnSinkFaucet

The downloader prompts for confirmation. Check disk and license first, then confirm manually. Do not run full automatic download in unattended mode.

Critical replayability gate

Before processing all 18 tasks, download and audit one representative task.

Gate:

Downloaded data must contain replayable simulator states and model metadata.
Flattened LeRobot RGB/action/proprio alone is not sufficient for oracle graph extraction.

Recommended first pilot tasks:

OpenDrawer
PickPlaceCounterToCabinet
one actuator task, e.g. TurnOnMicrowave or TurnOnSinkFaucet
NavigateKitchen as moving-base special case

Sanity checks and leakage guards

Alignment checks:

• RGB, segmentation, robot state, action, and graph frame counts must match exactly.
• action[t] must correspond to the correct transition convention.
• control_freq must be recorded.

No-depth checks:

• No file path or schema key may contain depth, median_depth, depth_quantiles, or pointcloud-from-depth fields.
• Simulator 3D geometry is allowed because it comes from oracle sim state, not RGB-D.

Camera checks:

• Every episode has right, left, and wrist views.
• Right view is marked canonical side.
• Per-view node visibility is recorded.

Graph leakage checks:

• No instruction-derived pair edge appears in rel_state.
• No task-goal edge appears in rel_prior.
• No reasoning-model output is used for contact/support/held/current physical state.
• Prior affordance edges are category-broadcast, not target-pair-only.
• Node inventory is deterministic from sim metadata/config, not language-filtered.
• Instruction-swap invariance: changing the instruction while holding sim state fixed must not change graph input tensors.

Extraction quality checks:

• Segmentation geom IDs map to valid body/node IDs.
• Node IDs persist across timesteps.
• Contact aggregation stats are logged before and after filtering.
• Event density matches task family expectations.
• Failed episodes are quarantined with reasons, not silently dropped.

Schema v1.1 clarification after multi-agent review

Fable 5 and Codex both reviewed the six design questions about multi-view graphs, velocity, feature balance, source availability, task-family coverage, and vocabulary edges. The v1.1 clarification is now the normative design.

1. One global graph, not one graph per camera

Use one authoritative global graph per timestep:

G_t = (V_t, E_state_t, E_prior, globals_t)

Do not create separate physical graphs for robot0_agentview_right, robot0_agentview_left, and robot0_eye_in_hand.

Reason:

• Object identity is global. A mug visible in the right camera and wrist camera is the same MuJoCo body/node.
• Physical relations are global. Contact, support, containment, qpos, held state, and robot interaction do not become false because a camera cannot see one endpoint.
• Per-camera graphs would confuse occlusion with object deletion and make physical edges view-dependent.
• RoboCasa/MuJoCo already gives free cross-view association through segmentation objid -> geom -> body -> node.

But the user’s concern is correct: camera evidence is different. Therefore v1.1 stores one global graph with per-view node evidence and per-view visual features.

Normative multi-view tensors:

visual_views   float16[T, N_max, 3, 256]   # per-view masked RGB/SAM2-style visual features
view_visible   bool[T, N_max, 3]
view_centroid  float16[T, N_max, 3, 2]
view_area      float16[T, N_max, 3, 1]

View order:

0 = robot0_agentview_right
1 = robot0_agentview_left
2 = robot0_eye_in_hand

The canonical side visual feature remains in the flat compatibility node tensor, but the complete visual evidence is visual_views.

2. Velocity definition

Velocity means node-level physical velocity from the simulator, source-tagged.

Recommended source in RoboCasa/MuJoCo:

mujoco.mj_objectVelocity(model, data, mjOBJ_BODY, body_id, res, flg_local=0)

This gives 6D world-frame body velocity. Store as linear and angular world velocity after confirming convention in the exporter.

Do not use raw free-joint qvel as object angular velocity without care: MuJoCo free-joint angular velocity conventions can be body-local. Use mj_objectVelocity for body-level velocity and store raw qvel only for joint/articulation state.

Per family:

Family	Body velocity	Joint velocity
object / movable item	root body world velocity	zero unless jointed
articulated_part	part body world velocity	scalar qvel is primary articulation signal
control	body velocity if meaningful	scalar qvel / control state if jointed
surface / receptacle / fixture	zero, with velocity_source=static_fixture	zero unless fixture state joint exists
optional robot node	TCP/eef velocity from robot state or MuJoCo body velocity	robot proprio stream remains primary

Add QA:

finite_difference(position_world) ~= stored_linear_velocity

on contact-free segments, and assert static fixtures have zero velocity.

3. Feature balance: 256D visual block should not dominate by raw concat

The dataset stores typed feature blocks. It does not recommend feeding a raw 300D+ concatenation directly into a GNN.

Downstream models should use per-block projections:

static_proj = MLP(node_static_feats)
dynamic_proj = MLP(node_dynamic_feats)
view_proj = PerViewEncoder(view_geom_feats, visual_views, view_visible)
edge_proj = EdgeEncoder(rel_state, rel_prior)

Then fuse into common d_model tokens.

Export rules:

• L2-normalize masked visual embeddings.
• Store per-block normalization stats.
• Keep visual features physically separate from symbolic state features.
• Publish a symbolic_only_v1_1 tensor view for ablation.
• Treat the old flat node_feats as a compatibility view, not the only model input.

4. Final v1.1 tensor layout

Published graph tensor file:

graph_tensors.npz
  node_feats        float32[T, N_max, 323]       # flat compatibility typed-block view
  node_mask         bool[N_max]
  category_ids      int16[N_max]

  visual_views      float16[T, N_max, 3, 256]
  view_visible      bool[T, N_max, 3]
  view_centroid     float16[T, N_max, 3, 2]
  view_area         float16[T, N_max, 3, 1]

  rel_state         float32[T, N_max, N_max, 8]
  rel_prior         float32[N_max, N_max, 5]
  event_masks       uint8[T, 13]

node_feats v1.1 slicing map, D = 323:

[0:256]    visual_256        canonical-side visual feature = visual_views[:, :, 0]
[256:259]  pos_world_3
[259:263]  quat_xyzw_4
[263:266]  linvel_world_3
[266:269]  angvel_world_3
[269:270]  qpos_norm_1
[270:271]  qvel_norm_1
[271:272]  binary_state_1
[272:274]  movability_2      [free_movable, articulated]
[274:275]  robot_contact_1
[275:276]  held_1
[276:279]  visibility_3      [side_right, side_left, wrist]
[279:291]  family_12
[291:323]  type_clip_32

5. Updated node families

Use 12 frozen family slots. Family is the relational role, not the full semantic class. Semantic class is carried by category_text, category_id, and CLIP type encoding.

0  object              free movable item: mug, can, food
1  distractor          free movable non-task item; metadata-derived, not language-derived
2  surface             static support plane: counter, stove top
3  receptacle          containment volume: cabinet/drawer/fridge/sink basin
4  fixture             appliance/furniture body: stove, microwave, kettle, blender, fridge
5  articulated_part    door, drawer, lid, rack, mixer head
6  handle              grasp point rigidly attached to articulated part
7  control             knob, button, switch, faucet lever; actuates fixture state
8  region              named zone: burner zone, rack slot, navigation region; v1 optional/reserved
9  robot               optional aggregate robot/TCP node for ablations
10 reserved
11 reserved

appliance_part is removed because it is ambiguous. Use articulated_part, handle, or control instead.

6. Updated relation tensors

State relation tensor:

rel_state: float32[T, N_max, N_max, 8]
channels:
  contact
  support
  near
  inside
  rel_dx
  rel_dy
  rel_dz
  dist_norm

Prior relation tensor:

rel_prior: float32[N_max, N_max, 5]
channels:
  part_of
  controls
  same_fixture_group
  can_contain
  can_support

Direction conventions:

support[i,j] = 1       means node i rests on/supports-contact with node j as support destination
inside[i,j] = 1        means node i is inside node j
part_of[i,j] = 1       means node i is part of node j
controls[i,j] = 1      means node i actuates/controls node j
can_contain[i,j] = 1   means node i can contain node j
can_support[i,j] = 1   means node i can support node j

Robot contact and held state are node flags by default. Robot-object edges are created only in a robot-node ablation.

7. Vocabulary information

Node vocabulary is included:

category_text
category_id
type_clip_32
full CLIP 512D type table

Edge vocabulary is primarily discrete and rule-table based:

relation channel IDs
human-reviewed affordance matrix
sim kinematic tree relations

Optional metadata may include CLIP embeddings of relation names, but relation CLIP vectors are not part of the default relation tensor.

Reasoning/VLM/LLM policy:

• No reasoning-model dependency in sim v1.
• LLM may draft rule tables, but committed source is human_reviewed_rule_table.
• category_text comes only from fixed rename tables keyed by asset/sim metadata; no per-episode language edits.
• No reasoning output is allowed for contact, support, held state, qpos, current inside state, or physical relations.

8. Feature source table

Feature	Source in v1	Needs CLIP/VLM/LLM?
node inventory	sim metadata + deterministic grouping rules	no
body/geom/joint IDs	MuJoCo model	no
family	deterministic role rules	no
category_text/category_id	fixed rename table from sim metadata	no
type_clip_32	frozen CLIP text encoder	CLIP yes, VLM/LLM no
RGB	replay render or stored video	no
masks/segmentation	MuJoCo segmentation render	no
bbox/centroid/area	masks	no
visual_views 256D	masked RGB visual encoder pooled by oracle mask	visual encoder yes; not reasoning
pose/orientation	sim state xpose/xquat	no
velocity	mj_objectVelocity; FD only QA/fallback	no
qpos/qvel	sim qpos/qvel via joint addresses	no
binary state	qpos/state thresholds	no
contact/support	sim contacts + deterministic filter/rule	no
inside/near/relative geometry	sim pose/AABB geometry	no
part_of/controls	kinematic tree/fixture metadata	no
can_contain/can_support	human-reviewed rule table	no LLM dependency
target labels	task metadata	supervision/eval only
depth-derived geometry	not in v1	not available

9. New sanity checks

• Swapping instruction text must not change node features, edge features, node inventory, or relation tensors.
• A node hidden in one camera but visible in another remains one global node.
• visual_views[t,n,v] is valid only when view_visible[t,n,v] is true.
• visual_views[:, :, 0] must match node_feats[:, :, 0:256] for the compatibility block.
• Every category ID resolves in the type table.
• Static fixtures have zero velocity.
• FD velocity approximately agrees with stored velocity on contact-free segments.
• Affordance channels must reproduce exactly from the published matrix gather.
• Event vocabulary must match across README, SCHEMA, relation vocab, and exporter output.

Visible-only segmentation and visual feature policy

Important clarification: segmentation is view-specific 2D evidence. It is not a 3D/global feature that should be copied into every camera view.

For each global node n, camera view v, and timestep t:

if node n is visible in camera v at timestep t:
    view_visible[t,n,v] = true
    view_centroid[t,n,v] = 2D mask centroid
    view_area[t,n,v] = normalized 2D mask area
    visual_views[t,n,v] = SAM2/image-encoder feature pooled over that visible 2D mask
else:
    view_visible[t,n,v] = false
    view_centroid[t,n,v] = [0, 0]
    view_area[t,n,v] = 0
    visual_views[t,n,v] = all zeros

Do not inject an invisible-instance segmentation feature. If the side camera cannot see a drawer handle but the wrist camera can, only the wrist slot should get a visual embedding. The side slot remains zero. The graph node still exists globally; only the per-view evidence is absent.

This separates:

global graph state: object identity, pose, qpos, contacts, edges
per-view 2D evidence: masks, centroids, visible visual embeddings

The canonical flat compatibility block follows the same rule:

node_feats[t,n,0:256] = visual_views[t,n,0]

where view 0 is robot0_agentview_right. If the node is invisible in the right camera, the compatibility visual block is zero even if the node is visible in the left or wrist view. Downstream models should use the full visual_views tensor, not only the flat compatibility block.

Two-pass implementation

Pass 1 runs in the robocasa environment:

input: replayable RoboCasa states/model/ep_meta
output: graph state, rel_state, rel_prior, packed 2D masks, view_visible, view_centroid, view_area
visual_views: zeros_pending_pass2

Pass 2 runs in the wdg environment:

input: shipped RGB videos + packed oracle masks + pass-1 graph tensors
SAM2: local /home/chris/gnn-world-model/sam2, checkpoint sam2.1_hiera_base_plus.pt
CLIP: OpenAI clip ViT-B/32
output: graph_tensors_pass2_visual.npz with visible-only SAM2 visual_views and CLIP type encodings

Current local wdg env supports:

torch 2.11.0+cu130 with CUDA
local sam2 package/checkpoint
OpenAI clip package, ViT-B/32
cv2/PIL/numpy

Pass-2 policy:

SAM2 is used as an image encoder only.
Oracle MuJoCo masks define the pooling region.
Only visible masks with area >= min_px receive visual embeddings.
Invisible node-view pairs remain exactly zero.
CLIP text encodes category/type strings once per node/category and projects 512D -> 32D.

This keeps the dataset schema honest: visual embeddings represent actual 2D evidence in a specific camera view, while the global graph state remains simulator-derived and view-independent.

Pilot extraction result: OpenDrawer episode_000000 v1.1

A first v1.1 pilot graph extraction has been run locally for:

Task: OpenDrawer
Episode: episode_000000
Output: /home/chris/gnn-world-model/agent_workspace/outputs/gwam_pilot/OpenDrawer_episode_000000_v11

Produced files:

graph/graph_tensors.npz
graph/graph_static.json
graph/frames.jsonl
masks/sample_masks_bool.npz
audit/summary.json
audit/contact_sheet.jpg

Pilot tensor shapes:

node_feats:   [334, 74, 323]
visual_views: [334, 74, 3, 256]
view_visible: [334, 74, 3]
rel_state:    [334, 74, 74, 8]
rel_prior:    [74, 74, 5]
event_masks:  [334, 13]

Pilot graph inventory:

74 nodes
334 frames

Important correction from Fable review: the input graph inventory must be language-blind and target-blind. The pilot now instantiates all drawer-like candidate fixtures found deterministically in the restored model, not only the drawer named by fixture_refs. fixture_refs is used only in goal_grounding_supervision_only metadata.

This prevents the graph from leaking the answer. The graph contains multiple candidate drawers; the instruction/goal metadata identifies the target only in supervision fields.

Pass-1 visual policy:

visual_views = zeros_pending_pass2_sam2_or_visual_encoder
node_feats[:, :, 0:256] = zeros_pending_pass2_sam2_or_visual_encoder
view_visible/view_centroid/view_area = real oracle MuJoCo segmentation outputs

This is intentional. The RoboCasa replay environment does not need Torch/SAM2. Pass 1 emits sim-state graph, masks, view geometry, and tensors. Pass 2 should run in the visual/SAM2 environment and fill only the visual arrays from shipped videos + pass-1 masks.

Camera alignment gate on sampled frames passed locally by comparing replay-rendered RGB against the shipped mp4s:

robot0_agentview_right mean PSNR: 38.72, mean MAD: 1.81
robot0_agentview_left  mean PSNR: 39.52, mean MAD: 1.66
robot0_eye_in_hand     mean PSNR: 39.18, mean MAD: 1.80

Pilot checks passed:

target_info_not_in_graph_tensors: True
no_depth_fields: True
visual_views_right_equals_node_feats_compat_block_max_abs: 0.0
any_segmentation_visible: True
required_replay_extras_present: True

Known pilot limitations before full 18-task processing:

• visual_views are pass-1 zeros until SAM2/visual pass 2.
• Full-frame masks are not stored densely in the pilot because a 74-node candidate graph would make dense masks large; the production exporter should stream masks into packed/chunked sparse files.
• support currently uses a contact proxy in the pilot; production should add the contact-normal/above/low-relative-velocity resting rule.
• inside and articulation-open events require a stricter AABB/qpos threshold rule before scale-up.
• N_max is not frozen. This pilot has 74 nodes because it includes all drawer candidate fixtures. Full N distribution should be measured across all 18 tasks before final tensorization.

Verified pass-2 SAM2/CLIP feature fill: OpenDrawer episode_000000

Pass 2 has been verified locally for the OpenDrawer v1.1 pilot.

Output tensor file:

/home/chris/gnn-world-model/agent_workspace/outputs/gwam_pilot/OpenDrawer_episode_000000_v11/graph/graph_tensors_pass2_visual.npz

Pass-2 encoder environment:

conda env: wdg
SAM2: /home/chris/gnn-world-model/sam2/checkpoints/sam2.1_hiera_base_plus.pt
CLIP: OpenAI clip ViT-B/32
CUDA: enabled

Policy verified:

Only visible node-view masks receive SAM2 pooled visual embeddings.
Invisible node-view pairs remain exactly zero.
Tiny/border masks that cannot produce valid SAM2 pooled support are marked not-visible in the pass-2 tensor rather than receiving fake features.
node_feats[:, :, 0:256] exactly equals visual_views[:, :, 0, :].
node_feats[:, :, 291:323] contains CLIP 512D -> 32D type embeddings.

Verification result:

frames_processed: 334
nodes: 74
visible_pairs_before_validity_filter: 6021
filled_pairs: 6018
invisible_nonzero_count: 0
visible_zero_count: 0
compat_block_max_abs: 0.0
visual norm on visible pairs: approximately 1.0
visual norm on invisible pairs: 0.0

Checks:

no_invisible_features_injected: True
some_visible_features_filled: True
canonical_side_matches_node_feats: True
type_clip32_filled: True

This resolves the key design question: segmentation is 2D per-view evidence, and SAM2/visual embeddings are only attached to the specific views where a node is actually visible.

Graph-readiness smoke test across full v1.2 scope

A first graph-readiness smoke test has been run across the full v1.2 scope:

17 target/atomic/human non-navigation tasks
18 pretrain/atomic/human PickPlace tasks
35 task/split datasets total
first episode per task/split

The smoke test verifies, for each dataset:

required replay extras exist: states.npz, model.xml.gz, ep_meta.json
RoboCasa/robosuite env can be created from dataset_meta
saved XML/state can be restored
side_right, side_left, wrist RGB render works
MuJoCo segmentation render works
replay RGB frame 0 aligns with shipped mp4 frame 0
a target-blind candidate graph inventory can be built
some candidate nodes are visible in rendered segmentation

Smoke script:

agent_workspace/scripts/smoke_gwam_v12_graph_scope.py

Manifest files in this HF package:

metadata/gwam_v12_graph_readiness_smoke_expanded_inventory_20260702.json
metadata/gwam_v12_graph_readiness_smoke_compact_20260702.json

Result summary:

scope_count: 35
ok_count: 35
fail_count: 0
node_count_min: 68
node_count_max: 253
node_count_mean: 132.83
suggested_N_max: 256

Top node-count cases:

pretrain PickPlaceFridgeDrawerToShelf         nodes=253 visible_any_view=15  frac=0.059
target   OpenStandMixerHead                   nodes=229 visible_any_view=18  frac=0.079
pretrain PickPlaceCounterToDrawer             nodes=216 visible_any_view=43  frac=0.199
pretrain PickPlaceToasterToCounter            nodes=216 visible_any_view=12  frac=0.056
pretrain PickPlaceCounterToOven               nodes=191 visible_any_view=15  frac=0.079
target   OpenCabinet                          nodes=160 visible_any_view=22  frac=0.138
pretrain PickPlaceCounterToBlender            nodes=159 visible_any_view=29  frac=0.182
target   PickPlaceToasterToCounter            nodes=158 visible_any_view=16  frac=0.101
target   CoffeeSetupMug                       nodes=157 visible_any_view=21  frac=0.134
target   SlideDishwasherRack                  nodes=156 visible_any_view=13  frac=0.083
pretrain PickPlaceCounterToToasterOven        nodes=149 visible_any_view=16  frac=0.107
pretrain PickPlaceFridgeShelfToDrawer         nodes=144 visible_any_view=13  frac=0.090

Camera alignment, replay render frame 0 vs shipped mp4 frame 0:

robot0_agentview_right   psnr_min=35.58 psnr_mean=38.20 mad_max=2.80 mad_mean=2.02
robot0_agentview_left    psnr_min=35.70 psnr_mean=38.33 mad_max=2.72 mad_mean=1.99
robot0_eye_in_hand       psnr_min=35.48 psnr_mean=38.33 mad_max=2.64 mad_mean=1.91

Aggregated node-family counts over the 35 first-episode inventories:

{
  "robot": 35,
  "fixture": 2210,
  "articulated_part": 887,
  "handle": 746,
  "surface": 204,
  "receptacle": 493,
  "object": 48,
  "distractor": 26
}

Interpretation:

All scoped task/split datasets pass replay/render/segmentation smoke.
Expanded salient fixture inventory raises the max first-episode node estimate to 253.
Use N_max = 256 for the first production graph tensor layout.
Low visible fractions are expected because the global graph keeps target-blind candidate components that may be occluded or visible later.
Per-view visual features must remain visible-only; invisible node-view pairs stay zero.

Important caveat:

This is first-episode smoke only. Before full export, run a full episode-distribution inventory scan to confirm whether N_max=256 covers every episode or whether rare layouts require a larger/padded/sparse layout.

Full episode-distribution inventory scan: N_max validation

After the replay/render/segmentation smoke passed for every v1.2 task/split dataset, a full fast XML inventory scan was run over every scoped episode. This scan parses each episode's ep_meta.json and model.xml.gz, checks body names directly, and applies the same target-blind candidate inventory rules used by the graph smoke. It does not render all frames; the earlier graph-readiness smoke is the replay/render validation gate.

Scanner:

agent_workspace/scripts/scan_gwam_v12_inventory_distribution_xml.py

Local outputs:

/home/chris/gnn-world-model/agent_workspace/reports/gwam_v12_inventory_distribution_xml_20260702/inventory_distribution_summary.json
/home/chris/gnn-world-model/agent_workspace/reports/gwam_v12_inventory_distribution_xml_20260702/episode_inventory_records.jsonl

Manifest files in this HF package:

metadata/gwam_v12_inventory_distribution_summary_20260702.json
metadata/gwam_v12_inventory_distribution_records_20260702.jsonl.gz

Full-scope result:

scope_datasets: 35
episodes scanned: 10565
ok_count: 10565
fail_count: 0
node_count_min: 58
node_count_p50: 126.0
node_count_p95: 230.0
node_count_p99: 232.0
node_count_max: 255
over_256_count: 0
over_320_count: 0
suggested_N_max: 256
unknown_nonstructural_class_totals: {}

Conclusion:

N_max = 256 is validated for all 10,565 scoped episodes under the current v1.2 target-blind inventory rules.
No episode exceeds 256 nodes.
The maximum observed node count is 255.

Top task/split maxima:

pretrain/PickPlaceCounterToMicrowave          episodes=110  node_min=61  node_max=255 node_mean=119.11
pretrain/PickPlaceCabinetToCounter            episodes=106  node_min=60  node_max=254 node_mean=122.00
pretrain/PickPlaceCounterToBlender            episodes=106  node_min=60  node_max=254 node_mean=120.58
pretrain/PickPlaceCounterToCabinet            episodes=108  node_min=60  node_max=254 node_mean=118.94
pretrain/PickPlaceCounterToSink               episodes=108  node_min=60  node_max=254 node_mean=122.97
pretrain/PickPlaceCounterToStove              episodes=108  node_min=60  node_max=254 node_mean=119.11
pretrain/PickPlaceSinkToCounter               episodes=108  node_min=59  node_max=254 node_mean=127.51
pretrain/PickPlaceStoveToCounter              episodes=109  node_min=59  node_max=254 node_mean=116.64
pretrain/PickPlaceCounterToDrawer             episodes=107  node_min=59  node_max=253 node_mean=126.84
pretrain/PickPlaceCounterToToasterOven        episodes=108  node_min=60  node_max=253 node_mean=126.63
pretrain/PickPlaceDrawerToCounter             episodes=103  node_min=59  node_max=253 node_mean=116.11
pretrain/PickPlaceFridgeDrawerToShelf         episodes=106  node_min=59  node_max=253 node_mean=117.99

Family totals across all scanned episodes:

{
  "robot": 10565,
  "fixture": 694114,
  "articulated_part": 256208,
  "handle": 212321,
  "surface": 66231,
  "receptacle": 155404,
  "object": 11426,
  "distractor": 7937
}

Fixture class totals across all scanned episodes:

{
  "Drawer": 155404,
  "Box": 134585,
  "Accessory": 122201,
  "HingeCabinet": 95669,
  "Wall": 72166,
  "Counter": 66231,
  "WallAccessory": 55627,
  "SingleCabinet": 46352,
  "Floor": 25036,
  "Stool": 20892,
  "HousingCabinet": 19012,
  "PanelCabinet": 14167,
  "OpenCabinet": 12109,
  "CoffeeMachine": 10565,
  "Dishwasher": 10565,
  "Microwave": 10565,
  "Sink": 10565,
  "Toaster": 10565,
  "ToasterOven": 8646,
  "Window": 8205,
  "Stove": 6268,
  "Hood": 5478,
  "FridgeFrenchDoor": 4468,
  "Oven": 4297,
  "Stovetop": 4297,
  "FridgeSideBySide": 3322,
  "FridgeBottomFreezer": 2775,
  "StandMixer": 609,
  "Blender": 608,
  "ElectricKettle": 520,
  "BlenderLid": 502
}

Implementation note:

The full distribution scan is XML/body-name based for speed and exact inventory counting.
The replay/render smoke remains the evidence that these datasets can restore XML/state and render RGB + MuJoCo segmentation.
Together, these two tests justify starting production pass-1 graph export with dense padded N_max=256.

Production Phase 1 / Phase 2 pipeline status

The v1.2 production pipeline is now implemented and smoke-tested.

Scripts:

agent_workspace/scripts/export_gwam_v12_phase1.py
agent_workspace/scripts/fill_gwam_v12_phase2_sparse.py
agent_workspace/scripts/run_gwam_v12_phase_pipeline.py

Phase 1 runs in the robocasa environment and writes simulator-derived graph state plus per-view 2D evidence:

graph/node_state.npz              # [T, 256, 32], padded global node state
graph/view_evidence.npz           # view_visible, view_centroid, view_area, view_bbox
graph/dynamic_edges.jsonl         # sparse per-frame dynamic edges, currently contacts + visibility changes
graph/graph_static.json           # node inventory, sparse priors, supervision-only goal metadata
graph/frames.jsonl                # timestamp/action alignment metadata
audit/summary.json
_PHASE1_DONE.json

Phase 1 deliberately does not write dense all-node masks or dense [T,256,256,*] relation tensors; it writes sparse visible-only RLE masks instead. Dense full-scope storage would be TB-scale. Instead:

N_max = 256 padded nodes
node state is dense per node
view evidence is dense but compact
relations are sparse
masks are stored only as visible-pair RLE rows
visual features are not stored in Phase 1

Phase 2 runs in the wdg environment and writes sparse visible-only SAM2/CLIP features:

graph/visual_features_sparse.npz  # sparse rows: t, node, view, 256D SAM2 feature
graph/visual_features_sparse.npz::type_clip32  # [256,32] CLIP type features

Phase 2 uses:

local SAM2: /home/chris/gnn-world-model/sam2/checkpoints/sam2.1_hiera_base_plus.pt
OpenAI CLIP: ViT-B/32
Phase-1 oracle 2D visibility/bbox from MuJoCo segmentation
shipped RGB mp4 videos

Important policy:

Only Phase-1-visible node/view pairs receive visual features.
Invisible node/view pairs are absent from the sparse feature file and decode as zero.
No invisible visual feature is injected.
Target/goal information remains supervision-only and is not graph input.

Environment note:

wdg was adjusted to satisfy RoboCasa/SAM2 compatibility checks for this pipeline:
  mujoco == 3.3.1
  numpy == 2.2.5
  numba == 0.61.2

A full-episode eval on target/OpenDrawer/episode_000000 passed:

Phase 1: 334 frames, 123 nodes, 9,324 visible node-view pairs, ~10.8s wall time
Phase 2: 334 frames, 9,317 SAM2 features written, 7 degenerate bbox pairs skipped, 0 invisible features injected, ~34.3s wall time

A 35-task/split end-to-end smoke passed:

1 episode per task/split
4 frames per episode
35 / 35 Phase 1 exports passed
35 / 35 Phase 2 exports passed
validation passed
smoke total frames: 140
smoke total sparse SAM2 features: 4,731
smoke total invalid visible pairs: 0

A full v1.2 Phase 1 -> Phase 2 -> validation run has been launched locally at:

/home/chris/gnn-world-model/agent_workspace/outputs/gwam_v12_phase1_full

This full run is resumable. Phase 1 writes _PHASE1_DONE.json; Phase 2 discovers completed Phase-1 episode directories. Final full-run validation manifests will be uploaded after the background run completes.

Fable alignment update: final Phase 1 / Phase 2 mask contract

Fable reviewed the full v1.2 Phase 1/Phase 2 plan in:

agent_workspace/claude_code/fable_gwam_v12_full_phase1_phase2_alignment_20260703.md

The final decision is not to recompute MuJoCo masks in Phase 2. Phase 1 already renders segmentation to compute visibility, so it now stores the exact Phase-1 visible-only masks as sparse RLE:

graph/visible_masks_rle.jsonl.gz

Mask contract:

codec: row_major_binary_rle_v1
index: (frame, node_id, view)
visible node/view pairs only; invisible pairs are absent
min_visible_px: 10
same masks drive view_visible, view_centroid, view_area, view_bbox, and Phase-2 pooling

Phase 2 now reads those exact Phase-1 masks and pools SAM2 image embeddings over the RLE masks. It does not rerender RoboCasa in the wdg environment. This avoids doubled render cost and keeps visual features pixel-consistent with Phase-1 geometry.

The sparse visual feature file includes explicit coverage fields:

t, n, v, feat                  # sparse visible features
invalid_t, invalid_n, invalid_v # visible masks too degenerate to pool, if any
visual_computed                # [T] bool: distinguishes not-computed from invisible
type_clip32                    # [256,32] CLIP type feature

Loader validity rule:

visual feature valid iff visual_computed[t] and (t,n,v) exists in sparse feature rows.
Invisible node/view pairs are absent and decode as zero.
Not-computed frames have visual_computed[t] = false and must not be conflated with invisibility.

The RLE end-to-end smoke passed:

35 / 35 task-split Phase 1 exports passed
35 / 35 task-split Phase 2 exports passed
RLE masks present and readable
visual_computed present
invalid visible pairs are explicitly indexed
no invisible features injected

Downstream Graph-WAM instructions

The next student should treat this dataset as graph-augmented trajectory data for joint vision+action world modeling.

Typical chunk:

context_rgb = frames[t-L:t]
context_state = robot_state[t-L:t]
context_graph = graph_tensors[t-L:t]
target_rgb = frames[t:t+H]
target_action = action[t:t+H]
target_graph_delta = events_or_transition_masks[t:t+H]
language = episode.language_instruction

Recommended graph uses:

1. Auxiliary target:

Predict future Delta-G / relation events in addition to future video/action.
Graph does not need to enter the input.

2. Structured modality:

Encode graph tensors as a parallel state stream aligned with visual/action tokens.

3. Joint graph modality:

Flow-match [future video latent, future action, future graph state] if the model architecture supports it.

4. Conditioning ablation:

Add graph tokens as conditioning only as an ablation, with no-graph and same-information controls.

Minimum ablation ladder:

• RGB/action/proprio only.
• Node-only object tokens, same node features, no edges.
• Same-information Transformer over nodes/pairs.
• Typed-edge graph model.
• Oracle graph versus predicted graph.
• Corrupted graph: shuffled nodes, stale graph, dropped contacts, randomized edge families, removed semantic priors, removed Delta-G.
• Right-only vs left-only vs right+wrist vs all three views.

License / redistribution status

The documentation is published first. Processed RoboCasa-derived data should not be uploaded until RoboCasa dataset redistribution terms are verified for:

• RGB videos;
• segmentation masks;
• simulator state;
• derived graph artifacts;
• redistributed metadata.

The dataset-card license is therefore marked other for now.

Repository contents

README.md                         # this complete design card
SCHEMA.md                         # standalone schema reference
CHANGELOG.md
VERSION
LICENSE_PENDING.md
configs/
metadata/
docs/
examples/
schemas/
scripts/
loaders/

The auxiliary docs mirror the details in this README so the design can be consumed either from the HF landing page or from individual files.

Initial upload / verification record

Initial docs package uploaded by Loki on 2026-07-02.

Local verification at upload time:

Package sanity: passed.
Repo targeted tests: 61 passed, 44 warnings.
HF file count after upload: 34.

Fable + Codex v2 resolution status

As of 2026-07-03, the initial full_rle production attempt was stopped after independent Fable 5 and Codex GPT-5.5/xhigh reviews. Both reviewers agreed that the two-phase sparse design is sound, but that the first production tree must not be treated as publishable data because it used pre-v2 graph attribution and tensor semantics. The stopped tree is retained only as a regression/debug fixture.

Current production root:

/home/chris/gnn-world-model/agent_workspace/outputs/gwam_v12_phase1_full_rle_v2

Current v2 schema stamp:

GWAM_Data_v1.2_phase1_sparse_v2

Implemented before v2 restart

Review item	Resolution	Status
Fixture subparts invisible because parent fixtures shadow child bodies	Phase 1 now maps geom/contact bodies by nearest ancestor root body, so door/handle/drawer/tray/button nodes receive their own masks, visibility, visual features, and contact endpoints.	Implemented
Object-vs-distractor family leaks target/role metadata into node_state[...,1]	Model-visible family now collapses task object and distractors to object; role lists are supervision-only metadata under goal_grounding_supervision_only.object_roles; rule stamp: families: object_distractor_merged_v2. Hardened validation rejects family index 1 and distractor node families.	Implemented
fp16 node state quantizes small motions	node_state is now float32.	Implemented
Free-joint qpos/qvel duplicated world x / linear x	Scalar qpos/qvel are now articulation-only; free-joint bodies leave those scalar channels at zero because world pose and velocity are already separate channels.	Implemented
Pure-Python RLE hot loop	RLE encoder is vectorized with np.flatnonzero, preserving the row-major counts-start-with-zero convention.	Implemented
Phase 1/Phase 2 final-path writes can leave partial canonical artifacts	Critical artifacts are written temp-file -> os.replace; _PHASE1_DONE.json and summaries are atomic.	Implemented
Phase 2 live-list modulo sharding is unstable while Phase 1 is producing	Phase 2 sharding is now stable crc32(relative_episode_path) % num_shards, safe for concurrent catch-up workers during Phase 1.	Implemented
Phase 2 skip accepted partial smoke outputs	Skip now requires full frame coverage, pair-accounting equality, readable npz files, and visual_computed.sum() == num_frames.	Implemented
Video truncation could be stamped as computed	Phase 2 asserts exact decoded frame count per view for the requested frame range; missing frames fail loudly.	Implemented
SAM2/CLIP were reloaded per episode	Phase 2 loads SAM2 and CLIP once per worker; per-episode category text is still encoded per node inventory.	Implemented
Validation was existence-only	Validation now loads npz files and checks schema, dtype/shape, frame coverage, visible-pair accounting, duplicate keys, v2 schema, and forbidden target-family leakage.	Implemented
Watcher counted manifest lines and hardcoded stale PIDs	v2 watcher counts _PHASE1_DONE.json and Phase 2 summaries, reports milestones, and has no stale hardcoded worker PIDs.	Implemented
Worker topology was unbalanced / overlapping	v2 uses four disjoint balanced Phase 1 task shards plus two stable-hash Phase 2 watch workers.	Implemented

Reasonable but intentionally deferred or documented

Review item	Decision	Rationale
Per-episode seeded node permutation	Deferred; raw node order is documented as metadata, not a model input.	Full permutation would require remapping every node-indexed artifact and downstream loader convention. The urgent leakage path was the object/distractor role bit, which is removed. Consumers must avoid positional encodings over raw inventory slots unless they apply their own permutation/loader discipline.
Episode-level lock directory	Deferred for current run; operational shards are disjoint and writes are atomic.	Atomic writes make accidental overlap corruption-resistant, and current v2 launch scripts use non-overlapping task partitions. A lock can still be added later for extra protection.
QR/orthonormal CLIP 32-D projection or PCA wording	Documented as seeded_gaussian_column_normalized_v1.	The current projection is deterministic and normalized but not PCA/orthonormal; README now uses the implementation name rather than claiming PCA.
Split graph_static.json into model-input and supervision files	Deferred; loader discipline documented.	graph_static.json contains both metadata and supervision-only blocks. Model loaders should explicitly admit only intended fields and ignore goal_grounding_supervision_only, node ids, source strings, and instruction metadata unless evaluating supervision.
Pixel-center centroid/bbox convention	Documented; not changed in v2.	Current values use normalized pixel index/min/max conventions already consumed by smoke/validation. This is a minor convention issue compared with the corrected mask semantics.
Instruction-swap leakage gate	Deferred.	The reviews note that instruction-swap invariance is necessary but not sufficient and cannot catch generator-metadata leaks. The concrete leak was removed and validation now scans forbidden family leakage.

Verification evidence for v2

The patched scripts passed all of the following before the v2 production restart:

Python compile: export_gwam_v12_phase1.py, fill_gwam_v12_phase2_sparse.py, run_gwam_v12_phase_pipeline.py, watch_gwam_v12_v2_progress.py
Shell syntax: run_gwam_v12_v2_phase1_shard0..3.sh
Targeted pytest: 61 passed, 44 warnings
35-task v2 scope smoke: 35 / 35 Phase 1 episodes passed; 35 / 35 Phase 2 episodes passed
Hardened validation on smoke: records=35, ok_count=35, fail_count=0, total_frames=140, total_features=5671, total_invalid=24
Subpart visibility smoke: nonzero subpart visibility in OpenDrawer, CloseBlenderLid, and PickPlaceCounterToCabinet
Leakage smoke: family index 1 count = 0; `distractor` absent from model-visible node families

Current v2 production status

The fresh v2 production run is in progress with:

4 balanced Phase 1 workers over disjoint task lists
2 stable-hash Phase 2 watch workers
1 milestone progress monitor

At the latest local status snapshot during README update:

Phase 1 done episodes: 116 / 10565
Phase 2 done episodes: 13 / 10565
Output size: 235M

Final upload/update should occur only after the v2 root passes full hardened validation.