Bigenlight/carrot_in_pot_lerobot_v3

carrot_in_pot — UR7e teleop with RGB and depth, "Put carrot in pot" (LeRobot v3.0)

Joint-space imitation-learning dataset: 54 human teleoperation demos of a UR7e arm picking a plastic carrot off a table and placing it into a pot, with two 720p RGB views and two native 848×480 depth streams. Ready to load with the LeRobot API out of the box.

• 54 episodes · 17,088 frames · 30 fps · 9.5 min · 1.91 GB
• Format: LeRobot v3.0 (lerobot 0.6.1), robot_type: "ur7e_gello"
• Action / state space: 7-D absolute joint (6 UR joints + gripper)
• ⚠️ observation.state is time-corrected — its six joint channels are shifted by −0.900 s (13 of the 54 episodes: −0.895 s) to undo a recorder timestamp artefact in the raw source. action, grip_pos, the RGB videos and both depth streams are untouched. See Timestamp correction
• ⚠️ The stale tail of every take is dropped, not clamped. Frames with no real joint sample after the shift — the last 26–28 frames = the last ~0.9 s of every take, 1,469 frames in total, the arm's post-placement return motion — are DROPPED, not clamped; v2 (superseded) clamped them — a frozen state under moving images for 8 % of frames. That is why this release has 17,088 frames while the raw source has 18,557 colour frames. See Timestamp correction
• First release in this family with depth — observation.images.cam1_depth / cam2_depth, is_depth_map: true, HEVC gray12le lossless, decoded to float32 millimetres
• First release in this family where the camera mapping is asserted: cam1 = scene, cam2 = wrist
• Every episode is an operator-reported success (three of them after a re-grasp).

This is a pilot-to-medium-scale dataset. 9.5 minutes of demonstration is small — larger than the sibling cube_in_cup_lerobot_v3 (23 episodes / ~3.4 min) but still a seed set rather than something expected to train a robust policy on its own. No trained policy exists for this task yet.

Setup

