---
license: apache-2.0
task_categories:
- robotics
tags:
- lerobot
- LeRobot
- imitation-learning
- ur7e
- manipulation
- act
size_categories:
- 10K<n<100K
---

# banana_in_pot_ee — UR7e teleop with TCP pose + wrench (LeRobot v3.0, EE variant)

The **end-effector variant** of [`banana_in_pot`](https://huggingface.co/datasets/Bigenlight/banana_in_pot_lerobot_v3):
the **same 51 demonstrations** of "put the right banana in the pot," with two extra
observation streams — the **6-axis TCP pose** and the **6-axis force/torque wrench** —
added so you can train end-effector-space policies (e.g. HIL-SERL EE-delta) without
touching the raw logs.

- **51 episodes · 21,524 frames · 30 fps · ~11.96 min**
- Format: **LeRobot v3.0** (`lerobot` 0.6.1)
- Same episodes & videos as the main dataset; **extra features** `observation.tcp_pose` (7)
  and `observation.wrench` (6).

## Setup

Collected on a **Universal Robots UR7e** — a 6-DOF collaborative arm (joints in
**radians**) — driven by a **GELLO** 3D-printed **leader arm** for kinesthetic
teleoperation. Two Intel RealSense cameras record the scene as **RGB video only**:

- **Camera 1 — Intel RealSense D435**
- **Camera 2 — Intel RealSense D435if** (a D435 variant)

Both stream **1280×720 (720p) @ 30 fps**, `yuv420p`. One is on a **tripod** (scene view),
the other views the workspace. **No depth or IR was recorded** — only the RGB color stream
was saved. cam1 ↔ cam2 order must be preserved at deploy. An ArUco/AprilTag fiducial is on
the table.

![setup](assets/setup_01.jpg)
![setup](assets/setup_02.jpg)

## Task

**"put the right banana in the pot."** The scene contains distractors — **two bananas, an
apple, carrots/peppers, and a slice of watermelon** — and a **silver pot**. The operator
grasps the **RIGHT banana** (target) and places it in the pot.

- **Success criterion:** the right banana ends up inside the pot.
- **Distractors:** left banana, apple, carrots/peppers, watermelon slice.
- All 51 demos are successes.

## Schema

| feature | dtype | shape | meaning |
|---|---|---|---|
| `observation.state` | float32 | (7,) | UR7e measured joints `ur_q1..ur_q6` (rad) + `grip_pos` |
| `observation.tcp_pose` | float32 | (7,) | TCP pose in robot **base frame**: `x, y, z` (m) + quaternion `qw, qx, qy, qz` |
| `observation.wrench` | float32 | (6,) | end-effector force/torque: `fx, fy, fz` (N) + `tx, ty, tz` (N·m) |
| `action` | float32 | (7,) | commanded absolute joint targets `cmd1..cmd6` (rad) + `grip_cmd` |
| `observation.images.cam1` | video (AV1) | (720, 1280, 3) | viewpoint 1 (RGB, HWC uint8) |
| `observation.images.cam2` | video (AV1) | (720, 1280, 3) | viewpoint 2 (RGB, HWC uint8) |

Plus the standard LeRobot bookkeeping columns. The two extra streams are resampled onto
the same 30 fps camera clock as everything else. `tcp_pose` is the **recorded RTDE TCP**
(validated to be the flange pose, sub-mm / sub-0.2° at rest); it is the trustworthy EE
signal — no forward-kinematics approximation is involved.

> Note: LeRobot metadata records `robot_type: "ur5e_gello"` (legacy label). The physical
> robot is a **UR7e**.

## Why the EE variant

For **end-effector-space RL / HIL-SERL**, the policy action is a base-frame TCP
displacement `[Δx, Δy, Δz, gripper]`. `observation.tcp_pose` gives you the per-step TCP
position/orientation directly, so EE-delta targets can be derived as
`(p_{t+1} − p_t) / step_size` (plus the normalized gripper) with no FK needed. The task is
effectively a **3-DoF position + gripper** problem (orientation held fixed in the RL
pipeline). `observation.wrench` additionally exposes contact forces for force-aware or
safety-gated policies.

## Hardware & Collection

Identical pipeline to the main dataset: **UR7e** (6-DOF, radians) + **GELLO** leader arm;
Intel RealSense **D435** (cam1) + **D435if** (cam2), **RGB only**, 1280×720 @ 30 fps
(`yuv420p`, MPEG-4 raw → AV1 here); **no depth/IR**.

### Source stream rates (native, before resampling)

| stream | native rate | in this dataset |
|---|---|---|
| cameras (cam1, cam2) | 30 Hz | master 30 fps clock |
| `command` (UR joint targets) | ~56 Hz | → `action[0:6]` |
| `ur_joint_states` | ~56 Hz | → `observation.state[0:6]` |
| `tcp_pose` | ~56 Hz | → **`observation.tcp_pose` (7)** |
| `wrench` (6-axis F/T) | ~56 Hz | → **`observation.wrench` (6)** |
| `gripper` | ~37 Hz | → `grip_pos` / `grip_cmd` |
| `gello_joint_states` | ~30 Hz | excluded (leader-only) |

Every included stream is **resampled onto the 30 fps camera grid** by nearest-timestamp
lookup on the cam1 timeline. `gello_*` leader streams are excluded. Original takes
#9/23/30/35 are absent by design; re-takes fill the count to 51. Scale: 51 episodes /
21,524 frames / ~718 s (~12 min).

### Known quirks

- **1 take** had `NaN` `grip_cmd` (333 frames) — repaired by forward/back-fill.
- **~7 takes** have raw robot-stream dropouts (75–280 ms), giving up to ~40 ms cam↔robot
  match error at those frames; mostly harmless.
- `grip_pos` peaks at 0.898 = fully-open gripper (physical).
- The recorded `tcp_pose` vs. FK shows a small **timing-jitter** offset on fast motions
  (a logging artifact between async streams, not a kinematic error); at rest it agrees to
  sub-mm. Use the recorded `tcp_pose` as ground truth.

## Usage

```python
from lerobot.datasets.lerobot_dataset import LeRobotDataset

ds = LeRobotDataset("Bigenlight/banana_in_pot_ee_lerobot_v3")
sample = ds[0]
sample["observation.state"]      # (7,)  joints + grip
sample["observation.tcp_pose"]   # (7,)  x,y,z, qw,qx,qy,qz
sample["observation.wrench"]     # (6,)  fx,fy,fz, tx,ty,tz
sample["action"]                 # (7,)  absolute joint targets + grip
```

Train a joint-space ACT exactly as the main dataset
(`--dataset.repo_id=Bigenlight/banana_in_pot_ee_lerobot_v3 --policy.type=act …`); the extra
observations are available for EE-space methods. A trained joint-space ACT policy is at
[**Bigenlight/act_banana_in_pot**](https://huggingface.co/Bigenlight/act_banana_in_pot).

## Related repositories (this family)

| repo | contents |
|---|---|
| [Bigenlight/banana_in_pot_lerobot_v3](https://huggingface.co/datasets/Bigenlight/banana_in_pot_lerobot_v3) | main LeRobot joint-space dataset |
| [**Bigenlight/banana_in_pot_ee_lerobot_v3**](https://huggingface.co/datasets/Bigenlight/banana_in_pot_ee_lerobot_v3) | **this** — adds `observation.tcp_pose` (7) + `observation.wrench` (6) |
| [Bigenlight/banana_in_pot_raw](https://huggingface.co/datasets/Bigenlight/banana_in_pot_raw) | raw HDF5 + MP4 (all original signals, incl. GELLO leader) |
| [Bigenlight/act_banana_in_pot](https://huggingface.co/Bigenlight/act_banana_in_pot) | trained ACT policy |

## Limitations & intended use

- Single task / scene layout / operator; **all demos are successes** (no failure data).
- `tcp_pose` on fast motions carries a small timing-jitter offset (see quirks); best used
  as recorded rather than differentiated aggressively without smoothing.
- Offline metrics are strong but **real-robot closed-loop is not guaranteed** — validate
  on hardware.
- Intended for research in imitation learning, end-effector-space RL (HIL-SERL), and
  force-aware manipulation.

## Citation

```bibtex
@misc{theo2026bananainpotee,
  title        = {banana_in_pot_ee: UR7e teleoperation demonstrations with TCP pose
                  and wrench for "put the right banana in the pot"},
  author       = {Theo and {Bigenlight}},
  year         = {2026},
  howpublished = {\url{https://huggingface.co/datasets/Bigenlight/banana_in_pot_ee_lerobot_v3}},
  note         = {LeRobot v3.0 dataset, 51 episodes, EE variant}
}
```

License: **Apache-2.0**.