mcobzarenco/community_curated_v0

Community Curated v0

A filtered, quality-annotated union of crowd-sourced robot manipulation datasets: 981 datasets · 52,507 episodes · 24.8M frames (~229 hours) of real-world teleoperation on 6-DoF hobby-class arms (largely SO-100 / SO-101), all at 30 fps in LeRobot v3.0 format — plus per-episode annotations produced by a vision-language judge: quality verdicts and scores, task-instruction rewrites, subgoal segments, per-frame progress / grasp / visibility labels, notable events, and semantic camera tags.

The collection keeps one directory per source dataset (<user>/<dataset>), so you can consume a single dataset, a subset, or the whole corpus with standard LeRobot tooling.

Lineage

1. Sources. ~1,242 public community datasets recorded by hundreds of contributors with the LeRobot stack and converted to LeRobot v3.0. Recording conditions, cameras, lighting, task labels and skill levels vary wildly — that heterogeneity is the point, and the annotations below exist to let you navigate it.
2. Scope. Datasets with 6-dimensional action and state (single 6-DoF arm) recorded at 30 fps.
3. Per-episode mechanical filters (applied before any model-based judging; an episode is dropped if any of these hold):
   • shorter than 50 frames, or shorter than 2 seconds;
   • longer than the scope's 99.5th percentile (2,367 frames ≈ 79 s) — marathon recordings are overwhelmingly idle or stuck sessions;
   • actions contain NaN/Inf;
   • zero motion (the commanded trajectory never moves);
   • ≥ 80% idle steps (no motor moves more than 1% of its episode range).
4. Dataset floor. Datasets with fewer than 5 surviving episodes were dropped entirely.
5. Union. Survivors were merged into this collection: episodes renumbered contiguously where drops occurred, videos losslessly remuxed (never re-encoded), per-dataset statistics recomputed from the surviving frames — including exact (not approximated) q01/q99 action and state quantiles in meta/stats.json.

Result: 981 of the in-scope datasets, 52,507 of ~53,200 in-scope episodes.

Layout

<user>/<dataset>/
  meta/
    info.json               # LeRobot v3.0 metadata (features, fps, totals)
    stats.json              # per-dataset stats incl. exact q01/q99
    episodes/…              # per-episode index, lengths, task strings
    tasks.parquet
    judgments.json          # full judge verdicts (see below)
    camera_kinds.json       # semantic camera tags (majority vote)
    judge_annotations.json  # which judge/prompt produced the columns
  data/chunk-*/file-*.parquet   # actions, states, timestamps + annotation columns
  videos/…                      # one MP4 stream per camera

Every sub-dataset is a self-contained LeRobot v3.0 dataset:

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

local = snapshot_download(
    "mcobzarenco/community_curated_v0",
    repo_type="dataset",
    allow_patterns=["00ri/so100_battery/**"],
)
ds = LeRobotDataset("00ri/so100_battery", root=f"{local}/00ri/so100_battery")

Annotations

Every episode was reviewed by a vision-language judge (Anthropic Claude Opus 5). For each episode the judge saw the stored task instruction, 5–20 evenly spaced frames (about one per 1.5 s of episode, first and last frames always included) from every camera, and summary statistics of the full motor trajectory. Its structured verdict was strictly validated (frame coverage, camera coverage, subgoal coverage, score ranges) before being stored — malformed verdicts were rejected and re-judged, never repaired. Cameras were shown to the judge under anonymous labels so that recorded camera names could not bias viewpoint classification; semantic tags were then majority-voted per dataset across its episodes.

Per-frame columns (in the data parquet, NaN-masked)

