Upload folder using huggingface_hub (part 18)

4245ec7 verified 26 days ago

58.3 kB

license: cc-by-4.0
task_categories:
  - robotics
  - image-segmentation
  - graph-ml
language:
  - en
tags:
  - robotics
  - manipulation
  - disassembly
  - tower-of-hanoi
  - constraint-graph
  - gnn
  - world-model
  - sam2
  - segmentation
  - ur5e
size_categories:
  - 1K<n<10K
pretty_name: GNN Constraint-Aware World Model Dataset (v3)

GNN Constraint-Aware World Model Dataset (v3)

Real robot episodes with per-frame constraint graphs, SAM2 segmentation masks + 256-D feature embeddings, full 3D depth bundles, and synchronized robot states across two manipulation domains. Both domains share the v3 on-disk layout (same JSON/NPZ schemas, same delta-encoded frame_states, same fully-connected PyG expansion at load time) and now share a unified 270-D node feature format — the PyG loader reads a fixed 10-D type encoding from a YAML config so both domains produce identical node dimensionality.

Project: CoRL 2026 — GNN world model for constraint-aware video generation
Author: Chang Liu (Texas A&M University)
Hardware: UR5e + Robotiq 2F-85 gripper, OAK-D Pro (static side view)
Format version: v3.0 (updated 2026-04-16)

What's in this repo — at a glance

Where	Contains	Use for
`session_` (Desktop) and `hanoi/session_hanoi_`	Raw episodes + per-frame `annotations/` (masks, embeddings, depth bundles, `side_graph.json`)	Training data for the world model
`config/type_encoding_*.yaml`	Fixed 10-D per-type encoding YAMLs	Loader inputs (pick one per run)
`tools/hanoi_pipeline/`	SAM2 FT checkpoint + all Python code to regenerate / extend / run the Hanoi pipeline end-to-end (auto-labeler, single-frame inferer, per-frame materializer)	Reproducing or re-running the pipeline on new Hanoi sessions; inference-time RGB→graph
Not in this repo (source repo only): `scripts/hanoi/orchestrator.py` (robot data collection), `scripts/run_annotator.sh` (browser verification UI), `scripts/sam2_finetune/` (FT training harness)	Hardware-facing and web-UI code	Clone the source repo if you want to collect new data, verify labels in a browser, or retrain the SAM2 FT checkpoint

Domains at a glance

Domain	Graph variants offered	Node vocab size	Node feature dim	Edge feature dim	Data root
Desktop disassembly	products-only, with-robot-node, with-robot-state, with-robot-action	9 (8 products + `robot`)	270	3	`session_<date>_<time>/episode_XX/`
Tower of Hanoi	products-only, with-robot-state, with-robot-action	4 (`ring_1..ring_4`)	270	3	`hanoi/session_hanoi_<date>_<time>/episode_XX/`

Node feature dim = 256 (SAM2 emb) + 3 (3D pos) + 10 (fixed type encoding) + 1 (visibility) = 270. The 10-D type encoding is a fixed, deterministic per-type vector (NOT trained) read from config/type_encoding_random.yaml or config/type_encoding_clip.yaml at load time — so both domains, and any future component vocabulary up to 13 types, share the same node dimension.

Four loader variants (all return torch_geometric.data.Data):

load_pyg_frame_products_only — V1 bare graph: products/rings only, no robot info.
load_pyg_frame_with_robot — V2 ablation: robot attached as a graph NODE (Desktop only; Hanoi has no robot mask in v1, so this falls back to products-only).
load_pyg_frame_with_robot_state — V3 recommended: products-only graph + robot_state=[13] side-tensor. Works for both domains because robot_states.npy is present everywhere.
load_pyg_frame_with_robot_action — V3 action-conditioned: same as above + robot_action=[13] delta for the next frame.

The three paper options map cleanly: Option 1 (direct graph encoding) → products_only; Option 2 (encoder → latent → world model with robot context) → with_robot_state; Option 3 (action-conditioned GNN) → with_robot_action.

File layout (same for both domains)

episode_XX/
├── metadata.json            # episode metadata (domain-specific extras)
├── robot_states.npy         # (T, 13) float32 — joints + TCP + gripper
├── robot_actions.npy        # (T-1, 13) float32 — frame deltas
├── timestamps.npy           # (T, 3) float64
├── side/
│   ├── rgb/frame_XXXXXX.png     # 1280×720 RGB
│   └── depth/frame_XXXXXX.npy   # 1280×720 uint16 (mm)
├── wrist/                   # raw wrist camera (not used in v3)
└── annotations/
    ├── side_graph.json          # components, static edges, frame_states
    ├── side_masks/              # {component_id: (H,W) uint8} per frame
    ├── side_embeddings/         # {component_id: (256,) float32} per frame
    ├── side_depth_info/         # flat-keyed depth bundle per frame
    ├── side_robot/              # robot bundle per frame (visible flag)
    └── dataset_card.json        # format description

Alignment guarantee: every labeled frame index has files in all four of side_masks/, side_embeddings/, side_depth_info/, side_robot/. Files are keyed by the same integer frame index, so a loader can key off the mask directory and trust the rest to be present.

Pipeline — four stages from raw video to training-ready graphs

┌─────────────┐     ┌───────────────┐     ┌───────────────────┐     ┌──────────────────┐
│ Collection  │ →   │ Auto-labeling │ →   │ Verification / UI │ →   │  PyG loader @    │
│ (30 Hz RGBD │     │ (SAM2-FT)     │     │ (optional edit)   │     │  training time   │
│  + robot)   │     │               │     │                   │     │                  │
└─────────────┘     └───────────────┘     └───────────────────┘     └──────────────────┘
   episode_XX/         annotations/           annotations/             torch_geometric
                        masks, emb,            (corrected)              .data.Data
                        depth, robot,                                  x=[N,270], edge=[E,3]
                        side_graph.json

Stage 1 — Collection

30 Hz synchronous capture of side RGB + depth + robot state into episode_XX/. No image processing or graph work happens here.

Desktop: human teleop via a game controller; the operator decides what to disassemble in what order.
Hanoi: autonomous — scripts/hanoi/orchestrator.py pre-plans N missions upfront from the captured initial state, samples each as classical/single_ring/rearrange at 40/40/20 weights, writes metadata.json with goal_prompt, initial_state, target_state, and the deterministic solver_moves (reference action sequence from a classical Hanoi BFS solver). The UR5e executes each mission with blended waypoints and per-ring grasp offsets.

Stage 2 — Auto-labeling (SAM2 detection → graph)

Separate offline step that produces the entire annotations/ tree. Hanoi is fully automatic in v3; Desktop currently uses manual + SAM2-assisted labeling. The Hanoi auto-labeler ships inside this dataset under tools/hanoi_pipeline/ (so users cloning the dataset can reproduce or extend it):

python tools/hanoi_pipeline/scripts/hanoi/auto_label.py <session_dir>

Per-frame algorithm (Hanoi):

Ring detection. HSV range + color-specific mask → largest connected blob → bbox per ring.
SAM2 segmentation. Run SAM2 with (bbox + centroid point) prompt on each ring. The Hanoi-fine-tuned checkpoint is auto-loaded if present (checkpoints/sam2_hanoi_ft.pt); otherwise falls back to vanilla sam2.1_hiera_base_plus.
256-D embedding. Masked average-pool of SAM2's vision_features spatial grid over each ring mask.
Depth backprojection. Masked pixels → (u, v) + depth → 3D point cloud in camera frame; centroid used as the node position.

