README.md

---
license: apache-2.0
task_categories:
- robotics
tags:
- LeRobot
- ur10e
- robotiq
- manipulation
- vla
- teleoperation
configs:
- config_name: default
  data_files: data/*/*.parquet
---

# UR10e Multitask Teleop

335 teleoperated manipulation episodes on a Universal Robots UR10e with a Robotiq 2F gripper, covering 7 tabletop tasks. Packaged in LeRobot v2.1 format with precomputed normalization statistics, so it can be dropped into a VLA finetuning run the same way LIBERO is.

| | |
|---|---|
| Episodes | 335 |
| Frames | 60,416 |
| Tasks | 7 |
| Control rate | 15 fps |
| Robot | UR10e, 6-DoF, Robotiq 2F gripper |
| Cameras | 2 exterior (Azure Kinect) + 1 wrist (RealSense) |
| Image size | 180 x 320 x 3 |
| Format | LeRobot `codebase_version` v2.1 |
| Size | ~14 GB |

### Episodes per task

| Task instruction | Episodes |
|---|---|
| `put the pen in the bin` | 55 |
| `stack the blue block on the gray block` | 50 |
| `stack the blocks of same color` | 50 |
| `pick up the plushie and place in bowl` | 49 |
| `stack the gray block on the blue block` | 48 |
| `put the knife in the tray` | 42 |
| `put the spoon in the tray` | 41 |

Every episode in this release is a successful demonstration. Failed attempts were filtered out during conversion, so there are no negative examples here.

---

## Quick start

```python
from datasets import load_dataset

ds = load_dataset("bag100/ur10e-multitask", split="train")
print(ds)
sample = ds[0]
print(sample["joint_position"], sample["actions"])
```

Or with LeRobot:

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

ds = LeRobotDataset("bag100/ur10e-multitask")
print(ds.meta.info)
```

Download the raw files instead:

```bash
hf download bag100/ur10e-multitask --repo-type dataset --local-dir ./ur10e-multitask
```

---

## The data contract

This is the section to read before wiring the dataset into any model. Three details will silently corrupt a training run if you miss them.

### Feature schema

| Key | dtype | Shape | Meaning |
|---|---|---|---|
| `exterior_image_1_left` | image | (180, 320, 3) | **Overhead / bird view.** Primary camera. |
| `exterior_image_2_left` | image | (180, 320, 3) | **Side view.** Secondary camera. |
| `wrist_image_left` | image | (180, 320, 3) | Wrist-mounted RealSense |
| `joint_position` | float32 | (7,) | 6 joint angles in radians, then 1 zero pad |
| `gripper_position` | float32 | (1,) | Normalized aperture in [0, 1] |
| `actions` | float32 | (8,) | 6 joint velocities in rad/s, 1 zero pad, 1 gripper target |
| `timestamp` | float32 | (1,) | Seconds from episode start |
| `frame_index`, `episode_index`, `index`, `task_index` | int64 | (1,) | LeRobot bookkeeping |

Images are stored as encoded bytes inside the parquet files. There are no separate `.mp4` video files, and `total_videos` is 0 in `meta/info.json`.

### Detail 1: the camera slots are intentionally swapped

The names are inherited from DROID, and the physical mapping does not follow the numbering:

- `exterior_image_1_left` holds the **overhead bird view** (`camera_1` on the rig)
- `exterior_image_2_left` holds the **side view** (`camera_0` on the rig)

This swap is deliberate. In DROID-matched 2-camera configurations the second exterior slot gets zeroed and masked, so the view the model should actually rely on was placed in slot 1 to keep it from being the dropped camera. If you build a single-exterior-camera pipeline, use `exterior_image_1_left`.

One caveat carried over from the conversion source: the mapping assumes `camera_1` was the bird view on this rig. That assumption was not independently re-verified against the recorded footage. If overhead versus side matters to your setup, inspect a few frames before committing to it.

### Detail 2: index 6 is a permanent zero pad

The UR10e is a 6-DoF arm. `joint_position` is 7-wide and `actions` is 8-wide because the layout mirrors DROID's 7-DoF Franka, which keeps the tensors compatible with checkpoints pretrained on DROID.

Index 6 is therefore **always exactly 0.0** in both `joint_position` and `actions`. It carries no information. Verified across a 40-episode random sample at packaging time.

### Detail 3: the zero pad has zero standard deviation

Because index 6 never varies, its entry in `norm_stats.json` is `mean = 0.0` and `std = 0.0`.

Any normalizer written as `(x - mean) / std` will emit `NaN` on that dimension and the NaN will propagate through your loss within one step. Guard it with an epsilon:

```python
normalized = (x - mean) / (std + 1e-6)
```

openpi already does this in `src/openpi/transforms.py`. If you are integrating a different stack, confirm the guard exists before your first training run.

### Action semantics

`actions[0:6]` are **joint velocities in rad/s**, not positions and not deltas. They were taken from RTDE `actual_qd` where recorded, and reconstructed by finite differences of measured joint positions for earlier episodes where the velocity field was an all-zero placeholder. Observed range across a 40-episode sample is roughly ±0.7 rad/s.

`actions[7]` is the gripper target in [0, 1], where 0 is open and 1 is closed. It **leads** the observed `gripper_position` by one timestep. This is intentional: labeling the gripper action with the current frame lets a model drive its loss to zero by copying state straight to action, after which the gripper never actuates at deploy time. If you re-derive gripper labels yourself, preserve this lookahead.

### Timing

Episodes were captured at varying teleop loop rates and resampled onto a uniform 15 fps grid by nearest-neighbor frame selection. Velocities remain physically correct because they were measured or differenced against real timestamps before resampling.

---

## Normalization

`norm_stats.json` ships at the repo root. It contains `mean`, `std`, `q01`, and `q99` for `state` (8-dim: 7 joint slots plus gripper) and `actions` (8-dim), computed over all 60,416 frames.

```json
{"norm_stats": {"state": {"mean": [...], "std": [...], "q01": [...], "q99": [...]},
                "actions": {"mean": [...], "std": [...], "q01": [...], "q99": [...]}}}
```

Two conventions are supported by the same file:

- **Mean/std normalization** for Gaussian-style action heads
- **Quantile normalization** using `q01`/`q99` mapped to [-1, 1], which is what pi0 and pi05 use by default. Quantiles are more robust here because teleop velocity distributions are heavy-tailed around direction reversals.

Recomputing these from the dataset is straightforward if your stack prefers its own statistics. They are provided so results are reproducible without a preprocessing pass over 14 GB.

---

## Integrating with any VLA

What a model needs to supply or adapt:

**Observation.** Three RGB images at 180x320 plus an 8-dim proprioceptive state formed by concatenating `joint_position` (7) with `gripper_position` (1). If your model takes fewer cameras, drop `exterior_image_2_left` first and keep `exterior_image_1_left` as the primary.

**Action space.** 8-dim, joint-velocity control. Models that expect end-effector deltas need forward kinematics applied against the UR10e DH parameters, plus integration of the velocities. Models that expect absolute joint positions need the velocities integrated against the 15 fps timestep. Neither conversion is provided here.

**Action horizon.** The data supports any chunk length. The reference pi05 configuration uses a horizon of 16 at 15 fps, roughly one second of lookahead.

**Padding to wider action dims.** Models with a fixed wider action dimension, such as pi0's 32, should zero-pad from index 8 onward and mask the padded entries in the loss. Index 6 is already inert and can be left in place.

**Language conditioning.** The task string is available per frame via `task_index` resolved through `meta/tasks.jsonl`. Prompts are plain natural language and are used verbatim as the instruction.

**Recommended sanity checks before a long run.** Confirm no NaN after normalization, confirm your dataloader is not shuffling frames across episode boundaries when building action chunks, and overfit a single episode to near-zero loss before scaling up.

---

## Appendix: pi05 via openpi

Included because the dataset was built against openpi and every command below is reproducible from the reference configuration.

Place the dataset where LeRobot looks for it:

```bash
hf download bag100/ur10e-multitask --repo-type dataset \
  --local-dir ~/.cache/huggingface/lerobot/local/ur10e_multitask
```

Install the shipped normalization statistics so the compute pass can be skipped:

```bash
mkdir -p ./assets/pi05_ur10e_multitask/local/ur10e_multitask
cp norm_stats.json ./assets/pi05_ur10e_multitask/local/ur10e_multitask/
```

The path is load-bearing. openpi resolves it as `<assets_dir>/<asset_id>/norm_stats.json`, where `assets_dir` is `./assets/pi05_ur10e_multitask` and `asset_id` is `local/ur10e_multitask`.

To recompute instead:

```bash
uv run scripts/compute_norm_stats.py --config-name pi05_ur10e_multitask
```

Train:

```bash
XLA_PYTHON_CLIENT_MEM_FRACTION=0.9 uv run scripts/train.py \
  pi05_ur10e_multitask --exp-name=ur10e_multitask_v1
```

Reference hyperparameters for full finetuning from the `pi05_droid` checkpoint: action dim 32, action horizon 16, cosine decay with 1,000 warmup steps, peak LR 2.5e-5 decaying to 2.5e-6 over 20,000 steps, global batch 256 across 8 GPUs via FSDP, EMA decay 0.99.

A LoRA variant is also available under the config name `pi05_ur10e_multitask_lora`, using `gemma_2b_lora` and `gemma_300m_lora`, peak LR 1.5e-4, and no EMA. It fits on a single 80 GB GPU when the batch size is reduced.

---

## Limitations

- **Single rig, single scene.** One UR10e in one lab environment with fixed camera placement. Expect little out-of-the-box transfer to other robots or viewpoints.
- **Successes only.** No failure demonstrations, so this dataset does not support failure detection or recovery training.
- **Small by VLA standards.** 60k frames is a finetuning dataset. It is not sufficient to train from scratch.
- **No depth.** Both exterior cameras are Azure Kinects and the wrist is a RealSense, but only RGB was retained.
- **Aspect ratio handling.** The Kinect frames were captured at 720p, stretched to 640x480 at collection time, then stretched to 320x180 here, which restores native 16:9. The wrist camera is natively 4:3 and receives the same 320x180 stretch. This matches the distortion applied at deploy time, so train and inference geometry agree. Reusing these images in a different deploy pipeline requires reproducing that treatment.
- **Two tasks were dropped.** `pick up the silverware` and `stack the gold bars` were set up during collection but produced no usable episodes, so they do not appear.

## Provenance

Collected 2026-07-24 to 2026-07-25 by teleoperation. Converted to LeRobot v2.1 with `examples/ur10e/convert_teleop_to_lerobot.py` from openpi. Normalization statistics computed 2026-07-25 over all 335 episodes.

## Citation

```bibtex
@misc{ur10e_multitask_2026,
  title  = {UR10e Multitask Teleop},
  author = {bag100},
  year   = {2026},
  url    = {https://huggingface.co/datasets/bag100/ur10e-multitask}
}
```