Collected on a Universal Robots UR7e — a 6-DOF collaborative arm (joint values 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.

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. Nothing in this dataset changes because of it: command is the true absolute joint target in either mode, so action still means "go to these joint angles", and the leader's own joint angles — which in EEF mode are a different kinematic solution and do not track the follower joint-by-joint — are excluded here anyway, as they are in the joint-mode siblings. The difference matters only if you go to the raw release and try to read gello_*; see carrot_in_pot_raw for the measured leader/follower relationship.

Two Intel RealSense cameras record colour and depth, and — unlike the sibling cube/banana releases, which decline to say which view is which — the mapping here is known and asserted:

• 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, both on a powered USB-3 hub. Colour is 1280×720 @ 30 fps, yuv420p; the raw MPEG-4 recordings were re-encoded to AV1 (crf 30, preset 12, GOP 2, pyav backend) here. Depth is 848×480 @ 30 fps, re-encoded as lossless HEVC gray12le — see Depth.

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 episodes end with the carrot in the pot, three of them after a retry (see Episode set). There are no per-step success labels and no reward column — the only outcome statement is the operator's.

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

Schema

feature	dtype	shape	meaning
observation.state	float32	(7,)	UR7e measured joints ur_q1..ur_q6 (rad) + grip_pos (measured gripper opening). ⚠️ ur_q1..6 are time-corrected by −0.900 s (−0.895 s in 13 episodes); grip_pos is not — see Timestamp correction
action	float32	(7,)	commanded absolute joint targets cmd1..cmd6 (rad) + grip_cmd
observation.images.cam1	video (AV1, crf 30)	(720, 1280, 3)	scene camera, RGB HWC uint8
observation.images.cam2	video (AV1, crf 30)	(720, 1280, 3)	wrist camera, RGB HWC uint8
observation.images.cam1_depth	video (HEVC gray12le, lossless)	(480, 848, 1)	scene depth in mm, decoded as float32 (1, 480, 848); 0 = no return; ±1.25 mm quantization; UNALIGNED to the colour image (native depth imager frame); intrinsics/extrinsics in meta/depth_cameras.json
observation.images.cam2_depth	video (HEVC gray12le, lossless)	(480, 848, 1)	wrist depth, same contract as above

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

action is an absolute joint-target command (not a delta), even though the teleop was EEF-delta — the bridge already solved IK before logging it. The gripper convention is 0.0 = open, 1.0 = closed for both grip_pos and grip_cmd. grip_cmd is effectively binary; grip_pos is not — it is continuous and it is the only channel that tells you whether the grasp caught anything (holding the carrot plateaus at 0.47–0.66, whereas the fingers meeting each other with nothing between them reads 0.898).

The two depth features are listed by ds.meta.depth_keys, and lerobot's reader dequantizes them automatically (pyav backend) — you get millimetres back, not 12-bit codes.

Depth

Both depth streams are the D435's own 848×480 uint16 millimetre frames, carried as first-class LeRobot depth features (is_depth_map: true) and encoded losslessly as HEVC gray12le over a 12-bit LINEAR quantization of 0 – 10.0 m (depth_min=0.0, depth_max=10.0, shift=0.0, use_log=False).

Why linear instead of lerobot's default log quantizer. The default DepthEncoderConfig uses a logarithmic mapping with depth_min = 0.01 m, which sends raw 0 to 10 mm — that silently destroys the invalid mask, because a "no return" pixel becomes indistinguishable from a real 10 mm reading and every downstream d > 0 test passes on garbage. The linear 0–10 m mapping keeps 0 → exactly 0.0, so decoded == 0 is the invalid mask, and it is uniform: step = 10000/4095 = 2.442 mm, so every valid pixel decodes within ±1.25 mm of the recorded millimetre value. Nothing clips inside the sensor's range (the largest raw value observed in the raw release's 216 sampled frames is 9,899 mm, with zero pixels over 10,000 mm). Decoded values are integer millimetres — a float32 tensor whose values happen to be whole numbers — and the measured worst-case error against the raw 16-bit PNGs is 1 mm.

depth = sample["observation.images.cam1_depth"]   # float32 (1, 480, 848), millimetres
valid = depth > 0                                  # 0 == no return, NOT zero distance
depth_m = depth / 1000.0

⚠️ The wrist camera works at or below the D435 minimum range. At 848×480 the D435 bottoms out around 0.2 m, and cam2's measured median range is 0.207 m — the whole scene sits on the sensor's floor. Measured over the raw takes: cam1 (scene) is 85.15 – 88.71 % valid (median 86.94 %) at a comfortable 0.54 m, while cam2 (wrist) is only 50.48 – 67.95 % valid (median 62.32 %), and it is worst exactly when it matters — at the moment of the grasp the worst take drops to 37.13 % valid, with the carrot and the fingers as holes. Treat cam2 depth as a sparse cue, not as a depth map.

⚠️ Depth is not aligned to colour. aligned_to_color = false: the depth frames live in the 848×480 depth optical frame, which is neither the resolution nor the field of view of the 1280×720 colour image. Do not assume depth[v, u] is the depth of colour[v, u]. To align, meta/depth_cameras.json ships, per camera, the depth K and D (plumb_bob, all-zero D; cam1 fx = fy = 426.742, cx = 423.939, cy = 233.149; cam2 fx = fy = 425.264, cx = 425.044, cy = 232.822) and the depth→colour extrinsics. Back-project with K, apply the extrinsics, then project onto the colour image:

import json, numpy as np

meta = json.load(open("meta/depth_cameras.json"))["cam1_depth"]
K    = np.asarray(meta["camera_info"]["K"]).reshape(3, 3)                       # row-major
R    = np.asarray(meta["extrinsics_depth_to_color"]["rotation"]).reshape(3, 3).T  # column_major!
t    = np.asarray(meta["extrinsics_depth_to_color"]["translation_m"])           # metres

fx, fy, cx, cy = K[0, 0], K[1, 1], K[0, 2], K[1, 2]
v, u    = np.nonzero(depth_m[0] > 0)
Z       = depth_m[0][v, u]
P_color = np.stack([(u - cx) / fx * Z, (v - cy) / fy * Z, Z], 1) @ R.T + t

The rotation_layout is column_major, so .reshape(3, 3) gives you the transpose — use .reshape(3, 3).T. The translation is the D435's physical depth-to-RGB baseline, ‖t‖ ≈ 15.07 mm (cam1) and 14.90 mm (cam2), with a rotation that is identity to within 0.011. The colour intrinsics are not in this release (the recorded camera_info describes the depth imager); read them off the same D435 bodies with rs-enumerate-devices -c, or treat the 15 mm baseline as negligible and use the depth frame as its own coordinate system.

Storage cost. Lossless depth is what this dataset mostly is: 1,121 MB for cam1_depth and 550 MB for cam2_depth, against 131 MB + 108 MB for the two AV1 colour streams and 1.5 MB for all the parquet data — about 66 KB and 32 KB per depth frame versus 6–8 KB per colour frame, so depth is 87 % of the 1.91 GB total. If you only want RGB, fetch the two colour video directories and skip the depth ones.

⚠️ Loadable is not the same as trainable "for free". Upstream lerobot's ACT policy does not consume single-channel inputs out of the box (lerobot issue #4475); its image normalization and backbone assume 3-channel RGB. The depth features load, decode and index correctly through the standard LeRobotDataset API, but wiring them into a policy is your work — expect to repeat the channel, add a separate encoder, or concatenate depth as a 4th channel yourself.

Rows: three takes, 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.

How this was built

Converted from Bigenlight/carrot_in_pot_raw (54 raw takes of multi-rate HDF5 + dual MP4 + dual lossless depth HDF5) with the same recipe as the cube/banana family, extended with depth:

• Master clock = cam1_frames/t_rel_s at 30 fps. Every other stream is resampled onto that grid by nearest-timestamp lookup on its own t_rel_s — never by index arithmetic, because the source streams are asynchronous and bursty.
• ur_joint_states is shifted back by its measured per-episode lag before that lookup — see Timestamp correction. This is the one substantive difference from the sibling cube/banana conversions.
• The trailing frames that shift leaves without a joint sample are dropped, not clamped — 1,469 of the 18,557 raw master frames (7.92 %), the last 26–28 of every take. See Timestamp correction.
• cam2 RGB is aligned to cam1 by nearest camera timestamp; the two cameras run on independent clocks and differ by ±1 frame in 24 of the 54 raw takes.
• Depth uses the same nearest-timestamp rule, each camera's depth t_rel_s against the cam1 master grid, so every episode ends up with exactly as many depth frames as colour frames even though the raw depth streams are ±1 frame off (and take_28's cam2 depth is 2 frames short).
• grip_cmd is forward-filled then back-filled across any gaps.
• gello_* leader streams are dropped — the deployed robot cannot observe the leader, and in this EEF-mode session they are a different kinematic solution anyway.
• tcp_pose, wrench, joint velocities and efforts are not carried over; they are in the raw release.
• Colour re-encoded to AV1 (crf 30, preset 12, GOP 2, pyav backend). Depth encoded to HEVC gray12le with x265-params=lossless=1, 12-bit linear quantization over 0–10 m.

Timestamp correction

The raw recording stamps ur_joint_states late, and this release undoes it. In the source session the GUI recorder wrote every row inside its ROS subscription callback and timestamped it with the moment that callback ran; message header stamps were not stored. All callbacks share one rclpy spin thread, and adding depth recording dropped its round rate to ≈67 Hz (41–70 Hz across takes) — so every topic published faster than that 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) was therefore stamped ≈0.9 s late. It is a pure delay — the waveform is intact, only displaced — so one constant shift per take recovers it, and that is what the conversion applies.

• Corrected: observation.state[0:6] (ur_q1..ur_q6). The ur_joint_states row clock becomes t_rel_s − τ before the nearest-timestamp lookup, i.e. the master frame at time t reads the raw row stamped t + τ.
• NOT corrected, deliberately: observation.state[6] (grip_pos), all of action (command + grip_cmd), observation.images.cam1 / cam2, and both depth features. They are already on the camera timebase, and shifting them would invent a misalignment that is not in the data. The evidence differs by stream: the images carry the driver's own header stamps, which put their age at 0.022 s; the 30–40 Hz gripper stream never outran the spin thread; and command is fresh by measurement rather than by the queue model — it is published at 250 Hz behind a depth-50 queue, so the model would predict ~0.2 s, while scene-camera motion energy cross-correlates with it at τ ≈ 0 (−0.055 s / +0.010 s on the two takes checked) and the queue algebra puts its residual age at ≈0.08 s, under three camera frames.

τ is per episode, measured, and recorded in the dataset. It was found by minimising the joint-space residual mean |ur_q_raw(t + τ) − cmd(t)| over the six joints on a 5 ms grid (equivalently: shift the ur_joint_states clock by −τ, then compare — the raw row stamped t + τ is the state at t):

	value
τ applied	0.900 s in 41 episodes, 0.895 s in 13 episodes
where it is written	meta/source_takes.json: per episode as ur_joint_states_lag_s, plus a top-level timestamp_correction block recording what it was applied to, what it was not applied to, and the sign convention
other estimators	velocity cross-correlation 0.875–0.915 s (median 0.900); TCP-position residual on a 10 ms grid 0.90 s (11 of 11 takes checked); the raw release's own median-over-time objective 0.900 s in all 54 takes

