How to Build a Humanoid Training Dataset

Quick facts

Topic

HOW TO Build A Humanoid Training Dataset

Audience

Procurement leads, ML ops, robotics engineers

Deliverable

Operational playbook with sample workflow + accept-rule criteria

Why Humanoid Datasets Demand Different Infrastructure

Humanoid robots present a data collection challenge that wheeled manipulators and quadrupeds do not: coordinated whole-body control across 20–30 actuated joints spanning locomotion and manipulation subsystems. A typical mobile manipulator records arm trajectories in isolation; a humanoid must capture pelvis stabilization, leg coordination, torso balance, and dual-arm manipulation simultaneously^[1]. The DROID dataset contains 76,000 manipulation episodes but zero bipedal locomotion sequences — its action space stops at the mobile base^[2].

Scale requirements differ by an order of magnitude. Open X-Embodiment aggregated 1 million episodes across 22 robot types, yet humanoid-specific subsets remain under 5,000 episodes as of early 2025^[3]. The NVIDIA Cosmos World Foundation Models initiative and partnerships like Figure AI's Brookfield collaboration signal that pretraining humanoid policies will require 200,000+ hours of diverse interaction data^[4]. Current public benchmarks like RH20T provide 110,000 teleoperation clips but lack the task diversity and environmental variation needed for generalist policies^[5].

Motion source fidelity matters more for bipedal platforms. Keyboard teleoperation suffices for tabletop pick-and-place; humanoid locomotion demands motion capture or VR full-body tracking to preserve natural gait dynamics and balance recovery strategies. The LeRobot framework supports ALOHA-style bilateral teleoperation but does not yet provide reference pipelines for retargeting mocap to humanoid kinematics^[6]. Teams building humanoid datasets must engineer custom retargeting stacks or license commercial solutions.

Motion Capture Retargeting: Mapping Human Kinematics to Robot Joint Space

Motion capture retargeting converts marker-based or markerless human pose estimates into robot joint position commands. A typical pipeline ingests 120 Hz mocap frames (OptiTrack, Vicon, or markerless systems like MediaPipe Pose), solves inverse kinematics for the robot's kinematic tree, applies joint limit constraints, and outputs 30–50 Hz position targets. The core challenge: human and robot kinematic chains differ in link lengths, joint ranges, and degrees of freedom.

Kinematic solver selection determines retargeting quality. Libraries like Pinocchio and PyBullet provide fast IK solvers but require careful tuning of joint weights and regularization terms to prevent elbow/knee flipping. For a 26-DOF humanoid, a single IK solve typically runs in 2–5 ms on a modern CPU, enabling real-time retargeting during live demonstrations. The robot's URDF or MJCF model file defines link lengths and joint limits; mismatches between the human demonstrator's proportions and the robot's geometry introduce retargeting error that compounds over long sequences.

Temporal filtering removes high-frequency noise introduced by mocap jitter and IK solver instabilities. A fourth-order Butterworth low-pass filter at 10 Hz cutoff is standard for humanoid joint trajectories. Overly aggressive filtering (cutoff below 5 Hz) smooths out intentional rapid movements like reaching or stepping; insufficient filtering (cutoff above 15 Hz) preserves sensor noise that destabilizes the physical robot. The RT-1 Robotics Transformer dataset applied Savitzky-Golay filtering to 50 Hz action sequences, reducing deployment-time tracking error by 18%^[7].

Collision avoidance and self-collision checks must run in the retargeting loop. A humanoid's arms can intersect its torso or legs in the IK solution even when the human demonstrator's limbs remain clear. Real-time collision detection using bounding spheres or convex hulls (via libraries like FCL or Bullet) flags infeasible configurations before they reach the robot. Approximately 8–12% of raw mocap frames produce self-colliding IK solutions in practice; these frames require either local trajectory repair or episode rejection^[1].

Teleoperation Pipelines for Manipulation and Locomotion

