andreu-collabs/flow-abstract-wm-datasets

Flow-abstract world models — datasets

Two folders:

• wm_datasets/ — the world-model transition datasets described below, one subfolder per action representation, named as in the paper: labeled/ (X⁰ + y), label_free/ (pure X⁰), label_free_code/ (X⁰ + a skill code learned from unlabeled demos), low_level_baseline/ (control-rate wm_dense_* data for the low-level-action baseline). Per-folder card: wm_datasets/README.md; on-disk format: wm_datasets/documentation_wm_dataset.md.
• cfm_datasets/ — flow-policy demonstration datasets (scripted-expert action chunks used to train the low-level flow policies; schema in the header of experiments/policy/generate_policy_dataset.py in the code repo): fullbj16_demos_60k (60k branched, kind-stratified, jittered expert chunks over ~3750 states — the training set of both production flow policies full_x0 / full_oracle) and ppb_demos_10k (pick-place only).

World-model transition datasets

World-model transition datasets (s_k, A_k) → s_{k+1}, where one step spans one full flow action executed by a trained low-level flow policy (the flow_policy) and states are snapshotted at settled boundaries. The WM action A_k is the policy's initial noise X⁰ (the label-free representation) — or, for the oracle flavor, (X⁰, y) with y the commanded symbolic-action token triple (the labeled representation). The paper compares the two under an identical world model and planner. Two more families: wm_full_code_* — (X⁰, code) with a discrete skill code learned from unlabeled demos (label-free too; the third representation, 2026-09-04); and wm_dense_*, the same rollouts at control rate with the low-level TCP-setpoint action — the data for a standard (non-symbolic) world-model baseline; see below.

Companion policy weights (the exact flow_policy that generated each dataset) live in the model repo andreu-collabs/flow-abstract-wm-policies. Full on-disk format: wm_datasets/documentation_wm_dataset.md. The shards live under wm_datasets/, one folder per action representation, named as in the paper:

folder	representation	WM action	families
labeled/	labeled (X⁰ + y)	noise + commanded symbolic label	wm_full_oracle_s*, wm_full_oracle_zprior_s*
label_free/	label-free (pure X⁰)	noise only	wm_full_x0_s*, wm_full_x0_zprior_s*
label_free_code/	label-free, learned code (X⁰ + code)	noise + discrete skill code from a latent action model	wm_full_code_s*
low_level_baseline/	none (low-level actions)	TCP setpoint + gripper at control rate	wm_dense_oracle_s*, wm_dense_oracle_img_s* (+ gen_logs/ checks)

(The pick-place-only families wm_pp_* of the superseded single-kind scenario were removed 2026-09-04.)

The datasets

