| """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() |
|
|