Quote it as 0.89–0.91 s depending on method and grid — the estimators agree to within ±0.02 s and the differences are grid quantisation, not disagreement about the lag.

The stale tail is dropped, not clamped. The shift leaves the last τ seconds of every take with no joint sample at all, and a nearest-timestamp lookup there can only clamp to the final raw row and repeat it. Frames with no real joint sample after the shift — the last 26–28 frames = the last ~0.9 s of every take, 1,469 frames in total, the arm's post-placement return motion — are therefore DROPPED, not clamped; v2 (superseded) clamped them — a frozen state under moving images for 8 % of frames. A master frame k survives only if cam1_t[k] + τ ≤ ur_joint_states t_rel_s[-1], and the cut is applied to the whole frame (state, action, both colour streams, both depth streams), so every episode stays internally consistent. That window is not idle: raw tcp_pose travels a median 54 mm over it (p90 111 mm, max 133 mm), which is exactly what a clamped state would have hidden. The counts are recorded per episode in meta/source_takes.json as n_frames_dropped_stale_tail (min 26, median 27, max 28), with timestamp_correction.stale_tail = "dropped" and the rule written out in stale_tail_rule. Passing --no-drop-stale-tail to the converter reproduces the v2 behaviour.

Physics sanity check — does the follower now sit on its command? The independent validator re-derives the same episodes at τ = 0 (the uncorrected v1 behaviour) and compares the mean |observation.state[0:6] − action[0:6]| per episode, skipping the first 1.6 s (48 frames) of each episode where the arm is still catching up to the leader:

	corrected (shipped)	uncorrected (τ = 0)
median over 54 episodes	0.00183 rad	0.06344 rad
mean	0.00199 rad	0.06472 rad
min → max	0.00073 → 0.00487 rad	0.05054 → 0.09318 rad

Every one of the 54/54 episodes improves, by a median factor of 33.7× (min 14.2×, max 95.3×), and the worst corrected episode (take_22, episode 20) is still 0.0049 rad — a quarter of the 0.02 rad gate. A real servo-tracking lag could not be removed this way; only a timestamp offset can. (The v2 card quoted 0.00442 rad median for this same check. The residual fell by ~2.4× here for one reason: the clamped tail — a frozen state under a still-moving command — is no longer in the average.)

What this means for training. observation.state and action in this release describe the same instant, and both are aligned with the images to within the camera's own sampling. In the uncorrected v1 the state trailed the action by ~0.9 s, so a policy trained on it would have learned that the arm is permanently ~0.063 rad behind wherever it was told to go — an offset that does not vanish when the arm is standing still.

⚠️ The raw release is not corrected and ships as recorded, with the per-take τ documented. If you resample it yourself, subtract 0.900 s from ur_joint_states/t_rel_s and ≈0.41 s from tcp_pose / wrench (the two constants must differ by the measured 0.495 s), and shift nothing else.

Source stream rates (native, before resampling)