Each boundary dataset is 10 seed shards × 512 episodes × 25 actions (≈128k transitions), rendered at 256×256 — the full pair at 4-camera RGBD (top_down/wrist/side/front + metric depth), the pp pair at top_down + side RGB (read each file's cameras/depth attrs). Every transition stores the noise x0, the denoised flow endpoint x1 (same space as x0; diagnostic/ablation only), the realized symbolic label, and — for oracle files — the commanded y.

Relabeled 2026-07-31 (experiments/wm/relabel_wm_dataset.py, provenance in each file's relabeled attr): classify_transition's exactly-one-mover gate was relaxed — a grasp that incidentally nudges a neighboring block (support unchanged) no longer masks the action as none. Only previously-none rows changed (~9–15% of them per dataset).

dataset	shards	scenario	encoding	source policy (→ model repo folder)
wm_full_x0	_s100…109	pick_place + stack + unstack	X⁰	full-xattn-branch-ot-100k → full_x0/
wm_full_oracle	_s100…109	pick_place + stack + unstack	X⁰ + y	full-oracle-xattn-ytok-100k → full_oracle/
wm_full_oracle_zprior	_s200…203	pick_place + stack + unstack	X⁰ + y, z stored	full-oracle-xattn-ytok-100k → full_oracle/ + latent_action_full_oracle_z2/
wm_full_x0_zprior	_s210…214	pick_place + stack + unstack	X⁰, z stored	full-xattn-branch-ot-100k → full_x0/ + latent_action_full_x0_z8/
wm_full_code	_s400…404 (no images)	pick_place + stack + unstack	X⁰ + learned code (actions/code)	full-code-fsq5555-xattn-100k + skill LAM skill_lam_fullbj16_fsq5555_e100 (local; model repo upload pending)
wm_dense_oracle	_s300…307	pick_place + stack + unstack	control-rate TCP setpoint + gripper (no images)	full-oracle-xattn-ytok-100k → full_oracle/
wm_dense_oracle_img	_s310…311 (+ _s312, 64 episodes, perception test only)	pick_place + stack + unstack	control-rate, + 3-camera RGB 224 px at stride 7 (256 episodes each)	full-oracle-xattn-ytok-100k → full_oracle/

The *_zprior datasets

Actions are drawn from a latent-action VAE's sampling prior and decoded to X⁰ through the frozen flow (--latent-run), with the sampled z stored in actions/z — the only shards carrying z. A z-native WM must read actions/z directly, never re-encode x1 through the VAE posterior. In both, actions/x0 is the decoded X̂⁰ the flow actually executed, not a fresh N(0, I) draw.

wm_full_oracle_zprior — z ~ N(0, I), (M, 2) f32. Useful frac 0.953–0.956, i.e. not measurably more failure-rich than the fresh-noise wm_full_oracle (0.960): under the unit prior, z rarely reaches the failure regions.

wm_full_x0_zprior — hybrid z, (M, 8) f32: a discrete code (one of 256, drawn from the empirical marginal) concatenated with 4 continuous dims ~ N(0, I). Useful frac 0.445–0.462 against the fresh-noise wm_full_x0's 0.76, so these shards are substantially failure-richer (173–174 of the 174 grounded actions still appear). Two properties matter before training on them:

• The action mix is skewed, not uniformly degraded. Blind z sampling collapses toward pick_place; the two multi-object actions nearly vanish. Ranges over the five shards:

  	none	pick_place	unstack	stack
  wm_full_x0 (fresh X⁰)	24.4%	52.2%	12.0%	11.5%
  wm_full_x0_zprior	53.8–55.5%	40.0–41.1%	2.9–3.4%	1.3–1.8%

• The decoded X̂⁰ is not standard-normal — do not assume it is. Every other dataset stores noise with mean|μ| ≈ 0.008 and ‖x‖² ≈ D = 2560. Here the marginal is a different distribution altogether (values are the range over the five shards, stored per file in the x0_normality attr):

  	zprior	fresh-noise datasets
  per-dim `mean	μ	`
  per-dim std	0.463–0.465	~1.0
  ‖x‖²	3409–3422 (expect 2560)	~2559
  ‖x‖² spread	536–541 (expect 72)	~72
  dims rejecting normality	98%	—
  dead-subset probe bal-acc	0.577–0.592	~0.50

  So each dimension is narrower than N(0,1) but carries a large mean offset, with heavy tails (some dims reach |μ| ≈ 5). The dead-subset probe also rises above chance for the first time in any of these datasets: unlike fresh noise, there is a linearly-separable "this noise does nothing" region. The flow policy is being fed noise from well outside the shell it was trained on, which is the likely mechanical cause of the ~55% no-op rate.

(Seeds 105–124 of wm_full_x0 also exist locally as image-free shards from a data-scaling study. All shards of a dataset are identical in format and interchangeable.)

The wm_dense_* datasets (control-rate, low-level actions)

Training data for the low-level-action world-model baseline: a standard world model over the action the flow policy actually emits — one TCP setpoint + gripper command per control step — instead of one X⁰ per skill. Same rollouts as wm_full_oracle (the labeled flow policy, a valid commanded y per action, same layouts and useful-action floor), but recorded at every control step (control_dt = 0.05 s) instead of only at settled boundaries. Generated with generate_wm_dataset.py --dense. y and the realized label are stored per flow action as metadata only; the baseline never reads them.

• Time unit = control step. One flow action = 266 control steps: 256 policy steps + 10 settle steps. The settle steps keep the last control held (identical physics to the boundary datasets) and are recorded with the last action repeated, flagged frame_phase = 1. Physics substeps are never stored.
• Per control step: sim/qpos, proprio/*, state/* (as in the boundary datasets) and the applied action actions/tcp_target_pos (3), actions/tcp_target_quat (4, wxyz), actions/gripper_cmd (1, 0 = closed … 255 = open). Per trajectory N = 25·266 + 1 = 6651 frames.
• Boundaries: boundary_idx (M+1,) gives the frame index of each settled boundary; the boundary datasets are exactly that subset. actions/{x0, x1, y, label} stay per flow action.
• Images only in the _img_ shards: side, front, wrist RGB at 224 px, every 7th control step (image_idx); 7 divides 266, so every boundary frame is rendered. 256 episodes per image shard (≈9.7 GB each); the state-only shards hold 512 episodes (≈1.7 GB each).
• What a per-step model faces: in 73 % of control steps no block moves more than 1 mm (the arm travels empty, or settles); 99 % of actions show exactly two gripper events (close, open). Reported per shard by experiments/wm/dense_dataset_check.py, which also verifies the layout and replays the stored qpos through MuJoCo to confirm the stored poses (zero block error, TCP error ~1e-7 m).

Per-shard checks (dense_dataset_check.py; static = fraction of policy-phase control steps with no block motion > 1 mm; distinct = realized symbolic actions present in the shard):

shard	ok	useful	none	pick_place	stack	unstack	distinct	static(policy)	track mm	2-crossings	GB
wm_dense_oracle_s300	True	0.962	0.038	0.353	0.310	0.299	174	0.732	5.2	0.988	1.72
wm_dense_oracle_s301	True	0.964	0.036	0.348	0.315	0.301	174	0.731	5.2	0.990	1.72
wm_dense_oracle_s302	True	0.969	0.031	0.346	0.316	0.308	174	0.732	5.2	0.991	1.72
wm_dense_oracle_s303	True	0.961	0.039	0.352	0.313	0.296	174	0.731	5.2	0.991	1.72
wm_dense_oracle_s304	True	0.962	0.038	0.350	0.313	0.299	174	0.733	5.2	0.988	1.72
wm_dense_oracle_s305	True	0.961	0.039	0.342	0.316	0.304	174	0.733	5.2	0.989	1.72
wm_dense_oracle_s306	True	0.961	0.039	0.351	0.313	0.296	174	0.734	5.2	0.988	1.72
wm_dense_oracle_s307	True	0.965	0.035	0.348	0.313	0.304	174	0.734	5.2	0.988	1.72
wm_dense_oracle_img_s310	True	0.965	0.035	0.358	0.309	0.297	174	0.732	5.2	0.989	9.71
wm_dense_oracle_img_s311	True	0.956	0.044	0.338	0.320	0.298	174	0.733	5.2	0.989	9.68

Generation (per shard, --seed = shard id; image shards add --episodes 256 --cameras side,front,wrist --no-depth --img-size 224 --image-stride 7 and drop --no-images):

uv run python experiments/wm/generate_wm_dataset.py --run runs/full_oracle --ema --oracle --dense \
  --episodes 512 --max-worlds-parallel 256 --actions 25 --no-images --seed 300 \
  --out data/wm_datasets/low_level_baseline/wm_dense_oracle_s300.hdf5

Wall-clock on one RTX 5090: ≈8 min per state shard (GPU rollout), ≈28 min per image shard (CPU render pass, ≈590 images/s).

Loading (world_model.dense_dataset.WMDenseDataset, the same item contract as the state-mode LeWM datasets; the action of one WM step is the frameskip skipped low-level actions concatenated, each 3 + 6 (quat→6D) + 1 = 10 dims, normalized with the shard's norm/ stats):

from flow_abstract_wm.world_model.dense_dataset import WMDenseDataset
ds = WMDenseDataset("wm_datasets/low_level_baseline/wm_dense_oracle_s300.hdf5", seq_len=2, frameskip=5, state_keys="blocks")
item = ds[0]   # {"state": (2, 54), "action": (2, 50)}

The wm_full_code datasets (X⁰ + learned skill code)

The third action representation (notes/skill_lam.md in the code repo). A skill-level latent action model (FSQ, 5×5×5×5 = 625 codes) learned a discrete code from each demonstration's (first, last) observation pair, without any symbolic label; the flow policy full-code-fsq5555-xattn-100k was then trained conditioned on that code through the same token channel as the labeled policy's y. These shards are the first-stage recipe of the labeled arm with the code in place of y: x0 ~ N(0, I) (standard normal, see x0_normality), the code in actions/code ((M, 4) i64, one integer per factor in [0, 5)), states at settled boundaries, realized label for analysis, no images (the perception model exists; the render option remains). Per state, the code is drawn from the LAM's fitted state-conditioned prior p(code | obs) (code_sampling = prior) — the label-free analogue of "a valid commanded action"; in a 512-transition test it gave 0.90 useful transitions vs 0.84 (train marginal) and 0.77 (uniform codes). The code's meaning is state-relative; it is not a symbolic label and the same code means different actions in different states.

shard	useful	distinct actions	kinds pick_place / unstack / stack	codes used	GB
wm_full_code_s400	0.81	174	6083 / 2136 / 2169	623/625	0.14
wm_full_code_s401	0.83	174	6215 / 2211 / 2144	622/625	0.14
wm_full_code_s402	0.82	174	6127 / 2175 / 2138	622/625	0.14
wm_full_code_s403	0.82	174	6254 / 2124 / 2166	621/625	0.14
wm_full_code_s404	0.81	174	6180 / 2096 / 2119	623/625	0.14

Useful fraction 0.81–0.83 (labeled shards 0.96; label-free z-prior shards 0.45), kind mix ≈ 58 / 21 / 21 % — no collapse onto pick_place. Generation (per shard, --seed = shard id, ≈7 min on one RTX 5090):

uv run python experiments/wm/generate_wm_dataset.py --run runs/full-code-fsq5555-xattn-100k_0904-0301 --ema \
  --code-run runs/skill_lam_fullbj16_fsq5555_e100 --code-sampling prior --max-worlds-parallel 256 \
  --episodes 512 --actions 25 --no-images --min-useful-frac 0 --seed 400 \
  --out data/wm_datasets/label_free_code/wm_full_code_s400.hdf5

Summary stats

Regenerate with uv run python experiments/wm/wm_dataset_summary.py (per-shard, shard s100):

dataset	useful frac	distinct actions	cmd==realized	X⁰ mean|μ|	X⁰ ‖x‖² (exp 2560)	dead-subset bal-acc
full / X⁰-only	0.76	174	—	0.008	2559	0.498
full / oracle	0.96	174	0.990	0.008	2559	0.505

Takeaways

• The oracle ceilings hold under physics at scale: commanded==realized is 0.990 (full) and 0.999 (pick-place) — the WM has a clean, near-perfect testbed. pp_oracle covers all 72 possible pick_place actions; the full oracle spans 174 distinct realized actions.
• Saved X⁰ stays standard-normal N(0, I) after the useful-action filter (mean|μ| ≈ 0, ‖x‖² ≈ D = 2560) — even for wm_pp_x0, where the filter drops 52% of transitions as no-ops (useful 0.48). Dropping all-none trajectories does not bend the noise marginal.
• No "dead" noise subregion: a linear probe from X⁰ to "this noise produced a no-op" sits at ≈0.5 (chance) across all datasets, including the heavily-filtered pp_x0. Wasted motions are not concentrated in an identifiable slice of noise space — they are not linearly separable from X⁰ alone. (Numbers stored per file in the x0_normality attr.)
• No-op transitions (label = -1) are intentionally kept: a world model must learn no-op dynamics too. useful_action_frac reports the fraction that realized a clean symbolic action.

Loading

from flow_abstract_wm.world_model.dataset import WMTransitionDataset
from glob import glob

ds = WMTransitionDataset(sorted(glob("wm_datasets/label_free/wm_full_x0_s*.hdf5")))   # all shards, shared vocab
s, a, s_next, labels = ds.sample(256)                                                 # a = X⁰ (flattened noise)
ds = WMTransitionDataset(sorted(glob("wm_datasets/labeled/wm_full_oracle_s*.hdf5")))  # ds.y = (kind, block, target)
ds = WMTransitionDataset(sorted(glob("wm_datasets/label_free_code/wm_full_code_s*.hdf5")))  # ds.code (n, 4), ds.code_vocab
ds = WMTransitionDataset("wm_datasets/label_free/wm_full_x0_s100.hdf5", use_x1=True)   # also expose denoised X¹

See wm_datasets/documentation_wm_dataset.md for the full schema, y decoding, and normalization conventions.