Per-episode algorithm: 5. Grasp-interval detection. Read robot_states.npy[:, 12] (Robotiq 2F-85 gripper position, 0-255). Find the lowest stable plateau above the fully-open cutoff (baseline ≈ pre-grasp width), threshold at baseline+10, morphologically close to bridge single-frame glitches, yielding [(start, end, ring_id)] intervals — one per move. 6. Symbolic state unroll. Starting from initial_state, apply solver_moves[i] after each interval closes, marking the moved ring as held=True during the interval and recording the resulting per-frame constraints / visibility / held dicts as deltas in frame_states. No per-frame ring re-identification is needed; the move plan is ground truth.

Stage 3 — Verification / correction (optional)

Browser UI over labeled episodes — live in the source repo (GitHub), not bundled with the dataset because it's a full React app not just a Python module:

# from the source repo:
bash scripts/run_annotator.sh --hanoi     # or --desktop
# → open http://localhost:8000

Per-frame bbox / point / brush / eraser / polygon editing. Save writes back to the same annotations/side_masks/*.npz; format is identical pre- and post-verification, so downstream loaders are unaffected. The only module from the annotator that's bundled here is tools/hanoi_pipeline/src/annotator/labeling_server.py (the SAM2 backend — reused by infer_graph_from_frame.py at inference time).

Stage 4 — SAM2 FT retraining (closes the loop)

After enough verified frames accumulate, retrain the SAM2 decoder+prompt_encoder on them. The training harness itself lives in the source repo (GitHub):

# from the source repo:
python scripts/sam2_finetune/collect_hanoi_samples.py   # pull (RGB, mask, bbox) triples
python scripts/sam2_finetune/train.py                   # fine-tune, save sam2_<domain>_ft.pt

The resulting sam2_hanoi_ft.pt goes at tools/hanoi_pipeline/checkpoints/sam2_hanoi_ft.pt (alongside the one already published here). auto_label.py and HanoiGraphInferer() both auto-select the checkpoint via that path on their next run.

SAM2 models used in this dataset

Two checkpoints are in play, both distributed by this repo under tools/hanoi_pipeline/checkpoints/ (also available from the SAM2 repo):

File	Size	What it contains	When it's used
`sam2.1_hiera_base_plus.pt` (Meta AI)	~320 MB	Full SAM2 model — image encoder + prompt encoder + mask decoder	Loaded as the base. Frozen during fine-tuning and inference
`sam2_hanoi_ft.pt` (this dataset)	~16 MB	Decoder + prompt_encoder only — fine-tuned weights	Auto-loaded when present; overrides the base decoder/prompt_encoder

The 16 MB FT checkpoint is small because the image encoder stays frozen at the base SAM2 weights. Training data: ~800 (image, bbox, ground-truth-mask) triples pulled from manually-corrected Hanoi episodes. Per-ring validation IoU (cross-episode held-out solve):

Ring	Vanilla SAM2 base	Hanoi-FT	Δ
ring_1 (red)	0.786	0.851	+6.5 pp
ring_2 (yellow)	0.803	0.842	+3.9 pp
ring_3 (green)	0.814	0.854	+4.0 pp
ring_4 (blue)	0.794	0.846	+5.2 pp
macro mean	0.799	0.848	+4.9 pp

Biggest gains are on partially-gripper-occluded rings where vanilla SAM2 tended to oversegment onto the gripper finger.

Usage in the world-model prediction loop. At inference time you don't need to run the full auto_label.py pipeline. Use the provided single-frame inferer:

from tools.hanoi_pipeline.infer_graph_from_frame import HanoiGraphInferer

inferer = HanoiGraphInferer()        # loads base + FT once
result = inferer(rgb_image, depth=depth_image)

graph      = result["graph"]         # side_graph.json schema
masks      = result["masks"]         # {ring_1..ring_4: (H, W) uint8}
embeddings = result["embeddings"]    # {ring_1..ring_4: (256,) float32}
depth_info = result["depth_info"]    # flat-keyed 3D bundle (empty if depth=None)
states     = result["ring_states"]   # {ring_id: RingState(peg, stack_index)}

This returns the same schema as the offline pipeline's per-frame output, so the PyG loaders work identically on both sources. Override the checkpoint via SAM2_FINETUNE_CKPT=<path>; set to empty string to force vanilla SAM2.

Desktop Disassembly Domain

Components (9 types)

Eight product types + one robot agent. Multiple instances (e.g. ram_1, ram_2) share the same 10-D type encoding and are disambiguated by SAM2 embedding + 3D position.

Index	Type	Color	Notes
0	`cpu_fan`	#FF6B6B	Always visible at start
1	`cpu_bracket`	#4ECDC4	Hidden at start (under fan)
2	`cpu`	#45B7D1	Hidden at start
3	`ram_clip`	#96CEB4	Multi-instance
4	`ram`	#FFEAA7	Multi-instance
5	`connector`	#DDA0DD	Multi-instance
6	`graphic_card`	#FF8C42	Always visible
7	`motherboard`	#8B5CF6	Always visible (base)
8	`robot`	#F5F5F5	Agent node (stored separately in `side_robot/`)

Sparse constraint edges

Directed prerequisite relations — A -> B means "A must be removed before B can be removed":

cpu_fan      -> cpu_bracket         (fan covers bracket)
cpu_fan      -> motherboard
cpu_bracket  -> cpu
cpu_bracket  -> motherboard
cpu          -> motherboard
ram_N        -> motherboard
ram_clip_N   -> motherboard
ram_clip_N   -> ram_M               (user pairs manually)
connector_N  -> motherboard
graphic_card -> motherboard

Typical episode has 10-15 product nodes and 10-14 stored directed edges.

Node feature layout (270-D)

[0   : 256]   SAM2 embedding (256)       — masked avg pool over vision_features
[256 : 259]   3D position (3)            — centroid in camera frame (meters)
[259 : 269]   type encoding (10)         — fixed 10-D vector from
                                            config/type_encoding_<method>.yaml
                                            (shared across domains)
[269]         visibility (1)             — 1 if visible this frame, else 0

Total: 270-D. The 10-D type slot is a deterministic encoding (NOT trained) — see "Fixed 10-D type encoding — how it's made" below.

Available Desktop episodes

Session / Episode	Labeled frames	Goal
`session_0408_162129/episode_00`	346	`cpu_fan`
`session_0410_125013/episode_00`	473	`cpu_fan`
`session_0410_125013/episode_01`	525	`graphic_card`

Total: 1344 frames.

Tower of Hanoi Domain

Components (4 types) — rings only, no robot node in v1

Hanoi episodes use native ring IDs (ring_1 .. ring_4) in components and as npz keys — no desktop-proxy remapping, and no robot node in v1. type_vocab is ["ring_1", "ring_2", "ring_3", "ring_4"] (length 4). Robot segmentation is deferred; side_robot/*.npz is zero-filled per frame for format uniformity but never becomes a graph node.

Note on V2 vs V3 for Hanoi. V2 (with_robot — robot as graph node) requires a labeled robot mask/embedding and is therefore Desktop-only in v1. V3 (with_robot_state / with_robot_action) uses the 13-D robot_states.npy trace, which IS recorded for Hanoi too — so V3 loaders work for both domains.

ID	Color	Disk size	Role
`ring_1`	red (#E63946)	32 mm	Smallest
`ring_2`	yellow (#F1C40F)	42 mm	—
`ring_3`	green (#2ECC71)	52 mm	—
`ring_4`	blue (#2E86DE)	62 mm	Largest

Mask .npz files carry the literal keys ring_1, ring_2, ring_3, ring_4. No robot in type_vocab, no robot edges, no robot node appended at load time.

Mission kinds (40 / 40 / 20 sampling)

Kind	Weight	Prompt template	Target
`classical`	0.40	`"Solve the puzzle: stack all rings on peg X"`	All 4 rings stacked in size order on one peg
`single_ring`	0.40	`"Move the <color> ring to peg X"`	One designated ring moved; others untouched
`rearrange`	0.20	`"Rearrange: red on peg A, green on peg B, ..."`	Uniformly sampled valid (larger-under-smaller) configuration

Every Hanoi metadata.json records mission_kind, goal_prompt, initial_state, target_state, and solver_moves (the reference action sequence from the classical-Hanoi solver, one entry per pickup/release pair).

Structural edges (static, always 6)

The 6 smaller → larger directed pairs are stored verbatim in side_graph.json:

ring_1 -> ring_2     ring_1 -> ring_3     ring_1 -> ring_4
                     ring_2 -> ring_3     ring_2 -> ring_4
                                          ring_3 -> ring_4

At PyG load time the loader expands to 4 × 3 = 12 fully-connected directed edges. The reverse (larger → smaller) direction carries the same has_constraint / is_locked but flipped src_blocks_dst.

Per-frame `is_locked` semantics

is_locked = 1 on edge (A, B) iff A is currently the immediately-stacked ring on top of B on the same peg (adjacent in the peg-stack with A above B). Every other pair — non-adjacent on the same peg, on different pegs, or with either ring in transit — gets is_locked = 0. This is strictly "physical stacking right now," not "A must move before B."

Held-ring rule (captures "constraint broken during transit")

When the robot holds a ring (gripper closed between grasp and release of that move), the ring is in transit and no longer touches any other ring. The auto-labeler flags held = 1 for that ring on every held frame, and every edge touching it gets is_locked = 0 — the constraint is physically broken mid-move. On release, the new adjacency emerges and that edge flips back to is_locked = 1.

Implementation: auto_label.py reads robot_states.npy[:, 12] (gripper position, Robotiq 2F-85, 0-255) and detects grasp intervals via baseline-mode thresholding (estimate "resting open" mode, threshold at baseline + margin, binary-close morphologically to bridge single-frame glitches). It then zips the resulting intervals with solver_moves in order — the k-th grasp interval is assigned to the k-th move. Validated on ep_00 (1 move, 1 interval), ep_01 (15 moves, 15 intervals), ep_02 (1 move, 1 interval). Per-frame held deltas are recorded as frame_states[f].held = {ring_id: True|False}.

Rule 2 — "larger must never sit on smaller"

Encoded without a new feature via the edge's existing src_blocks_dst bit:

Edge direction	`src_blocks_dst`	Meaning
smaller → larger (e.g. `ring_1 -> ring_3`)	1	Legal — smaller may rest on larger
larger → smaller (e.g. `ring_3 -> ring_1`)	0	Illegal — larger may not rest on smaller

Three dimension-preserving ways the world model can respect Rule 2:

Method	Where	One-liner	Guarantee
Training loss	objective	`λ * (pred_is_locked * (1 - src_blocks_dst)).sum()`	Soft (shapes distribution)
Rollout mask	inference	Reject any predicted `is_locked = 1` where `src_blocks_dst = 0`	Hard (eliminates illegal)
Dataset invariant	this spec	`is_locked` is never 1 on a larger→smaller edge in any training frame	Hard (on training distribution)

Node feature layout (270-D)

[0   : 256]   SAM2 embedding (256)
[256 : 259]   3D position (3)
[259 : 269]   type encoding (10)         — fixed 10-D vector from
                                            config/type_encoding_<method>.yaml
                                            (shared with Desktop)
[269]         visibility (1)

Total: 270-D — identical to Desktop. The 10-D encoding is domain-independent; unknown/unlisted types encode to a zero vector.

Mission metadata saved per episode

Every Hanoi side_graph.json carries goal_prompt, mission_kind, and target_state in addition to the fields shared with Desktop. Per-frame transitions (grasps, releases, re-stacks) are recorded as deltas in frame_states[f] with constraints, visibility, and held sub-dicts.

Hanoi episodes available

Session	Episodes	Frames	Collection mode	Notes
`hanoi/session_hanoi_0415_190808`	3	7,479	manual + teleop	Initial Hanoi pilot: 1 × classical 15-move solve + 2 × single-ring moves
`hanoi/session_hanoi_0417_133613`	7	10,968	autonomous orchestrator	Initial 4-stack on peg B, 40/40/20 mission mix, 1-10 moves per episode
`hanoi/session_hanoi_0417_144403`	20	30,942	autonomous orchestrator	Initial 4-stack on peg A, 40/40/20 mission mix, 1-10 moves per episode
`hanoi/session_hanoi_0417_164816`	20	64,185	autonomous orchestrator	Initial 4-stack on peg C, minimum 3 moves per episode (no upper cap). `episode_18.zip` and `episode_19.zip` are stored as zip archives (see note below).

Total across all Hanoi sessions: 50 episodes, 113,574 frames. Each episode_XX/metadata.json records the exact mission_kind, goal_prompt, initial_state, target_state, and solver_moves for that episode. All autonomous sessions are produced by scripts/hanoi/orchestrator.py, which pre-plans all N missions upfront from the captured initial state, resamples any mission exceeding the per-episode move cap, and records a deterministic solver reference trajectory for each accepted mission.

Zipped episodes. The last two episodes of session_hanoi_0417_164816 (episode_18.zip, episode_19.zip) are stored as uncompressed (zip -0) archives rather than expanded directory trees. HuggingFace datasets have a hard cap of 1 million files per repository, and expanding these two episodes would have exceeded it. Extract before use:

cd hanoi/session_hanoi_0417_164816
unzip episode_18.zip   # → episode_18/
unzip episode_19.zip   # → episode_19/

Once unzipped, the on-disk layout is identical to every other episode_XX/ directory in this dataset (same metadata.json, robot_states.npy, side/, wrist/, annotations/ tree, loadable by the exact same PyG loaders below). All other episodes in the dataset are stored as expanded directories and require no pre-processing.

Graph generation for Hanoi (reference)

The full pipeline that produced every annotations/ tree above is checked in under tools/hanoi_pipeline/ in this repo. For the pipeline overview, algorithm details, and SAM2 checkpoint stats see the Pipeline and SAM2 models sections above. For the single-frame runtime inferer (use it inside a world-model prediction loop to turn a predicted RGB back into a graph), see tools/hanoi_pipeline/infer_graph_from_frame.py and tools/hanoi_pipeline/README.md.

Per-frame graph retrieval — how it works (important)

Every frame in every episode has its own distinct graph. The dataset stores them as a (structural skeleton + per-frame deltas) decomposition rather than N JSON files per episode, because the skeleton is the same every frame and the deltas are small. This cuts ~6000× disk-space per episode while losing zero information — the loader reconstructs each frame's full graph on demand.

Where each piece of a per-frame graph lives:

Component of the frame-T graph	File
Node list (which rings exist) + structural edges (smaller→larger pairs)	`annotations/side_graph.json` → `components`, `edges` (shared across all frames)
`is_locked` / `visibility` / `held` as of frame T	`annotations/side_graph.json` → `frame_states` (delta-encoded up to T)
SAM2 mask of each ring at frame T	`annotations/side_masks/frame_TTTTTT.npz`
256-D SAM2 embedding at frame T	`annotations/side_embeddings/frame_TTTTTT.npz`
3D position (centroid) + bbox + depth-valid flag at frame T	`annotations/side_depth_info/frame_TTTTTT.npz`
Robot state at frame T	`robot_states.npy[T]` (13-D)

The PyG loader combines these into a torch_geometric.data.Data object for exactly that frame — node features differ per frame (new embeddings + new 3D positions + new visibility flags), and edge features differ per frame (is_locked bits flip as rings are stacked / unstacked / held mid-transit).

To get a distinct graph for every labeled frame in an episode: use the list_all_frame_graphs helper below, or run scripts/materialize_per_frame_graphs.py to materialize them as individual .pt (and optional .json) files on disk.

Where edge-feature transitions live

The 3-D edge_attr vector is [has_constraint, is_locked, src_blocks_dst]. Of these, only is_locked changes over time — it flips when a ring lifts off / lands on another ring (or enters/exits the held state mid-transit). has_constraint and src_blocks_dst are static per edge.

Every transition of is_locked (and every transition of held) is recorded as a delta in side_graph.json under frame_states. The key is the frame index at which the transition happens; the value lists exactly which entries changed. Example from a real Hanoi single-move episode:

"frame_states": {
  "0":   {"constraints": {"ring_1->ring_2": true,  "ring_2->ring_3": true,
                          "ring_3->ring_4": true}},                // initial stack
  "134": {"constraints": {"ring_1->ring_2": false},                // ring_1 lifted OFF ring_2
          "held":        {"ring_1": true}},                        // ring_1 now in transit
  "278": {"constraints": {"ring_1->ring_3": true},                 // ring_1 placed on ring_3
          "held":        {"ring_1": false}}
}

The loader's resolve_frame_state(graph_json, T) walks frame_states in ascending key order up to T, applies every listed constraint/held delta, and returns the resolved state at frame T. That resolved state then populates edge_attr[:, 1] (the is_locked column) and the held flags that zero out edges touching rings in transit. So for frame 200 in the example above, ring_1->ring_2 is unlocked and every other edge touching ring_1 is also unlocked (held-ring rule), whereas ring_3->ring_4 is still locked (never changed).

Bottom line: there's no separate edge-feature file per frame — the transitions are packed into one delta dict in side_graph.json, and the loader replays them to give you the exact edge_attr for whichever frame you ask for.

Shared: PyG edge feature semantics (3-D, both domains)

edge_attr[k] = [has_constraint, is_locked, src_blocks_dst]

`has_constraint`	`is_locked`	`src_blocks_dst`	Meaning
0	0	0	No physical constraint — message passing only. Used for: robot ↔ anything; Hanoi larger → smaller (non-edge at the pair level)
1	1	1	Constraint active, src is the blocker (physical Desktop) / src rests on top (physical Hanoi)
1	1	0	Same pair, reverse direction — src is the blocked / src is underneath
1	0	1	Constraint released, src was the blocker / legal rest direction with no contact right now
1	0	0	Same released pair, reverse direction

Symmetry invariants: has_constraint and is_locked are symmetric per unordered pair (same value for (i, j) and (j, i)). src_blocks_dst flips between the two directions. Robot ↔ anything edges are always [0, 0, 0].

Shared: Fixed 10-D type encoding — how it's made

Across both domains the component-type universe is 13 types (the two vocabularies unioned):

cpu_fan, cpu_bracket, cpu, ram_clip, ram, connector, graphic_card, motherboard,
ring_1, ring_2, ring_3, ring_4, robot

Each type is assigned a fixed 10-D vector. The encoding is NOT trained — it is a deterministic lookup read from a YAML at load time, so any consumer of the dataset gets the exact same node features bit-for-bit. Two methods are provided; both YAMLs live at the dataset repo root alongside the session directories:

Method	YAML file	How vectors are built	Semantic structure
`random`	`config/type_encoding_random.yaml`	`numpy.random.default_rng(42)` unit-norm 10-vectors, one per type	None — vectors are orthogonal-ish noise
`clip`	`config/type_encoding_clip.yaml`	CLIP ViT-B/32 text embedding of a humanised prompt (e.g. `"a CPU fan"`, `"a small red ring"`) → PCA to 10 → unit-normalise	Related types cluster (the four rings are close; the fan/bracket/cpu cluster is tight)

Unknown type → 10-D zero vector. If a component's type is not in the YAML, the loader returns np.zeros(10, dtype=np.float32) for that slot. This keeps node dim at 270 regardless of vocabulary drift.

To reproduce or extend: download whichever YAML you want from the dataset repo root, load it with yaml.safe_load, and look up each component's type. The loader code below shows the full pattern.

Shared: PyG loader — self-contained Python

Prerequisites

pip install torch numpy torch_geometric pillow pyyaml

Save as `gnn_world_model_loader.py`

The key design property: node_dim = 256 + 3 + 10 + 1 = 270 for both domains. The 10-D type slot comes from the fixed YAML encoding (loaded once), so there's no domain branching — Desktop, Hanoi, and any future vocabulary all produce 270-D nodes.

import json
from dataclasses import dataclass
from functools import lru_cache
from pathlib import Path
from typing import Dict, List, Optional
import numpy as np
import torch
import yaml
from torch_geometric.data import Data

# ---------- constants ----------
TYPE_ENCODING_DIM = 10          # fixed, domain-independent
SAM2_EMB_DIM = 256
POS_DIM = 3
VIS_DIM = 1
NODE_DIM = SAM2_EMB_DIM + POS_DIM + TYPE_ENCODING_DIM + VIS_DIM   # = 270
ROBOT_STATE_DIM = 13            # [j0..j5, tcp_x, tcp_y, tcp_z, tcp_rx, tcp_ry, tcp_rz, gripper_pos]


# ---------- fixed type encoding ----------
# Download once from the dataset repo root:
#   config/type_encoding_random.yaml   (seeded numpy unit vectors, seed=42)
#   config/type_encoding_clip.yaml     (CLIP ViT-B/32 text → PCA(10) → unit-norm)
# Point TYPE_ENCODING_ROOT at wherever you saved them.
TYPE_ENCODING_ROOT = Path("./config")


@lru_cache(maxsize=4)
def load_type_encoding(encoding_method: str = "random") -> Dict[str, np.ndarray]:
    """Load the fixed 10-D per-type encoding from YAML. Cached across calls."""
    path = TYPE_ENCODING_ROOT / f"type_encoding_{encoding_method}.yaml"
    with open(path) as f:
        raw = yaml.safe_load(f)
    return {k: np.asarray(v, dtype=np.float32) for k, v in raw.items()}


def type_encode(comp_type: str, encoding_method: str = "random") -> np.ndarray:
    """Return 10-D vector for `comp_type`; zeros for unknown types."""
    table = load_type_encoding(encoding_method)
    vec = table.get(comp_type)
    if vec is None:
        return np.zeros(TYPE_ENCODING_DIM, dtype=np.float32)
    return vec.astype(np.float32)


# ---------- file helpers ----------
def list_labeled_frames(episode_dir: Path) -> List[int]:
    mask_dir = episode_dir / "annotations" / "side_masks"
    if not mask_dir.exists():
        return []
    frames = []
    for p in mask_dir.glob("frame_*.npz"):
        try:
            frames.append(int(p.stem.split("_")[1]))
        except (ValueError, IndexError):
            continue
    return sorted(frames)


def resolve_frame_state(graph_json: dict, frame_idx: int):
    constraints, visibility = {}, {}
    for c in graph_json["components"]:
        visibility[c["id"]] = True
    for e in graph_json["edges"]:
        constraints[f"{e['src']}->{e['dst']}"] = True
    fs_dict = graph_json.get("frame_states", {})
    for f in sorted([int(k) for k in fs_dict]):
        if f > frame_idx:
            break
        fs = fs_dict[str(f)]
        for k, v in fs.get("constraints", {}).items():
            constraints[k] = v
        for k, v in fs.get("visibility", {}).items():
            visibility[k] = v
    return constraints, visibility


@dataclass
class FrameData:
    graph: dict
    masks: dict
    embeddings: dict
    depth_info: dict
    robot: Optional[dict]
    constraints: dict
    visibility: dict


def load_frame_data(episode_dir, frame_idx):
    anno = Path(episode_dir) / "annotations"
    with open(anno / "side_graph.json") as f:
        graph = json.load(f)
    def _npz(p):
        if not p.exists(): return {}
        d = np.load(p)
        return {k: d[k] for k in d.files}
    masks = _npz(anno / "side_masks" / f"frame_{frame_idx:06d}.npz")
    embeddings = _npz(anno / "side_embeddings" / f"frame_{frame_idx:06d}.npz")
    depth_info = _npz(anno / "side_depth_info" / f"frame_{frame_idx:06d}.npz")
    robot = None
    rp = anno / "side_robot" / f"frame_{frame_idx:06d}.npz"
    if rp.exists():
        r = np.load(rp)
        if r["visible"][0] == 1:
            robot = {k: r[k] for k in r.files}
    constraints, visibility = resolve_frame_state(graph, frame_idx)
    return FrameData(graph, masks, embeddings, depth_info, robot, constraints, visibility)


def _build_product_node_features(nodes, fd, encoding_method):
    feats = []
    for node in nodes:
        cid = node["id"]
        emb = fd.embeddings.get(cid, np.zeros(SAM2_EMB_DIM, dtype=np.float32))
        dvk = f"{cid}_depth_valid"; ck = f"{cid}_centroid"
        if dvk in fd.depth_info and int(fd.depth_info[dvk][0]) == 1:
            pos = fd.depth_info[ck].astype(np.float32)
        else:
            pos = np.zeros(POS_DIM, dtype=np.float32)
        vis = 1.0 if fd.visibility.get(cid, True) else 0.0
        if vis == 0.0:
            emb = np.zeros(SAM2_EMB_DIM, dtype=np.float32)
            pos = np.zeros(POS_DIM, dtype=np.float32)
        feats.append(np.concatenate([
            emb.astype(np.float32),
            pos,
            type_encode(node["type"], encoding_method),
            np.array([vis], dtype=np.float32),
        ]))
    if not feats:
        return torch.empty((0, NODE_DIM), dtype=torch.float32)
    return torch.tensor(np.stack(feats), dtype=torch.float32)


def _build_product_edges(nodes, graph, fd):
    N = len(nodes)
    constraint_set = {(e["src"], e["dst"]) for e in graph["edges"]}
    pair_forward = {frozenset([s, d]): (s, d) for s, d in constraint_set}
    src_idx, dst_idx, edge_attr = [], [], []
    for i in range(N):
        for j in range(N):
            if i == j: continue
            src_id, dst_id = nodes[i]["id"], nodes[j]["id"]
            src_idx.append(i); dst_idx.append(j)
            key = frozenset([src_id, dst_id])
            if key in pair_forward:
                fwd = pair_forward[key]
                is_locked = fd.constraints.get(f"{fwd[0]}->{fwd[1]}", True)
                sb = 1.0 if src_id == fwd[0] else 0.0
                edge_attr.append([1.0, 1.0 if is_locked else 0.0, sb])
            else:
                edge_attr.append([0.0, 0.0, 0.0])
    return src_idx, dst_idx, edge_attr


# ---------- 1) products-only (Option 1: direct graph encoding) ----------
def load_pyg_frame_products_only(episode_dir, frame_idx, encoding_method: str = "random"):
    fd = load_frame_data(episode_dir, frame_idx)
    nodes = fd.graph["components"]
    x = _build_product_node_features(nodes, fd, encoding_method)
    src, dst, ea = _build_product_edges(nodes, fd.graph, fd)
    return Data(
        x=x,
        edge_index=torch.tensor([src, dst], dtype=torch.long),
        edge_attr=torch.tensor(ea, dtype=torch.float32),
        y=torch.tensor([frame_idx], dtype=torch.long),
        num_nodes=len(nodes),
    )


# ---------- 2) V2 ablation: robot as graph NODE (Desktop only) ----------
def load_pyg_frame_with_robot(episode_dir, frame_idx, encoding_method: str = "random"):
    fd = load_frame_data(episode_dir, frame_idx)
    # Hanoi has no robot mask/embedding in v1 → fall back to products-only.
    if fd.robot is None:
        return load_pyg_frame_products_only(episode_dir, frame_idx, encoding_method)

    products = fd.graph["components"]
    N_prod = len(products); N = N_prod + 1

    x_prod = _build_product_node_features(products, fd, encoding_method)
    robot_emb = fd.robot["embedding"].astype(np.float32)
    robot_pos = (fd.robot["centroid"].astype(np.float32)
                 if int(fd.robot["depth_valid"][0]) == 1
                 else np.zeros(POS_DIM, dtype=np.float32))
    robot_feat = np.concatenate([
        robot_emb, robot_pos,
        type_encode("robot", encoding_method),
        np.array([1.0], dtype=np.float32),
    ])
    x = torch.cat([x_prod, torch.tensor(robot_feat, dtype=torch.float32).unsqueeze(0)], dim=0)

    src, dst, ea = _build_product_edges(products, fd.graph, fd)
    robot_idx = N_prod
    for i in range(N_prod):
        src.append(robot_idx); dst.append(i); ea.append([0.0, 0.0, 0.0])
        src.append(i); dst.append(robot_idx); ea.append([0.0, 0.0, 0.0])

    data = Data(
        x=x,
        edge_index=torch.tensor([src, dst], dtype=torch.long),
        edge_attr=torch.tensor(ea, dtype=torch.float32),
        y=torch.tensor([frame_idx], dtype=torch.long),
        num_nodes=N,
    )
    data.robot_point_cloud = torch.tensor(fd.robot["point_cloud"], dtype=torch.float32)
    data.robot_pixel_coords = torch.tensor(fd.robot["pixel_coords"], dtype=torch.int32)
    data.robot_mask = torch.tensor(fd.robot["mask"], dtype=torch.uint8)
    return data


# ---------- 3) V3 recommended: products graph + robot_state side-tensor ----------
def load_pyg_frame_with_robot_state(episode_dir, frame_idx, encoding_method: str = "random"):
    data = load_pyg_frame_products_only(episode_dir, frame_idx, encoding_method)
    robot_states = np.load(Path(episode_dir) / "robot_states.npy")   # (T, 13) float32
    rs = robot_states[frame_idx].astype(np.float32)                  # 13-D
    data.robot_state = torch.tensor(rs, dtype=torch.float32)
    return data


# ---------- 4) V3 action-conditioned: + robot_action delta ----------
def load_pyg_frame_with_robot_action(episode_dir, frame_idx, encoding_method: str = "random"):
    data = load_pyg_frame_with_robot_state(episode_dir, frame_idx, encoding_method)
    robot_states = np.load(Path(episode_dir) / "robot_states.npy")   # (T, 13)
    T = robot_states.shape[0]
    if frame_idx + 1 < T:
        action = robot_states[frame_idx + 1] - robot_states[frame_idx]
    else:
        action = np.zeros(ROBOT_STATE_DIM, dtype=np.float32)
    data.robot_action = torch.tensor(action.astype(np.float32), dtype=torch.float32)
    return data


# ---------- 5) Generator: one distinct graph per labeled frame ----------
_VARIANTS = {
    "products_only":     load_pyg_frame_products_only,
    "with_robot":        load_pyg_frame_with_robot,
    "with_robot_state":  load_pyg_frame_with_robot_state,
    "with_robot_action": load_pyg_frame_with_robot_action,
}


def list_all_frame_graphs(
    episode_dir,
    variant: str = "with_robot_state",
    encoding_method: str = "random",
):
    """Yield (frame_idx, Data) for every labeled frame in an episode.

    Each `Data` object is the full per-frame graph (node features, edges,
    edge features, and any requested side tensors). Feature values and
    `is_locked` bits differ per frame as rings move / stack / get held.
    """
    if variant not in _VARIANTS:
        raise ValueError(f"variant must be one of {list(_VARIANTS)}, got {variant!r}")
    loader = _VARIANTS[variant]
    for f in list_labeled_frames(Path(episode_dir)):
        yield f, loader(episode_dir, f, encoding_method=encoding_method)

Usage examples

All four loaders share the signature (episode_dir, frame_idx, encoding_method="random"). Swap "random" for "clip" to use the CLIP-derived encoding instead.

Desktop V1 — 15 product nodes, 270-D features, fully-connected edges (15×14 = 210):

from pathlib import Path
from gnn_world_model_loader import load_pyg_frame_products_only

episode = Path("session_0408_162129/episode_00")
data = load_pyg_frame_products_only(episode, frame_idx=42)
print(data)
# → Data(x=[15, 270], edge_index=[2, 210], edge_attr=[210, 3])

Desktop V3 (recommended) — same graph + 13-D robot_state side-tensor:

from gnn_world_model_loader import load_pyg_frame_with_robot_state

data = load_pyg_frame_with_robot_state(episode, frame_idx=42)
print(data)
# → Data(x=[15, 270], edge_index=[2, 210], edge_attr=[210, 3], robot_state=[13])

Desktop V3 action-conditioned — adds 13-D delta for the next frame:

from gnn_world_model_loader import load_pyg_frame_with_robot_action

data = load_pyg_frame_with_robot_action(episode, frame_idx=42)
# → Data(x=[15, 270], edge_index=[2, 210], edge_attr=[210, 3],
#         robot_state=[13], robot_action=[13])

Hanoi V1 — 4 ring nodes, 270-D features, 12 fully-connected edges:

episode = Path("hanoi/session_hanoi_0415_190808/episode_00")
data = load_pyg_frame_products_only(episode, frame_idx=250)
print(data)
# → Data(x=[4, 270], edge_index=[2, 12], edge_attr=[12, 3])

Hanoi V3 (recommended) — V3 works for Hanoi too because robot_states.npy is recorded for every episode:

data = load_pyg_frame_with_robot_state(episode, frame_idx=250)
print(data)
# → Data(x=[4, 270], edge_index=[2, 12], edge_attr=[12, 3], robot_state=[13])

V2 note. load_pyg_frame_with_robot falls back to load_pyg_frame_products_only on Hanoi (no robot mask), so for Hanoi V1 and V2 return identical graphs. On Desktop V2 attaches the robot as a 16-th node (x shape becomes [16, 270]).

How to use this dataset — full instructions

The sections below walk through every common task from scratch. All examples target the Hanoi subset (hanoi/), which is the more heavily instrumented of the two domains.

Step 0 — Download and set up

pip install huggingface_hub torch torch_geometric numpy pyyaml opencv-python pillow

# Pull the whole dataset (~150 GB) — or use allow_patterns to slim it down
hf download ChangChrisLiu/GNN_Disassembly_WorldModel --repo-type dataset --local-dir ./gnn_world_model

# Or cherry-pick just a few Hanoi episodes:
hf download ChangChrisLiu/GNN_Disassembly_WorldModel --repo-type dataset \
    --include "hanoi/session_hanoi_0415_190808/episode_00/*" \
               "hanoi/session_hanoi_0415_190808/episode_00/**/*" \
               "config/type_encoding_*.yaml" \
    --local-dir ./gnn_world_model

