Datasets:

Bigenlight
/

carrot_in_pot_sim_raw

	---
	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.