| --- |
| license: apache-2.0 |
| task_categories: |
| - robotics |
| tags: |
| - lerobot |
| - imitation-learning |
| - ur7e |
| - manipulation |
| - pick-and-place |
| - hdf5 |
| - teleoperation |
| size_categories: |
| - 1K<n<10K |
| --- |
| |
| # cube_in_cup_raw — raw HDF5 + MP4 teleop logs (UR7e, "put the cube in the cup") |
| |
| The **raw, unprocessed** recordings behind |
| [`cube_in_cup_lerobot_v3`](https://huggingface.co/datasets/Bigenlight/cube_in_cup_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) plus the two **raw camera MP4s**. Use this if you want to resample |
| differently, add features, or study the leader/follower relationship — otherwise start from the |
| ready-to-train LeRobot dataset. |
| |
| - **24 takes · 6,226 cam1 frames (6,231 cam2) · 207.6 s (~3.5 min) · 30 fps cameras · ~219 MB** |
| - Per take: `vectors.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-07-20** (20:52–21:04 local), one operator. |
| |
| Every number on this page was measured directly from the 24 HDF5 files and the MP4s; the |
| machine-readable version is [`dataset_stats.json`](dataset_stats.json) in this repo. |
| |
| ## 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 |
| operator moves the GELLO leader; its joint positions map to UR7e joint commands. The end |
| effector is a **Robotiq 2F-85** two-finger parallel gripper. |
| |
| Two Intel RealSense cameras record **RGB video only**: |
| |
| - **Camera 1 — Intel RealSense D435** |
| - **Camera 2 — Intel RealSense D435if** (a D435 variant) |
| |
| The two physical viewpoints are **different in kind**: one RealSense is mounted on the **robot |
| wrist**, just above the gripper (close-up / eye-in-hand view), and the other sits on a tall |
| **tripod** beside the table (scene / third-person view). *This card deliberately does not assert |
| which of the two is `cam1` and which is `cam2`* — that mapping was not verified for this release. |
| What matters downstream is that the **`cam1` ↔ `cam2` order is preserved at deploy time**, exactly |
| as recorded. |
| |
| Both stream **1280×720 (720p) @ 30 fps**, `yuv420p`; raw files are `cam1.mp4` / `cam2.mp4` |
| (**MPEG-4 encoded**, verified identical format across all 48 videos). **No depth or IR was |
| recorded** — despite the RealSense depth capability, only the RGB color stream was saved (no point |
| cloud, no depth map). The derived LeRobot copy re-encodes to AV1; RAW keeps MPEG-4. |
| |
| An **ArUco/AprilTag fiducial** is present in the cell, mounted on the **robot's base plate** — not |
| on the work surface. A UR teach pendant with E-stop and a plain white lab wall complete the |
| background. |
| |
|  |
|  |
| |
| ## Task |
| |
| **"put the cube in the cup."** The work surface holds exactly **two objects**: a **purple/lavender |
| wooden cube** (roughly 5 cm on a side) and a **sage-green plastic cup** (a tapered, planter-style |
| tumbler), both on a light wood-grain tabletop. The operator grasps the cube and drops it into the |
| cup. **Success = the cube ends up in the cup.** |
| |
|  |
| |
| Unlike the sibling [`banana_in_pot_raw`](https://huggingface.co/datasets/Bigenlight/banana_in_pot_raw) |
| dataset, there are **no distractor objects** — the scene is a clean two-object pick-and-place. (A |
| bowl of plastic fruit is visible in the setup photos, but it sits on a side cart *off* the work |
| table and is not part of the scene.) |
| |
| 23 of the 24 takes are successful demonstrations; `take_23` is a recording misfire that is |
| retained here because this is the raw release — see [Known quirks](#known-quirks). |
|
|
| ## 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 24 takes. |
|
|
| | group | native rate | rows (all takes) | fields | units / meaning | |
| |---|---|--:|---|---| |
| | `cam1_frames` | 30.0 Hz | 6,226 | `frame_idx`, `t_rel_s` | index/time of each cam1 MP4 frame | |
| | `cam2_frames` | 30.0 Hz | 6,231 | `frame_idx`, `t_rel_s` | index/time of each cam2 MP4 frame | |
| | `command` | **~98 Hz** | 20,371 | `cmd1..cmd6`, `t_rel_s` | commanded **absolute** UR joint targets (rad) | |
| | `ur_joint_states` | **~97 Hz** | 19,968 | `q1..q6`, `qd1..qd6`, `eff1..eff6`, `t_rel_s` | UR7e **follower** joint positions (rad), velocities (rad/s), efforts | |
| | `tcp_pose` | **~97 Hz** | 19,964 | `x,y,z`, `qw,qx,qy,qz`, `t_rel_s` | TCP pose in robot **base frame**: position (m) + quaternion | |
| | `wrench` | **~97 Hz** | 19,965 | `fx,fy,fz`, `tx,ty,tz`, `t_rel_s` | 6-axis end-effector force (N) + torque (N·m) | |
| | `gripper` | **~36.5 Hz** | 7,575 | `grip_pos`, `grip_cmd`, `gello_grip`, `t_rel_s` | measured opening, commanded, leader trigger | |
| | `gello_joint_states` | 30.0 Hz | 6,240 | `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 | |
|
|
| > **Faster than the banana session.** The robot-side streams here run at **~97–98 Hz**, notably |
| > faster than the ~56–60 Hz of `banana_in_pot_raw`. Anyone comparing the two datasets will see |
| > roughly **3.2 robot samples per camera frame** here versus ~2 there. 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*: about 5 % of intervals are ~2.9 ms and the median is ~13.3 ms. That is why the |
| > **mean** rate (98 Hz) is higher than the rate implied by the **median** interval (~76 Hz). Both |
| > figures are correct; they describe different things. `dataset_stats.json` reports both. |
|
|
| **Cameras:** `cam1.mp4` / `cam2.mp4`, 1280×720 RGB, 30 fps, MPEG-4. Use `cam*_frames` |
| `frame_idx` / `t_rel_s` to align frames to the vector streams. |
|
|
| > See **[`DATA_DICTIONARY.md`](DATA_DICTIONARY.md)** in this repo for the exhaustive per-field |
| > listing (every dataset key, dtype, unit, and measured value range) 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. `gello_joint_states.q*` are the **leader** joints — provided for |
| completeness but **not a valid inference input** (the deployed robot cannot see the leader). |
| - The physical robot is a **UR7e** and the derived LeRobot dataset labels it correctly as |
| `robot_type: "ur7e_gello"`. Note this differs from the older |
| [`banana_in_pot_lerobot_v3`](https://huggingface.co/datasets/Bigenlight/banana_in_pot_lerobot_v3), |
| which carries a legacy `"ur5e_gello"` label for the same physical arm. |
|
|
| ## Measured value ranges |
|
|
| Pooled over all 24 takes — the actual envelope this data covers. |
|
|
| | signal | min | max | mean | |
| |---|--:|--:|--:| |
| | `ur_q1` (rad) | 2.6016 | 3.2402 | 2.8606 | |
| | `ur_q2` (rad) | −1.7067 | −1.1299 | −1.4411 | |
| | `ur_q3` (rad) | 1.4553 | 2.3131 | 1.9832 | |
| | `ur_q4` (rad) | −2.6559 | −1.5613 | −2.2401 | |
| | `ur_q5` (rad) | −1.7499 | −1.3693 | −1.5022 | |
| | `ur_q6` (rad) | −3.7516 | −3.0714 | −3.4827 | |
| | joint velocity `qd*` (rad/s) | −0.648 | 0.663 | ≈0 | |
| | joint effort `eff*` | −7.084 | 5.802 | — | |
| | TCP `x` (m) | 0.4199 | 0.5975 | 0.5090 | |
| | TCP `y` (m) | −0.1456 | 0.1888 | −0.0019 | |
| | TCP `z` (m) | 0.1785 | 0.4873 | 0.2971 | |
| | force `fx,fy,fz` (N) | −143.19 | 63.42 | — | |
| | torque `tx,ty,tz` (N·m) | −6.882 | 3.509 | — | |
| | `grip_pos` (normalized) | 0.0118 | 0.6314 | 0.2183 | |
| | `grip_cmd` (normalized) | 0.0000 | 0.9998 | 0.3788 | |
| | `gello_grip` (normalized) | 0.0000 | 1.0000 | 0.3787 | |
|
|
| The commanded joints `cmd1..cmd6` track the measured joints closely (e.g. `cmd1` spans |
| 2.6016–3.2395 against `ur_q1`'s 2.6016–3.2402). The whole session lives in a **compact workspace**: |
| ~18 cm of TCP travel in x, ~33 cm in y, ~31 cm in z. All takes stay inside the joint safety |
| envelope. Per-channel min/max/mean/std for **every** channel is in `dataset_stats.json` and |
| `DATA_DICTIONARY.md`. |
|
|
| ## How the derived dataset is built from this |
|
|
| | dataset | contents | |
| |---|---| |
| | **raw (this repo)** | full multi-rate HDF5 + 2 MP4s — every signal above, native rates, **24** takes | |
| | [LeRobot joint](https://huggingface.co/datasets/Bigenlight/cube_in_cup_lerobot_v3) | `observation.state`(7)=`ur_q1..6`+`grip_pos`; `action`(7)=`cmd1..6`+`grip_cmd`; 2 AV1 videos, **23** episodes | |
|
|
| The LeRobot dataset is built with the same `convert_to_lerobot.py` recipe as the banana family: it |
| **resamples every stream onto the 30 fps cam1 timestamp grid** (nearest timestamp), drops the |
| `gello_*` leader streams, and re-encodes the videos to AV1. It has **23 episodes, not 24** — |
| `take_23` is excluded there (see below). This raw release keeps everything at native rate so you |
| can resample or add features yourself. |
|
|
| ## Usage |
|
|
| Read a take with `h5py`: |
|
|
| ```python |
| import h5py, cv2, numpy as np |
| |
| take = "take_03_20260720_205457" |
| 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) # (N97, 6) rad |
| cmd = np.stack([f["command"][f"cmd{k+1}"][:] for k in range(6)], axis=1) # (N98, 6) rad |
| tcp = np.stack([f["tcp_pose"][k][:] for k in "x y z qw qx qy qz".split()], 1) # (N97, 7) |
| wrench = np.stack([f["wrench"][k][:] for k in "fx fy fz tx ty tz".split()], 1) # (N97, 6) |
| grip = f["gripper"]["grip_pos"][:] # (N36,) |
| 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 RGB @ 30 fps |
| ``` |
|
|
| To go straight to training, use the ready LeRobot dataset instead |
| (`LeRobotDataset("Bigenlight/cube_in_cup_lerobot_v3")`). |
|
|
| > ⚠️ **`columns` attribute quirk.** Every group carries an attribute named `columns` that is a |
| > **single scalar JSON string**, not a list — verified `str` in all 24 files. Always |
| > `json.loads(grp.attrs["columns"])`; `list(...)` on it iterates character-by-character and yields |
| > garbage. |
|
|
| ## Known quirks |
|
|
| - **`take_23_20260720_210316` is a misfire — the one real defect in this release.** It is 1.64 s |
| long (49 cam1 frames), the UR barely moves (per-joint range < 0.013 rad, i.e. essentially |
| motionless), and the **gripper is never actuated** (`grip_pos` flat at 0.0118, `grip_cmd` flat at |
| 0.0). It contains no demonstration of the task. It is **included here** because this is the raw, |
| as-recorded release, and **excluded from** `cube_in_cup_lerobot_v3`. Drop it in any training |
| pipeline built from this repo. |
| - **Take-number gaps `{4, 6}` are by design.** Folders run `take_01` … `take_26` but takes 04 and |
| 06 were aborted/discarded during recording, giving exactly **24** folders. Do not treat the gaps |
| as missing data. |
| - **Duration outliers, not defects:** `take_01` (16.82 s) and `take_02` (16.41 s) are about **2× |
| the median take length** (8.24 s) — early, slower demonstrations. Their data is clean. |
| - **`cam1` / `cam2` frame-count mismatch:** in **16 of 24** takes the two cameras differ, by **±1 |
| frame** (±2 in `take_21`; totals 6,226 cam1 vs 6,231 cam2). The two cameras are on independent |
| clocks — map between them by nearest timestamp; **never assume `cam1[k]` and `cam2[k]` are |
| simultaneous.** Exact per-take deltas are in `DATA_DICTIONARY.md` and `dataset_stats.json`. |
| - **`synchronized/` group is empty** (0 rows) in all 24 takes, despite declaring 56 channels. |
| Fusion happens downstream at conversion time, not here. |
| - **`gello_q6` is wrapped +2π relative to `ur_q6`.** Leader joints 1–5 track the follower to within |
| ±0.011 rad, but joint 6 differs by **+6.2797 rad ≈ +2π** (`gello_q6` ∈ [2.53, 3.26] vs `ur_q6` ∈ |
| [−3.75, −3.07]) — the same physical wrist angle in a different revolution. Subtract 2π before |
| comparing leader to follower, or it looks like a massive tracking failure. |
| - `grip_pos` is normalized and never reaches 1.0 — the observed open extreme is **0.6314** (in |
| `take_09`), typical open is ~0.50, closed is 0.0118. This is the physical range the fingers |
| actually swept, not a clipping artifact. |
|
|
| ## Data quality |
|
|
| Audited over all 24 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 24 takes, **both** cameras |
| (48/48 videos) — verified with `ffprobe -count_frames`. |
| - **All takes stay within the joint safety envelope** (see measured ranges above). |
| - Timing is well behaved: the largest single gap in any robot stream is **44 ms**, and the largest |
| in any camera stream is **65 ms** (~2 frame periods). Ratio of max to median interval is 1.2–3.2× |
| per take. |
| - Schema is **identical across all 24 files** — same 9 groups, same channel names, all `float64`. |
| - Cleanliness: no stray files, no hidden files, no sub-directories inside the take folders, and no |
| `/home/` absolute-path strings inside any of the 24 H5 files. |
|
|
| No success/failure labels, no human quality ratings, and no policy-performance numbers are claimed |
| for this dataset. |
|
|
| ## Limitations & intended use |
|
|
| - **Small.** 24 takes / ~3.5 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. |
| - **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. |
| - Sampling is bursty (see the rate note above), so nearest-timestamp alignment is required rather |
| than index arithmetic. |
| - Intended for research in imitation learning, teleoperation analysis, and custom dataset |
| construction. |
|
|
| ## Related repositories (this family) |
|
|
| | repo | contents | |
| |---|---| |
| | [**Bigenlight/cube_in_cup_raw**](https://huggingface.co/datasets/Bigenlight/cube_in_cup_raw) | **this** — raw HDF5 + MP4, 24 takes | |
| | [Bigenlight/cube_in_cup_lerobot_v3](https://huggingface.co/datasets/Bigenlight/cube_in_cup_lerobot_v3) | LeRobot joint-space dataset, 23 episodes | |
| | [Bigenlight/banana_in_pot_raw](https://huggingface.co/datasets/Bigenlight/banana_in_pot_raw) | sibling raw dataset, same rig, different scene | |
|
|
| ## Citation |
|
|
| ```bibtex |
| @misc{theo2026cubeincupraw, |
| title = {cube_in_cup_raw: raw UR7e + GELLO teleoperation logs (HDF5 + MP4) for |
| "put the cube in the cup"}, |
| author = {Theo and {Bigenlight}}, |
| year = {2026}, |
| howpublished = {\url{https://huggingface.co/datasets/Bigenlight/cube_in_cup_raw}}, |
| note = {24 takes, native multi-rate HDF5 + dual RGB MP4} |
| } |
| ``` |
|
|
| License: **Apache-2.0**. |
|
|
