codelion/multi-drive-model-data

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.

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, dspeed/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.

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.