File size: 4,402 Bytes
9f41683 a328457 9f41683 a328457 9f41683 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 | ---
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.
|