README.md

---
pretty_name: "EXOKERN ContactBench v0.1.1 - Peg Insertion with Domain Randomization + Force/Torque"
license: cc-by-nc-4.0
task_categories:
  - robotics
language:
  - en
tags:
  - robotics
  - force-torque
  - contact-rich
  - manipulation
  - insertion
  - lerobot
  - domain-randomization
  - sim-to-real
  - isaac-lab
  - franka
  - benchmark
  - physical-ai
size_categories:
  - 1K<n<10K
dataset_info:
  features:
    - name: observation.state
      dtype: float32
      shape: [24]
    - name: observation.wrench
      dtype: float32
      shape: [6]
    - name: action
      dtype: float32
      shape: [7]
    - name: timestamp
      dtype: float32
    - name: frame_index
      dtype: int64
    - name: episode_index
      dtype: int64
    - name: index
      dtype: int64
    - name: task_index
      dtype: int64
  splits:
    - name: train
      num_examples: 745000
configs:
  - config_name: default
    data_files:
      - split: train
        path: "data/**/*.parquet"
---

# EXOKERN ContactBench v0.1.1 — Peg Insertion with Domain Randomization + Force/Torque

Versioned production release of the EXOKERN DR insertion corpus for LeRobot training.
This dataset contains contact-rich peg insertion demonstrations with full 6-axis wrench signals and multi-layer domain randomization.

