audit: README.md

README.md

@@ -5,118 +5,204 @@ tags:
 - world-model
 - driving
 - video-games
+- action-conditioned
 viewer: false
 ---
 
 # Multi-Drive World Model Data
 
-Action-conditioned driving gameplay from multiple racing games, grouped by visual **theme**, for
-training a single multi-game world model. 1,073,248 frames across 155 clips.
+Action-conditioned driving gameplay from four racing games, grouped by visual **theme**, for training
+a single multi-game world model. **1,073,285 frames** across **153 usable clips** at 384x216.
 
-| theme | source games | clips | frames |
-|---|---|---|---|
-| cartoon | supertuxkart | 118 | 589,560 |
-| realistic | forza-horizon, need-for-speed | 27 | 340,722 |
-| arcade | asphalt-9 | 10 | 142,966 |
+| theme | source games | clips | frames | mean \|r\| (label vs motion) |
+|---|---|---|---|---|
+| cartoon | supertuxkart | 118 | 589,560 | 0.828 |
+| realistic | forza-horizon, need-for-speed | 25 | 340,722 | 0.782 |
+| arcade | asphalt-9 | 10 | 142,966 | 0.805 |
+
+Every clip has been re-labelled and independently verified — see **Label alignment** below, which is
+the main reason to prefer this over the original release.
+
+## Actions (7-dim)
+
+**These are not recorded key presses.** The source is screen recordings of commercial games, so no
+controller ground truth exists. Every channel is derived from optical flow between consecutive
+frames. Treat indices 0–3 as *inferred* intent, not as a log of what the player pressed.
+
+| idx | field | type | ON-rate / range | notes |
+|---|---|---|---|---|
+| 0 | `accel` | binary | 14.9% | from the **change** in speed, not its level |
+| 1 | `brake` | binary | 15.1% | negative speed change |
+| 2 | `left` | binary | 21.4% | `turn` above a per-clip percentile |
+| 3 | `right` | binary | 18.6% | `turn` below it |
+| 4 | `drift` | binary | **0.0% — always zero** | dead channel, see below |
+| 5 | `speed` | float | mean +0.311, p5 −0.39, p95 +0.99 | signed forward expansion, negative when reversing |
+| 6 | `turn` | float | mean +0.023, p5 −0.82, p95 +0.87 | horizontal flow |
+
+Each record is `{frame_file, actions, dup}`. `dup` marks a near-duplicate of the previous frame
+(1.2% of frames — engine stutter in the source capture); dropping those windows is reasonable.
+
+**`drift` is identically zero in every frame.** The re-labelling pass had no flow signature that
+reliably distinguishes a drift, so rather than emit a guess it writes a constant. Use 6 channels, or
+expect index 4 to contribute nothing.
+
+**Why `accel` comes from the change in speed.** These games auto-accelerate. In the original labels
+the throttle bit was on in 73–88% of frames, which is nearly a constant, and a model conditioned on
+it learns to ignore the throttle entirely. Differencing gives a bit that actually varies.
+
+Normalisation is **per clip**: `speed` and `turn` are divided by that clip's own p95 of `|value|`
+and clipped to [−1, 1]. Absolute speeds are therefore not comparable between clips — a "1.0" in a
+slow kart clip and in a Forza clip are different real speeds.
+
+## Label alignment (the reason this release exists)
+
+Labels are attached to the transition `(i−1 → i)`, so `actions[i]` describes how the world got to
+`frames[i]` — which is what an action-conditioned model conditions on to predict frame `i`.
 
-- **Frames:** 384x216 RGB JPEG.
-- **`metadata.jsonl`:** one line per clip — `{clip, theme, game, n_frames, path}`.
+The original labels did not do this. Steering correlated with horizontal flow best at lag **+2**
+(cartoon), **+3** (arcade) and **+6** (realistic) instead of 0, even though they had been extracted
+from optical flow in the first place. In `realistic` this left steering essentially dead (r ≈ 0.05).
 
-## Why tar files (and why the dataset viewer is off)
+Re-derived labels were validated as a **gate**, not a report: a clip whose new labels failed the
+correlation check kept its original actions and is flagged, rather than being silently replaced with
+something worse. Per-run results are in `labelqc.json` inside each tar.
 
-The `.tar` files are **not a WebDataset**. Each tar holds ordered directories, one per contiguous
-gameplay run:
+Verified by `wm/dataset_audit.py` on **all 153 clips**, using optical flow recomputed at a different
+scale than the labeller used, so it is an independent measurement and not a restatement:
 
 ```
-<run>/frames/frame_000000.jpg
-<run>/frames/frame_000001.jpg
-...
-<run>/actions.jsonl          # one JSON line per frame, same order as the frames
+best lag == 0        153 / 153 clips  (100%)
+mean |r| at lag 0    0.819
+worst clip           0.673
 ```
 
