ExylosAi/table_spill_cleanup_bimanual

Exylos Bimanual Spill Cleanup — Rich-Modality 50-Episode Sample

50 episodes of a bimanual Franka Panda wiping a liquid spill off a tabletop. Synthetic, VR-teleop demonstrations retargeted to two 7-DoF arms — 6 RGB views (3 with depth + segmentation), 6-DoF object poses, and a ground-truth dirty_fraction cleanliness signal, packaged in LeRobot v2.1.

Release note: this rich-modality v2 release replaces the original public 50-episode preview in place. The previous dataset remains reproducible at legacy-public-v1. The v2 release contains a different episode set, camera rig, outcome distribution, and frame schema; consumers requiring the original files should pin that tag.

✅ Use it / ❌ Skip it

Use it for

• Fine-tuning a bimanual-Franka manipulation policy (ACT, Diffusion Policy, π0, VLA) on a contact-rich wiping task.
• Perception: depth + 7-class segmentation + 6-DoF object poses + a ground-truth dirty_fraction cleanliness signal.
• Failure detection / reward modeling: 35 of 50 episodes are incomplete cleanups — labeled negatives are included on purpose.
• Pipeline validation / inspection-scale experiments for checking loaders, modalities, annotations, bimanual coordination signals, and sim-to-real research fit before requesting a larger training-scale release.

Skip it if you need

• A from-scratch training corpus — 50 episodes (15 clean successes) is a fine-tune/eval-scale sample, not a large BC dataset.
• Force / torque / tactile signals — not included in this release.
• A non-Franka embodiment without retargeting, or real-world sensor data (this is synthetic).

At a glance

Episodes / frames	50 / 115,204 (≈64 min @ 30 FPS)
Outcome split	15 success / 35 cleanup-incomplete (next.success, episode.termination_reason)
Success threshold	Episode success means terminal liquid_spill.dirty_fraction <= 0.01 (<=1% dirty area); otherwise the termination reason is cleanup_incomplete.
Robot	Bimanual Franka Emika Panda, 2× 7-DoF + parallel grippers
Action	18-D absolute joint-position targets @ 30 Hz = 2×(7 joints + 2 gripper); plus 28-D end-effector action
Observation	18-D joint state, 16-D EE state, per-arm EE pose (local + world), per-object 6-DoF poses
Cameras	6 RGB: front_cam, head_cam, left_cam_45, right_cam_45, wrist_cam_l, wrist_cam_r — 1280×960 H.264
Depth / segmentation	3 views each (wrist_cam_l, head_cam, wrist_cam_r); seg = 7 classes
Task / language	1 task instruction + frame-level phase & subtask labels (838 phase / 76 subtask records)
Format	LeRobot v2.1 — Parquet + MP4 + NPZ + MKV + JSON/CSV metadata
Download footprint	~209 GB full repo (depth NPZ ≈189 GB, RGB ≈19 GB, masks ≈1 GB); default load_dataset pulls only ~62 MB of parquet (references, not media)
License	Apache 2.0

Ready to use out of the box: LeRobot v2.1 layout, normalization stats for the proprio/action vectors (min/max/mean/std/count) precomputed in meta/episodes_stats.jsonl, named joints/EE channels, and documented TCP + coordinate frames in meta/info.json / meta/cameras.json.

Verify these numbers in 60 seconds

import json
from huggingface_hub import hf_hub_download

repo = "ExylosAi/table_spill_cleanup_bimanual"
info = json.load(open(hf_hub_download(repo, "meta/info.json", repo_type="dataset")))
print(info["robot_type"], info["fps"], info["total_episodes"], info["total_frames"])
# -> panda 30.0 50 115204

stats = [json.loads(l) for l in open(hf_hub_download(repo, "meta/episodes_stats.jsonl", repo_type="dataset"))]
print("episodes with stats:", len(stats), "| stat keys:", list(stats[0]["stats"]["action"]))
# -> episodes with stats: 50 | stat keys: ['min', 'max', 'mean', 'std', 'count']

Load it

import json
from datasets import load_dataset

repo = "ExylosAi/table_spill_cleanup_bimanual"
frames = load_dataset(repo, split="train")    # flattened viewer config (~62 MB, references only)
row = frames[0]
print(row["observation.state"])               # 18-D joint state (typed array)
print(row["action.end_effector"])             # 28-D EE action (typed array)
print(row["observation.images.front_cam.path"])

# In the flattened config, nested fields arrive as JSON strings — parse them:
poses = json.loads(row["observation.object_poses"])   # also: ee_pose, ee_pose_world
spill = next(obj for obj in poses if obj["object_id"] == "liquid_spill")
print(spill["object_id"], spill["dirty_fraction"])

The canonical data/ parquet (read with PyArrow) keeps these same fields as native list<struct>; json.loads is only needed for the flattened datasets config.

For canonical LeRobot-style per-episode loading (Arrow map fields → read with PyArrow), plus videos and episodes viewer configs, see examples/quickstart.ipynb and the helper scripts:

python tools/load_episode.py     --repo-id ExylosAi/table_spill_cleanup_bimanual --episode 0 --summary
python tools/plot_trajectories.py --repo-id ExylosAi/table_spill_cleanup_bimanual --episode 0 --out-dir outputs

