Voxel51/robotwin-unified-27500ep

This is a FiftyOne dataset with 27500 samples.

Installation

If you haven't already, install FiftyOne:

pip install -U fiftyone

Usage

import fiftyone as fo
import fiftyone.utils.huggingface as fouh

# Load the dataset
# Note: other available arguments include 'max_samples', etc
dataset = fouh.load_from_hub("Voxel51/robotwin-unified-27500ep")

# Launch the App
session = fo.launch_app(dataset)

Dataset Card for RoboTwin Unified (FiftyOne full import, 27,500 episodes)

Dataset Details

Dataset Description

This is a full FiftyOne import of lerobot/robotwin_unified, the unified LeRobot-format release of the pre-collected trajectory dataset from RoboTwin 2.0. RoboTwin 2.0 is a scalable simulation framework for generating diverse, domain-randomized bimanual manipulation data. This dataset contains all 27,500 episodes (6,075,103 frames) from the source repo, spanning 50 dual-arm manipulation tasks executed on an aloha (AgileX) embodiment, with three synchronized wrist/overhead camera streams per episode plus 14-DoF proprioceptive state and action vectors. Every episode is re-exported as a self-contained LeRobot v3.0 repo via FiftyOne's LeRobotDataset exporter, so it loads directly with fiftyone.utils.huggingface.load_from_hub.

• Curated by: Original data generation and curation by the RoboTwin 2.0 team (see Dataset Sources); this FiftyOne export was prepared by Harpreet Sahota (Voxel51).
• Funded by: AgileX Robotics, D-Robotics, and the Jockey Club STEM Lab of Autonomous Intelligent Systems (Hong Kong Jockey Club Charities Trust) — per the source paper's acknowledgments.
• Shared by: Harpreet Sahota (Voxel51), re-exporting the lerobot/robotwin_unified Hugging Face dataset into FiftyOne format.
• Language(s): English (task instructions are English natural-language strings).
• License: Apache 2.0, matching the source lerobot/robotwin_unified dataset. The RoboTwin 2.0 code/generator (separate from this data) is released under the MIT license.

Dataset Sources

• Repository (source data): lerobot/robotwin_unified
• Repository (simulator/generator code): RoboTwin-Platform/RoboTwin
• Paper: Chen, Tianxing, et al. "RoboTwin 2.0: A Scalable Data Generator and Benchmark with Strong Domain Randomization for Robust Bimanual Robotic Manipulation." arXiv:2506.18088 (2025). https://arxiv.org/abs/2506.18088
• Demo/docs: https://robotwin-platform.github.io/ , https://robotwin-platform.github.io/doc/
• Leaderboard: https://robotwin-platform.github.io/leaderboard

Uses

Direct Use

This dataset is suited for training and evaluating imitation-learning and vision-language-action (VLA) policies for bimanual (dual-arm) robotic manipulation, including: single-task and multi-task behavior cloning, sim-to-real transfer research, robustness studies under environmental variation (domain-randomized scenes, cluttered backgrounds, varied lighting, language-instruction variation), and cross-task generalization benchmarking across the 50 RoboTwin 2.0 tasks. It is also useful for browsing, filtering, and curating robot-manipulation episodes by task text, episode length/duration, or camera stream in the FiftyOne App before exporting a custom training subset.

Out-of-Scope Use

This is entirely simulated data (generated in the RoboTwin/SAPIEN-based simulator), not real-world robot data — do not treat model performance on this dataset as a proxy for real-world deployment readiness without separate sim-to-real validation. It is not intended for tasks unrelated to robotic manipulation (e.g., general video understanding, human action recognition) given its narrow, task-scripted content and synthetic domain-randomized textures.

Dataset Structure

This dataset consists of 27500 samples of media type multimodal, and has the following fields:

Fields

Field	FiftyOne Type	Meaning
id	ObjectIdField	FiftyOne sample ID
media_reference	MediaReferenceField	Pointer into the referenced LeRobot Parquet/MP4 shards for this episode
tags	ListField(StringField)	FiftyOne sample tags (empty by default)
metadata	EmbeddedDocumentField(Metadata)	Media metadata (unset for multimodal samples)
created_at / last_modified_at	DateTimeField	FiftyOne bookkeeping timestamps
episode_index	IntField	Episode index in this export (0–27499)
task	StringField	Natural-language task instruction for the episode (frame-0 instruction)
tasks	ListField(StringField)	Full list of task instruction(s) associated with the episode
length	IntField	Number of frames in the episode (74–1084)
duration	FloatField	Episode duration in seconds (2.47–36.13)
robot_type	StringField	Robot embodiment, always aloha in this dataset
fps	FloatField	Frame rate, 30.0 for every episode

