Bigenlight/cube_in_cup_lerobot_v3

cube_in_cup — UR7e teleop, "put the cube in the cup" (LeRobot v3.0)

Joint-space imitation-learning dataset: 23 human teleoperation demos of a UR7e arm picking a wooden cube off a table and dropping it into a cup, with two 720p camera views. Ready to load with the LeRobot API out of the box.

• 23 episodes · 6,177 frames · 30 fps · ~3.4 min · ~124 MB
• Format: LeRobot v3.0 (lerobot 0.6.1)
• Action / state space: 7-D absolute joint (6 UR joints + gripper)
• Every episode is a successful demonstration.

This is a pilot-scale dataset. ~3.4 minutes of demonstration is small — roughly a quarter of the sibling banana_in_pot_lerobot_v3 (51 episodes / 12 min). Treat it as a seed set or a schema reference rather than something expected to train a robust policy on its own. No trained policy exists for this task yet.

Setup

Collected on a Universal Robots UR7e — a 6-DOF collaborative arm (joint values in radians) — driven by a GELLO low-cost 3D-printed leader arm for kinesthetic teleoperation. The operator moves the GELLO leader; its joint positions are mapped to UR7e joint commands. The end effector is a Robotiq 2F-85 two-finger parallel gripper.

Two Intel RealSense cameras record the scene as RGB video only:

• Camera 1 — Intel RealSense D435
• Camera 2 — Intel RealSense D435if (a D435 variant)

The two viewpoints differ in kind: one RealSense is mounted on the robot wrist just above the gripper (close-up / eye-in-hand), the other sits on a tall tripod beside the table (scene / third-person). This card does not assert which of the two is cam1 and which is cam2 — that mapping was not verified for this release. What matters is that the cam1 ↔ cam2 order is preserved at deploy time, exactly as recorded.

Both stream 1280×720 @ 30 fps, yuv420p; the raw MPEG-4 files were re-encoded to AV1 (crf 30) here. No depth or IR streams were recorded. An ArUco/AprilTag fiducial is present in the cell, on the robot's base plate — not on the work surface.

Task

"put the cube in the cup." The work surface holds exactly two objects: a purple/lavender wooden cube (roughly 5 cm on a side) and a sage-green plastic cup (a tapered, planter-style tumbler), on a light wood-grain tabletop. The operator grasps the cube and drops it into the cup. Success = the cube ends up in the cup.

Unlike the sibling banana dataset there are no distractor objects — this is a clean two-object pick-and-place. (A bowl of plastic fruit appears in the setup photos but sits on a side cart off the work table; it is not part of the scene.)

Schema

feature	dtype	shape	meaning
observation.state	float32	(7,)	UR7e measured joints ur_q1..ur_q6 (rad) + grip_pos (gripper opening)
action	float32	(7,)	commanded absolute joint targets cmd1..cmd6 (rad) + grip_cmd
observation.images.cam1	video (AV1)	(720, 1280, 3)	viewpoint 1 (RGB, HWC uint8)
observation.images.cam2	video (AV1)	(720, 1280, 3)	viewpoint 2 (RGB, HWC uint8)

Plus the standard LeRobot bookkeeping columns (timestamp, frame_index, episode_index, index, task_index). action is an absolute joint-target command (not a delta); the gripper command grip_cmd is effectively binary (open/close).

Metadata records robot_type: "ur7e_gello" — the actual robot. Note the older banana_in_pot_lerobot_v3 carries a legacy "ur5e_gello" label for the same physical arm.

How this was built

Converted from Bigenlight/cube_in_cup_raw (24 raw takes of multi-rate HDF5 + dual MP4) with the same convert_to_lerobot.py recipe as the banana family:

• Master clock = cam1_frames/t_rel_s at 30 fps. Every robot stream is resampled onto that grid by nearest-timestamp lookup on its own t_rel_s.
• cam2 is aligned to cam1 by nearest camera timestamp — the two cameras run on independent clocks and differ by ±1 frame in 16 of the 24 raw takes, so positional indexing would drift.
• gello_* leader streams are dropped — the deployed robot cannot observe the leader.
• Videos re-encoded to AV1 (crf 30, preset 12, GOP 2, pyav backend).

