chess-sim/code/sim/validate_expert.py

"""Grasp validation: the scripted expert on every piece type on every square.

For each layout (its own piece set, board size, border, thickness and tray size)
and each piece type, the piece is put on each of the 64 squares with all its
neighbouring squares occupied by random pieces, and moved to a random square at least
two squares away whose neighbours are also occupied, or into the tray every
`bin_every`th trial. Every trial draws its own board pose (either colour facing the
robot), tray and table placement, as the dataset does. Success: the piece
rests within `success_center_mm` of the destination centre (or in the tray), upright,
and no other piece moved more than `disturb_mm`. Arm-to-piece contacts outside the
intended grasp are counted separately. Physics randomisation stays on.

Run:  .venv/bin/python sim/validate_expert.py            (writes sim/reports/)
"""
from __future__ import annotations

import argparse
import json
import multiprocessing as mp
import sys
import time
from collections import Counter, defaultdict
from pathlib import Path

HERE = Path(__file__).resolve().parent
sys.path.insert(0, str(HERE))
REPORTS = HERE / "reports"


def trials(cfg, seed):
    import numpy as np

    from chess_world import KINDS, SQUARES

    v = cfg["validation"]
    out = []
    for p in range(v["layouts"]):
        pose = None                     # drawn per trial by the randomiser
        for kind in KINDS:
            for s, sq in enumerate(SQUARES):
                i = len(out)
                out.append(dict(index=i, pose=p, board_pose=pose, piece_set=p % v["piece_sets"], kind=kind,
                                square=sq, bin=(i % v["bin_every"] == v["bin_every"] - 1), seed=seed * 100000 + i))
    return out


def neighbours(sq):
    f, r = ord(sq[0]) - 97, int(sq[1]) - 1
    return [f"{chr(97 + f + df)}{r + 1 + dr}" for df in (-1, 0, 1) for dr in (-1, 0, 1)
            if (df or dr) and 0 <= f + df < 8 and 0 <= r + dr < 8]


def chebyshev(a, b):
    return max(abs(ord(a[0]) - ord(b[0])), abs(int(a[1]) - int(b[1])))


def build_task(runner, t, rng):
    from chess_world import SQUARES
    from episode import Destination, Task

    w = runner.w
    bodies = list(rng.permutation(w.pieces))
    target = next(n for n in bodies if w.kind[n] == t["kind"])
    bodies.remove(target)
    squares = {t["square"]: target}
    for sq in neighbours(t["square"]):
        squares[sq] = bodies.pop()
    if t["bin"]:
        dest = Destination("bin", None)
    else:
        options = [s for s in SQUARES if chebyshev(s, t["square"]) >= 2]
        dst = options[rng.integers(len(options))]
        dest = Destination("square", None, dst)
        for sq in neighbours(dst):
            if sq not in squares and bodies:
                squares[sq] = bodies.pop()
    return Task(target, t["square"], dest, squares, [], "", "validation")


def worker(k, n, cfg, all_trials, queue):
    import warnings

    warnings.filterwarnings("ignore")
    import numpy as np

    from episode import EpisodeRunner
    from piece_sets import reference_set, sample_piece_set

    sets = [reference_set()] + [sample_piece_set(np.random.default_rng(1000 + j), cfg, f"validation_set{j}")
                                for j in range(1, cfg["validation"]["piece_sets"])]
    runners = {}
    for t in all_trials[k::n]:
        j = t["piece_set"]
        if j not in runners:
            runners[j] = EpisodeRunner(cfg, sets[j])
        runner = runners[j]
        rng = np.random.default_rng(t["seed"])
        task = build_task(runner, t, rng)
        runner.setup(rng, task=task, board_pose=t["board_pose"])
        info = runner.episode_info
        t0 = time.time()
        res = runner.run(task, t["seed"])
        queue.put(dict(t, board_pose=None, success=res.success, reason=res.reason,
                       destination=task.dest.square or "bin", centre_error_mm=res.centre_error_mm,
                       tilt_deg=res.tilt_deg, max_disturbance_mm=res.max_disturbance_mm,
                       stray_contacts=res.stray_contacts, jaw_yaw_deg=res.yaw_deg,
                       piece_set_name=sets[j].name, robot_plays=info["board"]["robot_plays"],
                       board=info["board"], tray=info["tray"], seconds=round(time.time() - t0, 2)))
    queue.put(None)


