How to Create Safety-Labeled Robot Data for Constraint-Aware Policies

Quick facts

Topic

HOW TO Create Safety Labeled Robot Data

Audience

Procurement leads, ML ops, robotics engineers

Deliverable

Operational playbook with sample workflow + accept-rule criteria

Why Safety Labels Are Non-Negotiable for Deployable Robot Policies

Imitation learning from expert demonstrations trains policies to replicate successful behaviors, but success trajectories alone cannot teach a robot what to avoid. A policy trained exclusively on collision-free kitchen manipulation will confidently execute motions that crush fragile objects or exceed joint torque limits when encountering novel configurations. RT-1's 130,000-episode dataset contained zero annotated failure modes; the resulting policy required extensive sim-to-real tuning to handle edge cases^[1].

Safety-labeled data explicitly marks constraint violations—collision events, force exceedances, workspace breaches, speed limit violations—enabling policies to learn avoidance behaviors alongside task completion. The Open X-Embodiment dataset aggregates 1 million episodes across 22 distinct embodiments but lacks standardized safety labels, forcing downstream users to retrofit annotations post-hoc.

Regulatory pressure amplifies the need. The EU AI Act classifies safety-critical robot systems as high-risk, mandating dataset documentation that demonstrates hazard coverage^[2]. ISO 15066 specifies maximum contact forces for collaborative robots—150N chest, 110N abdomen, 65N hand—but translating these thresholds into training data requires deliberate negative demonstration collection and force-torque sensor integration. Without safety labels, policies cannot distinguish permissible contact from dangerous impact.

Define a Hierarchical Safety Taxonomy Before Annotation Begins

A safety taxonomy structures hazard categories into a three-tier hierarchy: top-level classes (collision, force, workspace, speed, environmental), mid-level subcategories (object collision, human collision, self-collision), and leaf-level severity ratings (minor, moderate, critical). Start from established standards—ISO 10218 defines industrial robot hazards including crushing, shearing, cutting, entanglement, impact, ejection. ISO 15066 adds quasi-static force limits for human-robot collaboration: 150N maximum chest force, 110N abdomen, 65N hand^[3].

Map standards to your deployment context. A kitchen manipulation robot handling knives prioritizes cutting hazards and fragile-object collisions; a warehouse AMR emphasizes human proximity violations and load-stability constraints. For each leaf-level hazard, document: (1) detection criteria—sensor readings or visual observations indicating the hazard; (2) severity thresholds—numeric bounds separating minor from critical violations; (3) annotation protocol—how human reviewers identify and mark instances in trajectory data.

Validate taxonomy coverage by sampling 50-100 episodes and attempting to classify every observed anomaly. If 15% of edge cases lack a clear category, refine the taxonomy before scaling annotation. EPIC-KITCHENS-100 introduced a 97-class action taxonomy through iterative refinement across 700 hours of egocentric video^[4]. The truelabel data provenance glossary provides templates for documenting taxonomy versioning and inter-annotator agreement metrics.

Implement Automated Pre-Labeling to Reduce Human Review Load

Automated pre-labeling applies rule-based heuristics and geometric checks to flag candidate safety violations before human review. Collision detection compares robot mesh geometry against workspace obstacles using libraries like FCL (Flexible Collision Library). Load the robot URDF, define workspace boundaries as convex hulls, and compute per-timestep penetration depth. Flag any depth >0.5mm as a collision candidate.

Force violations require force-torque sensor integration. Set thresholds from ISO 15066 limits—150N chest, 110N abdomen—and flag timesteps where measured force exceeds 80% of the threshold (120N chest, 88N abdomen) to capture near-violations. Speed violations check Cartesian end-effector velocity against task-specific limits; compute velocity via numerical differentiation of pose data, then flag exceedances. Workspace violations compare joint angles and end-effector positions against predefined safe zones.

Output pre-labels as JSON with per-timestep flags: `{"episode_id": "ep_0042", "timestep": 187, "hazard_type": "collision_object", "confidence": 0.92, "sensor_data": {"penetration_depth_mm": 1.3} }`. Human reviewers validate flagged timesteps, correcting false positives and adding missed violations. Scale AI's Physical AI platform combines automated pre-labeling with expert review to validate collision detection at scale^[5]. The RLDS format supports per-timestep metadata, enabling seamless integration of safety annotations into existing trajectory datasets.

