carrot_in_pot_raw — raw HDF5 + MP4 + depth teleop logs (UR7e, "Put carrot in pot")

The raw, unprocessed recordings behind carrot_in_pot_lerobot_v3: one folder per take, each with a native multi-rate HDF5 of every logged signal (UR joints with velocities and efforts, joint commands, TCP pose, 6-axis force/torque wrench, gripper, and the GELLO leader streams), the two raw camera MP4s, and — new in this family — a depth.h5 carrying every 16-bit depth frame from both RealSense cameras, losslessly. Use this if you want to resample differently, add features, use the depth, or study the leader/follower relationship — otherwise start from the ready-to-train LeRobot dataset.

• 54 takes · 18,557 cam1 colour frames (18,557 cam2) · 18,541 + 18,538 depth frames · 619.33 s (10.3 min) · 30 fps cameras · 3.73 GB
• Per take: vectors.h5 + depth.h5 + cam1.mp4 + cam2.mp4
• Nothing resampled — each stream keeps its own t_rel_s clock and native rate.
• Recorded in a single session on 2026-09-14 (16:48–17:22 local), one operator.

Every number on this page was measured directly from the 54 vectors.h5, the 54 depth.h5 and the 108 MP4s; the machine-readable version is dataset_stats.json in this repo, produced by the release script make_carrot_raw_stats.py (h5py + cv2 + ffprobe -count_frames).

Setup

Collected on a Universal Robots UR7e — 6-DOF collaborative arm, joints in radians — driven by a GELLO low-cost 3D-printed leader arm for kinesthetic teleoperation. The end effector is a Robotiq 2F-85 two-finger parallel gripper.

This is the first EEF-mode release in the family. The session was recorded in end-effector (EEF) delta teleop mode, not joint mode:

ur7e_gello_real.launch.py robot_ip:=<ROBOT_IP> headless_mode:=true control_mode:=eef

In EEF mode the bridge computes the GELLO leader's end-effector pose by forward kinematics of a virtual leader chain, takes the pose delta, and solves IK on the UR7e to produce the joint targets logged in command. The leader's own joint angles are therefore a different kinematic solution from the follower's and need not track it at all — which is exactly what the measurements in Known quirks show. The sibling cube_in_cup_raw and banana_in_pot_raw releases were joint-mode recordings, which is why their leader/follower offsets are ~0. command is the true absolute joint target in both modes, so nothing downstream changes.

Two Intel RealSense cameras record colour and depth, and — unlike the sibling cube/banana releases — the mapping is known and verified:

• cam1 — scene camera. Intel RealSense D435, serial 143322071682, on a black desk-clamp camera stand to the left of the robot, looking down at the work surface (third-person view).
• cam2 — wrist camera. Intel RealSense D435, serial 143322072540, strapped to the robot wrist just above the gripper (eye-in-hand).

Both are plain D435 bodies (no D435if this time), both on a powered USB-3 hub. Colour is 1280×720 @ 30 fps, yuv420p, in cam1.mp4 / cam2.mp4 (MPEG-4, measured identical format across all 108 videos). Depth is 848×480 uint16 millimetres @ 30 fps, stored losslessly in depth.h5 — see Depth below. The derived LeRobot copy re-encodes; RAW keeps the originals.

Task

"Put carrot in pot." The work surface holds exactly two objects: a plastic carrot (orange-red body with green leaves) and a silver steel saucepan with a black handle, on a white desk. The operator grasps the carrot and places it into the pot. Success = the carrot ends up in the pot.

The small yellow sticky notes visible on the table are placement markers — they tell the operator where the objects go at the start of a take. They are part of the scene, not distractors to be manipulated.

The operator reports that all 54 takes end with the carrot in the pot, three of them after a retry (see Known quirks). No per-step labels ship with this dataset.

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

HDF5 schema (vectors.h5)

Each group has its own t_rel_s (seconds, relative to take start) sampled 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). Row counts vary with take length; totals below are over all 54 takes.

