README.md

---
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](https://huggingface.co/datasets/ExylosAi/table_spill_cleanup_bimanual)

-> [**Request access / share what you need**](https://forms.gle/9jEK9uVwfhAuUWbEA) (60 seconds)

For full-release requirements, reply in the main dataset Discussion:
[What would make the full release useful for your pipeline?](https://huggingface.co/datasets/ExylosAi/table_spill_cleanup_bimanual/discussions/2)

For rich-modality notes specific to this sample, use this Discussion:
[Rich-modality sample: depth, masks, and object poses](https://huggingface.co/datasets/ExylosAi/table_spill_cleanup_bimanual_rgbd_segmentation_poses/discussions/2)

---

## 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

```text
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:

```text
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:

```text
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:

```text
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:

```text
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:

```text
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:

```text
observation.state
action
```

Motor order:

```text
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:

```text
observation.object_poses
```

It is a list of 3 objects per frame:

```text
sponge
cup
liquid_spill
```

Object fields:

```text
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:

```text
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:

```text
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:

```text
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:

```text
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:

```text
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

```python
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

```python
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

```python
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

```python
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](https://huggingface.co/datasets/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](https://exylos.ai) or contact us directly.

---

## Citation

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

```bibtex
@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](https://exylos.ai)
- Email: [email protected]
- LinkedIn: [Exylos on LinkedIn](https://www.linkedin.com/company/exylos-ai/)

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