GPU kernels, tolerance and graders
Collection
Kernels measured on real hardware, and the graders that decide when two correct answers disagree. • 4 items • Updated
You need to agree to share your contact information to access this dataset
This repository is publicly accessible, but you have to accept the conditions to access its files and content.
Use it freely, keep the attribution with it, and tell me what you are building with it.
Log in or Sign Up to review the conditions and access this dataset content.
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 binarylabel(0 normal, 1 fault), and afault_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.
Who built this
I am Laela Zorana. I write GPU kernels and measure them on real hardware, on AMD Instinct cards and on AWS Trainium, and most of my work sits at the point where two correct answers disagree and something has to decide which one to trust.
If this was useful, a like puts it in front of the next person looking for the same thing, and following means you see what I measure next. If you are using it for something, I would like to hear what.
Where the rest of my work lives.
- Hugging Face, https://huggingface.co/LaelaZorana
- GitHub, https://github.com/LaelaZorana
- Website, https://codezorana.ai
- LinkedIn, https://www.linkedin.com/in/laela-zorana-362309114
- Downloads last month
- 69