Per-frame features live in the referenced Parquet/MP4 shards (not as top-level sample fields) and are viewable in the FiftyOne App's State & Action / Streams tabs:

Feature	dtype	Shape	Notes
observation.state	float32	[14]	14-DoF joint state: left/right waist, shoulder, elbow, forearm_roll, wrist_angle, wrist_rotate, gripper
action	float32	[14]	14-DoF action vector, same joint ordering as observation.state
observation.images.cam_high	video	[480,640,3]	Overhead camera, AV1 codec, yuv420p, 30 fps
observation.images.cam_left_wrist	video	[480,640,3]	Left-wrist camera, AV1 codec, yuv420p, 30 fps
observation.images.cam_right_wrist	video	[480,640,3]	Right-wrist camera, AV1 codec, yuv420p, 30 fps
timestamp	float32	[1]	Per-frame timestamp (s)
frame_index	int64	[1]	Per-frame index within the episode
index	int64	[1]	Global frame index across the export
task_index	int64	[1]	Index into the re-exported task table

Label types and why

There are no Classification/Detection label objects in this dataset — task instructions are free-text natural language (one instruction per episode, occasionally more than one in tasks), so they are stored as a StringField/ListField(StringField) rather than forced into a fixed Classification label space. With 23,559 distinct task strings across 27,500 episodes (near one-to-one), a classification schema would not meaningfully group episodes; use task/tasks for text search and filtering instead.

dataset.info contents

dataset.info["lerobot"] carries the LeRobot importer's bookkeeping, including skipped_episodes: [] (all 27,500 source episodes imported successfully) and the source codebase_version (v3.0).

Parsing decisions

• Full import, no subsetting. All 27,500 episodes and all 8 data shards / 457 video shard files in lerobot/robotwin_unified were downloaded and imported — this is not a shard-0 or sampled subset.
• Re-export re-indexes and recomputes stats. Pushing via fiftyone.utils.huggingface.push_to_hub with dataset_type=fo.types.LeRobotDataset re-exports the data as a self-contained LeRobot v3.0 repo: episode_index values are remapped to a dense 0..N-1 range and per-episode / global feature statistics are recomputed from the exported data (they are not copied verbatim from the source meta/stats.json).
• No excluded modalities. Every feature declared in the source meta/info.json has dtype of video, float32, or int64 (no depth_video, pointcloud, or other sidecar modalities) — the FiftyOne LeRobot importer's video/image filter dropped nothing here.
• No format conversion needed. The source is already LeRobot v3.0 (not v2.x), so no legacy metadata synthesis or convert_dataset_v21_to_v30 repair was required.
• Codec caveat. All three camera streams use AV1/yuv420p, which decodes cleanly in Chromium-based browsers (used for the FiftyOne App); other browsers' AV1 support may vary.
• task vs tasks. task mirrors the first (and usually only) entry of tasks, kept as a flat field for easy grouping/sorting in the App sidebar; use tasks if an episode has multiple associated instruction variants.

Dataset Creation

Curation Rationale

RoboTwin 2.0 was built to address three gaps in prior synthetic manipulation datasets: (1) lack of automated, scalable expert-trajectory generation for novel tasks, (2) oversimplified simulation scenes that omit real-world visual/spatial complexity, and (3) neglect of cross-embodiment kinematic differences. The dataset released at lerobot/robotwin_unified is the pre-collected corpus of over 100,000 expert trajectories the RoboTwin 2.0 authors generated across 50 dual-arm tasks and 5 robot embodiments; this FiftyOne export ingests the full aloha-embodiment portion of that corpus (27,500 episodes) as distributed in unified LeRobot v3.0 format.

Source Data

Data Collection and Processing