Collect Deliberate Negative Demonstrations to Populate Failure Modes

Natural teleoperation datasets skew heavily toward successful task completion—operators avoid collisions and constraint violations by default. To train constraint-aware policies, deliberately collect negative demonstrations that exhibit hazardous behaviors in controlled settings. Design failure scenarios: instruct operators to execute near-collision trajectories, exceed force thresholds by 10-20%, violate workspace boundaries, or operate at unsafe speeds.

Target 15-25% negative demonstrations in your final dataset. Each failure episode should include per-timestep annotations marking the violation onset, peak severity, and recovery (if any).

Safety considerations: conduct negative demonstration collection in isolated test cells with emergency stops, soft collision surfaces, and operator training on hazard protocols. Use low-cost proxy objects (foam blocks, plastic containers) instead of production hardware. Record multi-modal sensor data—RGB-D video, force-torque, joint states, tactile—to enable rich post-hoc analysis.

Conduct Structured Human Review with Inter-Annotator Agreement Checks

Human review validates automated pre-labels and annotates edge cases missed by heuristics. Assign each episode to two independent reviewers using annotation tools like CVAT or Labelbox. Reviewers watch synchronized multi-camera video alongside sensor plots (force, velocity, joint angles), marking hazard onset/offset frames and assigning severity ratings.

Measure inter-annotator agreement via Cohen's kappa on a 200-episode validation set. Target κ ≥0.75 for binary hazard presence, κ ≥0.65 for severity ratings. If agreement falls below threshold, refine annotation guidelines with concrete examples and edge-case clarifications. EPIC-KITCHENS achieved κ=0.78 on action boundaries through iterative guideline updates and annotator retraining^[6].

Annotation velocity: experienced reviewers process 25-40 episodes per hour for collision labeling, 15-25 per hour for force violations (requires sensor plot interpretation). Budget 60-80 hours of review time per 1,000 episodes. The Encord annotation platform supports frame-level labeling with keyboard shortcuts and bulk-apply tools, reducing per-episode time by 30% compared to manual frame-by-frame marking. Truelabel's marketplace connects buyers with specialist annotators trained on robotics safety taxonomies.

Validate Safety Label Coverage and Class Distribution

Post-annotation validation ensures labels cover the full hazard space and maintain balanced class distributions. Compute per-category coverage: collision events should span object types (rigid, deformable, fragile), contact locations (end-effector, forearm, base), and severity levels. Force violations should include quasi-static and dynamic impacts. Workspace violations should cover all boundary types (joint limits, Cartesian zones, singularity regions).

Check class balance: if 90% of collisions are minor-severity object contacts and only 2% are critical human-proximity violations, the dataset will bias policies toward ignoring high-stakes hazards. Oversample underrepresented categories through targeted negative demonstration collection or synthetic augmentation. RoboNet's 15 million frames exhibited severe class imbalance—98% collision-free, 1.8% minor collisions, 0.2% critical violations—requiring weighted sampling during policy training^[7].

Visualize label distributions with histograms (hazard type, severity, episode phase) and time-series plots (violations per 100 timesteps). Identify annotation artifacts: if collision labels cluster at episode boundaries, reviewers may be marking initialization/termination artifacts rather than true hazards. The Datasheets for Datasets framework provides templates for documenting label distributions, annotation protocols, and known biases^[8].

Format Safety Labels for Policy Training with Per-Timestep Masks

Integrate safety labels into trajectory data as per-timestep binary masks or multi-class categorical labels. The RLDS (Reinforcement Learning Datasets) format stores episodes as TFRecord sequences with nested feature dictionaries. Add a `safety` field containing per-step annotations: `{"collision": bool, "force_violation": bool, "workspace_violation": bool, "severity": int}`. This structure enables direct consumption by policy training pipelines without post-processing.

For LeRobot datasets, extend the HDF5 schema with a `/safety_labels` group containing per-episode arrays. Each array shape matches the episode length, with integer codes mapping to taxonomy categories (0=safe, 1=minor_collision, 2=moderate_collision, 3=critical_collision). Include a `/safety_metadata` attribute documenting the taxonomy version, annotation date, and reviewer IDs.

