README.md

---
license: apache-2.0
task_categories:
- robotics
tags:
- lerobot
- imitation-learning
- ur7e
- manipulation
- pick-and-place
- hdf5
- teleoperation
- mujoco
- simulation
- sim2real
size_categories:
- 1K<n<10K
---

# carrot_in_pot_sim_raw — raw HDF5 + MP4 teleop logs from **MuJoCo** (UR7e, "Put carrot in pot")

The **simulated** twin of
[`carrot_in_pot_raw`](https://huggingface.co/datasets/Bigenlight/carrot_in_pot_raw): the same task,
the same file format, the same GELLO leader arm and the same ROS end-effector teleop math — but the
follower is a **MuJoCo UR7e** instead of the physical one. A human moved the real 3D-printed GELLO
leader by hand; the simulated arm followed.

Because everything is simulated, this release ships something the real one cannot: **the exact
MJCF scene and the complete generalized state at every physics tick**, so any take can be rebuilt
bit-for-bit and re-rendered from any camera, at any frame rate, forever.

- **22 takes · 359.13 s (6.0 min) · 1.32 GB total (0.66 GB per set)**, shipped **twice**:
  - **`takes/`** — the original live recording. Cameras actually captured at **23.4 – 27.3 fps**
    while the MP4 is stamped 30 fps. **9,173 cam1 frames (9,173 cam2).**
  - **`retimed_30hz/`** — both videos **re-rendered from the recorded MuJoCo state on an exact
    30.000 Hz grid**. **10,725 cam1 frames (10,725 cam2)**, cam1 and cam2 frame counts equal in
    every take. **This is the set the LeRobot conversion is built from, and the one to train on.**
- Per take: `vectors.h5` + `cam1.mp4` + `cam2.mp4` (**no depth** — depth recording was off).
- **Nothing resampled inside `vectors.h5`** — each stream keeps its own `t_rel_s` clock and native
  rate. The two sets share *identical* `vectors.h5` content except the `cam*_frames` tables and one
  extra `sim_meta.retimed` block.
- Recorded in a single session on **2026-09-15** (00:09–00:19 local), one operator, `sim_collect`
  at git commit `4bac8657be5a66adca0b5ccfacc11982420080a1`, MuJoCo **3.10.0**.
- **All 22 takes end with the carrot in the pot** — and here that is not an operator's word, it is
  the simulator's geometry: `sim_control/task_success` is recorded per tick.

Every number on this page was measured directly from the 44 `vectors.h5` and the 88 MP4s; the
machine-readable versions are [`dataset_stats.json`](dataset_stats.json) (for `takes/`) and
[`retimed_30hz/dataset_stats.json`](retimed_30hz/dataset_stats.json), produced by the same release
script `make_carrot_raw_stats.py` (h5py + cv2 + `ffprobe -count_frames`) that generated the real
release's stats, in its depth-free mode.

![scene overview](assets/scene_overview.jpg)

## Setup

Everything below is **simulation**. There is no physical robot, no camera, no table in this
release.

| Component | Spec |
|---|---|
| **Simulator** | **MuJoCo 3.10.0**, timestep **2 ms** (500 Hz), `implicitfast` integrator, elliptic friction cone, `impratio` 10, gravity compensation on the arm links. |
| **Robot (follower)** | **UR7e**, built from the [`mujoco_menagerie`](https://github.com/google-deepmind/mujoco_menagerie) `ur5e.xml` structure with the **exact UR7e URDF link offsets** substituted (`ur_description` 2.7.0 ships the UR7e config as a byte-identical copy of the UR5e one, so the kinematics are the same: DH `d = [0.1625, 0, 0, 0.1333, 0.0997, 0.0996]`, `a = [0, −0.425, −0.3922, 0, 0, 0]`). Verified: the MuJoCo `attachment_site` world pose equals `ur_kin.fk(q)` to **0.000 mm** over 2,000 random configurations. ⚠️ **The visual geometry is the UR5e enclosure** — do not use it for appearance-critical sim2real. |
| **Gripper** | Menagerie **Robotiq 2F-85**, attached at `attachment_site`. Driver joint range 0 – 0.871 rad, normalized to **0.0 = open, 1.0 = closed** exactly as on the real rig. |
| **Teleoperation (leader)** | The **physical GELLO** arm, read over USB at 30 Hz, using the **real robot's ROS calibration file** (`ur_gello_bringup/config/ur7e_gello.yaml`, `gello_publisher` section) — no sim-only offsets. |
| **Control** | **EEF delta mode**, the *same code path as the real rig*: the ROS bridge stages (`bridge_stages.OneEuro` → `EefDeltaController.step`) at **250 Hz**, loading the real `ur7e_gello_eef.yaml` (`pos_scale 1.0`, `r_align_rpy [0,0,0]`, `tool_l = tool_r = 0.174 m`, `v_max 0.16`, `w_max 1.0`, `max_step_rad 0.0025 @ 250 Hz`, One-Euro `min_cutoff 1.0 / beta 2.0`, `soft_start_s 0.7`). `command` therefore means exactly what it means in the real release: absolute UR joint targets from IK on a leader **pose** delta. |
| **Scene** | **No table geometry — the work surface is the floor** (a 5 m textured plane at `z = 0`). The robot base sits at the world origin on that floor and the arm faces world **+x** at the home pose, matching the real cell. |
| **Floor texture** | LIBERO `seamless_wood_planks_floor.png` (MIT, © 2023 Lifelong Robot Learning), `texrepeat` 20×20. |
| **Objects** | A **procedural carrot** (tapered body with green leaves, ~18.5 cm, 0.08 kg) and a **procedural open pot** (inner radius 9 cm, rim 11 cm, 0.55 kg). Both are MJCFs written for this project — no third-party mesh is used by the default scene. The unused object library (YCB fruit, LIBERO bowl/basket, robosuite bread) ships in the repo, not here: see [`assets/object_candidates.jpg`](assets/object_candidates.jpg). |
| **Layout** | Convention "left = food, right = containers", seen from the base looking along **+x**: carrot at **+y**, pot at **−y**. Each `RESET SCENE` re-samples both from a seeded RNG — carrot nominal `(0.45, +0.18)` ± 6 cm and ±35° yaw, pot nominal `(0.45, −0.22)` ± 5 cm and any yaw — then drops them 2 cm and settles 0.5 s. Base keep-out radius 0.22 m, minimum object gap 2 cm. **Measured across the 22 takes: carrot x 0.396 – 0.492 m, y +0.124 – +0.242 m; pot x 0.405 – 0.489 m, y −0.191 – −0.258 m; both yaws vary freely.** |
| **`cam1` — scene camera** | Fixed, at **`(0.70, 0.00, 0.571)` m** looking back at `(0.45, 0, 0)`, colour fovy **42°** (a D435's colour vertical FOV), rendered **1280×720 @ 30 fps**. |
| **`cam2` — wrist camera** | Mounted on `wrist_3_link` relative to `attachment_site`: 0.05 m radial along tool **+y**, 0.08 m axial, pitched **15°** toward the fingertips, same fovy, same resolution. The fingers are visible at the bottom of every frame, exactly like the real wrist camera. |
| **Video format** | 1280×720, **30 fps**, MPEG-4 (`mpeg4`), `yuv420p` — measured identical across all 88 videos, and identical to the real release's format. |
| **Depth** | **Not recorded.** Depth is opt-in in `sim_collect` and was off for this session, so there is no `depth.h5` and no `assets/color_depth_samples.jpg`. (The sim *can* render the same 848×480 `uint16` mm PNG sidecar the real rig produces.) |

## Task

**"Put carrot in pot."** The floor holds exactly two objects: a carrot on the robot's left (+y) and
an open pot on its right (−y). The operator grasps the carrot with the GELLO leader and places it
in the pot.

**Success is evaluated by the simulator, every tick**, and recorded in `sim_control/task_success`:
the carrot's origin is inside the pot's opening cylinder (above the pot floor, below the rim,
within the inner radius) **and** its vertical speed is < 0.05 m/s **and** the gripper is open
(`grip_cmd < 0.3`). **All 22 takes reach success** — first at **8.68 s**, median **12.26 s**, last
at **25.28 s** into the take — and `sim_meta.task_success_at_stop` is `true` in all 22.

> ⚠️ 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/<take>/{vectors.h5, cam1.mp4, cam2.mp4}            <- the ORIGINAL live recording
dataset_stats.json                                        <- stats for takes/
retimed_30hz/<take>/{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 <take_dir> --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 <take_dir> --viewer
MUJOCO_GL=glfw DISPLAY=:0 .venv/bin/python -m sim_collect.tools.replay_take <take_dir> \
    --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.