-Three reasons for this layout:
+## Integrity
+
+Full pass over every run and every frame:
 
-1. **A world model trains on contiguous sequences, not independent samples.** The unit of training
-   is a window of N consecutive frames plus the actions taken across them. WebDataset's flat
-   `key.jpg` / `key.json` pairing has no way to express "these frames are consecutive and ordered",
-   and the viewer would shuffle them — which is meaningless for video.
-2. **File count.** Stored as loose files this would be millions of objects in one repo, which makes
-   listing, cloning and LFS painful. Tars keep it to a few hundred objects.
-3. **Sequential reads.** Training reads neighbouring frames together; a tar keeps them adjacent
-   rather than scattered across a bucket.
+```
+unreadable runs         2   (empty tars — see note below)
+corrupt/truncated JPEG  0   (checked for the FFD9 end-of-image marker on all 1,073,285 files)
+frame/action mismatch   0
+frame_file mismatch     0
+NaN / out-of-range      0
+non-binary key bits     0
+```
 
-Because the layout is deliberately not WebDataset, HF's auto-detection cannot parse it and the
-dataset viewer is disabled (`viewer: false`). Load the tars directly with the snippets below.
+`md_integrity.jsonl` has one row per run. `md_quality_all.jsonl` ranks every clip; see below.
 
-## Loading
+Two tars in `data/realistic/` contain an `actions.jsonl` and no frames at all. They are honestly
+declared as `n_frames: 0` in `metadata.jsonl` and are still present rather than deleted, so
+**filter on `n_frames > 0`** (or on membership in `md_quality_all.jsonl`, which excludes them):
+
+```
+data/realistic/forza-horizon__78c15140-4eae-48e7-ba0a-6aba108182d2.tar
+data/realistic/need-for-speed__30b4c31f-cb43-4717-88c3-847d032cd436.tar
+```
+
+## Choosing what to train on
+
+`md_quality_*.jsonl` rank clips by measured training value, so you can take the good half instead of
+all of it. Six rank-normalised measures: `control` (does the player act at all), `agreement` (does
+the label visibly move the world), `smooth` (lag-1 autocorrelation of frame difference — jittery
+timing makes dynamics unlearnable), `motion`, `detail` (Laplacian variance), `clean` (1 − duplicate
+rate), plus run length.
 
 ```python
-import json, tarfile, glob, os
+import json
 from huggingface_hub import hf_hub_download
 
 REPO = "codelion/multi-drive-model-data"
+best = [json.loads(l) for l in
+        open(hf_hub_download(REPO, "md_quality_top35.jsonl", repo_type="dataset")) if l.strip()]
+print(len(best), "clips", sum(r["frames"] for r in best), "frames")
+for r in best[:3]:
+    print(r["run"], r["tar"], round(r["score"], 3), "lag", r["best_lag"], "r", round(r["lag_r"], 2))
+```
 
-# the index: one line per run -> pick what you want without downloading everything
-meta = [json.loads(l) for l in
-        open(hf_hub_download(REPO, "metadata.jsonl", repo_type="dataset")) if l.strip()]
-print(len(meta), "runs")
+| tier | clips | frames | share |
+|---|---|---|---|
+| `md_quality_top20.jsonl` | 30 | 356,198 | 33% |
+| `md_quality_top35.jsonl` | 53 | 522,751 | 49% |
+| `md_quality_top50.jsonl` | 76 | 680,408 | 63% |
+| `md_quality_all.jsonl` | 153 | 1,073,285 | 100% |
 
-# fetch and unpack one tar
-tar = hf_hub_download(REPO, meta[0]["path"] if "path" in meta[0]
-                      else f"data/{meta[0]['shard']}.tar", repo_type="dataset")
-with tarfile.open(tar) as tf:
-    tf.extractall("work")
-```
+Nothing is pruned from the tars — the ranking is shipped instead, so you can pick your own cutoff or
+ignore ours.
 
-Each tar unpacks to a single `<clip>/` directory.
+## Layout
 
-## Building training sequences
+The `.tar` files are **not a WebDataset**. Each holds one clip directory:
 
-Frames and action records are index-aligned, so a training window is just a slice:
+```
+<clip>/frames/frame_000000.jpg
+<clip>/frames/frame_000001.jpg
+...
+<clip>/actions.jsonl      # one JSON line per frame, same order as the frames
+<clip>/labelqc.json       # relabelling QC for this clip
+```
+
+A world model trains on contiguous windows, not independent samples, and WebDataset's flat
+`key.jpg`/`key.json` pairing cannot express "these frames are consecutive and ordered" — the viewer
+would shuffle them, which is meaningless for video. Tars also keep the repo to a few hundred objects
+instead of a million, and keep neighbouring frames adjacent on disk. HF's auto-detection cannot parse
+this layout, so the dataset viewer is off.
 
 ```python
+import json, tarfile, glob, os
 import numpy as np
 from PIL import Image
