scripts/run_repro.py

"""AQM reproduction driver: trains quasimetric, tests all three claims, writes JSON/CSV."""
import argparse, json, time, sys
import numpy as np
import torch
from pathlib import Path

sys.path.insert(0, str(Path(__file__).parent))
from aqm import (Maze, make_dataset, train_quasimetric, qdist, greedy_dominating_set,
                 ilp_dominating_set_lb, AQMGraph, DenseGraph, navigate)


def run(maze_name, seed, args, device):
    rng = np.random.default_rng(seed)
    maze = Maze(maze_name)
    print(f"== {maze_name} seed {seed}: dataset", flush=True)
    obs, nxt, trajs = make_dataset(maze, n_traj=args.n_traj, seed=seed)
    print(f"   {len(obs)} transitions", flush=True)

    print("   training quasimetric", flush=True)
    t0 = time.time()
    model = train_quasimetric(obs, nxt, steps=args.qm_steps, device=device, seed=seed, trajs=trajs)
    t_train = time.time() - t0

    # candidate states for graph building
    n_cand = min(args.n_cand, len(obs))
    cand_idx = rng.choice(len(obs), n_cand, replace=False)
    cand = obs[cand_idx]
    D = qdist(model, cand, cand, device=device)
    D_sym = np.maximum(D, D.T)

    # ---------------- Claim 2: greedy dominating set ----------------
    tau = args.tau
    kp_idx, t_cover, n_unc = greedy_dominating_set(D_sym, tau)
    lb = ilp_dominating_set_lb(D_sym[:args.lp_n, :args.lp_n], tau) if n_cand >= args.lp_n else None
    kp = cand[kp_idx]
    claim2 = {
        "n_candidates": int(n_cand), "tau": tau,
        "n_keypoints": len(kp_idx), "cover_seconds": t_cover,
        "uncovered": n_unc,
        "lp_lower_bound_on_subset": lb,
        "greedy_on_same_subset": None,
    }
    if lb is not None:
        kp_sub, _, _ = greedy_dominating_set(D_sym[:args.lp_n, :args.lp_n], tau)
        claim2["greedy_on_same_subset"] = len(kp_sub)

    # ---------------- graphs ----------------
    D_kk = qdist(model, kp, kp, device=device)
    aqm_graph = AQMGraph(kp, D_kk, edge_thresh=args.edge_thresh)

    # dense baseline: nodes = all candidate states (prior-graph-based scale)
    t0 = time.time()
    dense_graph = DenseGraph(cand, D, edge_thresh=args.edge_thresh_dense)
    t_dense_build = time.time() - t0

    # ---------------- Claim 1: success vs keypoint count ----------------
    cells = maze.free_cells()
    evals = []
    while len(evals) < args.n_eval:
        a, b = rng.choice(len(cells), 2, replace=False)
        p = maze.astar(cells[a], cells[b])
        if p is not None and len(p) >= 4:
            evals.append((maze.cell_center(cells[a]), maze.cell_center(cells[b])))

    def evaluate(graph, replan=False, m=None):
        succ, steps_l, times, replans = 0, [], [], 0
        for s, g in evals:
            t0 = time.time()
            graph.pruned = set()
            ok, steps, nrep = navigate(m or maze, graph, model, s, g, device=device,
                                       replan=replan, budget_beta=args.beta)
            times.append(time.time() - t0)
            replans += nrep
            if ok:
                succ += 1
                steps_l.append(steps)
        return {"success_rate": succ / len(evals),
                "mean_steps": float(np.mean(steps_l)) if steps_l else None,
                "mean_wall_s": float(np.mean(times)), "total_replans": replans}

    print("   evaluating AQM graph", flush=True)
    res_aqm = evaluate(aqm_graph)
    print("   evaluating dense graph", flush=True)
    res_dense = evaluate(dense_graph)
    claim1 = {
        "aqm_keypoints": len(kp_idx), "dense_nodes": int(n_cand),
        "ratio": n_cand / max(1, len(kp_idx)),
        "aqm": res_aqm, "dense": res_dense,
        "aqm_edges": aqm_graph.n_edges(), "dense_edges": dense_graph.n_edges(),
        "dense_build_s": t_dense_build, "aqm_build_s": t_cover,
    }

    # ---------------- Claim 3: zero-shot replanning ----------------
    # pick blocking cells programmatically: on many eval shortest paths, removal
    # keeps every eval pair feasible (alternative route exists)
    from collections import Counter
    usage = Counter()
    routes = {}
    for idx, (s_, g_) in enumerate(evals):
        rs, rg2 = (int(s_[1]), int(s_[0])), (int(g_[1]), int(g_[0]))
        p = maze.astar(rs, rg2)
        routes[idx] = p
        for rc in (p or [])[1:-1]:
            usage[rc] += 1
    blocks = []
    for rc, _cnt in usage.most_common():
        test = Maze(maze_name, extra_walls=tuple(blocks + [rc]))
        if all(test.astar((int(s_[1]), int(s_[0])), (int(g_[1]), int(g_[0]))) is not None
               for s_, g_ in evals):
            blocks.append(rc)
        if len(blocks) >= 2:
            break
    args.blocks[maze_name] = [list(rc) for rc in blocks]
    blocked_maze = Maze(maze_name, extra_walls=tuple(map(tuple, blocks)))
    res_frozen = None
    res_replan = None
    # only evaluate goal pairs whose A* route changes and remains feasible
    evals3 = []
    for s, g in evals:
        rs = (int(s[1]), int(s[0]))
        rg = (int(g[1]), int(g[0]))
        p_old = maze.astar(rs, rg)
        p_new = blocked_maze.astar(rs, rg)
        if p_new is None or p_old is None:
            continue
        crosses = any(tuple(rc) in blocked_maze.extra for rc in p_old)
        if crosses:
            evals3.append((s, g))
    if evals3:
        def eval3(replan):
            succ, reps = 0, 0
            for s, g in evals3:
                aqm_graph.pruned = set()
                ok, _, nrep = navigate(blocked_maze, aqm_graph, model, s, g,
                                       device=device, replan=replan, budget_beta=args.beta)
                succ += ok
                reps += nrep
            return {"success_rate": succ / len(evals3), "n_evals": len(evals3),
                    "total_replans": reps}
        print(f"   claim 3: {len(evals3)} affected goal pairs", flush=True)
        res_frozen = eval3(False)
        res_replan = eval3(True)
    claim3 = {"blocked_cells": args.blocks[maze_name],
              "frozen_graph": res_frozen, "with_replanning": res_replan}

    return {"maze": maze_name, "seed": seed, "n_transitions": len(obs),
            "qm_train_s": t_train, "claim1": claim1, "claim2": claim2, "claim3": claim3}


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--mazes", nargs="+", default=["medium"])
    ap.add_argument("--seeds", type=int, default=1)
    ap.add_argument("--n-traj", type=int, default=300, dest="n_traj")
    ap.add_argument("--qm-steps", type=int, default=3000, dest="qm_steps")
    ap.add_argument("--n-cand", type=int, default=3000, dest="n_cand")
    ap.add_argument("--n-eval", type=int, default=30, dest="n_eval")
    ap.add_argument("--tau", type=float, default=8.0)
    ap.add_argument("--edge-thresh", type=float, default=25.0, dest="edge_thresh")
    ap.add_argument("--edge-thresh-dense", type=float, default=12.0, dest="edge_thresh_dense")
    ap.add_argument("--beta", type=float, default=3.0)
    ap.add_argument("--lp-n", type=int, default=800, dest="lp_n")
    ap.add_argument("--out", default="outputs/aqm_results.json")
    args = ap.parse_args()
    # test-time blocks per maze: chosen to sever a main corridor
    args.blocks = {"medium": [(5, 4), (5, 3)],
                   "large": [(3, 3), (3, 4)],
                   "giant": [(7, 7), (7, 8), (13, 8)]}

    device = "cuda" if torch.cuda.is_available() else "cpu"
    print("device:", device, flush=True)
    results = []
    for m in args.mazes:
        for s in range(args.seeds):
            results.append(run(m, s, args, device))
    Path(args.out).parent.mkdir(exist_ok=True, parents=True)
    with open(args.out, "w") as f:
        json.dump({"args": {k: v for k, v in vars(args).items() if k != "blocks"},
                   "blocks": args.blocks, "results": results}, f, indent=1)
    print("wrote", args.out)
    for r in results:
        c1, c2, c3 = r["claim1"], r["claim2"], r["claim3"]
        print(f"\n{r['maze']} s{r['seed']}: kp={c1['aqm_keypoints']} vs dense={c1['dense_nodes']} "
              f"(ratio {c1['ratio']:.0f}x) | AQM sr={c1['aqm']['success_rate']:.2f} "
              f"dense sr={c1['dense']['success_rate']:.2f}")
        print(f"  cover: {c2['n_keypoints']} kp in {c2['cover_seconds']:.2f}s, "
              f"uncovered={c2['uncovered']}, LP-lb={c2['lp_lower_bound_on_subset']}, "
              f"greedy-same-subset={c2['greedy_on_same_subset']}")
        if c3["frozen_graph"]:
            print(f"  replanning: frozen sr={c3['frozen_graph']['success_rate']:.2f} -> "
                  f"replan sr={c3['with_replanning']['success_rate']:.2f} "
                  f"({c3['with_replanning']['total_replans']} prunes)")


if __name__ == "__main__":
    main()