README.md

---
license: cc-by-4.0
task_categories:
- robotics
tags:
- LeRobot
- dexterous-manipulation
- point-cloud
- xarm7
- leap-hand
configs:
- config_name: default
  data_files: data/*/*.parquet
---

<div align="center">

# DexMulti: Grasp + Open (sample efficiency)

[![Website](https://img.shields.io/badge/Project-Website-1f6feb?style=for-the-badge&logo=githubpages&logoColor=white)](https://dexmulti.github.io/)
[![Paper](https://img.shields.io/badge/arXiv-2603.11655-b31b1b?style=for-the-badge&logo=arxiv&logoColor=white)](https://arxiv.org/abs/2603.11655)
[![Code](https://img.shields.io/badge/Code-GitHub-181717?style=for-the-badge&logo=github&logoColor=white)](https://github.com/Msornerrrr/dexmulti)

<video src="https://huggingface.co/datasets/HJ666/dexmulti_grasp_open_sample_efficiency/resolve/main/media/demo.mp4" controls autoplay loop muted playsinline width="100%"></video>

<sub>One teleoperated demonstration: the two RGB cameras (left); the robot, the segmented object clouds with hand contact, and the end-effector path coloured by skill (right).</sub>

</div>

Sample-efficiency demonstrations of the **Grasp + Open** task (paper: sample-efficiency experiments): 124 unique demonstrations recorded on 2026-01-28, from which seven training sets were drawn. The sets overlap (the same recording appears in several sets), so every recording is stored once and `dexmulti/splits.json` lists the episodes of each set.

Paper: *Concurrent Prehensile and Nonprehensile Manipulation: A Practical Approach to Multi-Stage Dexterous Tasks*
(IROS 2026, [arXiv:2603.11655](https://arxiv.org/abs/2603.11655)). Code: <https://github.com/Msornerrrr/dexmulti>. Full documentation (conventions, loading without LeRobot, npz conversion): <https://github.com/Msornerrrr/dexmulti/blob/main/docs/dataset.md>.

**Task:** Grasp an object, push open a container lid, and place the object inside.

| | |
|---|---|
| robot | xArm7 arm + LEAP Hand (right), teleoperated with DexCap |
| cameras | 2x Intel RealSense L515 (RGB 640x480) |
| episodes / frames | 124 / 19539 (length 106–202, mean 157.6) |
| rate | 10 Hz |
| format | LeRobot v3.0, videos H.264 (yuv420p) |

## Features

| feature | shape | description |
|---|---|---|
| `observation.images.cam1`, `observation.images.cam2` | 480x640x3 video | RGB of the two cameras |
| `observation.state` | (29,) float32 | see below |
| `action` | (22,) float32 | see below |
| `observation.pointcloud.object` | (512, 3) float32 | segmented point cloud of the first (grasped) object, robot base frame [m] |
| `observation.pointcloud.drawer` | (512, 3) float32 | segmented point cloud of the container (key name kept from the code base) |
| `observation.pointcloud.hand` | (512, 3) float32 | points on the LEAP Hand surface from forward kinematics |
| `observation.contact.object`, `observation.contact.drawer` | (512, 1) float32 | per-point hand contact score in [0, 1] of the matching cloud |
| `observation.skill` | int64 | 0: not in a skill (approach / transition), 1: skill 1 (first object), 2: skill 2 (the container) |
| `task` | string | language instruction (one per dataset) |

`observation.state`:

| index | source key | meaning |
|---|---|---|
| 0–5 | `eef_pose` | measured end-effector pose: x, y, z [m], roll, pitch, yaw [rad] (scipy Euler `xyz`) |
| 6–12 | `arm_state` | xArm7 joint positions [rad] |
| 13–28 | `hand_state` | LEAP Hand joint positions [rad] (LEAP ROS order: 4 per finger, thumb last) |

`action` (what the robot was commanded at this step, 10 Hz):

| index | source key | meaning |
|---|---|---|
| 0–5 | `arm_cmd` | commanded end-effector pose: x, y, z [m], roll, pitch, yaw [rad] |
| 6–21 | `hand_cmd` | LEAP Hand joint commands [rad] |

Element names are in `meta/info.json`.

## Frames and conventions

- All poses and point clouds are in the xArm7 base frame (`link_base`), metres. Orientations are scipy Euler
  `"xyz"` angles in radians; roll is near ±π, so its plot wraps.
- Point clouds come from the two depth cameras (fused, segmented, 512 points per object) and are the inputs used by
  DexMulti. Depth images and masks are not included.
- `observation.skill` is derived from the skill keyframes (`task1_start..task1_end` = 1,
  `task2_start..task2_end` = 2, inclusive).
  Where the two recorded ranges overlap, skill 1 takes precedence; frames of `task2_start..task2_end`
  outside skill 1 are 2 even when `task2_start < task1_start`. The ranges overlap in 5 episode(s)
  (`dexmulti/keyframe_overlaps.json`, with the resulting label runs; `set: null` = the keyframes behind
  `observation.skill`, other entries = per-set keyframes), e.g. `session_20260128_211639` with keyframes
  [34, 74, 74, 162] is labelled 0 on [0, 33], 1 on [34, 74], 2 on [75, 162]. The keyframe files are unchanged.
- `timestamp` is `frame_index / 10`; the original wall-clock times are in `dexmulti/episodes.json`.

## DexMulti extras (`dexmulti/`)

Not part of the LeRobot schema; used by the DexMulti code base:

- `episodes.json`: per `episode_index` the original recording name, length, source set and wall-clock times.
- `keyframes/<episode>.json`: keyframes of the stored copy (used for `observation.skill`); `keyframes/<set>/<episode>.json`: keyframes as used by each set.
- `set_clouds/<set>.npz`: each set's own keyframe clouds where they differ from the stored copy (see below).
- `library/<set>.npz`: the skill library of each set (see Training sets below).
- `keyframe_overlaps.json`: recordings whose two keyframe ranges overlap, with the resulting `observation.skill` runs.
- `cameras.json`: intrinsics (fx, fy, cx, cy) and extrinsics `T_base_cam` (camera optical frame to robot base) of
  both cameras; constant for the whole dataset.

Load as DexMulti episodes (no `lerobot` or `torch` needed):

```python
from dexmulti.data.lerobot import LeRobotEpisodes
ds = LeRobotEpisodes("<path or repo id>")
ep = ds.episode(0)          # dict: keys of dexmulti/data/episode.py + skill
kf = ds.keyframes(0)        # task1_start, task1_end, task2_start, task2_end
```

or with LeRobot: `LeRobotDataset("HJ666/dexmulti_grasp_open_sample_efficiency")`.

## Training sets (splits)

`dexmulti/splits.json` maps each set to `{"source": <original folder>, "episode_index": [...]}`.

| set | original folder | demos | skill library |
|---|---|---|---|
| `quantity_50` | `grasp-open-coconut50` | 50 | as run |
| `quantity_20` | `grasp-open-coconut20` | 20 | rebuilt |
| `quantity_10` | `grasp-open-coconut10` | 10 | rebuilt |
| `quantity_5` | `grasp-open-coconut5` | 5 | as run |
| `diversity_11obj_x4` | `grasp-open-11*4` | 44 | as run |
| `diversity_4obj_x11` | `grasp-open-4*11` | 44 | as run |
| `diversity_7obj_x6+2` | `grasp-open-7*6+2` | 44 | as run |

- `quantity_N`: N demonstrations with a single object (coconut); `quantity_5/10/20` are subsets of `quantity_50`.
- `diversity_*`: 44 demonstrations with 11 objects x 4, 4 objects x 11, or 7 objects x 6 + 2.

Each set was processed (segmentation, point-cloud fusion, contact maps) separately when it was recorded, so a
recording that appears in several sets has identical robot data and images in every copy but slightly different
point clouds / contact maps (the processing is stochastic). This dataset stores one copy per recording, chosen in
the order quantity_50, quantity_20, quantity_10, quantity_5, diversity_11obj_x4, diversity_4obj_x11,
diversity_7obj_x6+2 (`source_set` in `dexmulti/episodes.json`). The skill keyframes and skill libraries are kept per
set exactly as they were used (`dexmulti/keyframes/<set>/`, `dexmulti/library/<set>.npz`); the keyframes of the
same recording can differ slightly between sets. The libraries of `quantity_10` and `quantity_20` were not saved
when the experiments ran and were rebuilt with `dexmulti.library.build_library` from those sets' own processed
copies.

A library is built from two clouds per demonstration: the object cloud at the set's `task1_start` and the
second-object cloud at its `task2_start`. For the recordings whose stored copy comes from another set and differs at
those two frames, `dexmulti/set_clouds/<set>.npz` holds that set's own clouds (and contact maps) at those frames
(counts in `dexmulti/set_clouds/NOTES.json`). `LeRobotEpisodes(root, split="<set>")` returns the episodes of the set
with its own keyframes (`skill` recomputed from them) and these clouds substituted, so materializing a set and
rebuilding its library with `dexmulti.library.build_library` reproduces `dexmulti/library/<set>.npz` exactly, for
all seven sets. All other frames are those of the stored copy.

```python
from dexmulti.data.lerobot import LeRobotEpisodes, materialize
q5 = LeRobotEpisodes("<path or repo id>", split="quantity_5")
materialize(q5, "data/npz/quantity_5")   # then: python scripts/build_library.py --session data/npz/quantity_5
```

## Citation

```bibtex
@inproceedings{jiang2026concurrent,
  title     = {Concurrent Prehensile and Nonprehensile Manipulation: A Practical Approach to Multi-Stage Dexterous Tasks},
  author    = {Jiang, Hao and Wu, Yue and Wang, Yue and Sukhatme, Gaurav S. and Seita, Daniel},
  booktitle = {IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS)},
  year      = {2026}
}
```

## License

[CC-BY-4.0](https://creativecommons.org/licenses/by/4.0/). Please cite the paper when using the data.