group	native rate	rows (all takes)	fields	units / meaning
cam1_frames	30.0 Hz	18,557	frame_idx, t_rel_s	index/time of each cam1 MP4 frame
cam2_frames	30.0 Hz	18,557	frame_idx, t_rel_s	index/time of each cam2 MP4 frame
command	~67 Hz	40,640	cmd1..cmd6, t_rel_s	commanded absolute UR joint targets (rad). Timestamps are fresh
ur_joint_states	~67 Hz	40,629	q1..q6, qd1..qd6, eff1..eff6, t_rel_s	UR7e follower joint positions (rad), velocities (rad/s), efforts. ⚠️ t_rel_s is 0.900 s late — subtract it
tcp_pose	~67 Hz	40,619	x,y,z, qw,qx,qy,qz, t_rel_s	TCP pose in robot base frame: position (m) + quaternion. ⚠️ t_rel_s is ≈0.41 s late — subtract it
wrench	~67 Hz	40,621	fx,fy,fz, tx,ty,tz, t_rel_s	6-axis end-effector force (N) + torque (N·m). ⚠️ t_rel_s is ≈0.41 s late — subtract it
gripper	~38.8 Hz	24,015	grip_pos, grip_cmd, gello_grip, t_rel_s	measured opening, commanded, leader trigger
gello_joint_states	30.0 Hz	18,573	q1..q6, qd1..qd6, t_rel_s	GELLO leader joints (rad) + velocities (rad/s)
synchronized	—	0	(56 declared keys, all length 0)	EMPTY in every take — a scaffold group; ignore

Slower than the cube session. The robot-side streams here run at a measured 67.3 Hz (median of the per-take mean rate; range across takes 41.2 – 70.4 Hz), against ~97–98 Hz in cube_in_cup_raw. That is about 2.2 robot samples per camera frame here versus ~3.2 there. Four takes — take_24, take_25, take_26, take_28 — sit at the bottom of that range, 41.2–49.2 Hz. Never assume a fixed dt; always resample against t_rel_s.

Sampling is bursty, not uniform. For the robot streams the inter-sample interval is bimodal: 5 % of intervals are ≤ 4.3 ms while the median is 15.9 ms and the 95th percentile is 19.1 ms. That is why the mean rate (67.3 Hz) is higher than the rate implied by the median interval (62.9 Hz). Both figures are correct; they describe different things. dataset_stats.json reports both, per stream.

Cameras: cam1.mp4 / cam2.mp4, 1280×720, 30 fps, MPEG-4. Use cam*_frames frame_idx / t_rel_s to align frames to the vector streams.

See DATA_DICTIONARY.md in this repo for the exhaustive per-field listing (every dataset key, dtype, unit, and measured value range), the full depth-file spec, and the per-take table.

Notes:

• command (cmd1..6) are the joint targets sent to the UR7e; ur_joint_states.q* are the measured follower joints. The median per-take |cmd_i − q_i| is 0.023–0.080 rad depending on the joint (worst single sample 0.510 rad) — but ⚠️ that is measured on the raw timestamps and is mostly the 0.900 s timestamp artefact, not tracking error: on the corrected clock the residual falls to 0.0007–0.0103 rad (see Known quirks). Either way command is a target, not a measurement.
• gello_joint_states.q* are the leader joints. In this session they do not mirror the follower — see Known quirks. They are not a valid inference input either way (the deployed robot cannot see the leader).
• The physical robot is a UR7e and the derived LeRobot dataset labels it robot_type: "ur7e_gello".

Depth

depth.h5, one per take, holds every depth frame from both cameras, losslessly: each frame is the complete 16-bit PNG the camera driver produced, stored verbatim as one variable-length uint8 cell. No re-encoding, no quantization, no dropping.

/cam1/                          <- scene camera
    png        vlen uint8  (N,)   a complete 16-bit PNG file per frame
    t_rel_s    float64     (N,)   session-relative time, SAME origin as vectors.h5
    frame_idx  int64       (N,)   0-based running index
    stamp_s    float64     (N,)   ROS header stamp (s), NaN if unknown
    camera_info/                  attrs: width, height, distortion_model, frame_id, D, K, R, P
    extrinsics_depth_to_color/    attrs: rotation (9, COLUMN-major), translation (3, m), layout
  attrs: encoding='16UC1', unit='mm', depth_scale_m=0.001, container='png',
         header_bytes_stripped=12, width=848, height=480,
         aligned_to_color=False, source_topic='/cam1/cam1/depth/image_rect_raw/compressedDepth'
/cam2/                          <- wrist camera, identical structure

