naive-bench — Bin Sorting

A language-conditioned bin-sorting teleoperation dataset on a single SO-101 arm, collected for Project 2: Naive Bench — a hobbyist-oriented benchmark for comparing robot manipulation policies (ACT, VLAs, …) under fixed compute/data constraints.

The task is deliberately designed to differentiate VLAs from ACT/WAMs: the bins are arbitrary named targets (there is no color-matching rule), so the only way to route a bar correctly is to read both slots of the prompt — the bar color and the bin color. A policy that ignores the instruction cannot succeed, which makes the eval score a direct measure of language grounding.

Task

put the {bar_color} bar into the {bin_color} bin

• Bins (4): white, yellow, orange, blue — fixed positions, arbitrary targets (no color-matching rule).
• Bar colors (6): blue, purple, orange, red, yellow, green (~9 physical bars per color).
• Instruction space: 6 bars × 4 bins = 24 possible commands.

Every training scene contains a single bar. The target bin is varied across each bar's episodes so a policy cannot ignore the {bin_color} slot and still succeed.

Dataset summary

Robot	SO-101 follower (so101_follower), 6 position-controlled joints
Cameras	arm_camera + overhead_camera, 240×320 RGB, AV1
Control / video rate	30 fps
Episodes	312
Frames	115,378
Tasks (trained commands)	20 (of the 24-command space; 4 held out)
Format	LeRobotDataset v3.0

State / action are the six SO-101 joint positions, in this order: shoulder_pan.pos, shoulder_lift.pos, elbow_flex.pos, wrist_flex.pos, wrist_roll.pos, gripper.pos. This ordering is load-bearing — it matches the follower's native motor order, not alphabetical.

Held-out (bar, bin) pairs

Four (bar, bin) combinations are deliberately kept out of training so the benchmark's held-out tiers test composition, not memorization:

• blue bar → orange bin
• red bar → white bin
• yellow bar → blue bin
• green bar → orange bin

The other 20 pairs appear in training and are the 20 tasks in meta/tasks.parquet. (purple and orange bars are fully trained across all four bins.)

Recording distribution

Per-cell episode counts. ✗ = held out (nothing recorded). A bar with one held-out bin spreads its episodes across three bins; a fully-trained bar spreads across four.

Bar ↓ / Bin →	white	yellow	orange	blue	total
blue	18	18	✗	18	54
red	✗	18	18	18	54
yellow	18	18	18	✗	54
green	18	18	✗	18	54
purple	12	12	12	12	48
orange	12	12	12	12	48
total	78	96	60	78	312

Within each cell, bar start position and physical bar instance (~9 per color) are randomized so the policy doesn't overfit a single bar or spot. Bin totals are uneven because two bars hold out the orange bin — harmless for training a per-command policy.

Evaluation protocol

The dataset is scored with a graded, multi-tier rollout protocol (defined in the Naive Bench "Bin Sorting Evals" design). Bins are fixed; bar start positions are uniformly randomized; colors are counterbalanced ~uniformly within each tier; distractor bars in multi-bar tiers are other trained colors.

Tier	Scene	Command	Rollouts	Primarily tests
T0 — Sanity	1 bar	seen (bar, bin)	10	Reproduces training dist. (diagnostic floor)
T1 — Held-out routing	1 bar	held-out (bar, bin)	30	Compositional grounding — the two slots learned independently
T2 — Two-bar grounding	2 bars	name one, seen pairing	30	Object disambiguation by language (headline number)
T3 — Three-bar grounding	3 bars	name one	20	Grounding under heavier clutter
T4 — Two-bar + held-out	2 bars	named bar → held-out bin	20	Hardest: disambiguate object and route to unseen target

Total: 110 rollouts per policy.

Scoring (per episode, exactly one bar named)

Outcome	Credit
Named bar placed in named bin	+1.0
Named bar placed in wrong bin (right object, failed routing)	+0.5
Named bar grasped + lifted, not placed	+0.3
Named bar contacted, grasp failed	+0.1
No meaningful interaction with named bar	0
Grasps/moves a non-named bar (selective-attention failure)	−0.5

Episode score ∈ [−0.5, 1.0]. The two partial-credit paths (right object / wrong bin = +0.5 vs wrong object = −0.5/0) separate a bin-grounding failure from a bar-grounding failure. Report mean ± CI per tier; if a scalar is needed, weight toward grounding and drop T0:

grounding_score = 0.30·T1 + 0.35·T2 + 0.20·T3 + 0.15·T4

At low n (10–30 rollouts), use paired scenes (same randomized layouts across all policies within a tier), graded scoring, and report CIs rather than bare point estimates.

Loading

from lerobot.datasets.lerobot_dataset import LeRobotDataset

ds = LeRobotDataset("binhpham/naive-bench")
print(ds.meta.total_episodes, ds.meta.total_frames)
sample = ds[0]  # observation.state, observation.images.*, action, task, ...

Collection

Recorded with the naive-bench runtime — a LiveKit Portal room where a human teleoperates the SO-101 leader arm and a HITL recorder pairs each executed action with the observation it was responding to. See the repo's operators/teleoperator/ for the recorder.