Source stream rates (native, before resampling)

stream	native rate	in this dataset
cameras (cam1, cam2)	30 Hz	master 30 fps clock
command (UR joint targets)	~98 Hz	→ action[0:6], resampled to 30 fps
ur_joint_states	~97 Hz	→ observation.state[0:6], resampled to 30 fps
gripper	~36.5 Hz	→ grip_pos / grip_cmd, resampled to 30 fps
tcp_pose, wrench	~97 Hz	not in this dataset — available in the raw release
gello_joint_states	30 Hz	excluded (leader-only)

Note the robot streams here run at ~97 Hz, notably faster than the ~56–60 Hz of the banana session, so there are ~3.2 robot samples per camera frame rather than ~2. Sampling is also bursty rather than uniform (bimodal inter-sample intervals), which is why the conversion aligns by timestamp rather than index arithmetic.

Episode set

23 episodes from 24 raw takes. take_23 is excluded: it is a 1.64 s recording misfire in which the arm is essentially motionless (per-joint range < 0.013 rad) and the gripper is never actuated. It contains no demonstration and is retained only in the raw release. Raw take numbers 04 and 06 are absent by design (aborted during recording).

Verification

The conversion was checked by an independent validator that re-derives observation.state and action from the source HDF5 without importing the converter:

• max |Δ observation.state| = 0.0 and max |Δ action| = 0.0 — bit-exact against an independent re-implementation of the resampling (tolerance was 1e-6).
• Per-episode frame counts match each source take's cam1_frames row count, in order.
• Zero NaN/Inf in all stored arrays; exactly one task string; timestamps == frame_index / 30.
• Sampled AV1 frames vs the raw MPEG-4 source: correlation min 0.9982, mean 0.9991 over 24 sampled frames across both cameras (AV1 is lossy, so this is expected rather than perfect).
• 35 checks, 0 failures.

Usage

from lerobot.datasets.lerobot_dataset import LeRobotDataset

ds = LeRobotDataset("Bigenlight/cube_in_cup_lerobot_v3")
print(ds.meta.total_episodes, ds.meta.total_frames)   # 23, 6177

sample = ds[0]
sample["observation.state"]          # (7,) float32
sample["action"]                     # (7,) float32
sample["observation.images.cam1"]    # (3, 720, 1280) float32 CHW

If you want the full multi-rate signals — TCP pose, 6-axis wrench, joint velocities and efforts, and the GELLO leader streams — use the raw release Bigenlight/cube_in_cup_raw, which also ships a DATA_DICTIONARY.md and dataset_stats.json.

Related repositories

repo	contents
Bigenlight/cube_in_cup_lerobot_v3	this — LeRobot joint-space dataset, 23 episodes
Bigenlight/cube_in_cup_raw	raw HDF5 + MP4, 24 takes, all signals incl. GELLO leader
Bigenlight/banana_in_pot_lerobot_v3	sibling dataset, same rig, different scene, 51 episodes

Limitations & intended use

• Pilot scale — 23 episodes / ~3.4 min. Small for imitation learning; expect to combine it with more data or use it as a reference.
• Single task, single scene layout, single operator, single recording session, fixed object placement — limited generalization expected.
• All demonstrations are successes — no failure/recovery data.
• No policy has been trained or evaluated on this dataset; no performance numbers are claimed.
• Intended for research in imitation learning and robot manipulation.

Citation

@misc{theo2026cubeincup,
  title        = {cube_in_cup: UR7e teleoperation demonstrations for
                  "put the cube in the cup"},
  author       = {Theo and {Bigenlight}},
  year         = {2026},
  howpublished = {\url{https://huggingface.co/datasets/Bigenlight/cube_in_cup_lerobot_v3}},
  note         = {LeRobot v3.0 dataset, 23 episodes}
}

License: Apache-2.0.