• Units: millimetres, uint16. Multiply by depth_scale_m = 0.001 for metres.
• 0 means no return / invalid, not zero distance. Always mask with d > 0.
• 848×480, and aligned_to_color = False — the frames live in the depth optical frame, which is neither the resolution nor the field of view of the 1280×720 colour image. Depth intrinsics (measured identical across all 54 takes): cam1 fx = fy = 426.742, cx = 423.939, cy = 233.149; cam2 fx = fy = 425.264, cx = 425.044, cy = 232.822; D all zeros, plumb_bob.
• Depth→colour extrinsics are stored per camera and are measured identical across all 54 takes: translation ‖t‖ = 15.07 mm (cam1) and 14.90 mm (cam2) — the D435's physical baseline — with a rotation that is identity to within 0.011. layout='column_major', so np.asarray(rotation).reshape(3, 3) gives you the transpose; use .reshape(3, 3).T.
• Depth is its own stream on its own clock. Totals are 18,541 depth frames (cam1) and 18,538 (cam2) against 18,557 colour frames each. Per take the difference is ±1 in 24 takes (cam1) and in 29 takes (cam2), plus take_28 where cam2 depth is 2 frames short — 30 cam2 takes differing in total. Align by nearest t_rel_s, never by index.

import h5py, cv2, numpy as np

with h5py.File("take_01_20260914_164811/depth.h5", "r") as f:
    g        = f["cam1"]
    t_depth  = g["t_rel_s"][:]                                  # 30 Hz, vectors.h5 origin
    depth_mm = cv2.imdecode(np.asarray(g["png"][0], np.uint8),   # one whole PNG file
                            cv2.IMREAD_UNCHANGED)               # -> uint16 (480, 848), mm
    K    = np.array(g["camera_info"].attrs["K"]).reshape(3, 3)              # row-major
    R    = np.array(g["extrinsics_depth_to_color"].attrs["rotation"]).reshape(3, 3).T
    tvec = np.array(g["extrinsics_depth_to_color"].attrs["translation"])    # metres

valid   = depth_mm > 0                       # 0 == no return
depth_m = depth_mm.astype(np.float32) * 0.001

# back-project, then move into the colour camera's frame
fx, fy, cx, cy = K[0, 0], K[1, 1], K[0, 2], K[1, 2]
v, u    = np.nonzero(valid)
Z       = depth_m[v, u]
P_depth = np.stack([(u - cx) / fx * Z, (v - cy) / fy * Z, Z], axis=1)
P_color = P_depth @ R.T + tvec

⚠️ The colour intrinsics are not in this release. camera_info describes the 848×480 depth imager (its frame_id says so), so projecting P_color onto the 1280×720 image needs a colour K that was never recorded. Read it off the same two D435 bodies with rs-enumerate-devices -c (serials above), or treat the 15 mm baseline as negligible and use the depth frame as its own coordinate system. Do not assume depth[v, u] is the depth of colour[v, u].

Measured depth quality

Sampled on one mid-take frame per camera per take (108 decoded frames), and again on the frame nearest each take's final gripper closure:

	cam1 (scene)	cam2 (wrist)
valid pixels (d > 0), mid frame	85.15 – 88.71 % (median 86.94 %)	50.48 – 67.95 % (median 62.32 %)
median range of valid pixels	0.526 – 0.549 m (median 0.540 m)	0.184 – 0.341 m (median 0.207 m)
valid pixels at the grasp instant	85.36 – 88.35 % (median 86.91 %)	37.13 – 67.50 % (median 61.51 %)

⚠️ The wrist camera works at or below the D435 minimum range. At 848×480 the D435's minimum depth is ~0.2 m and the measured median range from cam2 is 0.207 m — the whole scene sits on the sensor's floor. A third to a half of every wrist depth frame is therefore invalid, and it is worst exactly when it matters: at the moment of the grasp the worst take is only 37.13 % valid, with the carrot and the fingers as holes. cam1 at 0.54 m has no such problem (85–89 % valid throughout). Treat cam2 depth as a sparse cue, not as a depth map.

Rows: take_01 / take_30 / take_55, mid-frame. Columns: cam1 colour, cam1 depth, cam2 colour, cam2 depth (jet colormap 0–1.5 m; black = invalid). All twelve panels are drawn the same size, but the depth panels visibly cover more of the scene than the colour panels beside them — that is the unaligned 848×480 depth imager's wider FOV, not a cropping mistake.

Measured value ranges

Pooled over all 54 takes — the actual envelope this data covers.

signal	min	max	mean
ur_q1 (rad)	−3.7028	−2.6809	−3.1325
ur_q2 (rad)	−1.7284	−0.9593	−1.3023
ur_q3 (rad)	1.3382	2.0708	1.7311
ur_q4 (rad)	−2.5867	−1.5425	−2.0613
ur_q5 (rad)	−1.8701	−1.2621	−1.5680
ur_q6 (rad)	−4.4087	−2.0574	−3.3592
joint velocity qd* (rad/s)	−0.6037	0.6098	≈0
joint effort eff*	−6.2647	3.6107	—
TCP x (m)	0.4148	0.7095	0.5674
TCP y (m)	−0.2141	0.3900	0.1307
TCP z (m)	0.0175	0.3066	0.1424
force fx,fy,fz (N)	−114.883	36.708	—
torque tx,ty,tz (N·m)	−10.870	9.525	—
grip_pos (normalized, 0 = open)	0.0118	0.8980	0.2385
grip_cmd (normalized, 0 = open)	0.0001	0.9998	0.3904
gello_grip (normalized)	0.0000	1.0000	0.3883

The commanded joints cmd1..cmd6 span essentially the same envelope as the measured joints (e.g. cmd1 spans −3.7024 … −2.6804 against ur_q1's −3.7028 … −2.6809). The session lives in a compact workspace: 29 cm of TCP travel in x, 60 cm in y, 29 cm in z, with a z floor of 1.75 cm where the fingers reach the table. Per-channel min/max/mean/std for every channel is in dataset_stats.json and DATA_DICTIONARY.md.

Gripper convention — 0.0 = open, 1.0 = closed in grip_pos, grip_cmd and gello_grip alike. The measured fully-open value is 0.0118; holding the carrot puts grip_pos at 0.4745 – 0.6627 (median 0.5569, and that plateau is the carrot's width); 0.8980 is the fingers meeting each other with nothing between them, which happens in exactly two takes.

How the derived dataset is built from this

dataset	contents
raw (this repo)	full multi-rate HDF5 + lossless depth + 2 MP4s — every signal above, native rates, 54 takes
LeRobot joint + depth	observation.state(7)=ur_q1..6+grip_pos; action(7)=cmd1..6+grip_cmd; 2 RGB videos + 2 native depth video features, 54 episodes / 17,088 frames — the last ~0.9 s of every take is dropped there, see below

The LeRobot dataset resamples every stream onto the 30 fps cam1 timestamp grid (nearest timestamp), drops the gello_* leader streams, and re-encodes the videos.

The LeRobot release is time-corrected; this one is not. Because observation.state[0:6] comes from ur_joint_states, the conversion first shifts that table's t_rel_s by that take's measured τ (−0.900 s in 41 of the 54 episodes, −0.895 s in the other 13) and only then resamples onto the camera grid — see the timestamp artefact above. Nothing else is shifted: grip_pos, action (command + grip_cmd), the RGB videos and both depth streams were already on the camera timebase and are resampled unchanged. The applied τ is recorded per episode in that dataset's meta/source_takes.json (ur_joint_states_lag_s). That shift also costs the tail, and the LeRobot release drops it. After the shift the last ~0.9 s of every take — the last 26–28 master frames, 1,469 of the 18,557 — has no ur_joint_states sample at or after its corrected lookup time, so those frames are dropped whole (state, action, both colour and both depth streams) rather than repeating the final joint row under a still-moving arm. The LeRobot release therefore holds 54 episodes / 17,088 frames against the 18,557 colour frames here, with the per-episode count in its meta/source_takes.json (n_frames_dropped_stale_tail). Those dropped frames — the arm's post-placement return motion — exist only here, in this raw release. tcp_pose and wrench, the other two late tables, are not part of the LeRobot release at all — if you need them, take them from here and subtract ≈0.41 s yourself. Depth is carried as first-class LeRobot depth features — observation.images.cam1_depth and observation.images.cam2_depth, (480, 848, 1), is_depth_map: true, HEVC gray12le lossless encoding of linearly 12-bit quantized codes over 0 – 10.0 m (step = 10000/4095 ≈ 2.44 mm), decoded back to float32 millimetres. Decoded values are therefore within ±1.25 mm of the raw millimetre value here, and invalid pixels (raw 0) decode to exactly 0 — the same "no return" sentinel as in this repo. Nothing clips: over the 216 depth frames sampled here (dataset_stats.json) the largest raw value is 9,899 mm and zero pixels exceed 10,000 mm. Unlike the cube release, no take is excluded: 54 raw takes → 54 episodes (17,088 frames there, after the stale-tail drop described above).

Usage

Read a take with h5py:

import h5py, cv2, numpy as np

take = "take_03_20260914_164930"
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)  # (N67, 6) rad
    cmd    = np.stack([f["command"][f"cmd{k+1}"][:]       for k in range(6)], axis=1)  # (N67, 6) rad
    tcp    = np.stack([f["tcp_pose"][k][:] for k in "x y z qw qx qy qz".split()], 1)   # (N67, 7)
    wrench = np.stack([f["wrench"][k][:]   for k in "fx fy fz tx ty tz".split()], 1)   # (N67, 6)
    grip   = f["gripper"]["grip_pos"][:]                                               # (N39,)
    cam1_t = f["cam1_frames"]["t_rel_s"][:]                                            # (Ncam,) 30 Hz
    # 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

⚠️ Before you align anything to ur_q, tcp or wrench above, subtract their timestamp offset — 0.900 s and ≈0.41 s respectively. See Known quirks.

For depth see the snippet in Depth above. To go straight to training, use the ready LeRobot dataset instead (LeRobotDataset("Bigenlight/carrot_in_pot_lerobot_v3")).

⚠️ columns attribute quirk — still present. Every group carries an attribute named columns that is a single scalar JSON string, not a list — measured str in all 54 files. Always json.loads(grp.attrs["columns"]); list(...) on it iterates character-by-character and yields garbage.

Known quirks

• ⚠️ Timestamp artefact — ur_joint_states, tcp_pose and wrench rows are stamped late. The arm was not late; the recording is. Three of the nine groups carry timestamps that are behind the rest of the take by a constant amount, so their samples describe the robot as it was a fraction of a second earlier than their t_rel_s claims.

  group	how late	per-take spread	how it was measured
  ur_joint_states	0.900 s	0.895 – 0.900 s, median 0.900 s — most takes land exactly on 0.900 and the rest one 5 ms grid step below	joint-space residual: shift the ur_joint_states clock by −τ, interpolate the six joints onto command, minimise mean |ur_q − cmd| on a 5 ms grid
  tcp_pose	≈ 0.41 s (0.900 − 0.495; speed cross-correlation against command gives 0.41 independently)	0.495 – 0.500 s ahead of ur_joint_states, median 0.495	forward-kinematics residual fk(q) ⊕ 0.174 m against tcp_pose: 11.2 – 23.3 mm at zero shift, 0.52 – 2.89 mm at the optimum
  wrench	≈ 0.41 s — same queue depth and publisher as tcp_pose	measured 0.000 s from tcp_pose (7 of 8 takes)	velocity cross-correlation

  Everything else is fresh and must not be touched: command, both colour cameras, both depth streams, gello_joint_states and gripper (⚠️ command's own residual age is ≈0.08 s rather than exactly zero — see Mechanism below). The evidence is direct — the depth frames store the driver's own header stamp, and their measured age at the moment they were written is 0.022 s; scene-camera motion energy correlates with command at τ ≈ 0 (−0.055 s / +0.010 s on the two takes checked) while the same motion correlates with ur_joint_states at +0.865 / +0.935 s; and tcp_pose ↔ wrench, two tables that come out of the same driver cycle, are 0.000 s apart, which no "the robot lagged" explanation can produce.

  Mechanism. The recorder writes every row inside its ROS subscription callback and stamps it with the time that callback ran — header stamps were not stored — and all callbacks share a single rclpy spin thread that serves one message per subscription per round. Adding depth recording to this session dropped that round rate to ≈67 Hz — 41–70 Hz across takes, so every publisher faster than it kept its KEEP_LAST queue permanently full and each row came out already queue_depth ÷ publish_rate old: /joint_states depth 100 at ~100 Hz → 1.0 s, tcp_pose / wrench depth 50 at ~100 Hz → 0.5 s. The signature is in the rate table above — command, ur_joint_states, tcp_pose and wrench have two different publish rates (the ~100 Hz controller_manager broadcasters and the 250 Hz command stream) yet all four converge on the same recorded rate (e.g. 59.792 / 59.791 / 59.793 / 59.792 Hz in take_01); that is what starvation looks like. Streams at or below the round rate (30–40 Hz) never queued, which is why they are fresh. ⚠️ command is the one stream the queue model does not predict — at 250 Hz behind a depth-50 queue it should have emerged ~0.2 s old, and it measures ≈0.08 s. It is treated as fresh on the measurements above (scene-camera cross-correlation at τ ≈ 0), not on the model.

  It is a pure delay, not a distortion — the waveform is intact, which is why one constant shift recovers it. Independently re-measured on all 54 takes, the ur_joint_states ↔ command residual drops from 0.049–0.090 rad (median 0.063) uncorrected to 0.0007–0.0103 rad (median 0.0062) at the per-take optimum; on the release script's own more robust objective it drops from 0.034–0.081 rad to 0.0004–0.0009 rad. For tcp_pose the same story in millimetres: fk(q) ⊕ 0.174 m versus tcp_pose goes from 11.2–23.3 mm to 0.52–2.89 mm. A servo lag would smear the waveform and could not collapse a residual by that factor; only a timestamp offset can.

  ⚠️ Quote the number with its method attached, because four estimators land within ±0.02 s of each other and none of them is "wrong": joint-space residual on a 5 ms grid → 0.895–0.900 s (median 0.900; 41 of 54 takes land exactly on 0.900 in the independent re-measurement the LeRobot release applies, 38 of 54 in dataset_stats.json's own run of the same estimator — same lag, different tie-break); the same residual with a median-over-time objective → 0.900 s in all 54 takes; velocity cross-correlation of command against ur_joint_states → 0.875–0.915 s (median 0.900; the sibling analysis reports 0.910 s); TCP-position residual on a 10 ms grid → 0.90 s (11 of 11 takes checked, residual median 0.42–0.64 mm against 44–67 mm at τ = 0). Say 0.89–0.91 s depending on method and grid; the derived LeRobot release applies the per-take optimum — 0.900 s for 41 takes and 0.895 s for 13 — recorded episode by episode in its meta/source_takes.json, and drops the last 26–28 master frames (~0.9 s) of every take, 1,469 of 18,557, which that shift leaves with no joint sample at all — so it ships 54 episodes / 17,088 frames. Both objectives are in dataset_stats.json → timestamp_lag (ur_joint_states_lag_s and ur_joint_states_lag_s_mean_objective) so you can see for yourself that they differ by at most one grid step. A single 0.900 s for everything is within 5 ms of correct and perfectly usable — 5 ms is a seventh of a camera frame.

  Fix rule for consumers. Subtract 0.900 s from ur_joint_states/t_rel_s and ≈0.41 s from tcp_pose/t_rel_s and wrench/t_rel_s (the two constants must differ by the measured 0.495 s, which is the tightest number here — 0.900 − 0.495 = 0.405). Do not shift anything else — the camera, depth, gripper and command tables already share one timebase, and shifting them would create a misalignment that is not in the data.

  import h5py, numpy as np
  with h5py.File("take_01_20260914_164811/vectors.h5", "r") as f:
      cam_t = f["cam1_frames"]["t_rel_s"][:]                       # master clock, fresh
      ur_t  = f["ur_joint_states"]["t_rel_s"][:] - 0.900           # <- the whole fix
      ur_q  = np.stack([f["ur_joint_states"][f"q{i}"][:] for i in range(1, 7)], 1)
  ur_on_cam = np.stack([np.interp(cam_t, ur_t, ur_q[:, k]) for k in range(6)], 1)
  

  The files here are exactly as recorded — nothing was rewritten — because a documented constant is recoverable and a silently re-stamped file is not. Per-take values, residuals and the cross-correlation checks are in dataset_stats.json under timestamp_lag. The recorder itself was fixed after this release (header stamps are now stored, the high-rate queue depths were shrunk, camera/depth writes were moved off the spin thread, and it now warns when the recorded rates of unrelated topics converge), and depth recording is now opt-in (ENABLE_DEPTH=1), default RGB-only, so later sessions in this family are not affected.

• take_12 is absent by design. Folders run take_01 … take_55 but take 12 was discarded during recording, giving exactly 54 folders. Do not treat the gap as missing data; there is no partial take_12 anywhere in the release.

• Three takes miss the first grasp and re-grasp. They are the only three takes with more than one gripper closure (grip_cmd ≥ 0.7 rising edge). Measured:

  take	1st close	released	grip_pos peak	2nd close	released	grip_pos peak
  take_15_20260914_165753	4.20 s	4.61 s	0.4314	6.67 s	11.61 s	0.6078
  take_39_20260914_171227	3.39 s	4.45 s	0.8980	6.65 s	10.59 s	0.5451
  take_40_20260914_171256	2.88 s	3.80 s	0.8980	6.81 s	10.35 s	0.5137

  take_39 and take_40 close fully on nothing — grip_pos reaches 0.8980, the empty-gripper stop — then reopen and re-approach. take_15 is a different failure and the distinction is worth keeping: its first closure was aborted after 0.41 s with grip_pos reaching only 0.4314, less closed than the 0.6078 it later reaches on the carrot, so the fingers never met. All three then grasp successfully and finish the task. All three are included in both releases — a recovery is a legitimate demonstration, not a defect.

• The GELLO leader stream does not mirror the follower — because this session is EEF mode. This is the biggest difference from cube_in_cup_raw, where leader joints 1–5 tracked the follower to within ±0.011 rad and joint 6 was a clean +2π wrap. That release was recorded in joint mode; this one in EEF delta mode (see Setup), where command comes from IK on a leader pose delta rather than from the leader's joint angles. Measured here (gello_qi − ur_qi, nearest-timestamp aligned, pooled over all 54 takes):

  joint	median diff (rad)	per-take median spread (std)	r(gello_qi, ur_qi)	r(gello_qi, cmd_i)
  1	+2.7019	0.160	−0.785	−0.956
  2	−0.0147	0.203	+0.078	+0.261
  3	−0.0242	0.225	−0.011	−0.059
  4	−0.3328	0.167	+0.537	+0.603
  5	−0.0247	0.132	+0.583	+0.435
  6	+2.8886	0.229	+0.025	−0.031

  There is no single offset to subtract: the per-take median of the difference itself moves by 0.13–0.23 rad, and joint 6's +2.889 rad is not a 2π wrap. Joint 1 is anti-correlated with the arm it is driving (r = −0.956 against cmd1, −0.599 on first differences). All of this is expected under EEF mode — the leader's joints are one IK branch of a virtual chain and the follower's are another solution of a different chain, so the two are related only through the end-effector pose delta, not joint-by-joint. The consequence for a consumer is unchanged: gello_* here is leader-frame telemetry with its own zeros and sign conventions, it cannot be used to reconstruct the action or the follower state, and the LeRobot conversion drops it. Use command for the action and ur_joint_states for the state, exactly as in the joint-mode siblings.

• cam1 / cam2 frame-count mismatch: in 24 of 54 takes the two cameras differ by ±1 frame (12 at +1, 12 at −1; none differ by more than 1). The session totals are equal at 18,557 each only because the signs happen to cancel — the two cameras are on independent clocks. Map between them by nearest timestamp; never assume cam1[k] and cam2[k] are simultaneous.

• Depth / colour frame-count mismatch: 24 takes (cam1) and 29 takes (cam2) differ by ±1, and take_28 cam2 depth is 2 frames short (30 cam2 takes differing in total). Same rule: align by t_rel_s.

• Wrist depth is below the sensor's minimum range — see Measured depth quality.

• Four takes log the robot streams at 41–49 Hz instead of the 67.3 Hz median: take_24 (44.3 Hz), take_25 (47.2 Hz), take_26 (49.2 Hz), take_28 (41.2 Hz). Nothing else about them is unusual — they simply have fewer robot samples per camera frame.

• synchronized/ group is empty (0 rows) in all 54 takes, despite declaring 56 channels. Fusion happens downstream at conversion time, not here.

• Duration outliers, not defects: take_49 (17.78 s) and take_54 (16.97 s) run about 1.6× the median take length (10.86 s) — slower demonstrations. Their data is clean.

Data quality

Audited over all 54 takes:

• Zero NaN and zero Inf in any channel of any group of any take.
• Video frame counts match cam*_frames row counts exactly for all 54 takes, both cameras (108/108 videos) — verified with ffprobe -count_frames.
• Depth metadata is stable: camera_info (K, D, distortion model, frame_id) and extrinsics_depth_to_color are byte-identical across all 54 takes, per camera. Group attrs (unit, depth_scale_m, width, height, aligned_to_color, source_topic) likewise.
• Uniform schema: identical 9 groups, identical channel names, all float64, in all 54 vectors.h5; identical video format (mpeg4 1280×720 yuv420p 30/1) in all 108 MP4s.
• Timestamp spacing is well behaved; timestamp offset is not, for three groups. No stream drops out: the largest single gap in any robot stream is 44.1 ms, the largest in any colour camera stream 61.0 ms (~2 frame periods), and the largest in any depth stream 69.2 ms. But ur_joint_states (0.900 s), tcp_pose and wrench (≈0.41 s) are stamped late as a whole — a constant offset, not jitter, and not corrected in these files. Cross-stream alignment is therefore wrong by that much until you apply the shift in Known quirks. command, the cameras, depth, gello_joint_states and gripper are on a common, correct timebase.
• Cleanliness: exactly four files per take folder, no stray files, no hidden files, no sub-directories, and no /home/ absolute-path string anywhere in the 216 data files (54 vectors.h5 + 54 depth.h5 + 108 MP4s, full byte scan).

No per-step success/failure labels, no human quality ratings, and no policy-performance numbers are claimed for this dataset. The only outcome statement is the operator's: all 54 takes end with the carrot in the pot.

Limitations & intended use

• Small. 54 takes / 10.3 minutes is a pilot-scale dataset. It is not enough on its own for a robust policy; treat it as a seed set or a schema reference.
• Single task, single scene layout, single operator, single session, fixed object placement (the sticky-note markers).
• No trained policy exists for this task yet.
• Streams are asynchronous (each has its own clock); you must resample/align them yourself — the synchronized/ group is empty.
• Three groups need a constant timestamp correction before they can be aligned to anything else (ur_joint_states −0.900 s, tcp_pose / wrench −≈0.41 s; see Known quirks). It is one subtraction, it is documented per take in dataset_stats.json, and the derived LeRobot release has it applied — but it is a real trap if you skip it. That release also drops the last ~0.9 s of every take (1,469 frames, leaving 54 episodes / 17,088 frames), because the shift leaves it with no joint sample; the full trajectories are here.
• Sampling is bursty (see the rate note above), so nearest-timestamp alignment is required rather than index arithmetic.
• Depth is unaligned to colour and the colour intrinsics are not included (see Depth), and wrist depth is unreliable at grasp time.
• gello_* is not usable as a follower proxy in this session (see Known quirks).
• Intended for research in imitation learning, teleoperation analysis, RGB-D manipulation, and custom dataset construction.

Related repositories

repo	contents
Bigenlight/carrot_in_pot_raw	this — raw HDF5 + lossless depth + MP4, 54 takes
Bigenlight/carrot_in_pot_lerobot_v3	LeRobot conversion of this data: 54 episodes / 17,088 frames (the last ~0.9 s of each take dropped — no joint sample after the τ shift), observation.state/action (7), 2 RGB video features plus observation.images.cam1_depth / cam2_depth — (480, 848, 1), is_depth_map: true, HEVC gray12le lossless, 12-bit linear quantization over 0–10.0 m (step ≈ 2.44 mm), decoded to float32 mm within ±1.25 mm; raw-0 pixels decode to exactly 0
Bigenlight/cube_in_cup_raw	sibling raw dataset, same rig family, RGB only, 24 takes
Bigenlight/cube_in_cup_lerobot_v3	its LeRobot conversion, 23 episodes
Bigenlight/banana_in_pot_raw	sibling raw dataset, same rig family, different scene
Bigenlight/banana_in_pot_lerobot_v3	its LeRobot conversion (legacy "ur5e_gello" label for the same physical arm)

Citation

@misc{theo2026carrotinpotraw,
  title        = {carrot_in_pot_raw: raw UR7e + GELLO teleoperation logs (HDF5 + MP4 + 16-bit
                  depth) for "Put carrot in pot"},
  author       = {Theo and {Bigenlight}},
  year         = {2026},
  howpublished = {\url{https://huggingface.co/datasets/Bigenlight/carrot_in_pot_raw}},
  note         = {54 takes, native multi-rate HDF5 + dual RGB MP4 + dual lossless RealSense depth}
}

License: Apache-2.0.