Upload validate_batch.py with huggingface_hub

validate_batch.py

@@ -0,0 +1,381 @@
+#!/usr/bin/env python3
+"""Data Validation engine (stage 4) — runs in the retarget venv (numpy<2 + h5py + scipy).
+
+Operates on the transformed output (store/<run>/transform/retargeted/*/retargeted.hdf5) which the
+retarget engine already annotates with rich QA (`qa`, `m4`, `ik_errors_*`). This script:
+
+  mode=qa          → per-clip Trajectory Quality & Hygiene report (feasibility + motion + integrity)
+  mode=correct     → clamp joint limits + smooth vel/acc/jerk → corrected hdf5 (no retime)
+  mode=similarity  → transformed-ego vs teleop action-distribution distance + score
+
+Writes JSON to --out (the API reads it back). Invoked exactly like transform_batch.py.
+"""
+from __future__ import annotations
+
+import argparse
+import glob
+import json
+import os
+import xml.etree.ElementTree as ET
+
+import numpy as np
+
+# ---- tunable thresholds (placeholder defaults; surfaced in the report so the UI can show them) ----
+TH = {
+    "ik_ok_m": 0.02,          # per-frame IK error under this (m) = frame "solved"
+    "ik_success_min": 0.90,   # >= this fraction of frames solved → feasibility OK
+    "limit_viol_warn": 0.001, # fraction of (frame×joint) samples out of joint range
+    "limit_viol_fail": 0.02,
+    "selfcol_min_dist_m": 0.02,   # min link clearance (m) below which = collision risk
+    "continuity_max_drad": 0.5,   # max per-frame per-joint jump (rad) before "teleport"
+    "chatter_warn": 2.0,          # oscillation rate (from retarget qa) warn level
+}
+
+FINGER_NAMES = ("left_finger", "right_finger", "finger")
+
+
+def joint_limits(xml_path: str) -> dict:
+    """Parse <joint name range> from yam_real.xml → {base_name: (lo, hi)} (radians)."""
+    out = {}
+    try:
+        root = ET.parse(xml_path).getroot()
+        for j in root.iter("joint"):
+            name, rng = j.get("name"), j.get("range")
+            if name and rng:
+                lo, hi = (float(x) for x in rng.split())
+                out[name] = (lo, hi)
+    except Exception:
+        pass
+    return out
+
+
+def limits_vector(joint_names: list, lims: dict) -> np.ndarray:
+    """Build (14, 2) lo/hi aligned to the clip's joint_names (strip R_/L_ prefix → base)."""
+    rows = []
+    for jn in joint_names:
+        base = jn.split("_", 1)[1] if (jn.startswith("R_") or jn.startswith("L_")) else jn
+        if base in lims:
+            rows.append(lims[base])
+        elif any(f in base for f in FINGER_NAMES):
+            # fingers: use whichever finger range exists
+            fr = next((lims[k] for k in lims if "finger" in k), (-1e9, 1e9))
+            rows.append(fr)
+        else:
+            rows.append((-1e9, 1e9))
+    return np.array(rows, dtype=float)
+
+
+def _attr_json(h, key):
+    v = h.attrs.get(key)
+    if v is None:
+        return {}
+    try:
+        return json.loads(v if isinstance(v, str) else v.decode())
+    except Exception:
+        return {}
+
+
+def qa_one(path: str, lims: dict) -> dict:
+    import h5py
+    with h5py.File(path, "r") as h:
+        jp = np.asarray(h["joint_positions"][:], dtype=float)          # (T, 14)
+        ts = np.asarray(h["timestamps"][:], dtype=float) if "timestamps" in h else None
+        fps = float(h.attrs.get("fps", 30.0))
+        jn = json.loads(h.attrs.get("joint_names", "[]"))
+        ik_L = np.asarray(h["ik_errors_L"][:], dtype=float) if "ik_errors_L" in h else None
+        ik_R = np.asarray(h["ik_errors_R"][:], dtype=float) if "ik_errors_R" in h else None
+        qa = _attr_json(h, "qa")
+        m4 = _attr_json(h, "m4")
+        clip = h.attrs.get("clip", os.path.basename(os.path.dirname(path)))
+        task = h.attrs.get("task", "")
+
+    T = jp.shape[0]
+    dt = 1.0 / fps if fps else 1.0 / 30
+
+    # --- integrity ---
+    finite = bool(np.isfinite(jp).all())
+    dframe = np.abs(np.diff(jp, axis=0)) if T > 1 else np.zeros((0, jp.shape[1]))
+    max_jump = float(dframe.max()) if dframe.size else 0.0
+    frame_drops = 0
+    if ts is not None and ts.size > 2:
+        gaps = np.diff(ts)
+        frame_drops = int(np.sum(gaps > 1.8 * np.median(gaps)))
+
+    # --- feasibility ---
+    lo_hi = limits_vector(jn, lims) if jn else np.tile([-1e9, 1e9], (jp.shape[1], 1))
+    below = jp < lo_hi[:, 0]
+    above = jp > lo_hi[:, 1]
+    viol = below | above
+    limit_viol_frac = float(viol.mean()) if viol.size else 0.0
+    per_joint_viol = viol.mean(axis=0).tolist() if viol.size else []
+
+    def ik_frac(ik):
+        return float(np.mean(ik <= TH["ik_ok_m"])) if ik is not None and ik.size else None
+    ik_success = [f for f in (ik_frac(ik_R), ik_frac(ik_L)) if f is not None]
+    ik_success_min = min(ik_success) if ik_success else None
+
+    # self-collision from the retarget qa (min link clearance across arms)
+    selfcol_dists = []
+    for arm in ("R", "L"):
+        d = ((qa.get("arms", {}).get(arm, {}) or {}).get("metrics", {}) or {}).get("selfcol_min_dist")
+        if d is not None:
+            selfcol_dists.append(float(d))
+    selfcol_min = min(selfcol_dists) if selfcol_dists else None
+
+    # --- motion (finite-diff on joints; peaks; plus retarget smoothness/chatter/saturation) ---
+    vel = np.diff(jp, axis=0) / dt if T > 1 else np.zeros((0, jp.shape[1]))
+    acc = np.diff(vel, axis=0) / dt if vel.shape[0] > 1 else np.zeros((0, jp.shape[1]))
+    jerk = np.diff(acc, axis=0) / dt if acc.shape[0] > 1 else np.zeros((0, jp.shape[1]))
+    peak_vel = float(np.abs(vel).max()) if vel.size else 0.0
+    peak_acc = float(np.abs(acc).max()) if acc.size else 0.0
+    peak_jerk = float(np.abs(jerk).max()) if jerk.size else 0.0
+
+    def arm_metric(key):
+        vals = []
+        for arm in ("R", "L"):
+            v = ((qa.get("arms", {}).get(arm, {}) or {}).get("metrics", {}) or {}).get(key)
+            if v is not None:
+                vals.append(float(v))
+        return vals
+    ldlj = arm_metric("ldlj")            # log dimensionless jerk (smoothness; more negative = jerkier)
+    chatter = arm_metric("chatter_rate")
+    saturation = arm_metric("saturation_frac")
+
+    # --- verdict: blend our checks with the retarget's own qa_verdict ---
+    reasons = []
+    verdict = "PASS"
+
+    def demote(level, why):
+        nonlocal verdict
+        order = {"PASS": 0, "WARN": 1, "FAIL": 2}
+        if order[level] > order[verdict]:
+            verdict = level
+        reasons.append(why)
+
+    if not finite:
+        demote("FAIL", "non-finite joint values")
+    if max_jump > TH["continuity_max_drad"]:
+        demote("WARN", f"discontinuity {max_jump:.2f} rad/frame")
+    if limit_viol_frac > TH["limit_viol_fail"]:
+        demote("FAIL", f"joint-limit violation {limit_viol_frac*100:.1f}%")
+    elif limit_viol_frac > TH["limit_viol_warn"]:
+        demote("WARN", f"minor limit violation {limit_viol_frac*100:.2f}%")
+    if ik_success_min is not None and ik_success_min < TH["ik_success_min"]:
+        demote("FAIL" if ik_success_min < 0.8 else "WARN", f"IK solved {ik_success_min*100:.0f}%")
+    if selfcol_min is not None and selfcol_min < TH["selfcol_min_dist_m"]:
+        demote("WARN", f"self-collision clearance {selfcol_min*100:.1f}cm")
+    if chatter and max(chatter) > TH["chatter_warn"]:
+        demote("WARN", f"chatter {max(chatter):.1f}")
+    rv = qa.get("verdict")
+    if rv == "FAIL":
+        demote("WARN", "retarget QA flagged FAIL")   # respect but don't hard-fail on retarget-only
+
+    return {
+        "clip": clip, "task": task, "n_frames": T, "fps": fps,
+        "verdict": verdict, "reasons": reasons,
+        "feasibility": {
+            "limit_viol_frac": round(limit_viol_frac, 4),
+            "per_joint_viol": [round(x, 4) for x in per_joint_viol],
+            "ik_success_min": None if ik_success_min is None else round(ik_success_min, 3),
+            "selfcol_min_dist_m": None if selfcol_min is None else round(selfcol_min, 4),
+        },
+        "motion": {
+            "peak_vel": round(peak_vel, 3), "peak_acc": round(peak_acc, 2), "peak_jerk": round(peak_jerk, 1),
+            "ldlj": [round(x, 2) for x in ldlj], "chatter": [round(x, 2) for x in chatter],
+            "saturation": [round(x, 3) for x in saturation],
+        },
+        "integrity": {"finite": finite, "max_jump_rad": round(max_jump, 3), "frame_drops": frame_drops},
+        "retarget_verdict": rv,
+    }
+
+
+def run_qa(retargeted_dir: str, xml_path: str) -> dict:
+    lims = joint_limits(xml_path)
+    files = sorted(glob.glob(os.path.join(retargeted_dir, "*", "retargeted.hdf5")))
+    clips = []
+    for f in files:
+        try:
+            clips.append(qa_one(f, lims))
+        except Exception as e:
+            clips.append({"clip": os.path.basename(os.path.dirname(f)), "verdict": "FAIL",
+                          "reasons": [f"read error: {e}"], "error": str(e)})
+    counts = {v: sum(1 for c in clips if c.get("verdict") == v) for v in ("PASS", "WARN", "FAIL")}
+    certified = [c["clip"] for c in clips if c.get("verdict") in ("PASS", "WARN")]
+    return {
+        "mode": "qa",
+        "n_clips": len(clips),
+        "counts": counts,
+        "certified": certified,
+        "clips": clips,
+        "thresholds": TH,
+    }
+
+
+def _peak_jerk(jp: np.ndarray, dt: float) -> float:
+    if jp.shape[0] < 4:
+        return 0.0
+    j = np.diff(jp, n=3, axis=0) / (dt ** 3)
+    return float(np.abs(j).max()) if j.size else 0.0
+
+
+def correct_one(path: str, lims: dict) -> dict:
+    """Clamp to joint limits + smooth (Savitzky-Golay) — no retime. Writes corrected.hdf5 alongside."""
+    import h5py
+    from scipy.signal import savgol_filter
+    with h5py.File(path, "r") as h:
+        jp = np.asarray(h["joint_positions"][:], dtype=float)
+        jn = json.loads(h.attrs.get("joint_names", "[]"))
+        fps = float(h.attrs.get("fps", 30.0))
+        clip = h.attrs.get("clip", os.path.basename(os.path.dirname(path)))
+        keep = {k: np.asarray(h[k][:]) for k in h.keys() if k != "joint_positions"}
+        attrs = dict(h.attrs)
+    T = jp.shape[0]
+    dt = 1.0 / fps if fps else 1.0 / 30
+    lo_hi = limits_vector(jn, lims) if jn else np.tile([-1e9, 1e9], (jp.shape[1], 1))
+
+    before = {"limit_viol_frac": round(float(((jp < lo_hi[:, 0]) | (jp > lo_hi[:, 1])).mean()), 4),
+              "peak_jerk": round(_peak_jerk(jp, dt), 1)}
+
+    clamped = np.clip(jp, lo_hi[:, 0], lo_hi[:, 1])
+    win = min(T if T % 2 else T - 1, 7)          # odd window ≤ T, ≤ 7
+    if win >= 5 and T > win:
+        smoothed = savgol_filter(clamped, win, 3, axis=0)
+        smoothed = np.clip(smoothed, lo_hi[:, 0], lo_hi[:, 1])   # re-clamp after smoothing
+    else:
+        smoothed = clamped
+
+    after = {"limit_viol_frac": round(float(((smoothed < lo_hi[:, 0]) | (smoothed > lo_hi[:, 1])).mean()), 4),
+             "peak_jerk": round(_peak_jerk(smoothed, dt), 1)}
+
+    out_path = os.path.join(os.path.dirname(path), "corrected.hdf5")
+    with h5py.File(out_path, "w") as o:
+        o.create_dataset("joint_positions", data=smoothed)
+        for k, v in keep.items():
+            o.create_dataset(k, data=v)
+        for k, v in attrs.items():
+            o.attrs[k] = v
+        o.attrs["corrected"] = True
+        o.attrs["smooth_window"] = int(win)
+    return {"clip": clip, "before": before, "after": after,
+            "jerk_reduction": round(before["peak_jerk"] - after["peak_jerk"], 1),
+            "smooth_window": int(win), "output": out_path}
+
+
+def run_correct(retargeted_dir: str, xml_path: str) -> dict:
+    lims = joint_limits(xml_path)
+    files = sorted(glob.glob(os.path.join(retargeted_dir, "*", "retargeted.hdf5")))
+    clips, tot_j = [], 0.0
+    for f in files:
+        try:
+            c = correct_one(f, lims)
+            clips.append(c)
+            tot_j += max(0.0, c["jerk_reduction"])
+        except Exception as e:
+            clips.append({"clip": os.path.basename(os.path.dirname(f)), "error": str(e)})
+    ok = [c for c in clips if "error" not in c]
+    return {"mode": "correct", "n_clips": len(clips), "corrected": len(ok),
+            "mean_jerk_reduction": round(tot_j / max(1, len(ok)), 1), "clips": clips}
+
+
+def _ego_actions(retargeted_dir: str, max_frames: int = 60000) -> np.ndarray:
+    import h5py
+    arrs, n = [], 0
+    for f in sorted(glob.glob(os.path.join(retargeted_dir, "*", "retargeted.hdf5"))):
+        with h5py.File(f, "r") as h:
+            a = np.asarray(h["joint_positions"][:], dtype=float)
+        arrs.append(a); n += a.shape[0]
+        if n >= max_frames:
+            break
+    return np.concatenate(arrs) if arrs else np.zeros((0, 14))
+
+
+def _teleop_actions(teleop_dir: str, max_frames: int = 60000) -> np.ndarray:
+    import pyarrow.parquet as pq
+    arrs, n = [], 0
+    for f in sorted(glob.glob(os.path.join(teleop_dir, "**", "*.parquet"), recursive=True)):
+        try:
+            col = pq.read_table(f, columns=["action"]).column("action").to_pylist()
+        except Exception:
+            continue
+        a = np.array(col, dtype=float)
+        if a.ndim != 2:
+            continue
+        arrs.append(a); n += a.shape[0]
+        if n >= max_frames:
+            break
+    return np.concatenate(arrs) if arrs else np.zeros((0, 14))
+
+
+def run_similarity(retargeted_dir: str, teleop_dir: str) -> dict:
+    """Task-agnostic execution similarity: do transformed-ego action distributions look like
+    expert teleop? Per-joint Wasserstein (action + velocity) + range coverage + histograms."""
+    from scipy.stats import wasserstein_distance
+    ego = _ego_actions(retargeted_dir)
+    tel = _teleop_actions(teleop_dir)
+    if ego.size == 0 or tel.size == 0:
+        return {"mode": "similarity", "error": "no ego or teleop actions",
+                "ego_frames": int(ego.shape[0]), "teleop_frames": int(tel.shape[0])}
+
+    D = min(ego.shape[1], tel.shape[1])
+    per_joint = []
+    for j in range(D):
+        e, t = ego[:, j], tel[:, j]
+        s = t.std() or 1.0
+        wd = wasserstein_distance(e / s, t / s)
+        ev, tv = np.diff(e), np.diff(t)
+        sv = tv.std() or 1.0
+        wdv = wasserstein_distance(ev / sv, tv / sv) if ev.size and tv.size else 0.0
+        lo, hi = np.percentile(t, [1, 99])
+        cov = float(np.mean((e >= lo) & (e <= hi)))
+        # shared-range histograms for the UI overlay
+        rlo, rhi = float(min(e.min(), t.min())), float(max(e.max(), t.max()))
+        be, _ = np.histogram(e, bins=20, range=(rlo, rhi), density=True)
+        bt, edges = np.histogram(t, bins=20, range=(rlo, rhi), density=True)
+        per_joint.append({
+            "joint": j, "w_action": round(float(wd), 3), "w_vel": round(float(wdv), 3),
+            "sim": round(float(np.exp(-wd)), 3), "coverage": round(cov, 3),
+            "hist": {"edges": [round(x, 3) for x in edges.tolist()],
+                     "ego": [round(x, 3) for x in be.tolist()],
+                     "teleop": [round(x, 3) for x in bt.tolist()]},
+        })
+    score = float(np.mean([p["sim"] for p in per_joint]))
+    coverage = float(np.mean([p["coverage"] for p in per_joint]))
+    verdict = "PASS" if (score >= 0.6 and coverage >= 0.7) else ("WARN" if score >= 0.4 else "FAIL")
+    return {"mode": "similarity", "score": round(score, 3), "coverage": round(coverage, 3),
+            "verdict": verdict, "ego_frames": int(ego.shape[0]), "teleop_frames": int(tel.shape[0]),
+            "n_joints": D, "per_joint": per_joint}
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--mode", default="qa", choices=["qa", "correct", "similarity"])
+    ap.add_argument("--retargeted", required=True, help="store/<run>/transform/retargeted")
+    ap.add_argument("--xml", default=os.path.join(os.path.dirname(__file__), "yam_real.xml"))
+    ap.add_argument("--teleop", default="", help="teleop actions .npy (for similarity)")
+    ap.add_argument("--thresholds", default="", help="JSON overrides merged into TH")
+    ap.add_argument("--out", required=True)
+    a = ap.parse_args()
+
+    if a.thresholds:
+        try:
+            TH.update({k: float(v) for k, v in json.loads(a.thresholds).items() if k in TH})
+        except Exception:
+            pass
+
+    if a.mode == "qa":
+        rep = run_qa(a.retargeted, a.xml)
+    elif a.mode == "correct":
+        rep = run_correct(a.retargeted, a.xml)
+    elif a.mode == "similarity":
+        rep = run_similarity(a.retargeted, a.teleop)
+    else:
+        rep = {"mode": a.mode, "error": "unknown mode"}
+
+    with open(a.out, "w") as f:
+        json.dump(rep, f, indent=2)
+    print(json.dumps({"mode": a.mode, "n_clips": rep.get("n_clips"), "counts": rep.get("counts"),
+                      "out": a.out}))
+
+
+if __name__ == "__main__":
+    main()