README.md

metadata

license: apache-2.0
language:
  - en
pretty_name: Exylos Bimanual Table Spill Cleanup Rich-Modality 5ep Sample
size_categories:
  - n<1K
task_categories:
  - robotics
configs:
  - config_name: default
    default: true
    data_files:
      - split: train
        path: viewer_data/chunk-000/*.parquet
  - config_name: videos
    data_files:
      - split: train
        path: viewer_videos/train.parquet
tags:
  - video
  - image
  - timeseries
  - depth
  - depth-maps
  - lerobot
  - robot-learning
  - imitation-learning
  - manipulation
  - bimanual-manipulation
  - spill-cleanup
  - liquid-spill
  - wiping
  - sponge
  - multi-view
  - segmentation
  - instance-segmentation
  - object-poses
  - 6dof
  - success-metric
  - vr-teleoperation
  - human-in-the-loop
  - human-seeded
  - synthetic
  - sim-to-real
  - visual-domain-randomization
  - domain-randomization
  - franka
  - panda
  - dual-arm
  - exylos
  - parquet
  - npy
  - png
  - mp4
  - time-series
  - trajectories
  - state-action
  - phase-annotations
  - failure-labels

Exylos Bimanual Table Spill Cleanup Rich-Modality Sample

A compact, rich-modality bimanual robot manipulation dataset for tabletop spill cleanup. Each episode combines synchronized dual-arm Panda state/action trajectories, 7 RGB camera streams, per-frame depth maps, per-frame segmentation masks, object pose streams, phase annotations, and an objective cleanup success metric based on the remaining spill fraction.

This dataset is a rich-modality inspection sample for the Exylos table-spill cleanup task. A human-in-the-loop demonstration is captured in VR, retargeted to a bimanual Franka Panda robot embodiment, and exported in a LeRobot-compatible layout for direct inspection and training experiments.

The task is simple to state and useful for robotics pipelines: clear any obstructing object if needed, then wipe a liquid spill from the table surface with a sponge. The dataset includes both successful and failed attempts, with failure labels and per-frame measurements that make the outcome auditable.

For the Hugging Face Dataset Viewer, viewer_data/chunk-000/*.parquet provides a schema-compatible preview mirror of the frame-level data. The canonical LeRobot episode parquet files remain in data/chunk-000/*.parquet, with external assets referenced under videos/.

---

Full Release & Main 50-Episode Preview

This is a 5-episode rich-modality preview focused on RGB video, depth maps, segmentation masks, object poses, object states, and cleanup metrics.

For broader behavior coverage, use the main 50-episode public preview:

Open the 50-episode table-spill cleanup dataset

-> Request access / share what you need (60 seconds)

For full-release requirements, reply in the main dataset Discussion: What would make the full release useful for your pipeline?

For rich-modality notes specific to this sample, use this Discussion: Rich-modality sample: depth, masks, and object poses

---

Included signals

Each episode is packaged as a synchronized rich-modality robot trajectory with dense visual observations, robot state/action streams, object-state labels, and task outcome metadata:

• Per-frame depth maps stored as external float32 .npy files and referenced from parquet.
• Per-frame segmentation masks stored as 8-bit grayscale .png label maps and referenced from parquet.
• Seven RGB camera views, including 5 fixed scene cameras and right and left wrist cameras.
• Per-frame object pose stream, observation.object_poses, with object 6DoF pose labels for interactable objects.
• Objective cleanup metric, stored as dirty_fraction for the liquid_spill object.
• Success/failure semantics tied to cleanup quality: an episode is successful when the terminal dirty_fraction <= 0.01, meaning 1% or less of the original spill remains.

---

Dataset summary

Property	Value
Episodes	5
Total frames	6,736
Total duration	224.37 seconds, about 3.74 minutes
Task	Remove obstructing objects if needed and wipe the spilled liquid from the tabletop with a sponge
Robot embodiment	Bimanual Franka Emika Panda setup, two 7-DoF arms plus parallel grippers
FPS	30
RGB camera views	7 synchronized MP4 streams
RGB video	H.264, 1280 x 960, no audio
Depth views	4 per-frame NPY streams
Segmentation views	4 per-frame PNG streams
Robot state	18-dimensional
Action vector	18-dimensional
Object-state stream	Per-frame observation.object_poses list with sponge, cup, and liquid_spill
Rigid object 6DoF labels	Sponge and cup include 3D position plus quaternion orientation
Cleanup metric	liquid_spill.dirty_fraction, range 0.0 to 1.0
Success criterion	Terminal dirty_fraction <= 0.01
Outcome mix	3 success episodes, 2 failure episodes
Failure reasons	2 cleanup-incomplete failures
Frozen frames	609 total frozen frames across 4 episodes
Phase-level annotations	approach, grasp, transport, place, clean_surface, clean_swipe_pass, retract, handover, collision, task_attempt
Format	LeRobot-compatible Parquet + MP4 + NPY + PNG
License	Apache 2.0

---

File layout

README.md
annotations.json
meta/
  info.json
  tasks.jsonl
  episodes.jsonl
  episodes_stats.jsonl
data/
  chunk-000/
    episode_000000.parquet
    episode_000001.parquet
    episode_000002.parquet
    episode_000003.parquet
    episode_000004.parquet
videos/
  chunk-000/
    observation.images.front_cam/
      episode_000000.mp4
      ...
    observation.images.left_cam/
      episode_000000.mp4
      ...
    observation.images.left_cam_45/
      episode_000000.mp4
      ...
    observation.images.right_cam/
      ...
    observation.images.top_cam/
      ...
    observation.images.wrist_cam_l/
      ...
    observation.images.wrist_cam_r/
      ...
    observation.depths.top_cam_seg/
      episode_000000/
        top_cam_seg.FinalImageDepth.0000.npy
        ...
    observation.depths.left_cam_45_seg/
      ...
    observation.depths.wrist_cam_l_seg/
      ...
    observation.depths.wrist_cam_r_seg/
      ...
    observation.masks.top_cam_seg/
      episode_000000/
        top_cam_seg.FinalImageStencil.0000.png
        ...
    observation.masks.left_cam_45_seg/
      ...
    observation.masks.wrist_cam_l_seg/
      ...
    observation.masks.wrist_cam_r_seg/
      ...

The videos/ directory contains RGB videos as well as external depth and segmentation assets. Depth and mask files are referenced from parquet rows using relative paths.

---

Modalities

RGB video streams

Each episode contains 7 synchronized RGB MP4 streams:

observation.images.front_cam
observation.images.left_cam
observation.images.left_cam_45
observation.images.right_cam
observation.images.top_cam
observation.images.wrist_cam_l
observation.images.wrist_cam_r

All RGB videos are 1280 x 960 H.264 streams at 30 FPS.

Depth maps

Depth maps are stored as float32 .npy arrays in meters:

observation.depths.top_cam_seg        shape: 467 x 640
observation.depths.left_cam_45_seg    shape: 467 x 640
observation.depths.wrist_cam_l_seg    shape: 480 x 640
observation.depths.wrist_cam_r_seg    shape: 480 x 640

Each parquet row contains a struct with the depth file path and timestamp:

observation.depths.top_cam_seg.path
observation.depths.top_cam_seg.timestamp

Segmentation masks

Segmentation masks are stored as 8-bit grayscale .png label maps:

observation.masks.top_cam_seg
observation.masks.left_cam_45_seg
observation.masks.wrist_cam_l_seg
observation.masks.wrist_cam_r_seg

The label map is:

Label	Class
0	background
1	left_franka_panda
2	right_franka_panda
3	sponge
4	liquid_spill
5	cup
6	table_surface

Each mask field is a parquet struct with:

instance_segmentation: relative PNG path
label_map: map from integer label to class name

Robot state and action

The robot state and action streams are 18-dimensional float32 vectors:

observation.state
action

Motor order:

left_panda_joint1
left_panda_joint2
left_panda_joint3
left_panda_joint4
left_panda_joint5
left_panda_joint6
left_panda_joint7
left_panda_finger_joint1
left_panda_finger_joint2
right_panda_joint1
right_panda_joint2
right_panda_joint3
right_panda_joint4
right_panda_joint5
right_panda_joint6
right_panda_joint7
right_panda_finger_joint1
right_panda_finger_joint2

Object poses and cleanup metric

The per-frame object-state stream is stored in:

observation.object_poses

It is a list of 3 objects per frame:

sponge
cup
liquid_spill

Object fields:

object_id
position          float32[3], meters, right-handed world frame
orientation       float32[4], quaternion_xyzw, nullable
velocity_linear   float32[3], meters/second, nullable
dirty_fraction    float32, nullable

The sponge and cup are interactable rigid objects and include 6DoF pose labels: 3D position plus quaternion orientation. The liquid_spill is tracked as a task-state object: it includes position and the remaining dirty fraction, but its orientation is null.

The objective cleanup metric is:

liquid_spill.dirty_fraction

This value is a fraction in [0.0, 1.0], where:

• 1.0 means 100% of the original dirty area remains.
• 0.01 means 1% remains.
• 0.0 means the spill is fully cleaned.

Episode success is determined from the terminal frame:

success = terminal_dirty_fraction <= 0.01

The next.success field matches this criterion on the final frame of each episode.

---

Parquet schema

Each episode parquet contains 25 columns:

timestamp
frame_index
episode_index
index
task_index
next.done
next.success
observation.state
action
observation.object_poses
observation.images.front_cam
observation.images.left_cam
observation.images.top_cam
observation.images.right_cam
observation.images.wrist_cam_l
observation.images.wrist_cam_r
observation.images.left_cam_45
observation.masks.top_cam_seg
observation.masks.wrist_cam_l_seg
observation.masks.wrist_cam_r_seg
observation.masks.left_cam_45_seg
observation.depths.top_cam_seg
observation.depths.wrist_cam_l_seg
observation.depths.wrist_cam_r_seg
observation.depths.left_cam_45_seg

Core indexing fields:

timestamp
frame_index
episode_index
index
task_index
next.done
next.success

next.done is true on the final frame of each episode. next.success is true only on the final frame of successful episodes.

---

Episode outcomes

Episode	Frames	Duration, sec	Terminal dirty fraction	Remaining spill	Success	Failure reason
episode_000000	1,467	48.87	0.000000	0.0000%	true	none
episode_000001	1,467	48.87	0.000339	0.0339%	true	none
episode_000002	1,727	57.53	0.075467	7.5467%	false	cleanup_incomplete
episode_000003	1,540	51.30	0.000000	0.0000%	true	none
episode_000004	535	17.80	1.000000	100.0000%	false	cleanup_incomplete

---

Episode annotations

Episode-level annotations are stored in annotations.json.

Top-level episode fields:

episode_id
success
task_success
failure_reason
duration_sec
frozen_frames
phase_annotations
scores
derived
raw_measurements
scorer_id

The phase_annotations field contains frame ranges and labels for phases such as approach, grasp, transport, place, retraction, surface cleaning, individual swipe passes, handover, collision, and failed task attempts.

The scores, derived, and raw_measurements fields include trajectory and execution diagnostics such as path efficiency, grasp precision, placement accuracy, temporal efficiency, motion smoothness, corrective movements, kinematic headroom, composite score, confidence, discontinuity count, low-frequency motion power, and peak kinematic ratio.

---

Loading examples

Read one episode parquet

from pathlib import Path
import pyarrow.parquet as pq

root = Path("path/to/dataset")
episode = root / "data/chunk-000/episode_000000.parquet"

table = pq.read_table(episode)
df = table.to_pandas()

print(df.columns)
print(df[["timestamp", "frame_index", "next.done", "next.success"]].tail())

Load a referenced depth map

from pathlib import Path
import numpy as np
import pyarrow.parquet as pq

root = Path("path/to/dataset")
df = pq.read_table(root / "data/chunk-000/episode_000000.parquet").to_pandas()

depth_ref = df["observation.depths.top_cam_seg"].iloc[0]
depth = np.load(root / depth_ref["path"])

print(depth.shape, depth.dtype, depth.min(), depth.max())

Load a referenced segmentation mask

from pathlib import Path
from PIL import Image
import numpy as np
import pyarrow.parquet as pq

root = Path("path/to/dataset")
df = pq.read_table(root / "data/chunk-000/episode_000000.parquet").to_pandas()

mask_ref = df["observation.masks.top_cam_seg"].iloc[0]
mask = np.array(Image.open(root / mask_ref["instance_segmentation"]))

print(mask.shape, mask.dtype, sorted(np.unique(mask).tolist()))
print(mask_ref["label_map"])

Read the terminal cleanup metric

from pathlib import Path
import pyarrow.parquet as pq

root = Path("path/to/dataset")
df = pq.read_table(root / "data/chunk-000/episode_000001.parquet").to_pandas()

terminal_objects = df["observation.object_poses"].iloc[-1]
spill = next(obj for obj in terminal_objects if obj["object_id"] == "liquid_spill")

dirty_fraction = float(spill["dirty_fraction"])
success = dirty_fraction <= 0.01

print("dirty_fraction:", dirty_fraction)
print("remaining_percent:", dirty_fraction * 100.0)
print("success:", success)

---

Intended use

This sample is suitable for:

• Inspecting a rich-modality LeRobot-compatible manipulation dataset.
• Testing data loaders for parquet rows that reference external RGB, depth, and segmentation assets.
• Prototyping imitation-learning workflows for bimanual table cleanup.
• Studying cleanup success/failure semantics using an objective remaining-spill metric.
• Inspecting phase-level annotations and failure cases in a compact bimanual task.

A larger 50-episode sample of the same task, without depth maps, is available at ExylosAi/table_spill_cleanup_bimanual.

---

Limitations

• This is a compact 5-episode inspection sample, not a broad benchmark.
• The depth and segmentation modalities are provided for 4 segmented camera views, not for every RGB camera to conserve sample size
• The 6DoF pose stream applies to interactable objects such as sponge and cup; the liquid_spill is represented as a task-state object with a remaining dirty fraction rather than a rigid 6DoF object.
• There is a single train split, train: 0:5.
• The sample is synthetic and human-seeded; real-world deployment still requires validation for the target robot, camera setup, environment, and task distribution.

---

Validation notes

The local sample was checked for:

• 5 parquet files with matching row counts and episode lengths.
• 35 RGB MP4 files, 7 camera streams per episode.
• 26,944 depth .npy files, 4 depth streams per frame.
• 26,944 segmentation .png files, 4 mask streams per frame.
• All parquet references to RGB, depth, and mask assets resolve to existing files.
• Sampled depth arrays load as float32 with the expected shapes.
• Sampled segmentation masks load as 8-bit grayscale images with labels 0..6.
• Terminal dirty_fraction <= 0.01 matches the recorded success/failure label for all 5 episodes.

---

About Exylos

Exylos is an early-stage robotics data company. We capture human manipulation demonstrations in consumer VR and procedurally expand them into physics-consistent, transfer-oriented training episodes with visual domain randomization. Datasets are delivered in LeRobot-compatible structure or adapted to client pipelines.

For larger production-scale skill packs, broader object families, configurable embodiments, custom evaluation logic, or higher episode volumes, visit exylos.ai or contact us directly.

---

Citation

If you use this dataset in research or in a public technical report, please cite it as:

@misc{exylos_bimanual_table_spill_cleanup_full_modalities_sample_2026,
  title        = {Exylos Bimanual Table Spill Cleanup Rich-Modality Sample: A Multi-View RGB-D, Segmentation, and Object-Pose Dataset},
  author       = {Exylos},
  year         = {2026},
  note         = {LeRobot-compatible dataset with RGB, depth, segmentation, object poses, and cleanup success metric}
}

---

License

Released under the Apache License 2.0. This sample is intentionally permissive so robotics and ML teams can inspect, load, test, and commercially evaluate the format without licensing friction.

---

Contact

• Website: exylos.ai
• Email: [email protected]
• LinkedIn: Exylos on LinkedIn

For questions specific to this dataset, including format, schema, or fields, please open a discussion in the Community tab on the dataset repository.