cd gnn_world_model

Unzip the two zipped episodes (only episode_18.zip and episode_19.zip in session_hanoi_0417_164816 are zipped; all others are expanded):

cd hanoi/session_hanoi_0417_164816
unzip episode_18.zip   # → episode_18/
unzip episode_19.zip   # → episode_19/
cd ../..

Save the loader code from the PyG loader section above as gnn_world_model_loader.py in the dataset root so from gnn_world_model_loader import ... resolves. The loader reads ./config/type_encoding_*.yaml, so make sure both YAMLs are in place.

Step 1 — Load one episode and inspect its per-frame graphs

Every labeled frame produces a distinct torch_geometric.data.Data object. The following script loads one Hanoi episode, picks a middle frame, shows the full graph, and iterates over the first few frames to demonstrate that is_locked bits change over time:

from pathlib import Path
from gnn_world_model_loader import (
    load_pyg_frame_with_robot_state,
    list_labeled_frames,
    list_all_frame_graphs,
)

episode = Path("hanoi/session_hanoi_0415_190808/episode_00")

# 1a. All labeled frame indices for this episode
frames = list_labeled_frames(episode)
print(f"{len(frames)} labeled frames ({frames[0]} .. {frames[-1]})")

# 1b. Load one specific frame
frame_idx = frames[len(frames) // 2]
data = load_pyg_frame_with_robot_state(episode, frame_idx, encoding_method="random")
print(data)
# → Data(x=[4, 270], edge_index=[2, 12], edge_attr=[12, 3], robot_state=[13], ...)
print("is_locked  :", data.edge_attr[:, 1].tolist())
print("src_blocks :", data.edge_attr[:, 2].tolist())

# 1c. Iterate all frames — each Data carries that frame's exact state
for f, g in list_all_frame_graphs(episode, variant="with_robot_state"):
    locked = int(g.edge_attr[:, 1].sum().item())
    print(f"frame {f:6d}  locked_edges={locked}/12")

The variant argument picks which of the four loader signatures to use:

"products_only" — graph alone (no robot info)
"with_robot" — Desktop V2 (Hanoi falls back to products-only)
"with_robot_state" — graph + 13-D robot_state side tensor (recommended for both domains)
"with_robot_action" — also adds a 13-D robot_action (next-frame delta)

Step 2 — Build a training DataLoader and train a GNN

Concatenate frames across any number of episodes into a plain list of Data, hand it to PyG's DataLoader, and you have batched mini-batches. This full training skeleton also shows the Rule-2 soft-compliance loss (discouraging the model from ever predicting is_locked=1 on a larger→smaller edge):

from pathlib import Path
from typing import List
import torch
import torch.nn.functional as F
from torch_geometric.data import Data
from torch_geometric.loader import DataLoader
from torch_geometric.nn import GATConv
from gnn_world_model_loader import (
    list_all_frame_graphs,
    NODE_DIM,          # = 270
    ROBOT_STATE_DIM,   # = 13
)

# 2a. Build the dataset — concatenate every frame of every selected episode.
def build_hanoi_dataset(roots: List[Path]) -> List[Data]:
    return [g for ep in roots for _, g in list_all_frame_graphs(ep, variant="with_robot_state")]

hanoi_root = Path("hanoi")
episodes = sorted(
    ep for sess in hanoi_root.glob("session_hanoi_*") for ep in sess.glob("episode_*") if ep.is_dir()
)
samples = build_hanoi_dataset(episodes[:5])      # first 5 episodes as a quick smoke-test
loader  = DataLoader(samples, batch_size=32, shuffle=True)

# 2b. A minimal GNN head that predicts per-edge `is_locked`.
class IsLockedPredictor(torch.nn.Module):
    def __init__(self, node_dim=NODE_DIM, edge_dim=3, hidden=128, robot_dim=ROBOT_STATE_DIM):
        super().__init__()
        self.gat1 = GATConv(node_dim + robot_dim, hidden, heads=4, concat=True, edge_dim=edge_dim)
        self.gat2 = GATConv(hidden * 4,            hidden, heads=1,             edge_dim=edge_dim)
        self.edge_head = torch.nn.Sequential(
            torch.nn.Linear(2 * hidden, hidden), torch.nn.ReLU(),
            torch.nn.Linear(hidden, 1),
        )

    def forward(self, data: Data):
        # PyG concatenates 1-D per-graph attrs along dim 0 (default __cat_dim__ = 0),
        # so after batching data.robot_state has shape [num_graphs * 13].  Reshape to
        # [num_graphs, 13] and broadcast to every node via data.batch.
        robot = data.robot_state.view(-1, ROBOT_STATE_DIM)[data.batch]   # [N_total, 13]
        x = torch.cat([data.x, robot], dim=-1)
        x = self.gat1(x, data.edge_index, data.edge_attr).relu()
        x = self.gat2(x, data.edge_index, data.edge_attr)
        src, dst = data.edge_index
        return self.edge_head(torch.cat([x[src], x[dst]], dim=-1)).squeeze(-1)

# 2c. Training loop with BCE loss on `is_locked` plus a Rule-2 compliance term.
device = "cuda" if torch.cuda.is_available() else "cpu"
model = IsLockedPredictor().to(device)
opt   = torch.optim.AdamW(model.parameters(), lr=3e-4)

for epoch in range(3):
    for batch in loader:
        batch  = batch.to(device)
        logits = model(batch)                                   # [E_total]
        target = batch.edge_attr[:, 1]                          # ground-truth is_locked
        ce     = F.binary_cross_entropy_with_logits(logits, target)
        # Rule-2: penalise predicting locked=1 on an illegal (larger→smaller) edge.
        legal  = batch.edge_attr[:, 2]
        rule2  = (torch.sigmoid(logits) * (1 - legal)).mean()
        loss   = ce + 0.1 * rule2
        opt.zero_grad(); loss.backward(); opt.step()
    print(f"epoch {epoch}  ce={ce.item():.4f}  rule2={rule2.item():.4f}")

Step 3 — Inference: turn a predicted RGB into a graph

When your world model has generated a future RGB (and optionally a matching depth), use the single-frame inferer to produce the same graph schema you trained on. It loads SAM2 base plus the Hanoi-FT decoder once, then maps an image to {graph, masks, embeddings, depth_info, ring_states} with no temporal context required.

import cv2
import numpy as np
from tools.hanoi_pipeline.infer_graph_from_frame import HanoiGraphInferer

inferer = HanoiGraphInferer()        # loads SAM2 base + sam2_hanoi_ft.pt

# A real frame from the dataset is a fine sanity-check input.
rgb   = cv2.cvtColor(cv2.imread(
    "hanoi/session_hanoi_0415_190808/episode_00/side/rgb/frame_000100.png"),
    cv2.COLOR_BGR2RGB)
depth = np.load(
    "hanoi/session_hanoi_0415_190808/episode_00/side/depth/frame_000100.npy")  # uint16 mm

result = inferer(rgb, depth=depth)

# Five-field output. Schema matches the offline pipeline exactly.
# result["graph"]       — same dict as side_graph.json (frame_states empty)
# result["masks"]       — {"ring_1".."ring_4": (H, W) uint8}
# result["embeddings"]  — {"ring_1".."ring_4": (256,) float32}
# result["depth_info"]  — flat-keyed 3D bundle (centroids, point clouds, bboxes)
# result["ring_states"] — {"ring_id": RingState(peg, stack_index)}

Convert the result to a PyG Data that matches the training format:

import torch
from gnn_world_model_loader import (
    NODE_DIM, SAM2_EMB_DIM, POS_DIM, type_encode,
)

components = result["graph"]["components"]
feats = []
for c in components:
    cid = c["id"]
    emb = result["embeddings"][cid].astype(np.float32)
    centroid_key = f"{cid}_centroid"
    pos = (result["depth_info"][centroid_key].astype(np.float32)
           if centroid_key in result["depth_info"]
           else np.zeros(POS_DIM, dtype=np.float32))
    feats.append(np.concatenate([
        emb, pos, type_encode(c["type"]), np.array([1.0], dtype=np.float32),
    ]))
x = torch.tensor(np.stack(feats), dtype=torch.float32)   # [4, 270] for Hanoi

# Fully-connected N×(N-1) edges with has_constraint / src_blocks_dst — reuse the
# same _build_product_edges helper from the loader module that the training
# pipeline uses, or expand manually from result["graph"]["edges"].

The same HanoiGraphInferer can be pointed at a different fine-tuned checkpoint via the SAM2_FINETUNE_CKPT environment variable, or set to the empty string to force vanilla SAM2.

Step 4 — Auto-label a freshly-captured session

If you collect new Hanoi data using the source repo's orchestrator, run the bundled auto-labeler to produce the full annotations/ tree. That's all that's needed — the PyG loaders above then work on the new session unchanged.

# (optional — in the source repo https://github.com/ChangChrisLiu/gnn-world-model)
# Collect a fresh session:
#   python scripts/hanoi/orchestrator.py --n-episodes 20 --data-root /path/to/sessions

# Auto-label the captured session — this is what ships with the dataset:
python tools/hanoi_pipeline/scripts/hanoi/auto_label.py \
    /path/to/sessions/session_hanoi_<date>_<time>/

auto_label.py produces, for every episode:

annotations/side_masks/frame_XXXXXX.npz — SAM2 masks (Hanoi-FT auto-selected if present)
annotations/side_embeddings/frame_XXXXXX.npz — 256-D pooled SAM2 embeddings
annotations/side_depth_info/frame_XXXXXX.npz — 3D positions, bboxes, depth-valid flags
annotations/side_robot/frame_XXXXXX.npz — robot bundle (zero-filled in Hanoi v1 for format uniformity)
annotations/side_graph.json — structural edges + frame_states deltas derived from solver_moves + the gripper-based held-interval detection
annotations/dataset_card.json — schema pointer

Then the usual pipeline:

from gnn_world_model_loader import list_all_frame_graphs
for f, g in list_all_frame_graphs("/path/to/sessions/session_hanoi_<date>_<time>/episode_00"):
    print(f, g)

Step 5 — Retrain the SAM2 Hanoi-FT checkpoint on your own labels

After you've corrected enough frames in the browser UI (step 6), the source-repo training harness pulls (image, bbox, ground-truth-mask) triples into a samples.jsonl and fine-tunes SAM2's decoder + prompt_encoder (the encoder stays frozen):

# from source repo:  https://github.com/ChangChrisLiu/gnn-world-model

# 5a. Collect triples.  Prefer collect_hanoi_from_sessions.py for native Hanoi
#     sessions under data/hanoi/ — it accepts explicit --episode, --val-episode,
#     or --all-episodes, and writes a JSONL samples file.
python scripts/sam2_finetune/collect_hanoi_from_sessions.py --all-episodes \
    --out data/sam2_finetune_hanoi/samples.jsonl

# 5b. Fine-tune.  Encoder stays frozen; only decoder + prompt_encoder update.
python scripts/sam2_finetune/train.py \
    --samples data/sam2_finetune_hanoi/samples.jsonl                     \
    --out     tools/hanoi_pipeline/checkpoints/sam2_hanoi_ft.pt          \
    --epochs  25 --lr 1e-4

On the next run, both auto_label.py and HanoiGraphInferer() pick up the new checkpoint automatically from tools/hanoi_pipeline/checkpoints/sam2_hanoi_ft.pt. Set SAM2_FINETUNE_CKPT=<path> to override, or set it to an empty string to force vanilla SAM2.

Step 6 — Verify / correct labels in the browser UI (source repo)

The correction UI is a web app (React + FastAPI) that lives in the source repo — it's not bundled here because it's not just a Python module. Clone the source, start the server, and open it:

# source repo
git clone https://github.com/ChangChrisLiu/gnn-world-model
cd gnn-world-model
bash scripts/run_annotator.sh --hanoi
# → browse to http://localhost:8000

The UI loads any labeled Hanoi episode under data/hanoi/ and lets you fix masks frame-by-frame with bbox / point / brush / eraser / polygon tools. Save writes back to the same annotations/side_masks/*.npz files. The format does not change pre- vs post-correction, so downstream loaders are unaffected. The only piece of the UI bundled in the dataset is tools/hanoi_pipeline/src/annotator/labeling_server.py, which is the SAM2 backend reused by infer_graph_from_frame.py.

Step 7 — Materialize per-frame graphs to disk (optional, for debugging)

For offline inspection, non-PyTorch consumers, or diff-friendly JSON, the materialize_per_frame_graphs.py script writes one .pt (and optional .json) file per labeled frame:

python tools/hanoi_pipeline/scripts/materialize_per_frame_graphs.py \
    hanoi/session_hanoi_0415_190808/episode_00 \
    --out     ./per_frame_graphs \
    --variant with_robot_state \
    --also-json

Reload:

import torch
data = torch.load("per_frame_graphs/frame_000100.pt", weights_only=False)
print(data)          # Data(x=[4, 270], edge_index=[2, 12], edge_attr=[12, 3], robot_state=[13])
print("is_locked:", data.edge_attr[:, 1].tolist())

To iterate in-process without touching disk, list_all_frame_graphs(episode_dir, variant="with_robot_state") yields the same (frame_idx, Data) pairs directly.

Shared: common v3 file schemas

`side_graph.json`

{
  "episode_id": "episode_00",
  "goal_component": "ring_1",            // Desktop: a product id; Hanoi: a ring id
  "view": "side",
  "components": [
    {"id": "ring_1", "type": "ring_1", "color": "#FF0000"}
  ],
  "edges": [
    {"src": "ring_1", "dst": "ring_3", "directed": true}
  ],
  "frame_states": {
    "0":   {"constraints": {"ring_1->ring_3": true},  "visibility": {"ring_1": true}, "held": {}},
    "120": {"constraints": {"ring_1->ring_3": false},                                   "held": {"ring_1": true}}
  },
  "node_positions": {"ring_1": [640, 360]},
  "type_vocab": ["ring_1", "ring_2", "ring_3", "ring_4"],     // Hanoi v1 — no robot
  "embedding_dim": 256,
  "feature_extractor": "sam2.1_hiera_base_plus",

  // Hanoi-only extras:
  "goal_prompt": "Move the red ring to peg B",
  "mission_kind": "single_ring",
  "target_state": {"peg_A": [], "peg_B": ["ring_1"], "peg_C": []}
}

`side_depth_info/frame_XXXXXX.npz` — 7 flat keys per component

Key	Shape	Dtype	Meaning
`{cid}_point_cloud`	(N, 3)	float32	3D points in camera frame (m). (0, 3) if no valid depth
`{cid}_pixel_coords`	(N, 2)	int32	(u, v) of valid depth pixels
`{cid}_raw_depths_mm`	(N,)	uint16	Filtered to [50, 2000]
`{cid}_centroid`	(3,)	float32	Mean of `point_cloud`; `[0,0,0]` if invalid
`{cid}_bbox_2d`	(4,)	int32	`[x1, y1, x2, y2]` from mask
`{cid}_area`	(1,)	int32	Mask pixel count
`{cid}_depth_valid`	(1,)	uint8	1 if N > 0 else 0

`side_robot/frame_XXXXXX.npz` — always 10 keys

Key	Shape	Dtype	Meaning
`visible`	(1,)	uint8	1 if robot labeled, 0 otherwise
`mask`	(H, W)	uint8	Binary mask
`embedding`	(256,)	float32	SAM2 256-D
`point_cloud`	(N, 3)	float32	3D points (m)
`pixel_coords`	(N, 2)	int32	(u, v)
`raw_depths_mm`	(N,)	uint16	mm
`centroid`	(3,)	float32	Mean of point cloud
`bbox_2d`	(4,)	int32	From mask
`area`	(1,)	int32	Pixel count
`depth_valid`	(1,)	uint8	1 if N > 0 else 0

Recording hardware

UR5e + Robotiq 2F-85 gripper; static-mounted Luxonis OAK-D Pro side view with intrinsics fx = 1033.8, fy = 1033.7, cx = 632.9, cy = 359.9; recording at 30 Hz, 1280 × 720 RGB and uint16 depth (mm) filtered to [50, 2000].

License

Released under CC BY 4.0. Use, share, and adapt freely with attribution.

Acknowledgements

Segment Anything Model 2 (SAM2) by Meta AI
PyTorch Geometric
Hugging Face Datasets
Source code: https://github.com/ChangChrisLiu/gnn-world-model

GNN Constraint-Aware World Model Dataset (v3)

What's in this repo — at a glance

Domains at a glance

File layout (same for both domains)

Pipeline — four stages from raw video to training-ready graphs

Stage 1 — Collection

Stage 2 — Auto-labeling (SAM2 detection → graph)

Stage 3 — Verification / correction (optional)

Stage 4 — SAM2 FT retraining (closes the loop)

SAM2 models used in this dataset

Desktop Disassembly Domain

Components (9 types)

Sparse constraint edges

Node feature layout (270-D)

Available Desktop episodes

Tower of Hanoi Domain

Components (4 types) — rings only, no robot node in v1

Mission kinds (40 / 40 / 20 sampling)

Structural edges (static, always 6)

Per-frame is_locked semantics

Held-ring rule (captures "constraint broken during transit")

Rule 2 — "larger must never sit on smaller"

Node feature layout (270-D)

Mission metadata saved per episode

Hanoi episodes available

Graph generation for Hanoi (reference)

Per-frame graph retrieval — how it works (important)

Where edge-feature transitions live

Shared: PyG edge feature semantics (3-D, both domains)

Shared: Fixed 10-D type encoding — how it's made

Shared: PyG loader — self-contained Python

Prerequisites

Save as gnn_world_model_loader.py

Usage examples

How to use this dataset — full instructions

Step 0 — Download and set up

Step 1 — Load one episode and inspect its per-frame graphs

Step 2 — Build a training DataLoader and train a GNN

Step 3 — Inference: turn a predicted RGB into a graph

Step 4 — Auto-label a freshly-captured session

Step 5 — Retrain the SAM2 Hanoi-FT checkpoint on your own labels

Step 6 — Verify / correct labels in the browser UI (source repo)

Step 7 — Materialize per-frame graphs to disk (optional, for debugging)

Shared: common v3 file schemas

side_graph.json

side_depth_info/frame_XXXXXX.npz — 7 flat keys per component

side_robot/frame_XXXXXX.npz — always 10 keys

Recording hardware

License

Acknowledgements

Per-frame `is_locked` semantics

Save as `gnn_world_model_loader.py`

`side_graph.json`

`side_depth_info/frame_XXXXXX.npz` — 7 flat keys per component

`side_robot/frame_XXXXXX.npz` — always 10 keys