Bigenlight/carrot_in_pot_sim_lerobot_v3

carrot_in_pot_sim — MuJoCo UR7e teleop (physical GELLO leader), "Put carrot in pot" (LeRobot v3.0)

Simulated sibling of Bigenlight/carrot_in_pot_lerobot_v3: 22 human teleoperation demos of a MuJoCo UR7e picking a carrot off the floor and placing it into a pot, driven by the same physical GELLO leader arm and the same end-effector bridge math as the real recordings, rendered from two 720p RGB cameras in the same cam1 = scene / cam2 = wrist arrangement. Ready to load with the LeRobot API out of the box.

• 22 episodes · 10,725 frames · 30 fps · 5.96 min · 0.61 GB
• Format: LeRobot v3.0 (lerobot 0.6.1), robot_type: "ur7e_gello" — the same feature names, shapes, fps, task string and robot_type as the real dataset, so the two load with one code path
• Action / state space: 7-D absolute joint (6 UR joints + gripper)
• No depth. The sim takes were recorded RGB-only (sim_collect records depth only on request); there is no *_depth feature and no meta/depth_cameras.json
• One extra feature, observation.sim.object_poses (float32, 14): the ground-truth MuJoCo poses of the carrot and the pot at every frame — ignored by policies that do not list it as an input, free for evaluation and analysis
• observation.state is NOT time-corrected here (τ = 0). The real dataset undoes a ≈0.9 s recorder artefact; the simulator stamps every row from the physics tick that produced it, so there is nothing to undo and no stale tail is dropped
• Every camera frame was re-rendered offline on an exact 30 Hz grid from the recorded simulator state — see Frame-rate note
• Every episode ends with the simulator's own geometric success test true (task_success_at_stop, 22/22)

This is a small seed set — 6 minutes of demonstration, one operator, one scene family. It exists to (a) test the sim → real pipeline on a task for which a real dataset with identical schema already exists, and (b) give ground-truth object poses that the real data cannot. No policy has been trained on it yet.

Simulation

Recorded with sim_collect, a MuJoCo re-creation of the real rig that reuses the real software wherever it can:

Simulator	MuJoCo 3.10.0, 2 ms timestep, implicitfast integrator, elliptic friction cones
Robot	UR7e: the mujoco_menagerie UR5e model structure with the five link offsets replaced by the exact UR7e URDF values (ur_description 2.7.0 ships UR7e kinematics identical to the UR5e); forward kinematics verified against the real bridge's ur_kin.fk to 0.000 mm over 2,000 random configurations. Visual meshes are the UR5e enclosure (the real UR7e differs cosmetically only). Position actuators, gravity-compensated arm
Gripper	Robotiq 2F-85 from mujoco_menagerie, attached at the flange, driven by the same grip_cmd ∈ [0, 1] (0 = open) the real driver receives
Floor	textured plane at z = 0 — the LIBERO seamless_wood_planks_floor texture (MIT)
Objects	procedural carrot (tapered chain of capsules, 18.5 × 3.7 × 3.6 cm, 80 g, lying on its side) and procedural pot (open cylinder, inner radius 9 cm, rim 11 cm high, 6 mm walls, 550 g). No meshes — two hand-written MJCFs
Placement	per take, the carrot is dropped within a 6 cm radius of (0.45, 0.18) m with yaw ± 35°, the pot within 5 cm of (0.45, −0.22) m with yaw ± 180°, then settled for 0.5 s. The sampled poses are in meta/source_takes.json (sim.layout, sim.initial_object_xy_m) and in the feature itself
cam1 (scene)	fixed camera at (0.70, 0.00, 0.571) m looking at (0.45, 0, 0), vertical FOV 42° (the D435 colour FOV), 1280 × 720 @ 30 fps — same resolution and fps as the real dataset
cam2 (wrist)	attached to wrist_3_link, 5 cm radial / 8 cm axial from the flange, pitched 15° toward the tool axis so the fingertips sit at the bottom of the frame; same FOV/resolution
Leader	the physical GELLO leader arm (read-only Dynamixel, 30 Hz), same calibration file as the real rig
Control	EEF delta teleop at 250 Hz through the same pure-Python modules the ROS bridge runs (bridge_stages One-Euro filter, eef_delta, analytic ur_kin IK) with the same parameter files (ur7e_gello.yaml + ur7e_gello_eef.yaml: pos_scale 1.0, v_max 0.16 m/s, w_max 1.0 rad/s, max_step_rad 0.0025). The joint target it produces is what action stores — exactly as on the real robot
Recorder	the real gello_recorder.RecordingSession, so the raw take layout (vectors.h5 + cam1.mp4 + cam2.mp4) is byte-compatible with the real takes; sim-only tables and a sim_meta JSON attribute are added
Success test	geometric: carrot origin inside the pot's opening cylinder (above the floor, below the rim, within the radius, measured in the pot's frame),
Provenance	sim_collect 0.1.0 at git 4bac865; every episode records the commit, the MuJoCo version, the compiled scene's SHA-256 and the sampled layout