stream	native rate	in this dataset
cameras (cam1, cam2) colour	30.0 Hz	master 30 fps clock
depth (cam1, cam2)	30.0 Hz	→ *_depth, nearest-timestamp onto the master clock
command (UR joint targets)	~67.3 Hz	→ action[0:6], resampled to 30 fps
ur_joint_states	~67.3 Hz	→ observation.state[0:6], clock shifted by −τ then resampled to 30 fps
gripper	~38.8 Hz	→ grip_pos / grip_cmd, resampled to 30 fps
tcp_pose, wrench	~67.3 Hz	not in this dataset — available in the raw release, where they carry their own ≈0.41 s timestamp lag
gello_joint_states	30.0 Hz	excluded (leader-only)

The robot-side streams here run at a measured 67.3 Hz (median of the per-take mean; range 41.2 – 70.4 Hz across takes, with take_24/25/26/28 at the bottom), against ~97 Hz in the cube session — about 2.2 robot samples per camera frame rather than ~3.2. Sampling is also bursty rather than uniform (5 % of intervals are ≤ 4.3 ms while the median is 15.9 ms), which is why the conversion aligns by timestamp.

Episode set

54 episodes from 54 raw takes — nothing is excluded. Episode indices are assigned in take order, episode_index = position of the take in the sorted take list (0-based), and the mapping is stored explicitly in meta/source_takes.json.

take_12 is absent by design — it was discarded during recording, so the raw folders run take_01 … take_55 with a gap and the episode indices shift by one from take 13 onward (take_13 → episode 11, take_55 → episode 53). Do not infer take numbers from episode indices; read meta/source_takes.json.

Three episodes contain a missed first grasp and a successful re-grasp — they are the only takes with more than one gripper closure, and they are included on purpose: a recovery is a legitimate demonstration, not a defect.

raw take	episode index	what happened
take_15	13	first closure aborted after 0.41 s, grip_pos peaking at only 0.4314 — less closed than the 0.6078 it later reaches on the carrot, so the fingers never met
take_39	37	closed fully on nothing (grip_pos 0.8980, the empty-gripper stop), reopened, re-approached
take_40	38	same as take_39 — closed fully on nothing, then re-grasped

Episode lengths run 233 – 506 frames (7.8 – 16.9 s), median 298 frames (9.9 s); the two long ones are take_49 (episode 47) and take_54 (episode 52), which are simply slower demonstrations. These are lengths after the stale-tail drop: the raw takes run 261 – 533 frames (median 325.5) and each one loses its last 26–28 frames — 18,557 raw colour frames, 1,469 dropped, 17,088 stored.

Verification

The conversion was checked by an independent validator that re-derives observation.state, action and the depth frames from the source HDF5 without importing the converter:

• 83 checks, 81 passed, 0 failures, 2 warnings — verdict PASS. (The v2 card reported 79 checks; the four new ones cover the stale-tail drop.)

• max |Δ observation.state| = 0.0 and max |Δ action| = 0.0 — bit-exact against an independent re-implementation of the resampling, including the −τ shift, which the validator re-derives from the same per-take lag file rather than from the converter (tolerance was 1e-6).

• Timestamp correction verified end to end: the per-episode τ stored in meta/source_takes.json matches the measured lag file take by take (0.900 s ×41, 0.895 s ×13), and the physics check below is the independent confirmation that shifting was the right thing to do.

• Physics sanity (check 15): mean |state[0:6] − action[0:6]| per episode, first 1.6 s skipped — median 0.00183 rad, mean 0.00199, min 0.00073, max 0.00487 as shipped, against median 0.06344, mean 0.06472, min 0.05054, max 0.09318 for an uncorrected (τ = 0) re-derivation of the same episodes. All 54/54 episodes improve, median factor 33.7×. Gate: < 0.02 rad in every episode.

• No clamped tail (check 16): the longest run of identical consecutive ur_q rows at the end of any episode is 2 frames (episode 22, take_24), median 1 — the gate is < 3, and a clamped tail would show up here as ~27 repeats. Every episode's stored length equals the length the stale-tail rule predicts: min 26, median 27, max 28 frames dropped per episode, 1,469 of 18,557 raw frames (7.92 %).

• Per-episode frame counts match the count the stale-tail rule predicts from each source take's cam1_frames row count, in order, for all 54 episodes; per-episode depth frame counts match too, and each depth stream's containers sum to 17,088 frames (3,336 + 3,201 + 3,011 + 2,807 + 2,889 + 1,844 for cam1_depth; 6,242 + 6,402 + 4,444 for cam2_depth).