def summarise(results, cfg, minutes):
    ok = [r for r in results if r["success"]]
    rate = lambda rs: round(100 * sum(r["success"] for r in rs) / max(len(rs), 1), 2)
    by = lambda key: {str(k): rate([r for r in results if key(r) == k]) for k in sorted({key(r) for r in results})}
    stage = Counter()
    for r in results:
        if not r["success"]:
            reason = r["reason"]
            stage["planning (no collision-free grasp or path)" if reason.startswith("plan")
                  else "grasp" if reason.startswith("grasp")
                  else "placement" if "placement" in reason or "tray" in reason
                  else "disturbed a neighbour" if "disturbed" in reason else "other"] += 1
    stray = [r for r in results if r["stray_contacts"]]
    stray_kinds = Counter(key.split(":")[0] for r in stray for key in r["stray_contacts"])
    errors = [r["centre_error_mm"] for r in ok if r["centre_error_mm"] is not None]
    return dict(trials=len(results), success_percent=rate(results), target_percent=99.0,
                passed=rate(results) >= 99.0, by_piece=by(lambda r: r["kind"]),
                by_source_rank=by(lambda r: r["square"][1]), by_layout=by(lambda r: r["pose"]),
                by_robot_side=by(lambda r: r["robot_plays"]),
                by_destination=by(lambda r: "bin" if r["bin"] else "square"),
                failures_by_stage=dict(stage),
                trials_with_unintended_arm_piece_contact=len(stray),
                unintended_contact_phases=dict(stray_kinds),
                placement_error_mm=dict(mean=round(sum(errors) / max(len(errors), 1), 2),
                                        max=round(max(errors, default=0), 2)),
                max_neighbour_motion_mm_in_successes=max((r["max_disturbance_mm"] for r in ok), default=0),
                minutes=round(minutes, 1))


def write_report(summary, results, cfg):
    REPORTS.mkdir(exist_ok=True)
    (REPORTS / "grasp_validation.json").write_text(json.dumps(dict(summary=summary, trials=results), indent=1))
    lines = ["# Grasp validation", "",
             f"{summary['trials']} trials: every piece type on every square with all neighbours present, "
             f"{cfg['validation']['layouts']} layouts (board and tray size, piece set), each trial with its own "
             f"board pose, tray and table placement.", "",
             f"**Success: {summary['success_percent']}%** (target above {summary['target_percent']}%) "
             f"- {'PASS' if summary['passed'] else 'FAIL'}", "",
             f"Success = centre within {cfg['validation']['success_center_mm']} mm of the destination square "
             f"(or in the tray), tilt under {cfg['validation']['success_tilt_deg']} deg, "
             f"no other piece moved more than {cfg['validation']['disturb_mm']} mm.", ""]
    for title, key in (("By piece", "by_piece"), ("By source rank", "by_source_rank"),
                       ("By layout", "by_layout"), ("By robot side", "by_robot_side"),
                       ("By destination", "by_destination")):
        lines += [f"## {title}", "", "| | success % |", "|---|---|"]
        lines += [f"| {k} | {v} |" for k, v in summary[key].items()] + [""]
    lines += ["## Failures", "", "| stage | trials |", "|---|---|"]
    lines += [f"| {k} | {v} |" for k, v in summary["failures_by_stage"].items()] + [""]
    lines += [f"Trials with any arm-to-piece contact outside the intended grasp: "
              f"{summary['trials_with_unintended_arm_piece_contact']} "
              f"(by phase: {summary['unintended_contact_phases'] or 'none'}).", "",
              f"Placement error in successes: mean {summary['placement_error_mm']['mean']} mm, "
              f"max {summary['placement_error_mm']['max']} mm.", ""]
    fails = [r for r in results if not r["success"]]
    if fails:
        lines += ["## Failed trials", "", "| piece | from | to | pose | reason |", "|---|---|---|---|---|"]
        lines += [f"| {r['kind']} | {r['square']} | {r['destination']} | {r['pose']} | {r['reason'][:140]} |"
                  for r in fails] + [""]
    (REPORTS / "grasp_validation.md").write_text("\n".join(lines))


def main():
    from episode import load_config

    cfg = load_config()
    ap = argparse.ArgumentParser(description=__doc__)
    ap.add_argument("--workers", type=int, default=cfg["validation"]["workers"])
    ap.add_argument("--seed", type=int, default=7)
    ap.add_argument("--limit", type=int, default=0, help="run only every nth trial (quick check)")
    args = ap.parse_args()
    all_trials = trials(cfg, args.seed)
    if args.limit:
        all_trials = all_trials[::args.limit]
    ctx = mp.get_context("spawn")
    queue = ctx.Queue()
    procs = [ctx.Process(target=worker, args=(k, args.workers, cfg, all_trials, queue)) for k in range(args.workers)]
    for p in procs:
        p.start()
    t0, results, finished = time.time(), [], 0
    while finished < len(procs):
        r = queue.get()
        if r is None:
            finished += 1
            continue
        results.append(r)
        if len(results) % 50 == 0:
            print(f"{len(results)}/{len(all_trials)} trials, {100 * sum(x['success'] for x in results) / len(results):.1f}% success", flush=True)
    for p in procs:
        p.join()
    results.sort(key=lambda r: r["index"])
    summary = summarise(results, cfg, (time.time() - t0) / 60)
    write_report(summary, results, cfg)
    print(json.dumps(summary, indent=1))
    by_fail = defaultdict(list)
    for r in results:
        if not r["success"]:
            by_fail[r["reason"][:60]].append(f"{r['kind']}@{r['square']}")
    for reason, where in sorted(by_fail.items(), key=lambda x: -len(x[1]))[:15]:
        print(len(where), reason, where[:6])


if __name__ == "__main__":
    main()