Datasets:

flex-pi
/

soft_bag_zipping

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

soft_bag_zipping

Deformable-object manipulation: unzip a soft bag, insert pens one at a time, then zip the bag closed.

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	534
Frames	1,047,427
Duration	~9.7 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

Unzip the bag, pick up the pens from the table one at a time and place them inside, then zip the bag closed.

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 .. 533, chunked at 1000 episodes (1 chunk). The parquet index column is a global frame counter running 0 .. 1,047,426 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.12	320.51	183.18
`cam_left_wrist`	365.72	365.50	318.08	182.79
`cam_right_wrist`	366.90	366.68	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:

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:

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

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

Provenance

Built from source recordings put_pen_into_green_bag_V2, put_pen_into_grey_bag_v2, put_pen_into_pink_bag_V2, put_pen_into_grey_and_purple_bag_V2, put_pen_into_orange_and_green_bag_V2.

Citation

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