| |
| """Budget, recomputation, and exact-optimum studies for TopoRisk. |
| |
| The script is local and deterministic. It reuses the simulator in |
| ``run_experiments.py`` and makes no model or network calls. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import csv |
| import itertools |
| import math |
| import random |
| from pathlib import Path |
| from statistics import mean, stdev |
|
|
| from run_experiments import Graph, choose, episode, expected_terminal_error, make_graph |
|
|
|
|
| def ci95(values: list[float]) -> float: |
| return 1.96 * stdev(values) / math.sqrt(len(values)) |
|
|
|
|
| def static_toporisk(g: Graph, k: int) -> set[int]: |
| base = expected_terminal_error(g, set()) |
| gains = [base - expected_terminal_error(g, {i}) for i in range(len(g.p))] |
| return set(sorted(range(len(g.p)), key=lambda i: (-gains[i], i))[:k]) |
|
|
|
|
| def exact_optimum(g: Graph, k: int) -> tuple[set[int], float]: |
| best_set: set[int] | None = None |
| best_loss = float("inf") |
| for items in itertools.combinations(range(len(g.p)), k): |
| selected = set(items) |
| loss = expected_terminal_error(g, selected) |
| if loss < best_loss - 1e-15: |
| best_set, best_loss = selected, loss |
| assert best_set is not None |
| return best_set, best_loss |
|
|
|
|
| def write_csv(path: Path, rows: list[dict]) -> None: |
| with path.open("w", newline="", encoding="utf-8") as handle: |
| writer = csv.DictWriter(handle, fieldnames=list(rows[0])) |
| writer.writeheader() |
| writer.writerows(rows) |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--out", type=Path, default=Path("results/ablations")) |
| parser.add_argument("--graphs", type=int, default=240) |
| parser.add_argument("--episodes", type=int, default=400) |
| parser.add_argument("--seed", type=int, default=7) |
| args = parser.parse_args() |
| args.out.mkdir(parents=True, exist_ok=True) |
|
|
| kinds = ["chain", "tree", "diamond", "random"] |
| master = random.Random(args.seed) |
| graphs = [ |
| (kind, make_graph(kind, 40, random.Random(master.randrange(2**63)))) |
| for kind in kinds |
| for _ in range(args.graphs // len(kinds)) |
| ] |
|
|
| budget_rows: list[dict] = [] |
| methods = ["local-risk", "risk-x-count", "risk-x-influence", "static-toporisk", "toporisk"] |
| for budget in [0.025, 0.05, 0.10, 0.15, 0.20, 0.30]: |
| per_method = {method: [] for method in methods} |
| success_method = {method: [] for method in methods} |
| for graph_id, (_, graph) in enumerate(graphs): |
| k = max(1, round(len(graph.p) * budget)) |
| for method_id, method in enumerate(methods): |
| if method == "static-toporisk": |
| selected = static_toporisk(graph, k) |
| else: |
| selected = choose( |
| graph, method, k, |
| random.Random(args.seed * 10_000 + graph_id * 100 + method_id), |
| ) |
| losses, successes = [], [] |
| for ep in range(args.episodes): |
| value, success = episode( |
| graph, |
| selected, |
| 0.90, |
| random.Random(args.seed * 10**8 + graph_id * 10_000 + ep), |
| ) |
| losses.append(value) |
| successes.append(float(success)) |
| per_method[method].append(mean(losses)) |
| success_method[method].append(mean(successes)) |
| for method in methods: |
| budget_rows.append({ |
| "budget": budget, |
| "method": method, |
| "terminal_error": mean(per_method[method]), |
| "terminal_error_ci95": ci95(per_method[method]), |
| "workflow_success": mean(success_method[method]), |
| "workflow_success_ci95": ci95(success_method[method]), |
| }) |
| write_csv(args.out / "budget_curve.csv", budget_rows) |
|
|
| |
| small_master = random.Random(args.seed + 331_007) |
| optimality_rows: list[dict] = [] |
| for kind in kinds: |
| for graph_index in range(50): |
| graph = make_graph(kind, 12, random.Random(small_master.randrange(2**63))) |
| k = 3 |
| optimum, optimum_loss = exact_optimum(graph, k) |
| greedy = choose(graph, "toporisk", k, random.Random(0)) |
| static = static_toporisk(graph, k) |
| greedy_loss = expected_terminal_error(graph, greedy) |
| static_loss = expected_terminal_error(graph, static) |
| no_audit = expected_terminal_error(graph, set()) |
| denom = max(1e-12, no_audit - optimum_loss) |
| optimality_rows.append({ |
| "graph": kind, |
| "graph_index": graph_index, |
| "budget_nodes": k, |
| "no_audit_loss": no_audit, |
| "optimal_loss": optimum_loss, |
| "greedy_loss": greedy_loss, |
| "static_loss": static_loss, |
| "greedy_excess_loss": greedy_loss - optimum_loss, |
| "static_excess_loss": static_loss - optimum_loss, |
| "greedy_fraction_of_optimal_gain": (no_audit - greedy_loss) / denom, |
| "static_fraction_of_optimal_gain": (no_audit - static_loss) / denom, |
| "greedy_exact_match": int(greedy == optimum), |
| "static_exact_match": int(static == optimum), |
| }) |
| write_csv(args.out / "exact_optimality.csv", optimality_rows) |
|
|
| print(f"wrote {args.out / 'budget_curve.csv'}") |
| print(f"wrote {args.out / 'exact_optimality.csv'}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