column	type	meaning
annotation.progress	float32	estimated task-completion fraction ∈ [0, 1] at this frame
annotation.holding	float32	1.0 if the gripper physically holds the task object, else 0.0
annotation.visible_object	float32 × n_cameras	task object visible per camera (order = the feature's names)
annotation.visible_gripper	float32 × n_cameras	gripper visible per camera

NaN means "the judge did not see this frame" — labels exist only on the sampled frames (5–20 per episode). Use isfinite as the supervision mask and do not interpolate between sampled frames:

import torch

item = ds[i]
mask = torch.isfinite(item["annotation.progress"])   # judge-sampled frame?
progress = item["annotation.progress"]                # 0.0 … 1.0 or NaN
holding = item["annotation.holding"]                  # 0.0 / 1.0 / NaN

Subgoals (every frame) and events (exact frames)

Subgoal segments split each episode into short natural-language phases ("reach toward the pen", "lower it into the mug and release", …). They are stored as LeRobot language_persistent rows with style="subtask" — a row activates at its segment's first frame and stays active until superseded, so every frame of every episode has a subgoal:

from lerobot.datasets.language_render import active_at

row = active_at(
    float(item["timestamp"]),
    persistent=item["language_persistent"],
    style="subtask",
)
print(row["content"])   # e.g. "grasp the pen"

Notable events (drops, resets, operator corrections, progress regressions) are stored as language_events rows with style="event" on the exact frame where they occur. Read the column directly:

events = [row["content"] for row in (item["language_events"] or [])]

A frame that carries per-frame labels (finite annotation.progress) but no event rows is a true "nothing happened here"; frames the judge never sampled are unknown, not negative.

Episode verdicts (meta/judgments.json)

The full verdict for every episode, one JSON record per episode:

{
  "episode_index": 12,
  "model": "claude-opus-5",          // judge identity
  "prompt_hash": "…",                // judge prompt version
  "judgment": {
    "overall_score": 8,              // 1–10
    "verdict": "keep",               // keep | review | discard
    "task_completion_visible": "yes",// yes | partial | no | unclear
    "scores": { "visual_quality": 7, "smoothness": 8,
                "efficiency": 8, "camera_framing": 7 },
    "instruction_quality": "good",   // good | vague | mismatched | placeholder
    "observed_task": "…",            // what actually happens, in the judge's words
    "suggested_instructions": ["…"], // 2–3 grounded task-string rewrites
    "subgoals": [ { "until_frame": 60, "subgoal": "…" }, … ],   // 1-based, inclusive
    "frame_annotations": [ … ],      // the per-frame labels, source form
    "camera_kinds": { "images": "top", … },
    "issues": ["…"],
    "summary": "…"
  }
}

Sidecars may contain records from more than one judge configuration. meta/judge_annotations.json states which one the materialized columns were built from — filter to it:

import json

stamp = json.load(open(f"{root}/meta/judge_annotations.json"))
side = json.load(open(f"{root}/meta/judgments.json"))
records = [
    r for r in side["judgments"]
    if r["prompt_hash"] == stamp["prompt_hash"]
    and r["model"] == (stamp["model_filter"] or stamp["models"][0])
]

# e.g. train only on episodes the judge would keep:
keep = [r["episode_index"] for r in records if r["judgment"]["verdict"] == "keep"]
ds = LeRobotDataset("00ri/so100_battery", root=..., episodes=keep)

Useful episode-level fields beyond filtering: suggested_instructions are grounded rewrites of the (frequently junk) community task strings — sample them as training-time instruction augmentation; instruction_quality tells you when the original string is a placeholder or mismatched.

Camera tags (meta/camera_kinds.json)

Per-dataset majority vote over the judged episodes, mapping each camera name to wrist | top | front | side | unknown, with the vote counts and a tie flag preserved (ties resolve to unknown):

kinds = json.load(open(f"{root}/meta/camera_kinds.json"))
print({cam: v["kind"] for cam, v in kinds["cameras"].items()})
# {'images': 'top', 'images2': 'wrist'}

Label quality — read before trusting

These are model-generated labels, produced in a single pass per episode: treat them as weak supervision.

• holding was benchmarked on a controlled rig against gripper-aperture ground truth: ~75–85% per-sampled-frame agreement, with errors concentrated at grasp/release transitions and a systematic bias toward labeling an open gripper hovering over the object as "holding".
• progress is monotone on clean episodes by construction (regressions must be justified by an event); absolute values are coarse.
• Camera tags flip on genuinely ambiguous viewpoints (oblique overhead views read as top or front) — hence the per-dataset majority vote and the preserved tie flags.
• Verdicts and scores are calibrated in aggregate but individually noisy; two verdicts on the same episode can differ. Score-threshold filtering is more stable than the categorical verdict field.
• The underlying community data is itself heterogeneous: wrong or placeholder task strings, dropped objects, occluded cameras, idle stretches. The annotations are there to help you decide what to keep — they are not a guarantee.

Provenance archive

provenance/curation_archive.tar.gz contains the raw curation records: judge journals (every verdict attempt, including failures and token usage), batch submission manifests, the mechanical-filter manifests (per-episode drop reasons), aggregate calibration statistics (including cross-model comparisons used to select the judge), and a corpus-wide decode census. Nothing in the pipeline is hidden — the annotations you consume can be traced back to the exact request that produced them.

License and acknowledgments

Apache-2.0, matching the source datasets. This collection repackages (filters, renumbers, annotates) the work of hundreds of community contributors who recorded and shared their episodes through the LeRobot ecosystem — all credit for the underlying demonstrations belongs to them. Built with LeRobot; annotations by Anthropic Claude Opus 5.