Toy-v0: a synthetic rigid-body dataset for latent world models

2,496 short video episodes of a single asymmetric cuboid sliding and rotating on a ground plane, rendered at 128x128. Every episode ships with the exact physical state that produced it (position, yaw, linear velocity, angular velocity), so a learned latent can be probed directly against ground-truth dynamics.

The dataset was built to ask one question: does a predictive latent actually encode the physical state, or does it find a shortcut?

Layout

Each split ships as one .tar.gz. Unpacking gives one directory per episode, exactly as generated:

data/<split>.tar.gz  ->  <split>/<episode_id>/
    rgb.npz           # (32, 128, 128, 3) uint8
    segmentation.npz  # (32, 128, 128)    uint8   object mask
    states.npz        # ground-truth physics, see below
    metadata.json     # per-episode physics / appearance / camera config
    config.json       # generator config the episode was drawn from
splits/<split>.json   # episode list; `path` is relative to the unpack root

The archives are packed so that extracting into a common directory reproduces the original data/ tree, which is what the path field in each split manifest assumes.

states.npz holds position (32,3), quaternion (32,4), yaw (32,), linear_velocity (32,3), angular_velocity (32,3), timestamps (32,), delta_t (). Episodes are 32 frames at 12 fps (delta_t = 1/12 s).

Splits

split	episodes	trajectories	renders	purpose
train	2000	2000	1	training
val	200	200	1	model selection
eval_iid	200	200	1	in-distribution evaluation
eval_same_current_diff_dynamics	48	48	1	same current frame, different velocity
eval_same_physics_diff_appearance	48	8	6	same trajectory, 6 appearances

Two of the splits are deliberately adversarial:

• eval_same_current_diff_dynamics — episodes whose current frame looks alike but whose velocities differ. A model that only reads the current frame cannot tell them apart.
• eval_same_physics_diff_appearance — 8 trajectories rendered 6 ways each (object colour, material, ground colour). Physics is identical across the six, so a representation that encodes dynamics should be invariant to the render.

Important: train contains a single appearance (v0a_fixed: red matte object, light-gray ground). Appearance is constant during training; the multi-render episodes are evaluation-only. Any claim about appearance invariance is a generalisation claim, not something the training set exercises.

Generation

Object: asymmetric cuboid, 1.0 x 0.6 x 0.3, with an orientation marker so yaw is visually resolvable. Initial position is sampled in [-1.6, 1.6]^2, linear velocity in [-0.8, 0.8]^2 (min speed 0.15), yaw rate in [-60, 60] deg/s (min |rate| 5 deg/s). Motion is constant-velocity — linear drift plus constant yaw rate, no collisions or gravity. Samples are rejected until the object stays visible and large enough in frame. Fixed camera at (0, -5.5, 3.025) looking at (0, 0, 0.15), 55mm on a 36mm sensor.

Loading

Download and unpack a split, then read episodes straight from disk:

from huggingface_hub import hf_hub_download
import tarfile, numpy as np, json, pathlib

root = pathlib.Path("toy_v0")
root.mkdir(exist_ok=True)

# grab one split (use "val" or an eval split for a smaller download)
tgz = hf_hub_download("minseo28/toy-v0", "data/train.tar.gz",
                      repo_type="dataset")
with tarfile.open(tgz) as f:
    f.extractall(root)

manifest = hf_hub_download("minseo28/toy-v0", "splits/train.json",
                           repo_type="dataset")
episodes = json.load(open(manifest))["episodes"]

ep     = episodes[0]
rgb    = np.load(root / ep["path"] / "rgb.npz")["rgb"]        # (32,128,128,3)
states = np.load(root / ep["path"] / "states.npz")
yaw, omega = states["yaw"], states["angular_velocity"]

To get everything, loop the five archives — train, val, eval_iid, eval_same_current_diff_dynamics, eval_same_physics_diff_appearance — into the same root.

Sizes: train 17 MB, val and eval_iid 1.7 MB each, the two paired eval splits under 0.5 MB (21 MB total, 69 MB unpacked).

Known caveats

• Constant-velocity motion only. There is no contact, collision, or gravity, so the dynamics are simple enough that a good model should nail them — that is the point, but it limits what the benchmark can claim.
• Single appearance in train, as noted above.
• Yaw is recoverable from a single frame (the silhouette's principal axis correlates with yaw at ~0.75-0.81), so a model given the current frame can infer orientation without encoding it. Angular velocity is the quantity that genuinely requires memory across frames.