What you get

• 6 RGB views — front_cam, head_cam, left_cam_45, right_cam_45, wrist_cam_l, wrist_cam_r (30 FPS, 1280×960, no audio).
• Depth — float32 metric depth for wrist_cam_l, head_cam, wrist_cam_r (packed NPZ, referenced per frame).
• Segmentation — FFV1 MKV label-map streams for the same 3 views; 7 classes (see below).
• Dual-arm state/action — 18-D joint observation.state and action; gripper open-scale, semantic mode, and activity labels per arm (hysteresis defined in meta/info.json).
• End-effector — packed 16-D state.end_effector / 28-D action.end_effector, plus explicit per-arm observation.ee_pose (robot-local) and observation.ee_pose_world. TCP = gripper grasp center; frames follow ROS REP 103.
• Object state — per-frame observation.object_poses (sponge, cup/obstacle, liquid_spill) with positions, orientations, linear velocities, and liquid_spill.dirty_fraction ∈ [0,1] as a ground-truth cleanliness label. An episode is marked successful when the terminal liquid_spill.dirty_fraction <= 0.01 (<=1% dirty area).
• Annotations & QA — per-episode success/failure + termination reason, plus quality scores, raw measurements, and frozen-frame counts in annotations.json; frame-level phase & subtask ranges in metadata.csv / subtask_metadata.csv.
• Calibration — intrinsics, lens params, and static extrinsics for all 6 cameras in meta/cameras.json.

Frame-level Parquet schema (click to expand)

Each row is one synchronized frame. The viewer_data mirror exposes the same rows in a flattened, datasets-friendly schema.

Column	Type	Meaning
timestamp / frame_index / episode_index / index	scalar	time + indices
task_index	int64	task ID (meta/tasks.jsonl)
next.done / next.success	bool	terminal / success markers
observation.state	float32[18]	bimanual joint + gripper state
action	float32[18]	bimanual joint + gripper target (absolute)
state.end_effector	float32[16]	packed EE position/orientation/gripper
action.end_effector	float32[28]	absolute pose + delta pose + gripper command
observation.ee_pose / observation.ee_pose_world	list[2]	per-arm EE pose (local / world)
observation.object_poses	list[3]	object poses, velocities, dirty_fraction
gripper_*	[2]	per-arm open-scale / mode / activity (state & action)
observation.images.*	video/struct	RGB stream ref + timestamp
observation.depths.*	struct{path,timestamp}	ref to packed float32 metric-depth NPZ (wrist_l / head / wrist_r)
observation.masks.*	struct{path, label_map}	ref to FFV1 MKV label-map stream

Exact packed-vector slices for the EE channels are in meta/modality.json; joint and EE channels are named in meta/info.json (left_panda_joint1 …).

In the canonical data/ parquet, observation.object_poses / ee_pose / ee_pose_world are native list<struct>. In the flattened viewer_data mirror (what load_dataset returns) they are serialized as JSON strings — apply json.loads.

Segmentation labels: 0 background · 1 left_franka_panda · 2 right_franka_panda · 3 sponge · 4 liquid_spill · 5 cup · 6 table_surface

Scaling up

This 50-episode release is an inspection-scale slice of a larger generation pipeline backed by 10,000+ hours of human-seeded trajectories. A training-scale release — more episodes, more tasks, additional randomization, and USD/Isaac scene assets — can be provided on request.

The full release is schema-identical to this sample: validate your loaders and policies on these 50 episodes, then scale up without changing a line of code.

File layout

meta/            info.json · modality.json · cameras.json · tasks.jsonl · episodes.jsonl · episodes_stats.jsonl
data/            chunk-000/episode_*.parquet          # canonical LeRobot frames
viewer_data/     chunk-000/episode_*.parquet          # flattened mirror (default config)
viewer_index/    metadata.parquet                     # "episodes" config
viewer_videos/   train.parquet                        # "videos" config
videos/          chunk-000/<cam>/episode_*.mp4 + depth NPZ + segmentation MKV
annotations/     gripper + phase annotation files
tools/           load_episode.py · plot_trajectories.py
examples/        quickstart.ipynb
metadata.csv · subtask_metadata.csv · annotations.json · agent_manifest.json

Path templates:

data:   data/chunk-{chunk:03d}/episode_{index:06d}.parquet
videos: videos/chunk-{chunk:03d}/{video_key}/episode_{index:06d}.mp4

Notes & limitations

• Synthetic data with domain randomization across 8 axes (distractor layouts, object poses, initial states, physics, lighting, environment, materials, sensor noise); no real-world sensor captures in this release. sim-to-real is an intended use case, not a claim of real data.
• Language is task-level (1 instruction) plus frame-level phase/subtask labels — not a large free-form language corpus.
• Heavy media: full repo ≈209 GB (depth NPZ ≈189 GB). load_dataset reads only the ~62 MB of parquet references — fetch videos/ (RGB/depth/masks) only for the views and episodes you actually need.
• No force/torque/contact/tactile streams in this release.
• Canonical frame-level Parquet uses Arrow map fields for segmentation; some datasets versions can't infer this — use PyArrow for canonical loading, or the default flattened config for datasets.

Citation

If you use this dataset, please cite the repository and the snapshot revision (commit hash) used in your experiments.