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 and RoboCasa teleoperation demos.

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:

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:

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 and RoboCasa; please cite those alongside this dataset.

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