README.md

---
license: other
pretty_name: Multi-Drive World Model Data
tags:
- world-model
- driving
- video-games
- action-conditioned
viewer: false
---

# Multi-Drive World Model Data

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 clips** at 384x216.

| 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`.

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).

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.

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:

```
best lag == 0        153 / 153 clips  (100%)
mean |r| at lag 0    0.819
worst clip           0.673
```

## Integrity

Full pass over every run and every frame:

```
unreadable runs         0   (two empty tars were removed from the repo)
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
```

`md_integrity.jsonl` has one row per run. `md_quality_all.jsonl` ranks every clip; see below.

## 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
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))
```

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

Nothing is pruned from the tars — the ranking is shipped instead, so you can pick your own cutoff or
ignore ours.

## Manifest file schema

`md_quality_all.jsonl` / `md_quality_top{20,35,50}.jsonl` — one JSON object per scored run, sorted by
`score` descending. `md_integrity.jsonl` — one object per run, **all** runs, unsorted.

| field | in | meaning |
|---|---|---|
| `run` | both | clip directory name |
| `tar` | both | which tar holds it, e.g. `data/cartoon/supertuxkart__lighthouse_010.tar` |
| `frames` / `actions` | both | file count and action-line count |
| `count_delta` | integrity | `frames - actions`; 0 everywhere in this release |
| `corrupt_jpeg` | integrity | files failing the FFD9 end-of-image check; 0 everywhere |
| `framefile_mismatch` | integrity | records whose `frame_file` names the wrong frame; 0 everywhere |
| `width_ok`, `nan`, `out_of_range`, `nonbinary_keys` | integrity | action-vector sanity |
| `scored` | both | false if the run is under 48 frames |
| `score` | quality | the combined rank-normalised ranking value, 0–1 |
| `control` | quality | how much the player acts: camera magnitude + key-change rate |
| `agreement` | quality | \|corr\| between the steering signal and horizontal optical flow |
| `best_lag`, `lag_r` | quality | lag maximising that correlation, and the signed r there |
| `smooth` | quality | lag-1 autocorrelation of frame difference; low means jittery timing |
| `motion` | quality | mean optical-flow magnitude; excludes AFK stretches |
| `detail` | quality | mean Laplacian variance; excludes featureless sky and cave walls |
| `clean` | quality | 1 − near-duplicate-frame rate |

`score` weights these as `(2·control + 2·agreement + 1.5·length + smooth + motion + detail + clean) / 9.5`,
each rank-normalised across runs first so no raw scale dominates. Every component ships, so you can
re-weight for your own priorities instead of accepting ours.

Each clip also carries its own `labelqc.json` from the re-labelling pass:

| field | meaning |
|---|---|
| `frames` | frames the relabeller saw |
| `steer_r` | corr(`left − right`, `turn`) at lag 0 |
| `steer_sep` | mean `turn` when steering left minus when steering right — the separation the gate checks |
| `accel_r` | corr(`accel − brake`, d`speed`/dt) |
| `stutter` | near-duplicate frame rate in the source capture |
| `relabelled` | **false means the new labels failed validation and the ORIGINAL actions were kept** |
| `note` | which of those two happened, in words |

## Layout

The `.tar` files are **not a WebDataset**. Each holds one clip directory:

```
<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
    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):
    for s in range(0, len(frames) - seq_len + 1, stride):
        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]
```

Horizontal-flip augmentation must mirror the controls too: swap indices 2↔3 and negate index 6.

## What we found training on this

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.

**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.

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

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.

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.