Part of the [ContactBench](https://huggingface.co/EXOKERN) collection by EXOKERN — The Data Engine for Physical AI.

## Why This Dataset Exists

Over 95% of existing robotics manipulation datasets contain **no force/torque data**. Yet contact-rich tasks — insertion, threading, snap-fit assembly — fundamentally depend on haptic feedback for reliable execution. Vision alone cannot distinguish a jammed peg from a seated one.

This dataset provides 5,000 **domain-randomized** peg-in-hole insertion episodes with full 6-axis wrench data at every timestep, generated using the [FORGE](https://arxiv.org/abs/2408.04587) (Force-Guided Exploration) framework in NVIDIA Isaac Lab. Every frame captures what the robot *feels*, not just what it sees — under varying physical conditions that simulate real-world uncertainty.

## Release Positioning

- **v0**: fixed-condition baseline dataset (`2,221` episodes) — [link](https://huggingface.co/datasets/EXOKERN/contactbench-forge-peginsert-v0)
- **v0.1**: first DR release (`5,000` episodes) — [link](https://huggingface.co/datasets/EXOKERN/contactbench-forge-peginsert-v0.1)
- **v0.1.1** ← **this release**: semantic versioned production publish for stable downstream references and reproducible training/evaluation

## Dataset Statistics

| Metric | v0.1.1 | v0 |
|---|---:|---:|
| Episodes | 5,000 | 2,221 |
| Total Frames | 745,000 | 330,929 |
| Avg Episode Length | 149 | 149 |
| Control Frequency | 20 Hz | 20 Hz |
| Format | LeRobot v3.0 (Parquet) | LeRobot v3.0 (Parquet) |
| Robot | Franka FR3 (7-DOF) | Franka FR3 (7-DOF) |
| Simulator | NVIDIA Isaac Lab | NVIDIA Isaac Lab |
| Domain Randomization | Active multi-layer stack | Mostly fixed conditions |

## Features

| Key | Shape | Description |
|---|---|---|
| `observation.state` | (24,) | Collapsed policy state tensor exported by the FORGE task |
| `observation.wrench` | (6,) | Force/Torque vector `[Fx, Fy, Fz, Mx, My, Mz]` in N / N·m |
| `action` | (7,) | Action vector used for rollout supervision |
| `timestamp` | scalar | Per-frame timestamp |
| `frame_index` | scalar | Frame index within episode |
| `episode_index` | scalar | Episode index |
| `index` | scalar | Global frame index |
| `task_index` | scalar | LeRobot task mapping index |

## State Tensor Semantics

The `observation.state` tensor is a flat 24-element vector produced by FORGE's `collapse_obs_dict()`. It concatenates the following quantities in order:

| Index Range | Field | Dim | Unit |
|:-----------:|-------|:---:|------|
| 0–2 | `fingertip_pos` | 3 | m |
| 3–5 | `fingertip_pos_rel_fixed` | 3 | m |
| 6–9 | `fingertip_quat` | 4 | — |
| 10–12 | `ee_linvel` | 3 | m/s |
| 13–15 | `ee_angvel` | 3 | rad/s |
| 16–21 | `force_sensor_smooth` | 6 | N / N·m |
| 22 | `force_threshold` | 1 | N |
| 23 | `ema_factor` | 1 | — |

**Note**: `observation.wrench` contains the same data as `observation.state[16:22]`. The wrench is stored as a dedicated column for direct access without index arithmetic.

Implementation reference: These fields correspond to `OBS_DIM_CFG` in [factory_env_cfg.py](https://github.com/isaac-sim/IsaacLab/blob/main/source/isaaclab_tasks/isaaclab_tasks/direct/factory/factory_env_cfg.py) (indices 0–15) extended by the FORGE force-sensing additions (indices 16–23). See [Noseworthy et al., 2024](https://arxiv.org/abs/2408.04587) §III for details.

## Wrench Specification

The wrench is reported at the end-effector body frame attached to the Franka gripper link (`panda_hand`). Forces are measured via Isaac Lab's `get_link_incoming_joint_force()` method applied to the wrist joint, then smoothed with an exponential moving average (EMA factor configurable, default 0.2).

| Component | Index | Unit | Description |
|-----------|:-----:|------|-------------|
| Fx | 0 | N | Force along x-axis |
| Fy | 1 | N | Force along y-axis |
| Fz | 2 | N | Force along z-axis (insertion axis) |
| Mx | 3 | N·m | Torque about x-axis |
| My | 4 | N·m | Torque about y-axis |
| Mz | 5 | N·m | Torque about z-axis |

## Domain Randomization Stack

Randomization is applied during data generation (not post-processing):

| Layer | Parameter | Range | Application mode |
|---|---|---|---|
| 1 - Geometric init | Peg x/y offset | `[-8 mm, +8 mm]` | per episode reset |
| 1 - Geometric init | Peg z offset | `[-3 mm, +5 mm]` | per episode reset |
| 1 - Geometric init | Peg roll/pitch | `±5 deg` | per episode reset |
| 1 - Geometric init | Peg yaw | `±10 deg` | per episode reset |
| 2 - Object physics | Peg mass scale | `[0.7, 1.3]` | reset/startup (runner dependent) |
| 3 - Contact materials | Static friction | `[0.2, 1.2]` | per episode reset |
| 3 - Contact materials | Dynamic friction | `[0.15, 0.9]` | per episode reset |
| 3 - Contact materials | Restitution | `[0.0, 0.3]` | per episode reset |
| 4 - Robot dynamics | Stiffness scale | `[0.8, 1.2]` (log-uniform) | per episode reset |
| 4 - Robot dynamics | Damping scale | `[0.7, 1.3]` (log-uniform) | per episode reset |
| 6/7 - Noise models | Observation/action Gaussian noise | active in v0.1 run config | runtime attachment |

Implementation notes:
- Final Option-A production run used fixed joint profile `nominal` (friction/armature ×1.0).
- Dedicated joint friction/armature EventTerm exists in code but was disabled for this final production collection.

## Force/Torque QC Snapshot

| Metric | Value |
|---|---|
| Episodes with wrench data | `5000 / 5000` (100%) |
| Contact-like episodes (QC proxy) | `4298 / 5000` (86.0%) |
| Contact-like criterion | `max(‖F_xyz‖) > 2.0 N` per episode |
| Peak force quantiles (0/50/90/99/100%) | `0.0388, 8.2533, 11.9820, 14.9128, 24.2634 N` |
| Mean force quantiles (0/50/90/99/100%) | `0.0189, 1.6533, 5.6933, 7.7840, 9.1356 N` |

This contact-like metric is a quality-control proxy, not a ground-truth success label.

## Quick Start

```python
from lerobot.datasets.lerobot_dataset import LeRobotDataset

ds = LeRobotDataset("EXOKERN/contactbench-forge-peginsert-v0.1.1")
print(f"Episodes: {ds.num_episodes}, Frames: {len(ds)}")

frame = ds[0]
state  = frame["observation.state"]   # (24,) — full observation
wrench = frame["observation.wrench"]  # (6,)  — force/torque

# Decompose wrench
force  = wrench[:3]  # [Fx, Fy, Fz] in N
torque = wrench[3:]  # [Mx, My, Mz] in N·m
print(f"Force: {force} N")
print(f"Torque: {torque} N·m")

# Decompose state vector
ee_pos      = state[0:3]    # fingertip position (m)
ee_pos_rel  = state[3:6]    # position relative to socket (m)
ee_quat     = state[6:10]   # orientation quaternion
ee_linvel   = state[10:13]  # linear velocity (m/s)
ee_angvel   = state[13:16]  # angular velocity (rad/s)
wrench_st   = state[16:22]  # force/torque (N, N·m) — same as observation.wrench
f_threshold = state[22]     # force threshold (N)
ema         = state[23]     # EMA smoothing factor
```

### Load with pure HuggingFace Datasets

```python
from datasets import load_dataset

ds = load_dataset("EXOKERN/contactbench-forge-peginsert-v0.1.1", split="train")
print(ds[0].keys())
```

## Intended Use

Designed for imitation learning and diffusion-policy training on contact-rich insertion, including:
- Force-aware policy learning (`full_ft` vs `no_ft`)
- Robustness studies under domain randomization
- Sim-to-real transfer preparation and stress-testing

Recommended training config:
- Architecture: Diffusion Policy (71.3M params)
- Seeds: 3 × 2 conditions (full_ft / no_ft) = 6 runs
- Epochs: 300, batch size 256, lr 1e-4

Not intended for direct safety-critical deployment without additional validation and real-system calibration.

## Evaluation Tool

Use [exokern-eval](https://github.com/Exokern/exokern_eval) to benchmark trained policies against EXOKERN baselines:

```bash
pip install exokern-eval
exokern-eval --policy your_checkpoint.pt --env Isaac-Forge-PegInsert-Direct-v0 --episodes 100
```

## Related Resources

| Resource | Link |
|---|---|
| v0 Dataset | [EXOKERN/contactbench-forge-peginsert-v0](https://huggingface.co/datasets/EXOKERN/contactbench-forge-peginsert-v0) |
| v0.1 Dataset | [EXOKERN/contactbench-forge-peginsert-v0.1](https://huggingface.co/datasets/EXOKERN/contactbench-forge-peginsert-v0.1) |
| Skill v0 (trained model) | [EXOKERN/skill-forge-peginsert-v0](https://huggingface.co/EXOKERN/skill-forge-peginsert-v0) |
| Skill v0.1.1 (trained model) | [EXOKERN/skill-forge-peginsert-v0.1.1](https://huggingface.co/EXOKERN/skill-forge-peginsert-v0.1.1) |
| Eval CLI | [github.com/Exokern/exokern_eval](https://github.com/Exokern/exokern_eval) |
| EXOKERN Org | [huggingface.co/EXOKERN](https://huggingface.co/EXOKERN) |

## Related Work

- **FORGE** — Noseworthy et al., "[Force-Guided Exploration for Robust Contact-Rich Manipulation under Uncertainty](https://arxiv.org/abs/2408.04587)" (ISRR 2024)
- **Factory** — Narang et al., "[Factory: Fast Contact for Robotic Assembly](https://arxiv.org/abs/2205.03532)" (RSS 2022)
- **IndustReal** — Tang et al., "[IndustReal: Transferring Contact-Rich Assembly Tasks from Simulation to Reality](https://arxiv.org/abs/2305.17110)" (RSS 2023)
- **Diffusion Policy** — Chi et al., "[Diffusion Policy: Visuomotor Policy Learning via Action Diffusion](https://arxiv.org/abs/2303.04137)" (RSS 2023)
- **LeRobot** — Cadene et al., "[LeRobot: State-of-the-art Machine Learning for Real-World Robotics](https://github.com/huggingface/lerobot)" (2024)

## Citation

```bibtex
@dataset{exokern_contactbench_peginsert_v011_2026,
  title   = {EXOKERN ContactBench v0.1.1: Peg Insertion with Domain Randomization and Force/Torque},
  author  = {{EXOKERN}},
  year    = {2026},
  url     = {https://huggingface.co/datasets/EXOKERN/contactbench-forge-peginsert-v0.1.1},
  license = {CC-BY-NC-4.0}
}
```

## License

CC-BY-NC 4.0 — Free for research and non-commercial use.
For commercial licensing, contact EXOKERN.

## About EXOKERN

**EXOKERN — The Data Engine for Physical AI**

We produce industrially calibrated force/torque manipulation data for enterprise robotics, humanoid manufacturers, and research institutions. Contact-rich. Sensor-annotated. Industrially validated.

🌐 [exokern.com](https://exokern.com) · 🤗 [huggingface.co/EXOKERN](https://huggingface.co/EXOKERN) · 🐙 [github.com/Exokern](https://github.com/Exokern)