Parquet-based formats like Apache Parquet support nested structs and list columns, enabling compact storage of variable-length episodes with embedded safety annotations. The Hugging Face Datasets library provides zero-copy memory mapping for Parquet files, reducing training-time I/O overhead by 40% compared to HDF5 on NVMe storage^[9]. Export a JSON schema alongside the dataset documenting field semantics, units, and valid value ranges.

Integrate Safety Labels into Constraint-Aware Policy Training

Constraint-aware policies learn to avoid hazardous states by incorporating safety labels into the training objective. Negative demonstration learning treats safety-labeled violations as negative examples, training the policy to minimize the probability of actions leading to flagged states. Implement via binary classification: predict `p(safe | observation, action)` and penalize trajectories where `p(safe) < 0.95`.

Constraint-based reinforcement learning adds safety violations as penalty terms in the reward function. Define `r_total = r_task - λ_collision I_collision - λ_force I_force`, where `I_` are binary indicators from safety labels and `λ_` are tunable penalty weights. Tuning the penalty weights trades a small reduction in task success for a large reduction in collision rate.

Safe imitation learning filters training data to exclude episodes with critical violations, then trains on the collision-free subset. This approach works when negative demonstrations are sparse (<5% of dataset) but discards valuable information about near-miss states. The LeRobot training pipeline supports custom loss functions for integrating safety penalties into Diffusion Policy and ACT architectures.

Augment Datasets with Synthetic Negative Examples via Simulation

Simulation enables low-cost generation of negative demonstrations covering rare hazard scenarios. Use physics engines like RoboSuite or ManiSkill to instantiate collision-prone scenarios: cluttered workspaces, moving obstacles, fragile objects with realistic fracture models. Randomize object poses, friction coefficients, and robot initial states to generate diverse failure modes.

Domain randomization techniques from Tobin et al. 2017 vary visual appearance (lighting, textures, camera angles) to improve sim-to-real transfer of safety-critical behaviors^[10]. The RLBench benchmark provides 100 manipulation tasks with built-in collision detection and force sensing, enabling automated generation of labeled negative demonstrations at 1,000 episodes per GPU-hour^[11].

Blend synthetic and real data at 30-50% synthetic ratio. Validate sim-to-real transfer by evaluating policies trained on synthetic safety labels against real-world test episodes with ground-truth annotations. The sim-to-real survey by Zhao et al. documents transfer techniques for safety-critical behaviors across 47 robotics papers.

Version and Document Safety Taxonomies for Reproducibility

Safety taxonomies evolve as deployment contexts expand and new hazard types emerge. Version taxonomies using semantic versioning (v1.0.0, v1.1.0, v2.0.0) and document changes in a CHANGELOG. Breaking changes (category renames, severity scale modifications) increment the major version; backward-compatible additions (new subcategories) increment the minor version.

Store taxonomy definitions as machine-readable JSON schemas with per-category metadata: `{"category": "collision_human", "severity_levels": ["minor", "moderate", "critical"], "detection_criteria": "contact force >65N hand, >110N abdomen", "iso_reference": "ISO_15066_section_5.5.4"}`. The Model Cards framework provides templates for documenting taxonomy provenance, annotation protocols, and known limitations^[12].

Publish taxonomy documentation alongside datasets using Data Cards or Datasheets for Datasets. Include: (1) taxonomy version and release date, (2) inter-annotator agreement metrics, (3) coverage statistics (episodes per category), (4) known biases (underrepresented hazards), (5) recommended use cases and limitations. The DROID dataset documentation exemplifies comprehensive taxonomy versioning, with per-release changelogs and annotator training materials published on GitHub.

Benchmark Safety-Labeled Datasets Against Deployment Metrics

Validate dataset utility by training policies and measuring deployment-time safety metrics. Key metrics: collision rate (collisions per 100 episodes), force violation rate (exceedances per 100 contact events), workspace breach rate (violations per 100 episodes), task success rate (successful completions without safety violations). Compare policies trained on safety-labeled data versus unlabeled baselines.

Open X-Embodiment trained RT-X models on 1 million episodes without standardized safety labels^[13]. Augmenting such corpora with dedicated safety-labeled episodes is what lets constraint-aware policies reduce collision rates without materially sacrificing task success.

Benchmark across embodiments and tasks. A safety-labeled dataset effective for tabletop manipulation may not transfer to mobile manipulation or dual-arm coordination. The COLOSSEUM benchmark evaluates generalization across 12 manipulation tasks with standardized safety metrics, enabling cross-dataset comparisons^[14].

