--- license: apache-2.0 task_categories: - robotics tags: - lerobot - imitation-learning - ur7e - manipulation - pick-and-place - hdf5 - teleoperation - mujoco - simulation - sim2real size_categories: - 1K ⚠️ The success test is a **geometric approximation written for the operator's on-screen badge**. > It is an honest signal and it is in the data, but it was never calibrated as a training label. | | | |---|---| | ![cam1 first frame of take_01](assets/take01_cam1_first_frame.jpg) | ![cam2 first frame of take_01](assets/take01_cam2_first_frame.jpg) | | **`cam1`** — scene view, first frame of `take_01` | **`cam2`** — wrist view, first frame of `take_01` (gripper fingers at the bottom) | ![first frames of two takes](assets/first_frames.jpg) *Two takes, both cameras, frame 0 — the layout really does move between takes even though the recorded `layout_seed` says otherwise (see [Known quirks](#known-quirks)).* ## Repository layout ``` takes//{vectors.h5, cam1.mp4, cam2.mp4} <- the ORIGINAL live recording dataset_stats.json <- stats for takes/ retimed_30hz//{vectors.h5, cam1.mp4, cam2.mp4} <- videos re-rendered on a 30 Hz grid retimed_30hz/retime_manifest.json <- per-take frame count + render log retimed_30hz/dataset_stats.json <- stats for retimed_30hz/ assets/ <- the images on this page ``` Both sets contain the **same 22 takes** with the **same names**. Take numbers run `take_01` … `take_23` with **`take_06` absent by design** (discarded during recording) — 22 folders, no partial take anywhere. ## HDF5 schema (`vectors.h5`) Each group has its own `t_rel_s` (seconds since take start) at that stream's native rate. All datasets are **1-D `float64`** in a columnar layout (channel `foo` is dataset `group/foo`, not a 2-D table). This is the **real recorder's own format** — `gello_recorder` writes it, and the existing converters read sim takes unchanged. **The nine real groups**, plus a trailing `stamp_s` column on six of them (added to the real recorder on 2026-09-14; older real takes do not have it): | group | native rate | rows (22 takes) | fields | units / meaning | |---|---|--:|---|---| | `cam1_frames` | **25.5 Hz live / 30.0 Hz retimed** | 9,173 / **10,725** | `frame_idx`, `t_rel_s`, `stamp_s` | index/time of each cam1 MP4 frame | | `cam2_frames` | **25.5 Hz live / 30.0 Hz retimed** | 9,173 / **10,725** | `frame_idx`, `t_rel_s`, `stamp_s` | index/time of each cam2 MP4 frame | | `command` | **125.5 Hz** | 44,660 | `cmd1..cmd6`, `t_rel_s` | commanded **absolute** UR joint targets (rad) — the **action** | | `ur_joint_states` | **125.5 Hz** | 44,660 | `q1..q6`, `qd1..qd6`, `eff1..eff6`, `t_rel_s`, `stamp_s` | simulated joint positions (rad), velocities (`d.qvel[:6]`), efforts (`d.actuator_force[:6]`) | | `tcp_pose` | **125.5 Hz** | 44,660 | `x,y,z`, `qw,qx,qy,qz`, `t_rel_s`, `stamp_s` | TCP pose in base frame = `fk(q) ⊕ 0.174 m` | | `wrench` | **125.5 Hz** | 44,660 | `fx,fy,fz`, `tx,ty,tz`, `t_rel_s`, `stamp_s` | flange force/torque sensor, **tared at take start** | | `gripper` | **62.8 Hz** | 22,336 | `grip_pos`, `grip_cmd`, `gello_grip`, `t_rel_s` | measured opening, commanded, leader trigger — all **0 = open** | | `gello_joint_states` | **30.2 Hz** | 10,797 | `q1..q6`, `qd1..qd6`, `t_rel_s`, `stamp_s` | **GELLO leader** joints (rad) + finite-difference velocities | | `synchronized` | 100 Hz | **33,848 — FILLED** | 56 channels | ⚠️ **the one structural difference from the real release**, where this group is empty | **And five simulation-only groups**, same columnar convention, all prefixed `sim_`: | group | rate | fields | what it is | |---|---|---|---| | `sim_object_poses` | 30 Hz | `carrot_{x,y,z,qx,qy,qz,qw}`, `pot_{…}`, `t_rel_s` | **ground-truth object poses.** The real release has no equivalent at any price | | `sim_control` | 125 Hz | `engaged`, `eef_state_code`, `pos_scale`, `sigma_min`, `gamma`, `ls_scale`, `task_success`, `sim_t`, `tick`, `t_rel_s` | teleop state machine + IK conditioning + the per-tick success flag | | `sim_leader_filtered` | 125 Hz | `qf1..qf6`, `t_rel_s` | the One-Euro filter output the controller actually consumed — lets you replay the controller offline | | `sim_mj_state` | 125 Hz | `qpos0..qpos{nq−1}`, `qvel0..`, `ctrl0..`, `sim_t`, `tick`, `t_rel_s` (attrs `nq`/`nv`/`nu`) | **the complete generalized state at every recorded tick** (nq 28, nv 26, nu 7) | | `sim_frame_capture` | ~51 Hz | `cam`, `frame_idx`, `seq`, `sim_t`, `tick`, `t_capture_rel_s`, `t_rel_s` | which physics tick each rendered frame came from | Plus a group `/sim_scene` holding the **exact MJCF the simulator compiled** (`xml` dataset, ~50 kB) with attrs `xml_sha256`, `assets_manifest` (per-asset sha256 + size, 29 assets), `layout`, `config`, `config_path`, `layout_seed`, `mujoco_version`, `timestep` — and a file-level attr **`sim_meta`** (one JSON string) with the git commit, camera poses and intrinsics, chosen food/container, object list, `eef_state_codes`, achieved fps, `problems`, `task_success_at_stop` and `duration_s`. > See **[`DATA_DICTIONARY.md`](DATA_DICTIONARY.md)** for the exhaustive per-field listing (every > dataset key, dtype, unit and measured value range), the full `sim_*` spec, and the per-take table. ## Reconstruction — rebuild the scene and replay any take This is the point of the release. `/sim_scene` + `sim_mj_state` reproduce every recorded instant **kinematically exactly**; the mesh/texture bytes (35 MB) are not copied into each take, they are identified by sha256 in `assets_manifest` and live in the [`sim_collect`](https://github.com/) source tree at the recorded `git_commit`. ```bash # in a checkout of the recording repo at sim_meta.git_commit (4bac865) .venv/bin/python -m sim_collect.tools.replay_take --check # -> model: nq 28 nv 26 nu 7 | rows 3002 | rebuilt xml matches: True | assets 29 # object pose reconstruction error (replayed vs recorded sim_object_poses): max 0.00 mm MUJOCO_GL=glfw DISPLAY=:0 .venv/bin/python -m sim_collect.tools.replay_take --viewer MUJOCO_GL=glfw DISPLAY=:0 .venv/bin/python -m sim_collect.tools.replay_take \ --render cam1 cam2 --out /tmp/frames --every 15 ``` The tool rebuilds the scene from `config` + `layout`, checks each asset's sha256, compiles the **stored** XML against those assets, then for each row writes `qpos`/`qvel` and calls `mj_forward` — **no physics is re-simulated**, so there is no divergence. Measured object-pose reconstruction error: **0.00 mm**. `retimed_30hz/` was produced exactly this way. Nothing stops you from re-rendering at 60 fps, adding cameras, rendering depth or segmentation masks, or replaying with a different visual theme. The trajectories are fixed; the pixels are not. ## Frame-rate quirk — and which set to train on The renderer runs on **software GL** (no NVIDIA driver on the recording machine), so it is exposed to CPU load. During this session it delivered **23.4 – 27.3 fps** (median 25.5) while the MP4 container is always stamped 30 fps — so **`takes/*/cam*.mp4` plays about 1.18× fast**. The recorder did not hide this: `sim_meta.achieved_fps_take` carries the measured rate and `sim_meta.problems` says, per take, e.g. ``` "cam1 captured at 25.2 fps but cam1.mp4 is stamped 30 (plays 1.19x fast)" ``` **`cam*_frames/t_rel_s` is correct in both sets** — the timestamps never lied, only the container frame rate did. So the live videos are perfectly usable *if you align by timestamp*. **`retimed_30hz/` removes the problem at the source.** Both videos were re-rendered from `sim_mj_state` on an exact 30.000 Hz grid, so: | | `takes/` (live) | `retimed_30hz/` | |---|--:|--:| | cam1 frames | 9,173 | **10,725** | | cam2 frames | 9,173 | **10,725** | | mean frame rate | 25.53 Hz (23.71 – 27.31) | **30.00 Hz in every take** | | median Δt / max Δt | 37.3 ms / **117.4 ms** | 33.3 ms / **33.4 ms** | | takes where cam1 ≠ cam2 frame count | **20 of 22** (−9 … +5) | **0** | | `sim_meta.problems` | 2 entries per take | `[]` (originals kept in `sim_meta.retimed.original_problems`) | The worst per-take state-lookup error introduced by snapping to the grid is **19.6 ms in `take_01` and at most 37.6 ms over all 22 takes** (`retime_manifest.json → max_state_lookup_dt_s`) — under one and a half physics-tick periods of the 125 Hz state stream. > **Train on `retimed_30hz/`.** The derived LeRobot dataset > [`carrot_in_pot_sim_lerobot_v3`](https://huggingface.co/datasets/Bigenlight/carrot_in_pot_sim_lerobot_v3) > is built from it. Use `takes/` when you want the literal capture, the real inter-frame jitter, or > `sim_frame_capture` provenance for the frames that were actually rendered live. ## Known quirks - 🐛 **`layout_seed` is recorded as `0` in every take, and it is wrong.** `sim_meta.layout_seed` says `0` and `/sim_scene` attr `layout_seed` says `-1` in all 22 takes, while `/sim_scene` attr `layout` carries **one single layout** (carrot `(0.480, +0.188)`, pot `(0.488, −0.243)`) for all of them. The scene really was re-randomized between takes — the *stored* layout metadata is stale, a bug fixed in the recorder **after** this session. **The truth is in the data, exactly and per take:** `sim_object_poses` row 0 (and `sim_mj_state` `qpos`) give the real initial poses, and they span carrot x 0.396 – 0.492 / y +0.124 – +0.242 and pot x 0.405 – 0.489 / y −0.191 – −0.258, with free yaw. `take_02` and `take_03` share a layout (no reset between them), as do `take_22` and `take_23`. **This does not affect reconstruction:** `replay_take.py` overwrites `qpos` from `sim_mj_state`, so the replay error is 0.00 mm regardless of the stale attr. **Never read `layout` or `layout_seed` as ground truth; read `sim_object_poses`.** - ⚠️ **In `retimed_30hz/`, `synchronized/cam1_frame_idx` and `cam2_frame_idx` still point at the ORIGINAL live frame numbers.** Only the `cam*_frames` tables were rewritten. The 56-channel `synchronized` table is otherwise untouched and internally consistent. If you use `synchronized` for camera indexing, use `takes/`; for the retimed videos, index through `cam*_frames`. - ⚠️ **Nothing is stamped late here — do NOT apply the real release's −0.900 s / −0.41 s fix.** The sim recorder stamps each robot row with the physics tick that produced it, and `command`, `ur_joint_states`, `tcp_pose` and `wrench` all come out of the **same** tick (their `t_rel_s` agree to 0.3 ms). `dataset_stats.json → timestamp_lag` nevertheless reports a `ur_joint_states_lag_s` of **0.190 – 0.205 s** (median 0.198): that is the **simulated arm's real tracking lag behind its commanded joint target** — bounded by the 250 Hz controller's `max_step_rad 0.0025` slew limit and the actuator gains — not a clock error. The stats JSON says so itself (`timestamp_lag.applies_to_this_release = false`, `timestamp_lag.simulation_note`); the surrounding `note`/`method` prose in that block is inherited verbatim from the real release and its *mechanism* (rclpy spin-thread starvation) does not exist here. Speed cross-correlation of `command` against every other robot table measures **0.000 s in all 22 takes**. - ⚠️ **Two different clocks live in `stamp_s`.** `ur_joint_states`, `tcp_pose`, `wrench`, `cam1_frames` and `cam2_frames` carry **unix epoch seconds** (~1.789e9), but `gello_joint_states/stamp_s` carries a **monotonic** clock (~1715 – 2362 s, the leader thread's own timebase). They are not comparable to each other. **`t_rel_s` is the common timebase in every group** — use it. - **`wrench` is the simulated flange force/torque sensor, tared at take start.** It has never been checked against the real UR's wrench for frame or sign convention. Values are far larger than the real rig's (|f| up to 279 N on contact transients at a 2 ms timestep). Treat it as a sim signal, not as a drop-in replacement for the real one. - **`grip_pos` does not identify "holding the carrot" the way it does on the real rig.** On the real robot the carrot's width pins `grip_pos` at 0.47 – 0.66. Here the carrot is tapered and the contact is soft, so the closed value while carrying the carrot ranges from **0.565 to 0.913** depending on where along the taper the grasp landed (measured while the carrot is airborne). The fully-open value is **0.000 – 0.003**. Use `sim_object_poses` if you need to know what is held. - **Seven takes contain more than one gripper closure** (`grip_cmd ≥ 0.7` rising edge): `take_04`, `take_08`, `take_09`, `take_14`, `take_17`, `take_20`, `take_21` — a missed first grasp followed by a successful re-grasp, 29 closures over the 22 takes. All seven finish the task and all are **included**: a recovery is a legitimate demonstration. - **`cam1` / `cam2` frame counts differ in 20 of 22 live takes** (−9 … +5; the two cameras render on independent workers). `retimed_30hz/` has them equal in every take. Either way: **map between cameras by nearest `t_rel_s`, never by index.** - **`synchronized` is FILLED here** (100 Hz grid, 33,848 rows over 22 takes) whereas the real release's is empty. It is the only structural schema difference. It starts only once both cameras have delivered a frame. - **The leader stream does not mirror the follower** — same reason as the real EEF-mode release: `command` comes from IK on a leader *pose* delta, so `gello_q*` is one IK branch of a virtual chain and `ur_q*` is another solution of a different chain. `gello_*` is leader-frame telemetry and **cannot** be used as an inference input. - **`retimed_30hz/*/vectors.h5` each contain one absolute path** — `sim_meta.retimed.from`, the source take's directory on the recording machine. It is provenance, it is the only `/home/` string in the release, and `takes/` has none. - **The operator's very first simulated session.** These 22 takes are the first real GELLO→MuJoCo teleop ever run on this stack. Expect the motion style to be less fluent than the real-robot release's. ## Data quality Audited over all 22 takes of **both** sets (44 `vectors.h5`, 88 MP4s): - **Zero NaN and zero Inf** in any channel of any group of any take. - **Video frame counts match `cam*_frames` row counts exactly** — 88/88 videos, verified with `ffprobe -count_frames`. - **Uniform schema:** the identical 15 groups (9 real + 5 `sim_*` + `sim_scene`), identical channel names, all `float64`, in all 44 files; identical video format (`mpeg4 1280×720 yuv420p 30/1`) in all 88 MP4s. - **Timestamps are well behaved and, unlike the real release, *unshifted*.** Largest single gap in any 125 Hz robot stream **79.4 ms**, in the gripper stream 96.1 ms, in a live camera stream 117.4 ms (a dropped render under load), and in a retimed camera stream **33.4 ms**. - Cleanliness: exactly three files per take folder, no stray files, no hidden files, no sub-directories, in all 44 folders. No `/home/` string anywhere in `takes/`; exactly one provenance path per retimed `vectors.h5` (see above). - **Reconstruction verified**: `replay_take.py --check` rebuilds the scene with `rebuilt xml matches: True`, all 29 assets matching their recorded sha256, and **0.00 mm** object-pose error. No human quality ratings and no policy-performance numbers are claimed. The outcome statement is the simulator's geometric success test, recorded per tick. ## Usage ```python import h5py, json, cv2, numpy as np take = "retimed_30hz/take_03_20260915_001003" with h5py.File(f"{take}/vectors.h5", "r") as f: ur_q = np.stack([f["ur_joint_states"][f"q{k+1}"][:] for k in range(6)], axis=1) # (N125,6) rad cmd = np.stack([f["command"][f"cmd{k+1}"][:] for k in range(6)], axis=1) # (N125,6) rad grip = f["gripper"]["grip_pos"][:] # (N63,) cam1_t = f["cam1_frames"]["t_rel_s"][:] # 30 Hz grid # ground truth the real dataset cannot give you: carrot = np.stack([f["sim_object_poses"][f"carrot_{k}"][:] for k in "xyz"], axis=1) win = f["sim_control"]["task_success"][:] # per tick meta = json.loads(f.attrs["sim_meta"]) mjcf = f["sim_scene"]["xml"][()] # the exact model, as bytes # each stream has its own f[group]["t_rel_s"] — align by nearest timestamp cap = cv2.VideoCapture(f"{take}/cam1.mp4") # 1280x720 colour @ 30 fps ``` > ⚠️ **`columns` attribute quirk — inherited from the real recorder.** Every group carries an > attribute named `columns` that is a **single scalar JSON string**, not a list (measured `str` in > all 44 files). Always `json.loads(grp.attrs["columns"])`; `list(...)` on it iterates > character-by-character and yields garbage. To go straight to training, use the LeRobot conversion instead (`LeRobotDataset("Bigenlight/carrot_in_pot_sim_lerobot_v3")`). ## Limitations & intended use - **Small, and simulated.** 22 takes / 6.0 minutes is *pilot scale*. It is a seed set, a schema reference and a sim2real probe — not enough on its own for a robust policy. - Single task, single scene family, single operator, single session. - **The visual gap is large**: UR5e enclosure geometry, a wood-plank floor instead of a white desk, procedural objects instead of a plastic carrot and a steel saucepan, software-GL shading. This is a **dynamics and schema** twin, not a photometric one. - **No depth**, no camera noise model, no motion blur, no rolling shutter, no calibration error. - The **success test is geometric**, not a curated label (see [Task](#task)). - **`wrench` is unvalidated** against the real arm (see [Known quirks](#known-quirks)). - Streams are **asynchronous** (each has its own clock) — resample against `t_rel_s`. The `synchronized` group is filled here, at 100 Hz, if you want a pre-fused table. - Intended for research in imitation learning, sim2real transfer, teleoperation analysis, and custom dataset construction from replayable simulator state. ## Related repositories | repo | contents | |---|---| | [**Bigenlight/carrot_in_pot_sim_raw**](https://huggingface.co/datasets/Bigenlight/carrot_in_pot_sim_raw) | **this** — raw MuJoCo HDF5 + MP4, 22 takes, live + retimed | | [Bigenlight/carrot_in_pot_sim_lerobot_v3](https://huggingface.co/datasets/Bigenlight/carrot_in_pot_sim_lerobot_v3) | LeRobot conversion of this data, built from `retimed_30hz/` | | [Bigenlight/carrot_in_pot_raw](https://huggingface.co/datasets/Bigenlight/carrot_in_pot_raw) | **the real-robot twin** — same task, same format, real UR7e + RealSense, 54 takes, with lossless depth | | [Bigenlight/carrot_in_pot_lerobot_v3](https://huggingface.co/datasets/Bigenlight/carrot_in_pot_lerobot_v3) | its LeRobot conversion, 54 episodes / 17,088 frames, RGB + depth | | [Bigenlight/cube_in_cup_raw](https://huggingface.co/datasets/Bigenlight/cube_in_cup_raw) | sibling real raw dataset, same rig family, RGB only, 24 takes | | [Bigenlight/banana_in_pot_raw](https://huggingface.co/datasets/Bigenlight/banana_in_pot_raw) | sibling real raw dataset, same rig family, different scene | ## Citation ```bibtex @misc{theo2026carrotinpotsimraw, title = {carrot_in_pot_sim_raw: raw MuJoCo UR7e + GELLO teleoperation logs (HDF5 + MP4, with full replayable simulator state) for "Put carrot in pot"}, author = {Theo and {Bigenlight}}, year = {2026}, howpublished = {\url{https://huggingface.co/datasets/Bigenlight/carrot_in_pot_sim_raw}}, note = {22 takes, native multi-rate HDF5 + dual RGB MP4 (live and 30 Hz retimed), exact MJCF scene and per-tick generalized state} } ``` ## License **Apache-2.0** for the recordings, the schema and this documentation. The scene is built from third-party art, none of which is redistributed in *this* repository (the takes reference assets by sha256 only) but which you will need in order to replay a take: | what | upstream | licence | |---|---|---| | floor texture `seamless_wood_planks_floor.png` | [LIBERO](https://github.com/Lifelong-Robot-Learning/LIBERO) — © 2023 Lifelong Robot Learning | **MIT** | | UR5e/UR7e robot meshes | [`mujoco_menagerie`](https://github.com/google-deepmind/mujoco_menagerie) | **Apache-2.0** | | Robotiq 2F-85 model | `mujoco_menagerie` | **Apache-2.0** | | carrot + pot MJCFs | written for this project | Apache-2.0, as this repo | | unused object library (`assets/object_candidates.jpg`): YCB banana/strawberry/lemon/peach/pear/plum | [YCB Object and Model Set](https://www.ycbbenchmarks.com/) | **CC BY 4.0** | | unused: LIBERO bowl + basket, robosuite bread | LIBERO (MIT), [robosuite](https://github.com/ARISE-Initiative/robosuite) (MIT) | **MIT** | Required YCB attribution (the objects appear only in `assets/object_candidates.jpg`, not in any take): > B. Calli, A. Singh, A. Walsman, S. Srinivasa, P. Abbeel and A. M. Dollar, "Benchmarking in > Manipulation Research: Using the Yale-CMU-Berkeley Object and Model Set", *IEEE Robotics and > Automation Magazine*, 22(3):36–52, Sept. 2015.