---
license: cc-by-4.0
task_categories:
- robotics
tags:
- LeRobot
- robotics
- manipulation
- yam
- depth
- bimanual
configs:
- config_name: default
  data_files: data/*/*.parquet
---

# self_repair_gripper_bc

Robot self-repair, human teleoperation (BC): install a gripper into an empty holder, drive a screw with a screwdriver, then clear the table.

Real-robot bimanual manipulation data collected on a **YAM** arm pair, released as part
of the Flex-π project. Stored in **LeRobot v2.1** format with **synchronized RGB and
metric depth** from three cameras.

## At a glance

| | |
|---|---|
| Episodes | 802 |
| Frames | 1,278,804 |
| Duration | ~11.8 h @ 30 fps |
| Tasks | 1 |
| Robot | `yam` (bimanual) |
| Cameras | `cam_high`, `cam_left_wrist`, `cam_right_wrist` |
| RGB | 640×360, H.264 `.mp4` |
| Depth | 640×360, FFV1 `.mkv`, uint16 **millimetres** |
| State / action | 32-D / 32-D |
| LeRobot version | `v2.1` |

## Tasks

0. Pick up the gripper from the table and insert it into the empty holder that is missing its gripper. Then pick up a screw, insert it into the mounting hole, and use the screwdriver to tighten it. Finally, clean up the table by picking up the vegetable and placing it on the rack.

## Layout

```
meta/
  info.json              # feature schema, totals, chunking
  tasks.jsonl            # task_index -> natural-language instruction
  episodes.jsonl         # per-episode length + task
  episodes_stats.jsonl   # per-episode min/max/mean/std for state & action
  camera_intrinsics.json # per-camera pinhole K at stored resolution
data/chunk-{NNN}/episode_{NNNNNN}.parquet
videos/chunk-{NNN}/observation.images.{cam}/episode_{NNNNNN}.mp4   # RGB
videos/chunk-{NNN}/observation.depth_ffv1.{cam}/episode_{NNNNNN}.mkv # depth
```

Episodes are indexed `0 .. 801`, chunked at
1000 episodes (1 chunk).
The parquet `index` column is a **global** frame counter running
`0 .. 1,278,803` across the whole dataset.

## Camera intrinsics

Pinhole `K` at the stored 640×360 resolution, averaged over episodes:

| camera | fx | fy | cx | cy |
|---|---|---|---|---|
| `cam_high` | 262.28 | 262.12 | 320.51 | 183.18 |
| `cam_left_wrist` | 365.72 | 365.50 | 318.08 | 182.79 |
| `cam_right_wrist` | 366.90 | 366.67 | 324.67 | 171.96 |

## Reading the depth

> **The depth streams are an extension to stock LeRobot.** They are declared with
> `dtype: "depth_video"` (not `"video"`) in `meta/info.json` precisely so that the
> stock `LeRobotDataset` loader skips them — you get a working RGB dataset out of the
> box, and depth needs the decoder below.

Each depth frame is a single-channel **uint16, millimetre** map, FFV1-encoded in
`gray16le` inside a Matroska container. `0` means no return. To decode a frame:

```python
import av, numpy as np

with av.open("videos/chunk-000/observation.depth_ffv1.cam_high/episode_000000.mkv") as c:
    for frame in c.decode(video=0):
        depth_mm = frame.to_ndarray(format="gray16le").astype(np.uint16)  # (H, W)
        depth_m = depth_mm.astype(np.float32) / 1000.0
```

FFV1 is lossless, so the decoded values are bit-exact with what the sensor reported.
Do **not** transcode these to a lossy codec.

## State and action layout

`observation.state` and `action` are both 32-D. The vector is grouped **by field**, not
by arm:

| index | contents |
|---|---|
| `0:3` | `left_pos_{x,y,z}` — left end-effector position |
| `3:9` | `left_rot6d_{0..5}` — left end-effector rotation, 6-D representation |
| `9:12` | `right_pos_{x,y,z}` |
| `12:18` | `right_rot6d_{0..5}` |
| `18:20` | `left_gripper`, `right_gripper` |
| `20:26` | `left_joint_{0..5}` |
| `26:32` | `right_joint_{0..5}` |

The authoritative per-dimension names are in `meta/info.json` under
`features.observation.state.names`. The 6-D rotation is the **first two rows** of the
3×3 rotation matrix, row-major flattened (Zhou et al., *On the Continuity of Rotation
Representations*); recover `R` by Gram–Schmidt on those two rows and their cross
product.

## Loading

RGB only, with stock LeRobot:

```python
from lerobot.common.datasets.lerobot_dataset import LeRobotDataset
ds = LeRobotDataset("flex-pi/self_repair_gripper_bc")
```

RGB + depth: use the depth-aware loader from the Flex-π codebase.

## Provenance

Built from source recordings
`self_repair_gripper_V2`, `self_repair_gripper_yellow_screw_holder_bc`.

## Citation

If you use this dataset, please cite the Flex-π project.