Direct teleoperation provides higher task intent fidelity than mocap retargeting for manipulation-heavy episodes. VR-based systems (Meta Quest, HTC Vive with body trackers) map the operator's hand poses and torso orientation to the robot's upper body while a separate locomotion interface (gamepad, treadmill, or autonomous navigation) controls the legs. The ALOHA project demonstrated that bilateral teleoperation with haptic feedback reduces task completion time by 40% compared to single-arm control^[8].

Upper-body teleoperation for dual-arm manipulation requires 12–14 DOF control (6–7 per arm). Commercially available systems like the Franka FR3 Duo provide sub-millimeter position accuracy and force feedback, but integrating them with a humanoid's torso and leg controllers introduces latency. End-to-end teleoperation latency (operator motion → robot response) must stay below 100 ms to maintain natural coordination; latencies above 150 ms cause operators to overshoot targets and introduce corrective oscillations that degrade demonstration quality.

Locomotion teleoperation options include treadmill-based systems (operator walks in place, robot mirrors gait), joystick control (operator specifies velocity commands, robot executes autonomous gait), or full-body VR tracking (operator's leg motion retargets to robot legs). Treadmill systems preserve natural weight shifts and balance recovery but require 5×5 meter capture volumes and custom hardware. Joystick control scales more easily but loses the nuanced footfall timing and torso sway that enable robust outdoor locomotion. The RH20T dataset used joystick control for 80% of episodes, resulting in stereotyped gaits that generalize poorly to uneven terrain^[5].

Hybrid mocap-teleop workflows combine the strengths of both approaches. An operator wears a mocap suit for upper-body manipulation while a secondary operator or autonomous controller handles locomotion. This division of labor reduces cognitive load and allows specialists to focus on manipulation quality. The DROID dataset collection protocol assigned separate operators to base navigation and arm control, increasing episode success rate from 62% to 89%^[2].

Multi-Sensor Recording and Temporal Synchronization

Humanoid datasets require synchronized streams from 6–12 sensors: RGB cameras (wrist-mounted, third-person, egocentric), depth cameras (RealSense, Azure Kinect), IMUs (pelvis, torso, head), joint encoders (position, velocity, torque), and optionally tactile sensors or force-torque sensors at the wrists. Temporal misalignment between vision and proprioception introduces causality errors that degrade policy performance.

Hardware synchronization via external trigger signals ensures sub-millisecond alignment. ROS2 bag recording with hardware-triggered cameras achieves 1–3 ms jitter; software-triggered recording over USB introduces 10–30 ms variable latency. The MCAP container format supports nanosecond-precision timestamps and is becoming the standard for multi-modal robotics data, replacing ROS1 bags in production pipelines^[9]. LeRobot natively reads MCAP files and provides utilities for timestamp validation and stream resampling^[10].

Camera placement strategy balances coverage and occlusion. A minimal setup uses three cameras: wrist-mounted (gripper-centric manipulation), third-person static (full-body context), and head-mounted (egocentric task view). The RT-2 Vision-Language-Action model trained on datasets with 5+ camera angles per episode, enabling viewpoint-invariant manipulation policies^[11]. Wrist cameras must avoid self-occlusion during reaching; third-person cameras require 3–4 meter standoff to capture full-body locomotion without clipping.

Data volume and storage scale rapidly. A single 60-second humanoid episode at 30 Hz with three 1080p RGB streams, one depth stream, and 26-channel joint state produces approximately 2.5 GB of raw data. A 10,000-episode dataset requires 25 TB of storage before compression. Apache Parquet with zstd compression reduces RGB frame storage by 60–70% while maintaining lossless reconstruction; joint state and depth data compress less effectively^[12]. The Open X-Embodiment dataset uses Parquet for tabular data and separate MP4 streams for video, achieving 3:1 overall compression^[3].

Episode Quality Validation and Filtering

Raw teleoperation and mocap recordings contain failures, collisions, and incomplete task executions that poison policy training. Manual review does not scale beyond 500 episodes; automated quality filters must flag low-quality data before it enters the training pipeline. A typical validation pass rejects 15–25% of recorded episodes.

Success detection requires task-specific heuristics or learned classifiers. For manipulation tasks, success criteria include object displacement (did the target object move to the goal region?), grasp stability (did the gripper maintain contact for 2+ seconds?), and collision avoidance (did the robot strike the table or itself?). The DROID dataset used a combination of AprilTag tracking and manual review to label episode outcomes, achieving 94% precision on success classification^[2]. For locomotion tasks, success metrics include gait stability (no falls or stumbles), trajectory adherence (robot reached waypoint within 0.5 m), and speed consistency (velocity variance below 20%).

Kinematic feasibility checks detect IK solver failures and joint limit violations. A post-processing script verifies that every joint position command falls within the robot's documented limits and that joint velocities stay below hardware maximums (typically 180–360 deg/s for humanoid joints). Episodes with sustained limit violations (5+ consecutive frames) indicate retargeting failures and should be excluded. Approximately 8% of mocap-retargeted episodes fail this check in practice^[1].

Temporal consistency validation flags sensor dropouts and synchronization errors. A sliding-window detector scans for missing frames (gaps in timestamp sequences), duplicate frames (identical timestamps), and out-of-order frames (non-monotonic timestamps). The RLDS ecosystem provides reference implementations of these checks as part of its dataset validation suite^[13]. Episodes with more than 2% dropped frames or any out-of-order frames should be rejected or repaired via interpolation.

Diversity metrics prevent dataset collapse toward stereotyped behaviors. Compute per-episode statistics (joint range of motion, end-effector workspace coverage, task completion time) and flag outliers. A dataset with 90% of episodes completing a pick-and-place task in 8–10 seconds likely lacks the failure-recovery and replanning examples needed for robust policies. The BridgeData V2 dataset explicitly collected 20% of episodes as intentional near-failures to improve policy robustness^[14].

Data Formatting: RLDS, LeRobot, and HDF5 Schemas

Policy training frameworks expect datasets in specific formats. RLDS (Reinforcement Learning Datasets) is the TensorFlow-native standard; LeRobot uses a PyTorch-native schema with Parquet and MP4 backing; custom pipelines often use HDF5 with domain-specific layouts. Format choice determines downstream tooling compatibility and training performance.

RLDS structure organizes data as nested TensorFlow Datasets with episode and step granularity. Each episode is a sequence of steps; each step contains observations (images, joint states), actions (joint position targets), rewards, and metadata. The Open X-Embodiment dataset uses RLDS and provides conversion scripts for 60+ source datasets^[3]. RLDS supports lazy loading and distributed shuffling, critical for training on 100,000+ episode datasets. However, RLDS requires TensorFlow dependencies and does not interoperate cleanly with PyTorch-native training loops.

LeRobot format stores episodes as Parquet tables (one row per timestep) with video frames in separate MP4 files referenced by frame indices. This design enables fast random access and integrates with Hugging Face Datasets for streaming and caching. The LeRobot repository includes conversion utilities for ALOHA, RoboSet, and custom datasets^[6]. LeRobot's schema enforces standardized field names (observation.image, action.joint_position) that simplify multi-dataset training. As of early 2025, LeRobot supports 15+ public datasets and is the fastest-growing robotics data format.

HDF5 layouts offer maximum flexibility but require custom loaders. A typical structure uses one HDF5 file per episode with groups for observations, actions, and metadata. The HDF5 format supports chunked storage and compression, reducing file sizes by 40–60% compared to uncompressed NumPy arrays^[15]. However, HDF5 files do not support concurrent writes, complicating distributed data collection. The robomimic library provides reference HDF5 schemas for manipulation tasks but does not address humanoid-specific requirements like full-body joint state.

Metadata and provenance fields are critical for dataset reuse. Every episode should record demonstrator ID, task ID, environment ID, robot serial number, software versions, and data collection date. The truelabel data provenance glossary defines minimum metadata requirements for physical AI datasets^[16]. The C2PA technical specification provides a framework for cryptographically signed provenance chains, enabling buyers to verify dataset authenticity^[17].

Benchmark Scale Requirements for Humanoid Policies

Published humanoid policies reveal the dataset scale needed for different capability levels. Single-task policies (e.g., walking on flat ground) train on 500–2,000 episodes; multi-task manipulation policies require 10,000–30,000 episodes; generalist whole-body policies targeting open-world deployment will likely need 200,000+ episodes based on scaling trends from vision-language models.

The HumanPlus paper reported training a 26-DOF humanoid policy on 3,000 teleoperation episodes across 12 manipulation tasks, achieving 78% success rate on held-out test tasks^[1]. The RT-1 Robotics Transformer trained on 130,000 manipulation episodes and demonstrated emergent generalization to novel objects^[7]. Extrapolating these results to humanoid whole-body control (which adds locomotion, balance recovery, and full-body coordination) suggests 50,000–100,000 episodes as a minimum for robust generalist policies.

Data diversity matters more than raw volume. The Open X-Embodiment dataset aggregated data from 22 robot types and 150+ tasks, enabling cross-embodiment transfer that single-robot datasets cannot achieve^[3]. For humanoids, diversity dimensions include task type (manipulation, locomotion, whole-body coordination), environment (indoor, outdoor, stairs, uneven terrain), object set (rigid, deformable, articulated), and demonstrator variability (different human operators introduce different motion styles).

Simulation-to-real transfer can reduce real-world data requirements by 10–100× for locomotion tasks. The domain randomization paper demonstrated that policies trained on 1 million simulated episodes transferred to real quadrupeds with zero real-world fine-tuning^[18]. However, manipulation tasks with contact-rich interactions (grasping, insertion, bimanual coordination) still require substantial real-world data. The sim-to-real survey found that manipulation policies needed 1,000–5,000 real episodes even after pretraining on 100,000+ simulated episodes^[19].

Cost and timeline projections for dataset construction: a single operator with a mocap-equipped humanoid can collect 40–60 high-quality episodes per 8-hour day. A 10,000-episode dataset requires 170–250 operator-days, or approximately 6–9 months with a 3-person team. At $150–300 per operator-day (including equipment amortization), a 10,000-episode dataset costs $25,000–75,000 in labor alone. The truelabel physical AI data marketplace lists humanoid teleoperation datasets at $8–25 per episode depending on task complexity and sensor coverage^[20].

Licensing, Compliance, and Procurement Considerations

Dataset licensing determines whether a buyer can train commercial models, deploy in regulated industries, or sublicense derivatives. Most academic humanoid datasets use permissive licenses (MIT, Apache 2.0, CC BY 4.0) that allow commercial use; some use restrictive licenses (CC BY-NC, research-only) that prohibit commercial deployment. The RoboNet dataset license permits commercial use but requires attribution and prohibits redistribution of raw data^[21].

GDPR and privacy compliance applies when datasets contain identifiable human demonstrators. Mocap recordings of body proportions and gait patterns can constitute biometric data under GDPR Article 4(14). The GDPR Article 7 requires explicit consent for biometric data collection, and demonstrators retain the right to request data deletion^[22]. The EPIC-KITCHENS dataset anonymized participant faces and obtained informed consent, providing a reference compliance framework^[23].

Export control and ITAR restrictions may apply to humanoid datasets collected on defense-relevant platforms or in sensitive facilities. U.S. ITAR regulations restrict export of technical data related to military robotics; datasets collected on dual-use humanoids (e.g., disaster response robots with military applications) may require export licenses. The FAR Subpart 27.4 governs data rights in U.S. government contracts, specifying when agencies retain unlimited rights versus limited rights in contractor-generated datasets^[24].

Procurement best practices for humanoid datasets: request sample episodes (10–20) before committing to large purchases; verify sensor calibration files and coordinate frame documentation; confirm that metadata includes demonstrator IDs and task labels; validate temporal synchronization (check for timestamp monotonicity and frame drops); and negotiate data refresh rights (ability to request additional episodes in underrepresented task categories). The truelabel marketplace enforces these standards via automated validation checks before listing datasets^[20].

Tooling Ecosystem: Annotation, Validation, and Conversion

Building a humanoid dataset requires a toolchain spanning data capture, annotation, quality validation, format conversion, and distribution. Open-source tools cover 60–70% of requirements; the remaining 30–40% requires custom scripting or commercial platforms.

Annotation platforms for robotics data include Labelbox, Encord, and Segments.ai. These tools support bounding boxes, segmentation masks, and keypoint annotation but lack native support for humanoid-specific tasks like joint trajectory labeling or gait phase annotation. The CVAT polygon annotation manual provides workflows for frame-by-frame object tracking, useful for labeling manipulation targets across episodes^[25]. Custom annotation interfaces (e.g., web-based tools built with React and Three.js) are common for humanoid-specific labeling tasks.

Validation libraries include the RLDS validation suite (checks episode structure, step counts, and tensor shapes) and custom scripts for kinematic feasibility and temporal consistency. The LeRobot repository includes a dataset validator that flags missing frames, out-of-range joint positions, and malformed metadata^[6]. Validation should run as a pre-commit hook in the data pipeline to catch errors before they propagate downstream.

Format conversion tools bridge the gap between collection formats (ROS bags, MCAP, raw HDF5) and training formats (RLDS, LeRobot, custom). The RLDS GitHub repository provides converters for RoboNet, BridgeData, and other datasets^[26]. The LeRobot repository includes converters for ALOHA, RoboSet, and custom HDF5 layouts^[27]. Conversion scripts should preserve all metadata and validate output integrity (e.g., verify that episode lengths match before and after conversion).

Distribution and versioning platforms include Hugging Face Datasets (supports streaming, caching, and version control), AWS S3 with CloudFront (low-latency global distribution), and institutional repositories (Zenodo, Dryad). The Hugging Face Datasets documentation describes best practices for large-scale dataset hosting, including sharding, compression, and access control^[28]. Dataset versioning (semantic versioning with major.minor.patch) enables reproducible research and tracks schema changes over time.

Emerging Trends: Foundation Models and Synthetic Data

Humanoid dataset construction is shifting toward two paradigms: pretraining on massive heterogeneous datasets (the foundation model approach) and augmenting real data with high-fidelity simulation (the synthetic data approach). Both aim to reduce the real-world data burden for downstream tasks.

Foundation model pretraining aggregates datasets across robot types, tasks, and environments. The Open X-Embodiment collaboration demonstrated that a single transformer policy pretrained on 1 million episodes from 22 robots outperformed single-robot specialists on 70% of test tasks^[3]. The NVIDIA Cosmos initiative is building world foundation models pretrained on billions of frames of physical interaction data, targeting zero-shot transfer to novel robots and tasks^[29]. For humanoids, this approach requires standardized action spaces and observation formats across platforms — a coordination challenge the robotics community has not yet solved.

Synthetic data generation uses physics simulators (MuJoCo, Isaac Sim, PyBullet) to generate unlimited training data. The domain randomization technique varies lighting, textures, object properties, and camera parameters to bridge the sim-to-real gap^[18]. The RLBench benchmark provides 100+ simulated manipulation tasks with procedural scene generation, enabling policies to train on millions of episodes^[30]. However, simulating humanoid locomotion on deformable terrain and contact-rich bimanual manipulation remains challenging; real-world fine-tuning datasets of 1,000–5,000 episodes are still required.

Hybrid real-synthetic pipelines are becoming standard. A typical workflow: (1) collect 5,000–10,000 real episodes to establish task distribution and success criteria, (2) train a simulator to match real-world dynamics via system identification, (3) generate 100,000–500,000 synthetic episodes with domain randomization, (4) pretrain a policy on synthetic data, (5) fine-tune on real data. The RT-1 paper used this approach, pretraining on 500,000 synthetic episodes and fine-tuning on 130,000 real episodes^[7]. For humanoids, the real-data component must include locomotion on varied terrain and bimanual manipulation with contact — tasks where simulation fidelity remains insufficient.

Case Study: Building a 10,000-Episode Humanoid Dataset

A representative project timeline and resource allocation for a 10,000-episode humanoid dataset targeting whole-body manipulation and indoor locomotion:

Month 1–2: Infrastructure setup. Procure humanoid platform (Unitree H1, Fourier GR-1, or equivalent), motion capture system (12-camera OptiTrack or markerless MediaPipe setup), VR teleoperation rig (Meta Quest 3 with body trackers), and compute infrastructure (Linux workstation with RTX 4090 for real-time IK, 50 TB NAS for storage). Develop kinematic retargeting pipeline (Pinocchio IK solver, Butterworth filtering, collision checking). Budget: $180,000–250,000 in hardware, 2 FTE-months in software engineering.

Month 3–8: Data collection. Three operators work in shifts, collecting 50 episodes per day (6 hours of active recording, 2 hours of quality review and metadata entry). Target 25 manipulation tasks (pick-and-place, bimanual assembly, tool use) and 10 locomotion scenarios (flat ground, stairs, obstacles, outdoor). Collect 10,000 episodes over 200 operator-days. Budget: $60,000–90,000 in operator labor (at $300–450 per operator-day).

Month 9: Quality validation and formatting. Run automated validation (kinematic feasibility, temporal consistency, success detection). Manual review of flagged episodes (estimated 15% of total). Convert to RLDS and LeRobot formats. Generate dataset card with metadata, task descriptions, and licensing terms. Budget: 1 FTE-month in data engineering.

Month 10: Distribution and documentation. Upload to Hugging Face Datasets and institutional repository. Write technical report describing collection methodology, sensor specifications, and known limitations. Register DOI and submit to arXiv. Budget: 0.5 FTE-months in documentation and release engineering.

Total cost: $240,000–340,000. Total timeline: 10 months. Per-episode cost: $24–34. This cost structure explains why commercial humanoid datasets on the truelabel marketplace list at $8–25 per episode — economies of scale and amortized infrastructure reduce per-episode costs for established collectors^[20].

Related pages

Use these to move from category-level context into specific task, dataset, format, and comparison detail.

External references and source context

1. OpenVLA: An Open-Source Vision-Language-Action Model

   HumanPlus paper describes coordinated whole-body control challenges and reports 8-12% IK solution rejection rate

   arXiv ↩
2. DROID: A Large-Scale In-The-Wild Robot Manipulation Dataset

   DROID dataset contains 76,000 manipulation episodes with no bipedal locomotion; hybrid operator protocol increased success rate to 89%

   arXiv ↩
3. Open X-Embodiment: Robotic Learning Datasets and RT-X Models

   Open X-Embodiment aggregated 1M episodes across 22 robots; humanoid subsets under 5,000 episodes; uses RLDS format and Parquet compression achieving 3:1 ratio

   arXiv ↩
4. Figure + Brookfield humanoid pretraining dataset partnership

   Figure AI + Brookfield partnership signals 200,000+ hour pretraining dataset requirements

   figure.ai ↩
5. Project site

   RH20T provides 110,000 teleoperation clips; 80% used joystick control resulting in stereotyped gaits

   rh20t.github.io ↩
6. LeRobot: State-of-the-art Machine Learning for Real-World Robotics in Pytorch

   LeRobot framework supports ALOHA teleoperation but lacks reference humanoid mocap retargeting pipelines; includes 15+ dataset converters

   arXiv ↩
7. RT-1: Robotics Transformer for Real-World Control at Scale

   RT-1 Robotics Transformer trained on 130,000 manipulation episodes demonstrating emergent generalization

   arXiv ↩
8. Teleoperation datasets are becoming the highest-intent physical AI content category

   ALOHA bilateral teleoperation with haptic feedback reduced task completion time by 40%

   tonyzhaozh.github.io ↩
9. MCAP specification

   MCAP specification defines nanosecond-precision timestamp format

   MCAP ↩
10. LeRobot documentation

    LeRobot documentation describes MCAP support, timestamp validation, and stream resampling utilities

    Hugging Face ↩
11. RT-2: Vision-Language-Action Models Transfer Web Knowledge to Robotic Control

    RT-2 trained on multi-angle datasets enabling viewpoint-invariant manipulation

    arXiv ↩
12. Apache Parquet file format

    Apache Parquet with zstd compression reduces RGB frame storage by 60-70% losslessly

    Apache Parquet ↩
13. RLDS: an Ecosystem to Generate, Share and Use Datasets in Reinforcement Learning

    RLDS ecosystem provides reference implementations for temporal consistency validation and episode structure checks

    arXiv ↩
14. BridgeData V2: A Dataset for Robot Learning at Scale

    BridgeData V2 explicitly collected 20% of episodes as intentional near-failures to improve policy robustness

    arXiv ↩
15. Introduction to HDF5

    HDF5 format supports chunked storage and compression reducing file sizes by 40-60% vs uncompressed NumPy arrays

    The HDF Group ↩
16. truelabel data provenance glossary

    truelabel data provenance glossary defines minimum metadata requirements for physical AI datasets

    truelabel.ai ↩
17. C2PA Technical Specification

    C2PA technical specification provides framework for cryptographically signed provenance chains

    C2PA ↩
18. Domain Randomization for Transferring Deep Neural Networks from Simulation to the Real World

    Domain randomization paper demonstrated policies trained on 1M simulated episodes transferred to real quadrupeds with zero real-world fine-tuning

    arXiv ↩
19. Crossing the Reality Gap: A Survey on Sim-to-Real Transferability of Robot Controllers in Reinforcement Learning

    Sim-to-real survey found manipulation policies needed 1,000-5,000 real episodes even after pretraining on 100k+ simulated episodes

    arXiv ↩
20. truelabel physical AI data marketplace bounty intake

    truelabel physical AI data marketplace lists humanoid teleoperation datasets at $8-25 per episode; enforces validation standards

    truelabel.ai ↩
21. RoboNet dataset license

    RoboNet dataset license permits commercial use but requires attribution and prohibits raw data redistribution

    GitHub raw content ↩
22. GDPR Article 7 — Conditions for consent

    GDPR Article 7 requires explicit consent for biometric data collection including mocap body proportions

    GDPR-Info.eu ↩
23. Rescaling Egocentric Vision: Collection, Pipeline and Challenges for EPIC-KITCHENS-100

    EPIC-KITCHENS dataset anonymized participant faces and obtained informed consent providing reference compliance framework

    arXiv ↩
24. Subpart 27.4 - Rights in Data and Copyrights

    FAR Subpart 27.4 governs data rights in U.S. government contracts specifying unlimited vs limited rights

    acquisition.gov ↩
25. CVAT polygon annotation manual

    CVAT polygon annotation manual provides workflows for frame-by-frame object tracking

    docs.cvat.ai ↩
26. RLDS GitHub repository

    RLDS GitHub repository provides converters for RoboNet, BridgeData, and other datasets

    GitHub ↩
27. LeRobot GitHub repository

    LeRobot repository includes converters for ALOHA, RoboSet, and custom HDF5 layouts

    GitHub ↩
28. Hugging Face Datasets documentation

    Hugging Face Datasets documentation describes best practices for large-scale dataset hosting including sharding and compression

    Hugging Face ↩
29. NVIDIA Cosmos World Foundation Models

    NVIDIA Cosmos World Foundation Models initiative targeting pretraining on billions of frames

    NVIDIA Developer ↩
30. RLBench: The Robot Learning Benchmark & Learning Environment

    RLBench paper describes simulation benchmark for robot learning

    arXiv ↩

FAQ