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

# kitchen_organization

Multi-task kitchen tidying (3 tasks): placing plates, cups and spoons onto a dish rack, including a hand-to-hand pass.

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 | 248 |
| Frames | 146,025 |
| Duration | ~1.4 h @ 30 fps |
| Tasks | 3 |
| 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 plate on the table, pass the plate to anther hand and put them onto the rack.
1. Pick up the cup on the table and put them onto the rack.
2. Pick up the spoon on the table one by one and put them onto 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 .. 247`, chunked at
1000 episodes (1 chunk).
The parquet `index` column is a **global** frame counter running
`0 .. 146,024` 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.27 | 262.11 | 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/kitchen_organization")
```

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

## Provenance

Built from source recordings
`uniflow_pass_and_put_plate_on_the_rack`, `uniflow_put_cup_on_the_rack`, `uniflow_put_plate_on_the_rack`, `uniflow_put_spoon_on_rack`.

## Citation

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