Datasets:

aaronngx
/

failbench-wm1

---
license: cc-by-4.0
task_categories:
- robotics
tags:
- LeRobot
- world-model
- robot-failure
- manipulation
- franka
- panda
- counterfactual
configs:
- config_name: default
  data_files: data/*/*.parquet
---

# FailBench `wm1` — a world-model corpus of robot actuator failures

**66,480 episodes · 7.3M frames · 5.5 s each · 20 fps · 640×480 · Franka Panda**

Each episode shows a robot mid-task, an actuator fault firing at a known instant,
and the five seconds that follow. The fault is given as an **8-dim vector, per
frame** — all-zero before the onset, constant after — so a model can be asked
*"if these joints go limp here, what happens next?"* before anything has
happened.

Built in MuJoCo on top of [LIBERO](https://libero-project.github.io/) and
[RoboCasa](https://robocasa.ai/) teleoperation demos.

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

past   = [-0.15, -0.10, -0.05, 0.0]        # 4 observed frames
future = [0.05 * i for i in range(1, 9)]   # 8 predicted frames

ds = LeRobotDataset(
    "aaronngx/failbench-wm1",
    delta_timestamps={k: past + future for k in
                      ("observation.images.agentview", "observation.state",
                       "action", "fault")},
)

s = ds[0]
s["observation.images.agentview"]   # (12, 3, 480, 640)
s["fault"]                          # (12, 8)  -> zeros, then the fault
s["task"]                           # "Pick the mug ... the shoulder joint loses actuation ..."
```

The onset is always frame 10, so a window anchored before it has the fault firing
inside the prediction horizon — observed frames pre-failure, target frames
post-failure.

## Features

| feature | dtype | shape | notes |
|---|---|---|---|
| `observation.images.agentview` | video | `[3,480,640]` | scene view, camera randomised per demo |
| `observation.images.wrist` | video | `[3,480,640]` | hand-mounted (72% of the download) |
| `observation.state` | float32 | `[9]` | 7 arm joints + 2 finger positions |
| `action` | float32 | `[7]` | the PD target that actually drove the physics |
| `action.demo` | float32 | `[7]` | the operator's recorded action |
| `fault` | float32 | `[8]` | `[j1…j7, gripper]`, **per frame** |
| `task` | string | | the natural-language prompt (62,883 distinct) |

**`action[k]` precedes `frame[k]` — apply no shift.** The value at index *k* is the
control in force during the physics steps that *end* at frame *k*. The source
LIBERO/RoboCasa demos use the opposite convention (an action at *t* takes effect
at *t+1*), but this corpus never replays recorded actions — it drives a PD target
and logs the operator action alongside. Shifting introduces the off-by-one it
appears to fix.

`observation.state` is robot-only and fixed-width; the underlying sim `qpos` is
scene-dependent (41–110 columns) and cannot be a fixed-shape feature. End-effector
position is omitted because it is a deterministic function of the arm joints.

## Composition

| | |
|---|---|
| LIBERO / RoboCasa | 27,000 / 39,480 episodes |
| demos · tasks · distinct scenes | 1,108 · 50 · 968 |
| nominal (fault = all zeros) | 2,297 |
| failure cells covered | 383 of 383, 163–172 episodes each |
| train / val | 59,880 / 6,600 (split **by demo**, never by episode) |

Failure coverage is **round-robin over the cell lattice** (127 non-empty joint
subsets × 3 gripper states, plus 2 gripper-only), so coverage is exact by
construction rather than by sampling. The number of failed joints is therefore
**binomial, not uniform** — `{0: 2632, 1: 3526, 2: 10563, 3: 17560, 4: 17604,
5: 10558, 6: 3530, 7: 507}`. Each episode carries `failure_prob`, the realistic
fault prior, for importance reweighting.

Per-episode metadata in `meta/episodes/`: `trial_id, source, task_name, demo_uid,
failure_key, failed_joints, n_failed_joints, gripper_mode, fail_idx,
traj_progress, cam_variant, failure_prob, is_nominal, is_holding, held_at_onset,
onset_frame, split`.

## Matched controls

Slot 0 of each timestep is a **nominal run from the same demo at the same
instant** as its five failures, so a difference between them is attributable to
the fault rather than to arm pose or task phase. 2,297 such groups share a single
camera and are pixel-comparable — their pre-failure frames agree to 0.17 grey
levels.

## Known defect — the gripper channel on RoboCasa

For episodes holding an object at the failure instant, RoboCasa loses the object
almost regardless of the fault:

| gripper mode | LIBERO released by t=5 s | RoboCasa released |
|---|---:|---:|
| `none` (no gripper fault) | 4% | **88%** |
| `slip` | 60% | 94% |
| `open` | 64% | 96% |

A grasp does not survive being teleported into: the sim state is written
directly, discarding the contact history that held the object, while the finger
actuators sit at a command that means *fully closed* — squeezing RoboCasa's
~5.4 cm objects out of the grasp. LIBERO's ~1.7 cm objects survive it.

**Filter with `held_at_onset`** for anything predicting pixels or object motion:

```python
import pandas as pd
eps = pd.read_parquet("meta/episodes/chunk-000/file-000.parquet")
clean = eps[(eps.source == "libero") | (~eps.held_at_onset)]   # 49,146 episodes
```

This costs **no diversity** — the same demos also produce non-holding episodes, so
all 1,108 scenes and every task survive.

**Arm-joint conditioning is unaffected**, being a separate actuator path: failed
joints deviate from the commanded target **14.2×** (LIBERO) / **16.5×**
(RoboCasa) more than healthy ones. If joint failure is what you are modelling,
the corpus is sound as published.

## Other caveats

- **A nominal episode is simulated, not replayed.** Only the 10 context frames
  reproduce the source demo exactly; the rest is re-simulated with a PD tracker
  and drifts (LIBERO 0.009 rad / 0.011 m, RoboCasa 0.025 rad / 0.055 m, mean over
  the branch). This is deliberate — a matched control must run through the same
  dynamics as its failures — but nominals are not ground truth for what the
  operator did next.
- **Limp-failure semantics model brake failure**, not a typical Franka fault (a
  real Panda has failsafe brakes). A worst-case envelope, which suits a safety
  planner, but say so in any writeup.
- **Both corpora are Panda** (RoboCasa uses `PandaMobile`), so this tests scene,
  task and camera transfer — not cross-embodiment transfer.
- **`torchcodec` may fail to load** depending on your torch/ffmpeg build. Pass
  `video_backend="pyav"` if so; it is a decoder issue, not a dataset issue.

## Partial download

The wrist stream is 33 GB of the 46 GB total:

```python
from huggingface_hub import snapshot_download
snapshot_download("aaronngx/failbench-wm1", repo_type="dataset",
                  allow_patterns=["meta/*", "data/*",
                                  "videos/observation.images.agentview/*"])
```

Stock `LeRobotDataset` expects every declared video feature to be present, so an
agentview-only checkout needs `observation.images.wrist` removed from the local
`meta/info.json`.

## Provenance

Generated with MuJoCo 3.3.4 at 640×480, H.264 CRF 20, 20 Hz (robosuite's control
timestep of 1/20 over a 0.002 s physics step). The branch is exactly 5.000 s —
2,500 `mj_step` sampled every 25. Video was stream-copied into LeRobot v3 shards
without re-encoding, and verified to decode bit-identically to the source clips.

Built on [LIBERO](https://libero-project.github.io/) and
[RoboCasa](https://robocasa.ai/); please cite those alongside this dataset.