---
license: apache-2.0
task_categories:
- robotics
tags:
- LeRobot
- so101
- bin-sorting
- vla
- language-conditioned
configs:
- config_name: default
  data_files: data/chunk-*/file-*.parquet
---

# 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

```python
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`](https://github.com/livekit-examples) 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.