Add files using upload-large-folder tool

chess-sim/code/sim/validate_dart.py

@@ -0,0 +1,131 @@
+"""Validate the perturbed (DART) teacher against the plain teacher on the same scenes.
+
+Each scene (episode seed, drawn as generate_dataset.py draws them) runs twice without
+cameras: plain (the teacher as used for baseline_v1) and perturbed with probability 1
+(Expert.perturb_pick). A perturbed run that fails is retried with fresh offsets, as the
+generator does, up to --retries times. Reported per condition: success, the executed offset,
+frames in which the arm touched the target before the jaws close, and arm contacts with other
+pieces during the approach and descent.
+
+Run:  PHASE2_PROFILE=baseline,dart .venv/bin/python sim/validate_dart.py --episodes 100
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import multiprocessing as mp
+import sys
+import time
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE))
+
+
+def worker(k, seeds, cfg, retries, queue):
+    import numpy as np
+
+    from episode import EpisodeRunner
+    from piece_sets import sample_piece_set
+
+    cfg["expert"]["dart_probability"] = 1.0
+    runner = EpisodeRunner(cfg, sample_piece_set(np.random.default_rng([0, k]), cfg, f"validate{k}"))
+
+    def one(seed, attempt):
+        task = runner.setup(np.random.default_rng(seed))
+        t0 = time.time()
+        r = runner.run(task, seed, dart_attempt=attempt)
+        near = {key: n for key, n in r.stray_contacts.items() if key.split(":")[0] in ("approach", "descend")}
+        return dict(success=bool(r.success), reason=r.reason, offset_mm=r.dart_offset_mm,
+                    pre_close_touch=int(r.pre_close_touch), near_contacts=near, seconds=round(time.time() - t0, 1),
+                    move=f"{task.source}-{task.dest.square}", piece=runner.w.kind[task.target])
+
+    for seed in seeds:
+        plain = one(seed, -1)
+        tries = [one(seed, a) for a in range(1 + retries)]
+        first_ok = next((i for i, t in enumerate(tries) if t["success"]), None)
+        queue.put(dict(seed=seed, move=plain["move"], piece=plain["piece"], plain=plain, dart=tries[0],
+                       dart_ok_within=first_ok, tries=tries))
+    queue.put(None)
+
+
+def main():
+    import numpy as np
+
+    from episode import load_config
+
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("--episodes", type=int, default=100)
+    ap.add_argument("--workers", type=int, default=8)
+    ap.add_argument("--seed", type=int, default=5_000_003)
+    ap.add_argument("--retries", type=int, default=2)
+    ap.add_argument("--out", default=str(HERE / "reports" / "dart_teacher"))
+    args = ap.parse_args()
+    cfg = load_config()
+    assert cfg["expert"].get("dart_radius_mm"), "run with PHASE2_PROFILE=baseline,dart"
+    out = Path(args.out)
+    out.mkdir(parents=True, exist_ok=True)
+    rng = np.random.default_rng(args.seed)
+    seeds = [int(rng.integers(2**62)) for _ in range(args.episodes)]
+    ctx = mp.get_context("spawn")
+    queue = ctx.Queue()
+    procs = [ctx.Process(target=worker, args=(k, seeds[k::args.workers], cfg, args.retries, queue))
+             for k in range(args.workers)]
+    for p in procs:
+        p.start()
+    rows, finished, t0 = [], 0, time.time()
+    while finished < len(procs):
+        r = queue.get()
+        if r is None:
+            finished += 1
+            continue
+        rows.append(r)
+        print(f"{len(rows)}/{args.episodes} {r['piece']} {r['move']}: plain {'ok' if r['plain']['success'] else 'FAIL'}, "
+              f"dart {'ok' if r['dart']['success'] else 'FAIL ' + r['dart']['reason']} offset {r['dart']['offset_mm']} "
+              f"touch {r['plain']['pre_close_touch']}/{r['dart']['pre_close_touch']}", flush=True)
+    for p in procs:
+        p.join()
+
+    def pct(a, b):
+        return f"{a}/{b} ({100 * a / max(b, 1):.1f}%)"
+
+    n = len(rows)
+    perturbed = [r for r in rows if r["dart"]["offset_mm"] is not None]
+    radii = np.array([np.hypot(*r["dart"]["offset_mm"]) for r in perturbed]) if perturbed else np.zeros(0)
+    summary = dict(
+        episodes=n, minutes=round((time.time() - t0) / 60, 1),
+        plain_success=sum(r["plain"]["success"] for r in rows),
+        dart_success_first=sum(r["dart"]["success"] for r in rows),
+        dart_success_within_retries=sum(r["dart_ok_within"] is not None for r in rows),
+        perturbation_found=len(perturbed),
+        radius_mm=dict(median=round(float(np.median(radii)), 2), min=round(float(radii.min()), 2),
+                       max=round(float(radii.max()), 2)) if len(radii) else None,
+        plain_touch_episodes=sum(r["plain"]["pre_close_touch"] > 0 for r in rows),
+        dart_touch_episodes=sum(r["dart"]["pre_close_touch"] > 0 for r in rows),
+        plain_near_contact_episodes=sum(bool(r["plain"]["near_contacts"]) for r in rows),
+        dart_near_contact_episodes=sum(bool(r["dart"]["near_contacts"]) for r in rows),
+        dart_failures=[dict(seed=r["seed"], move=r["move"], reason=r["dart"]["reason"], offset_mm=r["dart"]["offset_mm"])
+                       for r in rows if not r["dart"]["success"]])
+    (out / "validation.json").write_text(json.dumps(dict(summary=summary, config=cfg["expert"], episodes=rows), indent=1))
+    lines = ["# Perturbed (DART) teacher: validation", "",
+             f"{n} scenes of the baseline profile (seed {args.seed}), each run plain and perturbed "
+             f"(offset {cfg['expert']['dart_radius_mm']} mm, back on the plan {cfg['expert']['dart_clear_mm']} mm above "
+             f"the target, return over {cfg['expert']['dart_return_s']} s). No cameras.", "",
+             "| | plain teacher | perturbed teacher |", "|---|---|---|",
+             f"| success | {pct(summary['plain_success'], n)} | {pct(summary['dart_success_first'], n)} "
+             f"(within {args.retries} retries: {pct(summary['dart_success_within_retries'], n)}) |",
+             f"| arm touched the target before closing | {pct(summary['plain_touch_episodes'], n)} | "
+             f"{pct(summary['dart_touch_episodes'], n)} |",
+             f"| arm touched another piece during approach/descent | {pct(summary['plain_near_contact_episodes'], n)} | "
+             f"{pct(summary['dart_near_contact_episodes'], n)} |",
+             f"| perturbation found (collision-free) | - | {pct(summary['perturbation_found'], n)} |",
+             "", f"Executed offset: {summary['radius_mm']} mm.", ""]
+    if summary["dart_failures"]:
+        lines += ["Perturbed failures (first try):", ""] + [f"- {f['move']} offset {f['offset_mm']} mm: {f['reason']}"
+                                                            for f in summary["dart_failures"]]
+    (out / "validation.md").write_text("\n".join(lines) + "\n")
+    print("\n".join(lines))
+
+
+if __name__ == "__main__":
+    main()