Per the source paper, trajectories were produced by a closed-loop, automated expert-data-generation pipeline: a code-generation agent (built on multimodal LLMs) synthesizes Python task programs from natural-language instructions, executes them in simulation (built on SAPIEN), and a vision-language-model observer inspects execution frame-by-frame to detect and localize failures. The code agent iteratively repairs failing programs using this feedback until a target success rate is reached (or 5 refinement iterations are exhausted). Successful rollouts are recorded as expert trajectories with synchronized RGB video (3 cameras), joint state, and action vectors at 30 fps. Episodes were further diversified using domain randomization along five axes: scene clutter (distractor objects from the 731-object, 147-category RoboTwin-OD asset library), background/tabletop textures (11,000 AI-generated, human-filtered textures), lighting (color temperature, source type/position/intensity), tabletop height, and natural-language instruction phrasing (multiple LLM-generated templates and object descriptions per task). This FiftyOne dataset performs no additional data collection — it only re-parses and re-exports the already-collected lerobot/robotwin_unified release.

Who are the source data producers?

Trajectories were synthesized entirely in simulation by the automated RoboTwin 2.0 expert-generation pipeline (MLLM code-generation agent + VLM execution observer), not collected from human teleoperators. The robot embodiment recorded in this dataset is aloha (AgileX); the source project also covers Piper, Franka, UR5, and ARX-X5 embodiments in the broader RoboTwin 2.0 release (not all embodiments are necessarily present in lerobot/robotwin_unified).

Annotations

Annotation process

Task instructions are LLM-generated natural-language strings: for each of the 50 base tasks, a multimodal LLM produced multiple instruction templates and object description variants (varying in geometry, texture, functionality, part structure), which were combined and sampled per trajectory to produce linguistically diverse instructions (e.g., "Use left arm to place sauce can to the left of gray kitchenpot"). Per-episode "success" was determined during generation by the simulation-in-the-loop pipeline (execution logs + VLM diagnostics), not by post-hoc human annotation of this release.

Who are the annotators?

No human annotators labeled individual episodes in this release; instruction text and object descriptions were machine-generated by multimodal LLMs as part of the RoboTwin 2.0 pipeline, per the source paper (Section 3.1, 2.2). The RoboTwin-OD object library's semantic/affordance annotations did involve human-in-the-loop verification, per the paper.

Personal and Sensitive Information

None. All content is synthetic simulation renderings of a simulated tabletop/robot-arm environment with generated object/texture assets; there are no images or data derived from real people, and no personally identifiable information is present.

Citation

BibTeX:

@article{chen2025robotwin20,
  title   = {RoboTwin 2.0: A Scalable Data Generator and Benchmark with Strong Domain Randomization for Robust Bimanual Robotic Manipulation},
  author  = {Chen, Tianxing and Chen, Zanxin and Chen, Baijun and Cai, Zijian and Liu, Yibin and Li, Zixuan and Liang, Qiwei and Lin, Xianliang and Ge, Yiheng and Gu, Zhenyu and Deng, Weiliang and Guo, Yubin and Nian, Tian and Xie, Xuanbing and Chen, Qiangyu and Su, Kailun and Xu, Tianling and Liu, Guodong and Hu, Mengkang and Gao, Huan-ang and Wang, Kaixuan and Liang, Zhixuan and Qin, Yusen and Yang, Xiaokang and Luo, Ping and Mu, Yao},
  journal = {arXiv preprint arXiv:2506.18088},
  year    = {2025}
}

APA:

Chen, T., Chen, Z., Chen, B., Cai, Z., Liu, Y., Li, Z., Liang, Q., Lin, X., Ge, Y., Gu, Z., Deng, W., Guo, Y., Nian, T., Xie, X., Chen, Q., Su, K., Xu, T., Liu, G., Hu, M., Gao, H., Wang, K., Liang, Z., Qin, Y., Yang, X., Luo, P., & Mu, Y. (2025). RoboTwin 2.0: A Scalable Data Generator and Benchmark with Strong Domain Randomization for Robust Bimanual Robotic Manipulation. arXiv preprint arXiv:2506.18088.

More Information

Task documentation, object library details, and the RoboTwin 2.0 leaderboard are available at https://robotwin-platform.github.io/doc/. The data-generation code and simulator are at https://github.com/RoboTwin-Platform/RoboTwin (MIT-licensed).

Dataset Card Authors

Harpreet Sahota

Dataset Card Contact

Harpreet Sahota