• Zero NaN/Inf in all stored arrays; exactly one task string; timestamp == frame_index / 30; total_episodes 54, total_frames 17,088, codebase_version v3.0, fps 30.

• Sampled AV1 frames vs the raw MPEG-4 source: correlation min 0.9984, mean 0.9991 over 24 sampled frames across both cameras (worst: episode 26, cam1, frame 175 — AV1 is lossy, so this is expected rather than perfect).

• Depth fidelity, decoded through LeRobotDataset (pyav) and compared pixel-by-pixel against the raw 16-bit PNGs, re-aligned independently by nearest timestamp:

  	cam1_depth	cam2_depth
  frames compared	162	162
  valid pixels compared	57,721,353	42,893,168
  max-of-per-frame-median abs err	1 mm	1 mm
  max-of-per-frame-p99 abs err	1 mm	1 mm
  max abs err over all pixels	1 mm	1 mm
  raw-zero pixels decoding to exactly 0	100.0000 %	100.0000 %

  Decoded depth is integer-valued millimetres, so 1 mm is the smallest non-zero error that can be observed — it is one step of the integer-millimetre grid, comfortably inside the ±1.25 mm the linear 0–10 m mapping guarantees, and the invalid mask survives intact.

• Depth ↔ colour timing — this is where both warnings are. Depth is a separate 30 Hz stream matched by nearest timestamp, so each depth frame is a few milliseconds off its colour frame: median signed offset −8.77 ms (cam1) and +7.15 ms (cam2), worst single frame 44.49 ms / 51.49 ms. Within one frame period (33.3 ms) the worst episode still has 99.58 % (cam1) and 99.59 % (cam2) of its frames in tolerance; the largest single-frame offsets, 44.49 ms and 51.49 ms, are in ep53/take_55 and ep26/take_28 respectively. Within a tighter ±21.67 ms, 41 cam1 episodes and 3 cam2 episodes fall below 99 % — worst 75.91 % (cam1, ep1/take_02) and 97.35 % (cam2, ep26/take_28). Those are the two WARNs; they are raw-clock phase, not a conversion error — the timestamp correction touches ur_joint_states only and cannot move a camera, and the percentages differ from v1/v2 only because the dropped tail frames are no longer counted. If you need sub-frame depth/colour synchrony, go back to the raw release and resample yourself.

• Sidecar matches the source: the K, D, distortion model, frame id and depth→colour extrinsics in meta/depth_cameras.json were compared against all 54 source takes, per camera, with zero mismatches — the intrinsics really are constant across the session.

Usage

from lerobot.datasets.lerobot_dataset import LeRobotDataset

ds = LeRobotDataset("Bigenlight/carrot_in_pot_lerobot_v3")
print(ds.meta.total_episodes, ds.meta.total_frames)   # 54, 17088
print(ds.meta.depth_keys)                             # the two depth features

sample = ds[0]
sample["observation.state"]                # (7,) float32  — ur_q1..6 (time-corrected) + grip_pos
sample["action"]                           # (7,) float32  — cmd1..6 + grip_cmd
sample["observation.images.cam1"]          # (3, 720, 1280) float32 CHW — scene RGB
sample["observation.images.cam2"]          # (3, 720, 1280) float32 CHW — wrist RGB
sample["observation.images.cam1_depth"]    # (1, 480, 848)  float32 mm  — 0 == no return
sample["observation.images.cam2_depth"]    # (1, 480, 848)  float32 mm

Depth intrinsics travel in the repo as a sidecar rather than in info.json, so fetch them directly:

import json, numpy as np
from huggingface_hub import hf_hub_download

p = hf_hub_download("Bigenlight/carrot_in_pot_lerobot_v3", "meta/depth_cameras.json", repo_type="dataset")
K = np.asarray(json.load(open(p))["cam1_depth"]["camera_info"]["K"]).reshape(3, 3)

The per-episode timestamp correction that was applied travels with the dataset:

p = hf_hub_download("Bigenlight/carrot_in_pot_lerobot_v3", "meta/source_takes.json", repo_type="dataset")
src = json.load(open(p))
src["timestamp_correction"]["ur_joint_states_lag_s"]   # [0.895, 0.9] — the values used
src["episodes"][0]["ur_joint_states_lag_s"]            # 0.9 — this episode's tau

If you want the full multi-rate signals — TCP pose, 6-axis wrench, joint velocities and efforts, the GELLO leader streams, and the depth frames as untouched 16-bit PNGs — use the raw release Bigenlight/carrot_in_pot_raw, which also ships a DATA_DICTIONARY.md and dataset_stats.json.

Related repositories

repo	contents
Bigenlight/carrot_in_pot_lerobot_v3	this — LeRobot joint-space dataset with depth, 54 episodes
Bigenlight/carrot_in_pot_raw	the raw source: multi-rate HDF5 + lossless 16-bit depth + 2 MP4 per take, 54 takes, all signals incl. GELLO leader
Bigenlight/cube_in_cup_lerobot_v3	sibling dataset, same rig family, RGB only, 23 episodes
Bigenlight/banana_in_pot_lerobot_v3	sibling dataset, same rig family, RGB only (legacy "ur5e_gello" label for the same physical arm)

Limitations & intended use

• The correction puts observation.state on the command timebase. command itself carries a small residual receive-time age (≈0.08 s by the sibling velocity cross-correlation, 0 s by camera-motion alignment), so the shipped state may lead the images by up to that much. Sub-frame at 30 fps, but not zero.
• Pilot-to-medium scale — 54 episodes / 9.5 min. Larger than the cube release, still small for imitation learning; expect to combine it with more data or use it as a reference.
• The final ~0.9 s of every demonstration is missing from this release. The last 26–28 frames of each take — 1,469 in total, the arm's post-placement return motion — are dropped because the timestamp shift leaves no real joint sample for them (see Timestamp correction). Every episode still ends with the carrot in the pot; what is cut is the retreat afterwards. Those frames are present, uncorrected, in carrot_in_pot_raw — go there if you need the full trajectory, and re-derive the state yourself.
• Single task, single scene layout, single operator, single recording session, fixed object placement (the sticky-note markers).
• All demonstrations are operator-reported successes — three contain a failed grasp followed by a recovery, but there is no failure-only data and there are no per-step labels.
• Wrist depth (cam2_depth) is unreliable: 50–68 % valid overall and as low as 37 % at the grasp instant, because the camera sits at or below the D435's minimum range.
• Depth is unaligned to colour and the colour intrinsics are not included — see Depth.
• Depth is not trainable out of the box with upstream lerobot policies (issue #4475).
• The GELLO leader streams are not included. This session is EEF-delta teleop, so the leader joints would not be a follower proxy even if they were; use action (= command) as the action and observation.state (= ur_joint_states) as the state.
• observation.state[0:6] carries a correction, so it is not a verbatim copy of the raw file. The shift is measured, per episode, and written down (meta/source_takes.json), and τ = 0 reproduces the uncorrected dataset exactly — but if you are diffing against carrot_in_pot_raw, expect the ~0.9 s offset. See Timestamp correction.
• The raw sibling's tcp_pose and wrench are late too (≈0.41 s), and they are not in this release. The same recorder starvation that delayed ur_joint_states by ~0.9 s delayed those two tables by about half that (same publisher, half the queue depth). Nothing here depends on them — but if you go to the raw release for TCP pose or force/torque, you must subtract their own offset yourself. Only ur_joint_states is corrected, and only in this LeRobot copy.
• No policy has been trained or evaluated on this dataset; no performance numbers are claimed.
• Intended for research in imitation learning, RGB-D manipulation, and teleoperation analysis.

Citation

@misc{theo2026carrotinpot,
  title        = {carrot_in_pot: UR7e teleoperation demonstrations with RGB and depth for
                  "Put carrot in pot"},
  author       = {Theo and {Bigenlight}},
  year         = {2026},
  howpublished = {\url{https://huggingface.co/datasets/Bigenlight/carrot_in_pot_lerobot_v3}},
  note         = {LeRobot v3.0 dataset, 54 episodes, 2 RGB + 2 native depth video features}
}

License: Apache-2.0.