LaelaZ/vla-action-anomaly-eval

VLA Action Anomaly Eval

It's easy to assume a runtime safety check works because it catches an obvious NaN. Whether it actually catches the subtler failure, an action that's drifted somewhere the policy was never calibrated for, is a question you can only answer by measuring it. This is the small labelled set that lets you measure it.

It pairs real teleoperated robot actions (the in-distribution, "normal" class) with realistic faults injected into held-out real actions (the anomaly class), so a runtime supervisor for a vision-language-action policy can be scored with a real detection rate and a real false-positive rate instead of a claim.

Built for the runtime safety supervisor in github.com/LaelaZorana/embodied-efficiency, with a live demo at the Hugging Face Space.

What's in it

The actions are 7-dim Franka end-effector commands [x, y, z, roll, pitch, yaw, gripper], drawn from DROID (real teleoperated manipulation).

• calibration (6,000 rows): real actions you fit the supervisor's "normal" model on.
• eval (3,000 rows, balanced 50/50): each row is an action to vet plus the action before it (prev_*, which the jerk check needs), a binary label (0 normal, 1 fault), and a fault_type.

fault_type	label	how it's made
normal	0	a real held-out action, untouched
nonfinite	1	a real action with NaN/Inf in one dimension
out_of_bounds	1	a real action with 1 to 3 dims pushed past the joint limits
drift	1	a real action shifted 1.5 to 6 std from the calibrated posture, kept in-bounds
jerk	1	a large in-bounds jump from the previous accepted action

data/action_limits.json holds the per-dimension joint limits derived from the calibration set. data/supervisor_eval.npz is the same data bundled for the evaluation script. The in-distribution data is real and the faults are synthetic but injected into real actions and labelled as such, so nothing synthetic is presented as real.

What it shows

Running the supervisor against this set (see evaluate.py):

• The drift (OOD) detector scores AUC 0.99 separating normal from drifted actions.
• The non-finite and joint-limit checks catch 100% by construction, they're hard checks.
• The detector's threshold is an operating point you tune, not a guess. A conservative threshold catches every NaN and over-limit command while almost never raising a false alarm. Tuned from the ROC to a 1% false-positive budget, it catches 91% of all faults at 1% false positives.

A useful caveat the numbers expose: on real, correlated, non-Gaussian actions, the deliberately simple diagonal-Gaussian detector sits around 1% false positives where a clean Gaussian would sit near zero. That's the v0 model's known limit, and it's why you tune the threshold to your own fleet.

Reproduce

python3 make_eval_set.py     # rebuilds from DROID via the Hub (needs huggingface_hub, pyarrow)
python3 evaluate.py          # calibrates, sweeps the threshold, prints the ROC + operating point

Source and license

Derived from DROID (IPEC-COMMUNITY/droid_lerobot, the LeRobot port), released under CC-BY-4.0. DROID: A Large-Scale In-the-Wild Robot Manipulation Dataset, Khazatsky et al., 2024, https://droid-dataset.github.io. This set redistributes a small slice of those actions plus synthetic faults under the same CC-BY-4.0, with attribution.