Upload transform_batch.py with huggingface_hub

transform_batch.py

@@ -0,0 +1,309 @@
+"""T3/T4 — batch retarget over selected_clips.json with live, human-readable progress.
+
+Runs under .venv-retarget. For each shortlisted clip: materialize a single-episode parquet
+→ run the real M1..M6 engine → emit per-clip friendly-stage progress + metrics into
+transform_report.json (written incrementally so the console can poll it live).
+"""
+import argparse
+import contextlib
+import io
+import json
+import os
+import ssl
+import sys
+import urllib.request
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from pathlib import Path
+
+import numpy as np
+import pyarrow.compute as pc
+import pyarrow.parquet as pq
+
+# macOS Python's urllib has no CA bundle by default → HF downloads fail with
+# CERTIFICATE_VERIFY_FAILED. Use certifi's bundle (fall back to unverified only if absent).
+try:
+    import certifi
+
+    _SSL_CTX = ssl.create_default_context(cafile=certifi.where())
+except Exception:
+    _SSL_CTX = ssl._create_unverified_context()
+
+REPO = os.environ.get("FD_EGO_REPO", "Kavin60606/EgoDex-PickPlace-10hr")
+PREFIX = os.environ.get("FD_EGO_PREFIX", "")  # "" = 10hr root layout; "train/" = griffinlabs
+RESOLVE = "https://huggingface.co/datasets/%s/resolve/main/%s"
+
+# customer-facing stage names (replace M1..M6)
+STAGES = [
+    ("load", "Reading human demo"),
+    ("retarget", "Retargeting motion to robot"),
+    ("base", "Placing the robot"),
+    ("ik", "Solving arm joints (IK)"),
+    ("collision", "Checking arm collisions"),
+    ("smooth", "Smoothing trajectory"),
+    ("qa", "Quality check"),
+    ("output", "Saving robot trajectory"),
+]
+STAGE_KEYS = [k for k, _ in STAGES]
+# order matters: match "[M3.5]" before "[M3]"
+MARKERS = [("[M6]", "output"), ("[M5]", "qa"), ("[M4]", "smooth"),
+           ("[M3.5]", "collision"), ("[M3]", "ik"), ("[M2]", "base"), ("[M1]", "retarget")]
+
+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:
+    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
+
+
+def _episode_range(cache: Path, subset: str, ep: int) -> dict:
+    base = f"{PREFIX}{subset}"
+    cols = ["episode_index", "length", "tasks", "data/chunk_index", "data/file_index",
+            "dataset_from_index", "dataset_to_index"]
+    for i in range(0, 12):  # episodes/chunk-000/file-000.parquet, file-001, ...
+        rel = f"{base}/meta/episodes/chunk-000/file-{i:03d}.parquet"
+        try:
+            local = _ensure(cache, rel)
+        except Exception:
+            break
+        for row in pq.read_table(local, columns=cols).to_pylist():
+            if row["episode_index"] == ep:
+                return row
+    raise KeyError(f"episode {ep} not found in {subset}")
+
+
+def _materialize(cache: Path, subset: str, ep: int, out_root: Path) -> str:
+    r = _episode_range(cache, subset, ep)
+    ci, fi = r["data/chunk_index"], r["data/file_index"]
+    data_rel = f"{PREFIX}{subset}/data/chunk-{ci:03d}/file-{fi:03d}.parquet"
+    local = _ensure(cache, data_rel)
+    # a data file concatenates many episodes; `dataset_from/to_index` are GLOBAL offsets,
+    # so filter by the file's own episode_index column instead of slicing.
+    table = pq.read_table(local, columns=KP_COLS + ["episode_index"])
+    table = table.filter(pc.equal(table["episode_index"], ep)).select(KP_COLS)
+    mat = out_root / "materialized" / subset / "data" / "chunk-000"
+    mat.mkdir(parents=True, exist_ok=True)
+    out = mat / f"file-{ep:06d}.parquet"
+    pq.write_table(table, out)
+    return str(out)
+
+
+class Report:
+    def __init__(self, path: Path, clips: list, teleop: dict):
+        self.path = path
+        self.teleop = teleop
+        self.data = {
+            "clips_total": len(clips),
+            "clips": [{
+                "clip_id": c["clip_id"], "task": c.get("task", ""), "n_frames": c.get("n_frames", 0),
+                "status": "pending",
+                "stages": [{"key": k, "label": lbl, "status": "pending"} for k, lbl in STAGES],
+                "metrics": {}, "error": None, "output": None,
+            } for c in clips],
+            "match_report": None, "done": False,
+        }
+        self.write()
+
+    def write(self):
+        self.path.write_text(json.dumps(self.data, indent=2))
+
+    def advance(self, i: int, key: str):
+        pos = STAGE_KEYS.index(key)
+        for j, s in enumerate(self.data["clips"][i]["stages"]):
+            s["status"] = "done" if j < pos else ("running" if j == pos else "pending")
+        self.data["clips"][i]["status"] = "running"
+
+    def start(self, i: int):
+        self.data["clips"][i]["status"] = "running"
+        self.data["clips"][i]["stages"][0]["status"] = "running"
+
+    def finish(self, i: int, res: dict, collision: str):
+        c = self.data["clips"][i]
+        for s in c["stages"]:
+            s["status"] = "done"
+        c["status"] = "done"
+        c["output"] = res.get("output")
+        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,
+            "n_frames": res.get("n_frames_out", c["n_frames"]),
+        }
+
+    def fail(self, i: int, msg: str):
+        c = self.data["clips"][i]
+        for s in c["stages"]:
+            if s["status"] == "running":
+                s["status"] = "fail"
+        c["status"] = "failed"
+        c["error"] = msg
+
+    def finalize(self):
+        done = [c for c in self.data["clips"] if c["status"] == "done"]
+        failed = sum(1 for c in self.data["clips"] if c["status"] == "failed")
+        teleop_hz = int(self.teleop.get("fps") or 30)
+        if done:
+            iks = [(c["metrics"]["ik_R_cm"] + c["metrics"]["ik_L_cm"]) / 2 for c in done]
+            ik_mean = round(float(np.mean(iks)), 2)
+            clean = sum(1 for c in done if c["metrics"]["collision"] == "clean")
+            fidelity = round(max(0.0, 1 - ik_mean / 10.0), 2)
+            clean_rate = round(clean / len(done), 2)
+        else:  # nothing succeeded — report honestly, not a fake 100%
+            ik_mean = fidelity = clean_rate = None
+        self.data["match_report"] = {
+            "teleop_hz": teleop_hz, "ego_hz": 30,
+            "fps_variance": abs(teleop_hz - 30),
+            "action_hz_match": teleop_hz == 30,
+            "ik_mean_cm": ik_mean,
+            "traj_similarity": fidelity,
+            "collision_clean_rate": clean_rate,
+            "clips_done": len(done), "clips_failed": failed,
+        }
+        self.data["done"] = True
+
+
+class _Tee(io.TextIOBase):
+    def __init__(self, orig, on_line):
+        self.orig, self.on_line, self.buf = orig, on_line, ""
+
+    def write(self, s):
+        self.orig.write(s)
+        self.buf += s
+        while "\n" in self.buf:
+            line, self.buf = self.buf.split("\n", 1)
+            self.on_line(line)
+        return len(s)
+
+    def flush(self):
+        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:
+        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
+
+
+def _run_one(payload: dict) -> dict:
+    """Worker: materialize + retarget one clip (cache already warm). Returns a picklable result."""
+    clip = payload["clip"]
+    cache, out_root = Path(payload["cache"]), Path(payload["out_root"])
+    from retarget import process_clip
+
+    try:
+        subset, ep_s = clip["clip_id"].split("#")
+        buf = io.StringIO()
+        with contextlib.redirect_stdout(buf):
+            mat = _materialize(cache, subset, int(ep_s), out_root)
+            res = process_clip(mat, source="lerobot", out_root=str(out_root / "retargeted"))
+        if res is None:
+            return {"clip_id": clip["clip_id"], "status": "failed", "error": "clip skipped (QA gate or too few valid frames)"}
+        txt = buf.getvalue()
+        collision = "resolved" if any(k in txt for k in ("moved apart", "still colliding", "pushed")) else "clean"
+        return {"clip_id": clip["clip_id"], "status": "done", "res": res, "collision": collision}
+    except Exception as e:
+        return {"clip_id": clip["clip_id"], "status": "failed", "error": str(e)}
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--selected", required=True)
+    ap.add_argument("--report", required=True)
+    ap.add_argument("--cache", required=True)
+    ap.add_argument("--out-root", required=True)
+    ap.add_argument("--limit", type=int, default=3)
+    ap.add_argument("--workers", type=int, default=0, help="0 = auto (cores-1); 1 = sequential")
+    args = ap.parse_args()
+
+    from retarget import process_clip
+
+    selected = json.loads(Path(args.selected).read_text())
+    all_clips = selected.get("clips", [])
+    clips = all_clips if args.limit <= 0 else all_clips[: args.limit]  # limit<=0 → all
+    report = Report(Path(args.report), clips, selected.get("teleop", {}))
+    cache, out_root = Path(args.cache), Path(args.out_root)
+
+    workers = args.workers or max(1, min((os.cpu_count() or 2) - 1, len(clips)))
+
+    # ---- parallel path: process clips concurrently across cores ----
+    if workers > 1 and len(clips) > 1:
+        _prewarm(cache, clips)
+        idx = {c["clip_id"]: i for i, c in enumerate(clips)}
+        for i in range(len(clips)):
+            report.start(i)
+        report.write()
+        payloads = [{"clip": c, "cache": str(cache), "out_root": str(out_root)} for c in clips]
+        with ProcessPoolExecutor(max_workers=workers) as ex:
+            futs = [ex.submit(_run_one, p) for p in payloads]
+            for fut in as_completed(futs):
+                r = fut.result()
+                i = idx[r["clip_id"]]
+                if r["status"] == "done":
+                    report.finish(i, r["res"], r["collision"])
+                else:
+                    report.fail(i, r.get("error", "failed"))
+                report.write()
+        report.finalize()
+        report.write()
+        print(f"BATCH DONE ({workers} workers)")
+        return
+
+    # ---- sequential path (workers==1): live per-stage streaming ----
+    for i, clip in enumerate(clips):
+        report.start(i)
+        report.write()
+        try:
+            subset, ep_s = clip["clip_id"].split("#")
+            mat = _materialize(cache, subset, int(ep_s), out_root)
+
+            state = {"collision": "clean"}
+
+            def on_line(line, i=i, state=state):
+                for mk, key in MARKERS:
+                    if mk in line:
+                        report.advance(i, key)
+                        report.write()
+                        break
+                if "Collision check: clean" in line:
+                    state["collision"] = "clean"
+                elif "moved apart" in line or "still colliding" in line or "pushed" in line:
+                    state["collision"] = "resolved"
+
+            old = sys.stdout
+            sys.stdout = _Tee(old, on_line)
+            try:
+                res = process_clip(mat, source="lerobot", out_root=str(out_root / "retargeted"))
+            finally:
+                sys.stdout = old
+
+            if res is None:
+                raise RuntimeError("clip skipped (QA gate or too few valid frames)")
+            report.finish(i, res, state["collision"])
+        except Exception as e:  # isolate — one bad clip must not abort the batch
+            report.fail(i, str(e))
+        report.write()
+
+    report.finalize()
+    report.write()
+    print("BATCH DONE")
+
+
+if __name__ == "__main__":
+    main()