drivingbench/drivingbench-demos-preview

DrivingBench cone-course demonstrations (pre-release)

A working pre-release shared with collaborators for fine-tuning, not the official DrivingBench dataset release. It will change; please don't redistribute it or cite it yet.

A person drove a Tesla Model 3 through small cone courses in empty parking lots at walking to jogging pace (mostly 0.5–2 m/s) while a comma device recorded both road cameras and the car's state. Each episode is one pass of one course: start stopped, follow the corridor of cones through its turns, stop in the finish area. The goal is a policy that drives an unseen course of this kind from the camera, given one fixed instruction:

Follow the cone course, stay between the cones, and stop in the finish area.

Contents

LeRobot v3.0 datasets at 10 Hz, one per folder, and LeRobot v2.1 copies under v21/:

Folder	Episodes	What
train/	108	54 passes (94 minutes as driven; lots A–D, 6 course layouts, lot C at night), each twice: as recorded and mirrored left-right. 60% of episodes carry one mild colour change for their whole length. This is what we train on.
holdout-lot-d/	6	Two passes from each of lot D's three layouts, held out for choosing checkpoints. The layouts' other passes are in train/.
holdout-lot-b/	2	Two held-out passes from lot B, whose other passes are in train/.
clean/	54	The 54 training passes as recorded, without mirrors or colour changes, for building your own augmentation.
v21/train/, v21/clean/, v21/holdout-lot-d/	108, 54, 6	The same episodes as LeRobot v2.1 with the front camera only (one parquet and one H.264 MP4 per episode), for trainers that read v2.1, such as Dream Labs' fine-tuning. Each passes dream.datasets.validate_dataset with the embodiment below.

from huggingface_hub import snapshot_download
from lerobot.datasets.lerobot_dataset import LeRobotDataset

root = snapshot_download(
    "drivingbench/drivingbench-demos-preview", repo_type="dataset", allow_patterns="train/*"
)
fps = 10
train = LeRobotDataset(
    "drivingbench/demos-train",
    root=f"{root}/train",
    delta_timestamps={"action": [k / fps for k in range(10)]},
)

meta/drivingbench.json in each folder describes every episode: lot, layout, direction, pass, how much was trimmed, whether it is mirrored, and its colour change.

Features

Feature	Shape	Meaning
observation.images.road_left, road_right	240×336×3	The narrow camera's road band (rows 140–380 of the 380×672 frame) split down the middle: two near-square views. Our default policy input.
observation.images.front	380×672×3	The narrow road camera (about 61°×37°) at half resolution.
observation.images.wide	380×672×3	The wide fisheye road camera, uncorrected. It adds the sides of tight turns but shows the dashboard and the worst low-sun flare.
observation.state	2	Curvature (1/m, left positive) and speed (m/s), measured.
action	2	Curvature and speed at this step.
observation.yaw_rate_rad_s	1	Gyro yaw rate, rad/s, left positive.
action.acceleration_mps2	1	Longitudinal acceleration.
ego.pose	3	x m forward, y m left, yaw rad, relative to the episode's first frame.

The action interface. The action at a step is the measured curvature and speed at that step, limited to what the car can execute (curvature within the steering lock, about ±0.19/m or a 5.3 m radius; speed within 3.5 m/s; 1.5% of steps changed). So a chunk of future actions, built with delta_timestamps, is the curvature and speed the car actually had over the next steps: absolute setpoints at 10 Hz, starting at the current state. Curvature describes the path rather than a steering-wheel angle, so it is car-independent; the car converts it with its own geometry. In mirrored episodes images are flipped (so road_left and road_right swap content), and curvature, yaw rate and the pose's y and yaw change sign; speed is unchanged.

Episode boundaries. Each pass is trimmed to 1 s before the car first moves (over 0.15 m/s) and 3 s after its final stop, so a policy learns to stop without learning to idle. Don't trim idle frames again, or the stops disappear. Every episode ends stopped in the finish area.

Training a VLA

What we did, with results on the held-out passes below:

• Inputs and outputs. road_left and road_right as two cameras, observation.state, and the instruction; out come absolute (curvature, speed) chunks at 10 Hz. Treat the two road views as two cameras (we used π0.5's base and wrist slots). Padding the full 672×380 frame into a square input makes the cones a few pixels wide; the two views keep them twice as large.
• π0.5 (openpi): 1 s chunks (10 steps), batch 128, learning rate 3.5e-5 with a cosine schedule, real-time chunking on. On roughly half of this data the held-out error stopped improving after about 12k steps (25 passes through the data); 25k steps is a reasonable length for the full set.
• FLUX 3 Action: 3 s chunks (30 steps). It reads the two previous 0.1 s observations and the three previous actions with each call, so feed it history at the full 10 Hz.
• Augmentation. train/ already mirrors and recolours, because hosted trainers often allow no custom transforms. If your trainer has its own photometric augmentation, it adds to ours; avoid large crops and rotations, which make the steering label wrong.

Training a world-action model

The same episodes support models that predict future frames together with actions:

• Video is continuous at 10 Hz within each episode, with no cuts; trimming only removes idle frames at the ends. A recoloured episode keeps one look throughout, so there is no flicker.
• Mirrored episodes are consistent worlds: images, actions and pose all flip together, so a model predicting future frames from mirrored actions sees physically coherent motion.
• front at 380×672 is the natural target for a single-camera video model; the road views are crops of it. ego.pose and observation.yaw_rate_rad_s give the motion directly if you want an auxiliary target.
• Condition on the instruction like a VLA; the action chunk and the predicted frames share the 10 Hz clock.

Fine-tuning a model we'll call from the car

If you are fine-tuning a model for us to drive (Dream-1 or another world-action model), please match this contract exactly, so the checkpoint plugs into our car client unchanged:

• Data. v21/train/ (LeRobot v2.1), or v21/clean/ if your pipeline flips images itself. Use every episode as is: don't trim idle frames, drop episodes or resample. All 108 are good demonstrations that end stopped in the finish area.

• Embodiment. drive is [curvature 1/m, speed m/s], left positive, in both state and action; actions are absolute values, not deltas. front is the only camera; leave out wide and the road views.

  {"state": {"drive": [0, 2]}, "action": {"drive": [0, 2]},
   "video": {"front": "observation.images.front"}, "head_camera": "front"}
  

• Instruction. Exactly the sentence above, on every episode. It is a single task (Dream Labs' docs recommend a cosine learning-rate schedule for one task).

• What our client sends. Every 0.2 s, the newest front frame (stretched from 672×380 to 320×176, as your training resizes the recordings), state.drive and the instruction, so a 9-frame window spans the last 1.6 s. It requests a prediction at most every 0.7 s.

• What it expects back. action.drive rows of absolute (curvature, speed), the first row at the time of the newest frame. We want rows 0.1 s apart, the dataset's own 10 Hz; if your model's rows have another spacing, tell us which. A prediction must reach at least 2 s ahead, since about 1 s goes to the round trip.

• Before handing over a checkpoint, score it on v21/holdout-lot-d/ as below. It should beat holding the current state, above all on turn entries and stops.

Checking a checkpoint

Score predictions on the held-out passes against a trivial baseline: keep the current curvature and speed for the whole chunk. On straights that baseline is nearly right, so turn entries and stops are where a model has to beat it. Our current best, π0.5 at 1 s chunks, reduces the curvature error 0.9 s ahead by about 30% (0.0076/m against the baseline's 0.0108/m) and the speed error by 13%. A low training loss proves little: the first action equals the state.

How it runs on the car

The comma executes a chunk of (curvature, speed) setpoints, one per 0.1 s, through openpilot's controls with our speed and steering limits and a safety driver. The laptop sends the latest road views, the state and the instruction, skips the chunk's steps that inference and the camera's delay already used up, and sends the rest. A model that returns a chunk in about 0.5 s or less drives smoothly; a chunk should cover at least the round trip plus 0.2 s of actuator delay.

License

CC BY 4.0. The lots were empty; nothing is blurred.