make_eval_set.py

"""Build a labelled OOD / fault evaluation set for the safety supervisor.

The supervisor in this repo is calibrated on whatever "normal" looks like and
then flags actions that drift away from it. To say how *well* it does that we
need real in-distribution actions plus labelled faults, so this script:

  1. pulls a small slice of real teleoperated actions from DROID (a Franka arm,
     7-dim action [x, y, z, roll, pitch, yaw, gripper]), via LeRobot on the Hub,
  2. splits episodes into a calibration set and a held-out test set,
  3. derives per-dimension action limits from the calibration set,
  4. builds a balanced eval set: real actions (label 0, "normal") plus four
     realistic fault types (label 1) injected into held-out real actions:
        - nonfinite     a sensor glitch puts NaN/Inf in one dimension
        - out_of_bounds one or more dims pushed past the joint limits
        - drift         the action shifted k std away from the calibrated posture
        - jerk          a large in-bounds jump from the previous accepted action

The in-distribution data is real; the faults are synthetic but injected into
real actions and labelled as such (honest by construction). Output is a single
self-contained .npz (small) plus a data card, committed so evaluate.py needs
only numpy.

Run:  python3 safety/make_eval_set.py        # writes safety/data/supervisor_eval.npz
Deps (build-time only): huggingface_hub, pyarrow.  Consuming it needs only numpy.

Source dataset: IPEC-COMMUNITY/droid_lerobot (DROID, CC-BY-4.0). DROID:
A Large-Scale In-the-Wild Robot Manipulation Dataset (Khazatsky et al., 2024).
"""
from __future__ import annotations

import glob
import os

import numpy as np

REPO = "IPEC-COMMUNITY/droid_lerobot"
N_EPISODES = 100          # episodes 0..99 from chunk-000 (low-dim parquet only)
N_CALIB_EP = 70           # first N_CALIB_EP episodes calibrate; the rest are held out for test
SEED = 0
OUT = os.path.join(os.path.dirname(__file__), "data", "supervisor_eval.npz")

FAULTS = ["nonfinite", "out_of_bounds", "drift", "jerk"]
FTYPE_CODE = {"normal": 0, "nonfinite": 1, "out_of_bounds": 2, "drift": 3, "jerk": 4}


def _download_actions():
    """Return a list of [T, 7] action arrays, one per episode, real DROID data."""
    from huggingface_hub import snapshot_download
    import pyarrow.parquet as pq

    local = snapshot_download(
        REPO, repo_type="dataset",
        allow_patterns=["data/chunk-000/episode_0000*.parquet"],   # episodes 0..99
    )
    files = sorted(glob.glob(os.path.join(local, "data", "chunk-000", "*.parquet")))[:N_EPISODES]
    if not files:
        raise RuntimeError("no episode parquets downloaded; check network / dataset id")
    eps = []
    for f in files:
        col = pq.read_table(f, columns=["action"]).column("action").to_pylist()
        eps.append(np.asarray(col, dtype=np.float64))   # [T, 7]
    return eps


def main():
    rng = np.random.default_rng(SEED)
    eps = _download_actions()
    calib_eps, test_eps = eps[:N_CALIB_EP], eps[N_CALIB_EP:]

    calib = np.concatenate(calib_eps, axis=0)
    A = calib.shape[1]
    mean, std = calib.mean(0), calib.std(0)

    # Joint limits from the calibration range, with a 15% margin so legitimate
    # held-out actions stay in-bounds and only genuine over-range trips the check.
    lo, hi = calib.min(0), calib.max(0)
    margin = 0.15 * (hi - lo)
    low, high = lo - margin, hi + margin

    # subsample calibration so the committed file stays small
    if len(calib) > 6000:
        calib = calib[rng.choice(len(calib), 6000, replace=False)]

    # Held-out real (prev, action) consecutive pairs: the source of every eval row.
    pairs = []
    for ep in test_eps:
        for t in range(1, len(ep)):
            pairs.append((ep[t - 1], ep[t]))
    pairs = [pairs[i] for i in rng.permutation(len(pairs))]

    per = 600                                   # rows per class -> ~3000 total, balanced 50/50
    need = per * (1 + len(FAULTS))
    pairs = pairs[:need]
    chunks = {k: pairs[i * per:(i + 1) * per]
              for i, k in enumerate(["normal"] + FAULTS)}

    ev_act, ev_prev, ev_label, ev_ftype = [], [], [], []

    def add(action, prev, label, ftype):
        ev_act.append(action); ev_prev.append(prev)
        ev_label.append(label); ev_ftype.append(FTYPE_CODE[ftype])

    for prev, a in chunks["normal"]:
        add(a.copy(), prev.copy(), 0, "normal")

    for prev, a in chunks["nonfinite"]:
        f = a.copy(); f[rng.integers(A)] = np.nan if rng.random() < 0.5 else np.inf
        add(f, prev.copy(), 1, "nonfinite")

    for prev, a in chunks["out_of_bounds"]:
        f = a.copy()
        for d in rng.choice(A, rng.integers(1, 4), replace=False):
            over = (0.2 + rng.random()) * (high[d] - low[d])     # clearly past the limit
            f[d] = (high[d] + over) if rng.random() < 0.5 else (low[d] - over)
        add(f, prev.copy(), 1, "out_of_bounds")

    for prev, a in chunks["drift"]:
        k = rng.uniform(1.5, 6.0)                                # severity in std units, mild..strong
        direction = rng.normal(size=A); direction /= np.linalg.norm(direction) + 1e-9
        f = np.clip(a + k * std * direction * np.sqrt(A), low, high)   # drifted, kept in-bounds
        add(f, prev.copy(), 1, "drift")

    for prev, a in chunks["jerk"]:
        # large jump from prev, kept in-bounds and near the calibrated posture so
        # it isolates the jerk check rather than tripping bounds/drift.
        direction = rng.normal(size=A); direction /= np.linalg.norm(direction) + 1e-9
        f = np.clip(prev + rng.uniform(0.5, 0.9) * (high - low) * direction, low, high)
        add(f, prev.copy(), 1, "jerk")

    ev_act = np.asarray(ev_act); ev_prev = np.asarray(ev_prev)
    ev_label = np.asarray(ev_label, dtype=np.int64); ev_ftype = np.asarray(ev_ftype, dtype=np.int64)
    perm = rng.permutation(len(ev_act))         # shuffle so classes interleave

    os.makedirs(os.path.dirname(OUT), exist_ok=True)
    np.savez_compressed(
        OUT,
        calib_actions=calib.astype(np.float32),
        action_low=low.astype(np.float32), action_high=high.astype(np.float32),
        eval_action=ev_act[perm].astype(np.float32), eval_prev=ev_prev[perm].astype(np.float32),
        eval_label=ev_label[perm], eval_ftype=ev_ftype[perm],
        ftype_codes=np.asarray([f"{k}={v}" for k, v in FTYPE_CODE.items()]),
    )
    n = len(ev_act)
    print(f"wrote {OUT}")
    print(f"  calibration frames: {len(calib)} (from {N_CALIB_EP} episodes), action_dim={A}")
    print(f"  eval rows: {n}  ({(ev_label == 0).sum()} normal, {(ev_label == 1).sum()} fault)")
    for k, c in FTYPE_CODE.items():
        cnt = int((ev_ftype == c).sum())
        if cnt:
            print(f"    {k:<14} {cnt}")
    print(f"  action limits: low={np.round(low,3).tolist()}")
    print(f"                 high={np.round(high,3).tolist()}")


if __name__ == "__main__":
    main()