Upload transform_batch.py with huggingface_hub

transform_batch.py

@@ -11,6 +11,7 @@ import json
 import os
 import ssl
 import sys
+import time
 import urllib.request
 from concurrent.futures import ProcessPoolExecutor, as_completed
 from pathlib import Path
@@ -48,18 +49,66 @@ STAGE_KEYS = [k for k, _ in STAGES]
 MARKERS = [("[M6]", "output"), ("[M5]", "qa"), ("[M4]", "smooth"),
            ("[M3.5]", "collision"), ("[M3]", "ik"), ("[M2]", "base"), ("[M1]", "retarget")]
 
+
+# ── QA verdict: fold FAITHFULNESS (tracking / orientation / arm-collision) into the per-clip
+# PASS/WARN/FAIL alongside the motion-quality verdict. Was motion-only, which missed clips that
+# move smoothly but don't actually follow the human demo. Thresholds are env-overridable so the
+# UI can tune them per run (see config.py for the same defaults). higher value = worse.
+def _envf(key: str, default: float) -> float:
+    try:
+        return float(os.environ.get(key, default))
+    except (TypeError, ValueError):
+        return default
+
+_QA_IK_WARN = _envf("QA_IK_CM_WARN", 3.0)
+_QA_IK_FAIL = _envf("QA_IK_CM_FAIL", 6.0)
+_QA_ORI_WARN = _envf("QA_ORI_DEG_WARN", 15.0)
+_QA_ORI_FAIL = _envf("QA_ORI_DEG_FAIL", 30.0)
+_QA_ARMS_STRICT = os.environ.get("QA_ARMS_STRICT", "0") == "1"
+_QA_RANK = {"PASS": 0, "WARN": 1, "FAIL": 2, "?": 0}
+
+
+def _grade_high(v: float, warn: float, fail: float) -> str:
+    """Grade a metric where higher is worse against warn/fail bounds."""
+    if v is None:
+        return "PASS"
+    if v >= fail:
+        return "FAIL"
+    if v >= warn:
+        return "WARN"
+    return "PASS"
+
+
+def _worst(*verdicts: str) -> str:
+    return max(verdicts, key=lambda v: _QA_RANK.get(v, 0))
+
 KP_COLS = [f"observation.state.{h}{k}" for h in ("right", "left")
            for k in ("ThumbTip", "IndexFingerTip", "MiddleFingerTip", "Hand")]
 
 
-def _ensure(cache: Path, rel: str) -> Path:
+def _ensure(cache: Path, rel: str, timeout: int = 30, retries: int = 4) -> Path:
+    """Download a repo file to cache, ONCE. Bounded per-request timeout + retries + atomic write so a
+    single stalled host connection can't hang the whole run forever (urlopen has no default timeout —
+    that infinite block was what froze prewarm at 0% CPU)."""
     local = cache / REPO.replace("/", "__") / rel
-    if not local.exists():
-        local.parent.mkdir(parents=True, exist_ok=True)
-        req = urllib.request.Request(RESOLVE % (REPO, rel), headers={"User-Agent": "fd-studio"})
-        with urllib.request.urlopen(req, context=_SSL_CTX) as r:
-            local.write_bytes(r.read())
-    return local
+    if local.exists() and local.stat().st_size > 0:
+        return local
+    local.parent.mkdir(parents=True, exist_ok=True)
+    url = RESOLVE % (REPO, rel)
+    last = None
+    for attempt in range(retries):
+        try:
+            req = urllib.request.Request(url, headers={"User-Agent": "fd-studio"})
+            with urllib.request.urlopen(req, timeout=timeout, context=_SSL_CTX) as r:
+                data = r.read()
+            tmp = local.with_name(local.name + ".part")
+            tmp.write_bytes(data)
+            tmp.replace(local)   # atomic — a killed/partial download never looks complete
+            return local
+        except Exception as e:
+            last = e
+            time.sleep(min(5.0, 1.0 * (attempt + 1)))
+    raise RuntimeError(f"download failed after {retries} tries: {rel}: {last}")
 
 
 def _episode_range(cache: Path, subset: str, ep: int) -> dict:
@@ -129,10 +178,21 @@ class Report:
             s["status"] = "done"
         c["status"] = "done"
         c["output"] = res.get("output")
+        ik_R = round(res.get("ik_R_cm", 0), 2)
+        ik_L = round(res.get("ik_L_cm", 0), 2)
+        ori_R = round(res.get("ori_R_deg", 0), 1)
+        ori_L = round(res.get("ori_L_deg", 0), 1)
+        motion = res.get("qa_verdict", "?")            # m5_qa motion-quality verdict
+        # grade faithfulness on the worse of the two arms, then combine (worst wins)
+        track_g = _grade_high(max(ik_R, ik_L), _QA_IK_WARN, _QA_IK_FAIL)
+        ori_g = _grade_high(max(ori_R, ori_L), _QA_ORI_WARN, _QA_ORI_FAIL)
+        arms_g = "PASS" if collision == "clean" else ("FAIL" if _QA_ARMS_STRICT else "WARN")
+        verdict = _worst(motion, track_g, ori_g, arms_g)
         c["metrics"] = {
-            "ik_R_cm": round(res.get("ik_R_cm", 0), 2), "ik_L_cm": round(res.get("ik_L_cm", 0), 2),
-            "ori_R_deg": round(res.get("ori_R_deg", 0), 1), "ori_L_deg": round(res.get("ori_L_deg", 0), 1),
-            "collision": collision, "qa": res.get("qa_verdict", "?"), "dof": 14,
+            "ik_R_cm": ik_R, "ik_L_cm": ik_L, "ori_R_deg": ori_R, "ori_L_deg": ori_L,
+            "collision": collision, "qa": verdict, "qa_motion": motion, "dof": 14,
+            # per-component grades so the UI can show WHAT drove the verdict + re-grade live
+            "qa_components": {"tracking": track_g, "orientation": ori_g, "arms": arms_g, "motion": motion},
             "n_frames": res.get("n_frames_out", c["n_frames"]),
         }
 
@@ -184,21 +244,23 @@ class _Tee(io.TextIOBase):
         self.orig.flush()
 
 
-def _prewarm(cache: Path, clips: list) -> None:
-    """Download each clip's episodes-meta + data parquet ONCE in the parent, so parallel
-    workers only read the cache (no concurrent-download races on the same 100 MB file)."""
-    seen: set = set()
-    for clip in clips:
+def _prewarm(cache: Path, clips: list, workers: int = 24) -> None:
+    """Download each clip's episodes-meta + data parquet up front so the retarget workers only read
+    the cache. Runs in PARALLEL with bounded per-file timeouts — the old sequential + no-timeout
+    version froze the whole run for good if a single host connection stalled (0% CPU, flat disk).
+    Existence-check + atomic write make concurrent fetches of a shared file safe/idempotent."""
+    from concurrent.futures import ThreadPoolExecutor
+
+    def _warm(clip):
         try:
             subset, ep_s = clip["clip_id"].split("#")
             r = _episode_range(cache, subset, int(ep_s))
-            key = f"{subset}/{r['data/chunk_index']}/{r['data/file_index']}"
-            if key in seen:
-                continue
-            seen.add(key)
             _ensure(cache, f"{PREFIX}{subset}/data/chunk-{r['data/chunk_index']:03d}/file-{r['data/file_index']:03d}.parquet")
         except Exception:
-            pass
+            pass   # a clip that can't prefetch is retried lazily in its worker — never blocks prewarm
+
+    with ThreadPoolExecutor(max_workers=min(workers, max(1, len(clips)))) as ex:
+        list(ex.map(_warm, clips))
 
 
 def _run_one(payload: dict) -> dict: