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