The floor texture is MIT-licensed (LIBERO); the robot and gripper models are Apache-2.0 (mujoco_menagerie); the two task objects are written for this dataset.

Task

"Put carrot in pot." The floor holds exactly two objects, an orange carrot lying on its side and a dark grey pot. The operator grasps the carrot and places it into the pot. Success = the carrot ends up in the pot, and here the simulator checks it: task_success_at_stop is true for all 22 episodes.

cam1 — scene view, first frame of episode 0	cam2 — wrist view, first frame of episode 0 (gripper fingers at the bottom)

Schema

feature	dtype	shape	meaning
observation.state	float32	(7,)	UR7e measured joints ur_q1..ur_q6 (rad, MuJoCo qpos) + grip_pos (measured 2F-85 opening, 0 = open, 1 = closed). Same timebase as everything else — no correction applied
action	float32	(7,)	commanded absolute joint targets cmd1..cmd6 (rad, the bridge's IK output) + grip_cmd (0 = open, 1 = closed)
observation.images.cam1	video (AV1, crf 30)	(720, 1280, 3)	scene camera, RGB HWC uint8
observation.images.cam2	video (AV1, crf 30)	(720, 1280, 3)	wrist camera, RGB HWC uint8
observation.sim.object_poses	float32	(14,)	ground truth, sim only: carrot_x, carrot_y, carrot_z, carrot_qx, carrot_qy, carrot_qz, carrot_qw, pot_x, …, pot_qw — body origin (bottom centre) in metres, world frame, quaternion xyzw

Plus the standard LeRobot bookkeeping columns (timestamp, frame_index, episode_index, index, task_index). timestamp == frame_index / 30 exactly; there is exactly one task string, "Put carrot in pot".

The four robot features are schema-identical to the real dataset: same names, shapes, units and conventions (action is an absolute joint target even though the teleop was EEF-delta; the gripper convention is 0.0 = open, 1.0 = closed for both grip_pos and grip_cmd; grip_pos is continuous — holding the carrot plateaus around 0.57–0.79, the empty-gripper stop is ≈0.91). observation.sim.object_poses is the one addition; a policy config that lists only the real features never sees it.

The world frame is the robot base frame (base_link, z up), the same frame the real bridge's ur_kin.fk uses. The pot's opening is 0.11 m above its origin with a 0.09 m radius, so "carrot in pot" is ‖(carrot_xy − pot_xy)‖ < 0.09 and 0.006 < carrot_z − pot_z < 0.11 (for an upright pot).

How this was built

Converted from the raw sim takes (Bigenlight/carrot_in_pot_sim_raw) with convert_carrot_to_lerobot_sim.py, which is the real dataset's converter minus depth plus sim provenance — the shared parts are bit-identical:

• Master clock = cam1_frames/t_rel_s at 30 fps. Every other stream is resampled onto that grid by nearest-timestamp lookup on its own t_rel_s.
• observation.state[0:6] ← ur_joint_states (125 Hz), grip_pos ← gripper (62.5 Hz), action[0:6] ← command (125 Hz), grip_cmd ← gripper (forward-/back-filled), observation.sim.object_poses ← sim_object_poses (30 Hz), all by the same rule.
• τ = 0: no timestamp shift, no stale-tail drop (meta/source_takes.json still carries the real converter's timestamp_correction block, with the value 0 and the reason).
• cam2 is aligned to cam1 by nearest timestamp; after retiming the two clocks are identical.
• gello_* leader streams, tcp_pose, wrench, velocities/efforts and the sim-only sim_control / sim_leader_filtered / sim_mj_state / sim_scene tables are not carried over — they are in the raw release, and the last two reconstruct any recorded instant kinematically.
• Colour re-encoded to AV1 (crf 30, preset 12, GOP 2, pyav backend) — the same encoder settings as the real dataset.

Frame-rate note

The live capture did not hold 30 fps. The simulator renders in software GL, and under the CPU load of the session the two cameras delivered 23.4 – 27.3 fps (per take; median ≈25.4) while the mp4 files were stamped 30 fps — played back naively they run 10–28 % fast, and a policy trained on them would see dynamics that fast. The recorder flagged every take ("cam1 captured at 25.2 fps but cam1.mp4 is stamped 30 (plays 1.19x fast)").

Because every take also stores the complete MuJoCo generalized state at 125 Hz and the exact compiled scene, the frames could be re-rendered offline on an exact 1/30 s grid: for each grid time the nearest recorded state row is loaded (mj_forward, no re-simulation) and both cameras are rendered with the live capture's camera rig and quality flags. That is what this release contains:

• cam1/cam2 frame count == the frame-table row count, consecutive timestamps differ by exactly 0.0333/0.0334 s (4-decimal clock), and the two cameras share one clock;
• the state tables (ur_joint_states, command, gripper, sim_object_poses) are verbatim — they were never time-warped, only the videos were;
• state-lookup error of the re-rendered frames: ≤ 37.6 ms (per-take maximum; median of the per-take maxima 24.6 ms, best 15.5 ms). The 125 Hz state stream has occasional 50–80 ms holes where the physics thread missed ticks under the same load, which is where the maxima come from. So a rendered frame can lag its nominal time by up to one camera frame — comparable to the camera-vs-robot phase jitter of the real dataset, and far smaller than the 10–28 % speed error it replaces;
• provenance travels with each episode: sim.retimed (grid start, frame count, max lookup error, the original problem strings) and sim.original_achieved_fps.

Episode set

22 episodes from 22 raw takes — nothing is excluded. Episode indices are assigned in take order (episode_index = position in the sorted take list, 0-based) and the mapping is in meta/source_takes.json. take_06 does not exist — it was discarded during recording — so take_07 is episode 5 and take_23 is episode 21; do not infer take numbers from episode indices.

Episode lengths run 337 – 832 frames (11.2 – 27.7 s), median 468.5 frames (15.6 s); the long ones (take_09, take_08, take_17, take_14, take_12) contain re-approaches or pauses. Seven episodes contain more than one gripper closure (take_04, take_08, take_09 with three, take_14, take_17, take_20, take_21) — a missed grasp followed by a re-grasp, or a re-close after placement. They are included on purpose. In three takes (take_08, take_09, take_12) the operator disengaged the leader mid-take for a moment (16 %, 13 % and 28 % of the ticks respectively); the arm holds its last target during those stretches, so the frames are still and action equals the held joint target.

Layout seed caveat. meta/source_takes.json records layout_seed_recorded = 0 for every episode: the session was recorded with a bug (fixed the same day in f6697c3) that logged the configured base seed instead of the per-take seed. The placements were nonetheless randomised per take — the sampled layout (sim.layout) and the first-row object positions (sim.initial_object_xy_m) are recorded per episode and are the ground truth; the carrot's start position spans 0.396 – 0.492 m in x and 0.124 – 0.242 m in y across the 22 episodes.

Verification

The conversion was checked by the same independent validator as the real dataset, in its --sim mode (re-derives observation.state, action and observation.sim.object_poses from the source HDF5 without importing the converter; the five depth checks are skipped because there is no depth):

• 63 checks, 57 passed, 0 failures, 0 warnings, 6 skipped — verdict PASS. The six skips are the five depth checks (no depth feature, no depth.h5) and the "τ = 0 re-derivation is worse" sub-check of the physics test, which is the identity when the dataset itself was built at τ = 0.
• max |Δ observation.state| = 0.0, max |Δ action| = 0.0, max |Δ observation.sim.object_poses| = 0.0 — bit-exact against an independent re-implementation of the nearest-timestamp resampling (tolerance was 1e-6).
• Per-episode frame counts equal each source take's cam1_frames row count, in order, for all 22 episodes; mp4 frame count == row count == sim_meta.retimed.frames for both cameras of every take; every master clock is an exact 1/30 s grid (|dt − 0.0333| ≤ 0.15 ms) shared by both cameras; sim_meta.problems is empty and sim_meta.retimed present for all 22 takes.
• Zero NaN/Inf in all stored arrays; exactly one task string; timestamp == frame_index / 30; total_episodes 22, total_frames 10,725, codebase_version v3.0, fps 30, robot_type ur7e_gello.
• Sampled AV1 frames vs the raw MPEG-4 source: correlation min 0.9983, mean 0.9994 over 24 sampled frames across both cameras (AV1 is lossy, so this is expected rather than perfect).
• Physics sanity (check 15): mean |state[0:6] − action[0:6]| per episode, first 1.6 s skipped — median 0.0196 rad, mean 0.0201, min 0.0143, max 0.0260 (worst take_10). This is the MuJoCo position actuators' servo lag behind a moving target, present in every episode; the sim gate is < 0.05 rad (the real dataset's 0.02 rad gate, which assumes the real arm's tighter tracking, is exceeded by 9 of the 22 episodes — see Limitations).
• No repeated tail (check 16): the longest run of identical consecutive ur_q rows at the end of any episode is 1 frame; 0 frames dropped.
• meta/source_takes.json carries git_commit, mujoco_version, retimed, task_success_at_stop (true, 22/22), initial_object_xy_m and original_achieved_fps for every episode, and the take order matches the sorted source directory.

Usage

from lerobot.datasets.lerobot_dataset import LeRobotDataset

ds = LeRobotDataset("Bigenlight/carrot_in_pot_sim_lerobot_v3")
print(ds.meta.total_episodes, ds.meta.total_frames)   # 22, 10725

sample = ds[0]
sample["observation.state"]              # (7,) float32  — ur_q1..6 + grip_pos
sample["action"]                         # (7,) float32  — cmd1..6 + grip_cmd
sample["observation.images.cam1"]        # (3, 720, 1280) float32 CHW — scene RGB
sample["observation.images.cam2"]        # (3, 720, 1280) float32 CHW — wrist RGB
sample["observation.sim.object_poses"]   # (14,) float32 — carrot xyz+quat, pot xyz+quat (ground truth)

Training on the real and the sim dataset with one policy config works because the four robot features are identical; list observation.sim.object_poses as an input only if you want the policy to see ground truth (it will not exist on the real robot).

The per-episode provenance travels with the dataset:

import json
from huggingface_hub import hf_hub_download

p = hf_hub_download("Bigenlight/carrot_in_pot_sim_lerobot_v3", "meta/source_takes.json", repo_type="dataset")
src = json.load(open(p))
src["simulation"]["mujoco_version"]                 # ['3.10.0']
src["episodes"][0]["sim"]["retimed"]                # grid, frame count, max state-lookup error
src["episodes"][0]["sim"]["initial_object_xy_m"]    # {'carrot': [x, y], 'pot': [x, y]}
src["episodes"][0]["sim"]["task_success_at_stop"]   # True

Related repositories

repo	contents
Bigenlight/carrot_in_pot_sim_lerobot_v3	this — LeRobot joint-space dataset, MuJoCo, RGB only + ground-truth object poses, 22 episodes
Bigenlight/carrot_in_pot_sim_raw	the raw sim takes: multi-rate HDF5 (incl. leader, TCP, wrench, the full 125 Hz MuJoCo state and the compiled scene) + 2 MP4 per take
Bigenlight/carrot_in_pot_lerobot_v3	the real-robot counterpart: same task, same schema (+ depth), 54 episodes
Bigenlight/carrot_in_pot_raw	raw source of the real dataset
Bigenlight/cube_in_cup_lerobot_v3	sibling real dataset, same rig family, RGB only, 23 episodes
Bigenlight/banana_in_pot_lerobot_v3	sibling real dataset, same rig family, RGB only

Limitations & intended use

• It is a simulation. Rendering is un-textured primitives on a wood plane with simple lighting; the carrot and pot are procedural shapes, not the real plastic carrot and steel saucepan; there is no table, no sticky-note markers, no clutter. Expect a large visual domain gap to the real dataset; the kinematic/control gap is deliberately small (same leader, same bridge math, same parameters, same joint conventions).
• The follower lags its command more than the real arm does. MuJoCo position actuators trail a moving target; the per-episode mean |state[0:6] − action[0:6]| (first 1.6 s skipped) is 0.014 – 0.026 rad, versus ≈0.002 rad on the corrected real dataset. It is a physical servo lag, not a time-base error, and it is the same in every frame of every episode.
• Frames were re-rendered, not captured live, with a state-lookup error up to 37.6 ms (see Frame-rate note). The recorded state tables are untouched.
• Small — 22 episodes / 6 min, one operator, one session, one scene family with randomised placement only.
• All demonstrations are successes by the simulator's geometric test; seven contain a re-grasp, three contain a mid-take hold. No failure-only data, no per-step reward column in this release (the raw takes carry the per-tick task_success flag).
• No depth, and no colour intrinsics in info.json (the render FOV is 42° vertical; the raw release's sim_meta.cameras carries the render intrinsics).
• layout_seed is not trustworthy (recorded as 0 everywhere); use the recorded poses.
• No policy has been trained or evaluated on this dataset; no performance numbers are claimed.
• Intended for sim-to-real research, data-efficiency studies against the real sibling, and evaluation code that needs ground-truth object poses.

Citation

@misc{theo2026carrotinpotsim,
  title        = {carrot_in_pot_sim: MuJoCo UR7e teleoperation demonstrations with a physical
                  GELLO leader for "Put carrot in pot"},
  author       = {Theo and {Bigenlight}},
  year         = {2026},
  howpublished = {\url{https://huggingface.co/datasets/Bigenlight/carrot_in_pot_sim_lerobot_v3}},
  note         = {LeRobot v3.0 dataset, 22 episodes, 2 RGB video features + ground-truth object poses}
}

License: Apache-2.0. Third-party assets: LIBERO floor texture (MIT), mujoco_menagerie robot/gripper models (Apache-2.0).