README.md

metadata

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

DexMulti: Grasp + Open (sample efficiency)

_{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).}

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). 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):

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.

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

@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. Please cite the paper when using the data.