from __future__ import annotations import csv import json from collections import defaultdict from pathlib import Path import matplotlib matplotlib.use("Agg") import matplotlib.pyplot as plt import numpy as np ROOT = Path(__file__).resolve().parents[1] LEARNED = ROOT / "artifacts" / "phase13" / "learned_results_v2" HEURISTICS = ROOT / "artifacts" / "phase13" / "heuristics" MANIFEST = ROOT / "artifacts" / "phase10" / "final" / "selected_manifest.jsonl" OUTPUT = ROOT / "artifacts" / "phase13" / "analysis" REPORT = ROOT / "reports" / "phase13_statistical_analysis.json" BOOTSTRAP_REPS = 10_000 BOOTSTRAP_SEED = 130524 ALPHA = 0.05 LEARNED_METHODS = [ "hutace_full", "ariadne_graph_attention_ppo_adapted", "cnn_ppo", "plain_unet_ppo", ] HEURISTIC_METHODS = [ "random_local_waypoint", "nearest_frontier", "expected_gain_per_estimated_energy", ] ORACLE = "full_map_greedy_oracle_diagnostic" METRICS = { "final_coverage": ("coverage", "higher"), "coverage_energy_auc": ("coverage_auc", "higher"), "coverage_at_320": ("coverage_at_320", "higher"), "energy_to_0_50_censored": ("energy_to_0_50", "lower"), } def read_jsonl(path: Path) -> list[dict]: with path.open("r", encoding="utf-8") as handle: return [json.loads(line) for line in handle if line.strip()] def write_csv(path: Path, rows: list[dict]) -> None: if not rows: raise RuntimeError(f"Refusing to write empty table: {path}") with path.open("w", newline="", encoding="utf-8") as handle: writer = csv.DictWriter(handle, fieldnames=list(rows[0])) writer.writeheader() writer.writerows(rows) def load_results(): learned_rows: dict[str, list[tuple[int, list[dict]]]] = defaultdict(list) learned_curves: dict[str, list[np.ndarray]] = defaultdict(list) for directory in sorted(path for path in LEARNED.iterdir() if path.is_dir()): summary = json.loads((directory / "summary.json").read_text(encoding="utf-8")) method = summary["model_id"] learned_rows[method].append((int(summary["seed"]), read_jsonl(directory / "test_rows.jsonl"))) learned_curves[method].append(np.load(directory / "test_curves.npz")["curves"]) for method in learned_rows: learned_rows[method].sort(key=lambda item: item[0]) heuristic_rows = { method: read_jsonl(HEURISTICS / f"{method}_test_rows.jsonl") for method in HEURISTIC_METHODS + [ORACLE] } heuristic_curves = { method: np.load(HEURISTICS / f"{method}_test_curves.npz")["curves"] for method in HEURISTIC_METHODS + [ORACLE] } return learned_rows, learned_curves, heuristic_rows, heuristic_curves def validate_alignment(learned_rows, heuristic_rows) -> list[tuple[str, int]]: if set(learned_rows) != set(LEARNED_METHODS): raise RuntimeError(f"Learned method mismatch: {set(learned_rows)}") reference = None for method in LEARNED_METHODS: if len(learned_rows[method]) != 10: raise RuntimeError(f"Expected 10 seeds for {method}") for _, rows in learned_rows[method]: keys = [(row["terrain_id"], int(row["start_seed"])) for row in rows] if len(keys) != 256 or len(set(keys)) != 256: raise RuntimeError(f"Episode-key failure for {method}") reference = keys if reference is None else reference if keys != reference: raise RuntimeError(f"Episode alignment failure for {method}") for method, rows in heuristic_rows.items(): keys = [(row["terrain_id"], int(row["start_seed"])) for row in rows] if keys != reference: raise RuntimeError(f"Episode alignment failure for {method}") return reference def holm_adjust(p_values: list[float]) -> list[float]: order = np.argsort(p_values) adjusted = np.empty(len(p_values), dtype=float) running = 0.0 total = len(p_values) for rank, index in enumerate(order): value = min(1.0, (total - rank) * p_values[index]) running = max(running, value) adjusted[index] = running return adjusted.tolist() def main() -> None: OUTPUT.mkdir(parents=True, exist_ok=True) learned_rows, learned_curves, heuristic_rows, heuristic_curves = load_results() keys = validate_alignment(learned_rows, heuristic_rows) metadata = { row["candidate_id"]: row for row in read_jsonl(MANIFEST) if row["split"] == "test" } strata: dict[tuple[str, str], list[int]] = defaultdict(list) for index, (terrain_id, _) in enumerate(keys): row = metadata[terrain_id] strata[(row["continent"], row["stratum"])].append(index) arrays: dict[str, dict[str, np.ndarray]] = {} seeds: dict[str, list[int]] = {} for method, runs in learned_rows.items(): seeds[method] = [seed for seed, _ in runs] arrays[method] = { metric: np.asarray([[row[field] for row in rows] for _, rows in runs], dtype=float) for metric, (field, _) in METRICS.items() } for method, rows in heuristic_rows.items(): arrays[method] = { metric: np.asarray([[row[field] for row in rows]], dtype=float) for metric, (field, _) in METRICS.items() } if any(seeds[method] != seeds["hutace_full"] for method in LEARNED_METHODS): raise RuntimeError("Learned methods do not share paired training seeds") overall = [] for method in LEARNED_METHODS + HEURISTIC_METHODS + [ORACLE]: for metric in METRICS: per_seed = arrays[method][metric].mean(axis=1) overall.append({ "method": method, "method_type": "learned" if method in LEARNED_METHODS else ("oracle_diagnostic" if method == ORACLE else "heuristic"), "metric": metric, "mean": float(per_seed.mean()), "training_seed_sd": float(per_seed.std(ddof=1)) if len(per_seed) > 1 else "", "training_seeds": len(per_seed) if method in LEARNED_METHODS else 0, "test_episodes": 256, }) write_csv(OUTPUT / "overall_metrics.csv", overall) rng = np.random.default_rng(BOOTSTRAP_SEED) terrain_samples = np.empty((BOOTSTRAP_REPS, len(keys)), dtype=np.int32) cursor = 0 for group in sorted(strata): indices = np.asarray(strata[group], dtype=np.int32) width = len(indices) terrain_samples[:, cursor:cursor + width] = rng.choice( indices, size=(BOOTSTRAP_REPS, width), replace=True ) cursor += width seed_samples = rng.integers(0, 10, size=(BOOTSTRAP_REPS, 10), dtype=np.int16) comparisons = [] raw_p_values = [] for baseline in LEARNED_METHODS[1:] + HEURISTIC_METHODS: for metric, (_, direction) in METRICS.items(): hut = arrays["hutace_full"][metric] hut_boot = hut[seed_samples[:, :, None], terrain_samples[:, None, :]].mean(axis=(1, 2)) base = arrays[baseline][metric] if baseline in LEARNED_METHODS: base_boot = base[seed_samples[:, :, None], terrain_samples[:, None, :]].mean(axis=(1, 2)) else: base_boot = base[0, terrain_samples].mean(axis=1) raw_diff = hut_boot - base_boot oriented = raw_diff if direction == "higher" else -raw_diff point_raw = float(hut.mean() - base.mean()) probability = float(np.mean(oriented > 0.0)) p_value = min(1.0, 2.0 * min(np.mean(oriented <= 0.0), np.mean(oriented >= 0.0))) row = { "model": "hutace_full", "baseline": baseline, "metric": metric, "preferred_direction": direction, "hutace_mean": float(hut.mean()), "baseline_mean": float(base.mean()), "raw_difference_hutace_minus_baseline": point_raw, "oriented_improvement": point_raw if direction == "higher" else -point_raw, "ci95_low_oriented": float(np.quantile(oriented, 0.025)), "ci95_high_oriented": float(np.quantile(oriented, 0.975)), "probability_improvement": probability, "bootstrap_two_sided_p": float(p_value), } comparisons.append(row) raw_p_values.append(float(p_value)) adjusted = holm_adjust(raw_p_values) for row, p_adjusted in zip(comparisons, adjusted): row["holm_adjusted_p"] = p_adjusted row["holm_significant_0_05"] = p_adjusted < ALPHA write_csv(OUTPUT / "paired_hierarchical_bootstrap_holm.csv", comparisons) stratum_rows = [] for (continent, stratum), indices in sorted(strata.items()): for method in LEARNED_METHODS + HEURISTIC_METHODS + [ORACLE]: for metric in METRICS: stratum_rows.append({ "continent": continent, "stratum": stratum, "episodes": len(indices), "method": method, "metric": metric, "mean": float(arrays[method][metric][:, indices].mean()), }) write_csv(OUTPUT / "metrics_by_continent_stratum.csv", stratum_rows) energy_grid = np.linspace(0.0, 640.0, 65) plt.figure(figsize=(9, 5.5)) for method in LEARNED_METHODS: curve = np.mean(np.stack(learned_curves[method]), axis=(0, 1)) plt.plot(energy_grid, curve, label=method, linewidth=2.0 if method == "hutace_full" else 1.4) for method in HEURISTIC_METHODS: plt.plot(energy_grid, heuristic_curves[method].mean(axis=0), label=method, linestyle="--", linewidth=1.2) plt.xlabel("Energy consumed") plt.ylabel("Observed-map coverage") plt.ylim(0, 1) plt.grid(alpha=0.25) plt.legend(fontsize=7, ncol=2) plt.tight_layout() plt.savefig(OUTPUT / "coverage_energy_curves.png", dpi=220) plt.close() report = { "schema_version": 1, "phase": 13, "status": "completed", "gate_passed": True, "test_accessed": True, "test_episodes": len(keys), "learned_seeds_per_method": 10, "bootstrap": { "repetitions": BOOTSTRAP_REPS, "seed": BOOTSTRAP_SEED, "resampling": "paired training seeds plus test episodes within continent-by-terrain-stratum cells", "confidence_interval": "percentile 95%", "multiplicity": "Holm family-wise correction across 24 primary comparisons", }, "primary_baselines": LEARNED_METHODS[1:] + HEURISTIC_METHODS, "oracle": {"method": ORACLE, "primary_comparison": False, "purpose": "diagnostic upper reference only"}, "outputs": [ "artifacts/phase13/analysis/overall_metrics.csv", "artifacts/phase13/analysis/paired_hierarchical_bootstrap_holm.csv", "artifacts/phase13/analysis/metrics_by_continent_stratum.csv", "artifacts/phase13/analysis/coverage_energy_curves.png", ], } REPORT.write_text(json.dumps(report, indent=2) + "\n", encoding="utf-8") print("PHASE13_STATISTICS_COMPLETED", flush=True) if __name__ == "__main__": main()