+from huggingface_hub import hf_hub_download
+
+REPO = "codelion/multi-drive-model-data"
+meta = [json.loads(l) for l in
+        open(hf_hub_download(REPO, "metadata.jsonl", repo_type="dataset")) if l.strip()]
+
+tar = hf_hub_download(REPO, meta[0]["path"], repo_type="dataset")
+with tarfile.open(tar) as tf:
+    tf.extractall("work")
 
 def load_run(run_dir):
     frames = sorted(glob.glob(os.path.join(run_dir, "frames", "*.jpg")))
     recs = [json.loads(l) for l in open(os.path.join(run_dir, "actions.jsonl")) if l.strip()]
-    n = min(len(frames), len(recs))                 # always slice to the shorter of the two
-    actions = np.array([r["actions"] for r in recs[:n]], np.float32)   # [n, 7]
-    return frames[:n], actions
+    n = min(len(frames), len(recs))            # always slice to the shorter of the two
+    return frames[:n], np.array([r["actions"] for r in recs[:n]], np.float32)   # [n, 7]
 
 def windows(frames, actions, seq_len=16, stride=8):
-    """contiguous (frames, actions) windows — the unit a world model trains on"""
     for s in range(0, len(frames) - seq_len + 1, stride):
-        imgs = np.stack([np.asarray(Image.open(f).convert("RGB"), np.float32) / 255.0
-                         for f in frames[s:s + seq_len]])       # [seq,H,W,3]
-        yield imgs, actions[s:s + seq_len]                      # [seq,7]
+        imgs = np.stack([np.asarray(Image.open(f).convert("RGB"), np.float32) / 255.
+                         for f in frames[s:s + seq_len]])
+        yield imgs, actions[s:s + seq_len]     # [seq,H,W,3], [seq,7]
 ```
 
-Themes are the conditioning label used by the model (game names stay in the metadata).
+Horizontal-flip augmentation must mirror the controls too: swap indices 2↔3 and negate index 6.
 
-## Actions (7-dim)
+## What we found training on this
 
-| idx | field | type | notes |
-|---|---|---|---|
-| 0-4 | `accel, brake, left, right, drift` | binary | key presses = the player's *intent* |
-| 5 | `speed` | float [-1,1] | measured forward expansion, **negative when reversing** |
-| 6 | `turn_rate` | float [-1,1] | measured horizontal flow |
+Reported because negative results are worth more than silence, and because they tell you where the
+difficulty actually is.
+
+We trained latent diffusion world models (ConvVAE codec + DiT, rectified flow, per-frame diffusion
+forcing) on this data repeatedly. **Steering became genuinely controllable after the re-labelling**
+— A/B at matched settings moved separation from +0.177 → −0.008 (old labels, i.e. backwards) to
++0.509 → +0.381 (new labels). That is what the alignment fix bought.
 
-Indices 0-4 are what the player pressed; 5-6 measure what the world actually did (optical flow).
-Both are included deliberately: key presses alone are a weak conditioning signal here, because
-`accel` is held in 73-88% of frames — a near-constant bit carries almost no information, and a
-model trained on it alone ignores the throttle entirely.
+**Long-horizon stability was never solved.** Rollouts stay coherent for roughly 10–20 frames and then
+degrade. That survived correct labels, quality selection, a purpose-trained codec, more capacity,
+longer training, few-step distillation, and a different game domain entirely. We do not have an
+explanation, and we are not claiming the data is the cause.
 
-Normalisation: `speed /= 1.266`, `turn_rate /= 1.559` (p95 of |value|), then clipped to [-1,1].
-Note `turn_rate` is a *measurement*, so it lags the key press by ~6 frames (~0.4 s) — the car's
-visual response to steering, not the input event.
+One measurement worth passing on: our codec retained **36%** of a frame's Laplacian edge energy where
+Neural Drive's retained **58%** on identical frames, while scoring *higher* PSNR. PSNR flatters a
+blurry autoencoder. If you train a codec on this data, do not use PSNR as the stopping signal.
 
+## Provenance and licence
 
-## Curation
+Screen recordings of SuperTuxKart (open source), and of Forza Horizon, Need for Speed and Asphalt 9
+(commercial titles), curated to gameplay only with a CLIP content classifier that removes menus,
+car-select, results screens, loading and non-game content. Roughly 45% of the raw recordings were not
+gameplay.
 
-1. Gameplay-only filtering of commercial-game screen recordings: a CLIP content classifier removes
-   menus, car-select, results/reward screens, loading, and non-game content (browsers, streams)
-   present in the source captures; near-static frames are dropped by a motion floor. ~45% of the
-   raw recordings were not gameplay.
-2. Ego-motion measured per frame with optical flow and appended to the action vector.
+Footage of the commercial titles is included for research use; rights in the underlying games remain
+with their publishers. Check your own jurisdiction and intended use before redistributing or training
+commercially.