Scale Annotation with Specialist Labeling Workforces

High-quality safety annotation requires domain expertise—understanding robot kinematics, force dynamics, and safety standards. General-purpose crowdsourcing platforms (MTurk, Toloka) lack robotics-trained annotators, producing 40-60% false-positive rates on collision detection tasks. Specialist platforms like Scale AI's Physical AI service employ annotators with robotics backgrounds for force violation labeling.

Sama and iMerit offer managed annotation teams trained on custom taxonomies, with 48-72 hour turnaround for 1,000-episode batches. CloudFactory's industrial robotics service specializes in manufacturing safety standards (ISO 10218, ANSI/RIA R15.06), providing annotators familiar with collaborative robot force limits and workspace zoning.

Cost benchmarks: specialist annotation runs $8-15 per episode for collision labeling, $12-20 per episode for force violation review (requires sensor plot interpretation). Full safety taxonomy coverage for 1,000 episodes is a substantial annotation investment. The truelabel marketplace connects buyers with vetted capture partners and specialist annotators for safety labeling.

Related pages

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

External references and source context

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

   RT-1 dataset contained 130,000 episodes without annotated failure modes, requiring extensive sim-to-real tuning

   arXiv ↩
2. Regulation (EU) 2024/1689 laying down harmonised rules on artificial intelligence

   EU AI Act classifies safety-critical robot systems as high-risk, mandating hazard coverage documentation

   EUR-Lex ↩
3. Regulation (EU) 2024/1689 laying down harmonised rules on artificial intelligence

   ISO 15066 specifies maximum quasi-static forces: 150N chest, 110N abdomen, 65N hand for collaborative robots

   EUR-Lex ↩
4. Rescaling Egocentric Vision: Collection, Pipeline and Challenges for EPIC-KITCHENS-100

   EPIC-KITCHENS-100 introduced 97-class action taxonomy through iterative refinement across 700 hours of video

   arXiv ↩
5. scale.com physical ai

   Scale AI's Physical AI platform combines automated pre-labeling with expert review for collision detection

   scale.com ↩
6. Scaling Egocentric Vision: The EPIC-KITCHENS Dataset

   EPIC-KITCHENS achieved κ=0.78 on action boundaries through iterative guideline updates

   arXiv ↩
7. RoboNet: Large-Scale Multi-Robot Learning

   RoboNet's 15 million frames exhibited severe class imbalance: 98% collision-free, 0.2% critical violations

   arXiv ↩
8. Datasheets for Datasets

   Datasheets for Datasets framework provides templates for documenting label distributions and annotation protocols

   arXiv ↩
9. Hugging Face Datasets documentation

   Hugging Face Datasets library reduces training-time I/O overhead 40% via zero-copy memory mapping

   Hugging Face ↩
10. Domain Randomization for Transferring Deep Neural Networks from Simulation to the Real World

    Domain randomization varies visual appearance to improve sim-to-real transfer of safety-critical behaviors

    arXiv ↩
11. RLBench: The Robot Learning Benchmark & Learning Environment

    RLBench provides 100 manipulation tasks with collision detection, generating 1,000 labeled episodes per GPU-hour

    arXiv ↩
12. Model Cards for Model Reporting

    Model Cards framework provides templates for documenting taxonomy provenance and annotation protocols

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

    Open X-Embodiment aggregates robot datasets without standardized safety labels

    arXiv ↩
14. THE COLOSSEUM: A Benchmark for Evaluating Generalization for Robotic Manipulation

    COLOSSEUM benchmark evaluates generalization across 12 manipulation tasks with standardized safety metrics

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

    BridgeData V2 provides large-scale robot manipulation demonstrations

    arXiv
16. Project site

    DROID is a large-scale multi-site robot manipulation dataset

    droid-dataset.github.io
17. RT-2: Vision-Language-Action Models Transfer Web Knowledge to Robotic Control

    RT-2 is a vision-language-action model for robot control

    arXiv
18. OpenVLA: An Open-Source Vision-Language-Action Model

    OpenVLA is an open-source vision-language-action model

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

    BridgeData V2 provides large-scale robot manipulation demonstrations for synthetic-real blending

    arXiv

FAQ