| """Scan runs/ and, for every model, plot Strategy 2 (supervised baseline) vs |
| Strategy 3 (refinement), AVERAGED ACROSS ALL PHASES found for that model. |
| |
| Six measures per model (mean across phases, error bars = std across phases): |
| |
| * BIoU (band, d-pixel) evaluation.json -> metrics.biou.mean |
| * BIoU (contour, 1-pixel) evaluation.json -> metrics.biou_contour.mean |
| * Total training time (min) summary.json -> elapsed_seconds |
| * Inference time (ms/image) evaluation.json -> timing.mean_per_image_inference_ms |
| * Time per epoch (s) summary.json -> seconds_per_epoch |
| * Time to best ckpt (min) best.pt.meta.json -> epoch x seconds_per_epoch |
| (falls back to argmax of selection_metric_value in history.json) |
| |
| Usage: |
| python plot_s2_vs_s3.py # scans ./runs |
| python plot_s2_vs_s3.py --runs-root X |
| """ |
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import pathlib |
| import re |
| from collections import defaultdict |
|
|
| import matplotlib |
| matplotlib.use("Agg") |
| import matplotlib.pyplot as plt |
| import numpy as np |
|
|
| STRATEGY_LABEL = {2: "S2 (baseline)", 3: "S3 (refinement)"} |
| BAR_COLORS = {2: "#4C78A8", 3: "#F58518"} |
|
|
| |
| PANELS = [ |
| ("biou", "Boundary IoU (band)", "BIoU", True, "{:.4f}"), |
| ("biou_contour", "Boundary IoU (contour)", "BIoU contour", True, "{:.4f}"), |
| ("infer_ms", "Inference time", "ms / image", False, "{:.2f}"), |
| ("train_min", "Total training time", "minutes", False, "{:.1f}"), |
| ("epoch_sec", "Time per epoch", "seconds", False, "{:.1f}"), |
| ("time_to_best_min", "Time to best checkpoint", "minutes", False, "{:.1f}"), |
| ] |
|
|
|
|
| def load_json(path: pathlib.Path): |
| try: |
| return json.loads(path.read_text(encoding="utf-8")) |
| except Exception: |
| return None |
|
|
|
|
| def best_epoch_for(final_dir: pathlib.Path) -> int | None: |
| """Epoch at which the best checkpoint was saved.""" |
| meta = load_json(final_dir / "checkpoints" / "best.pt.meta.json") |
| if meta and meta.get("epoch") is not None: |
| return int(meta["epoch"]) |
|
|
| |
| hist = load_json(final_dir / "history.json") |
| if isinstance(hist, list) and hist: |
| best_ep, best_val = None, None |
| for row in hist: |
| val = row.get("selection_metric_value") |
| if val is None: |
| continue |
| if best_val is None or float(val) > float(best_val): |
| best_val, best_ep = float(val), int(row.get("epoch", 0)) |
| return best_ep |
| return None |
|
|
|
|
| def collect(runs_root: pathlib.Path) -> dict[str, dict[int, dict[str, list[float]]]]: |
| """model -> strategy -> metric -> [one value per phase]""" |
| data: dict[str, dict[int, dict[str, list[float]]]] = defaultdict( |
| lambda: defaultdict(lambda: defaultdict(list)) |
| ) |
| for eval_path in runs_root.glob("*/**/strategy_*/final/evaluation.json"): |
| final_dir = eval_path.parent |
| m = re.search(r"strategy_(\d+)", final_dir.parent.name) |
| if not m: |
| continue |
| strategy = int(m.group(1)) |
| if strategy not in (2, 3): |
| continue |
| try: |
| model = eval_path.relative_to(runs_root).parts[0] |
| except ValueError: |
| continue |
|
|
| ev = load_json(eval_path) |
| if not ev: |
| continue |
| bucket = data[model][strategy] |
| metrics = ev.get("metrics", {}) or {} |
|
|
| for key in ("biou", "biou_contour"): |
| val = (metrics.get(key) or {}).get("mean") |
| if val is not None: |
| bucket[key].append(float(val)) |
|
|
| infer = (ev.get("timing", {}) or {}).get("mean_per_image_inference_ms") |
| if infer is not None: |
| bucket["infer_ms"].append(float(infer)) |
|
|
| summary = load_json(final_dir / "summary.json") |
| if summary: |
| if summary.get("elapsed_seconds") is not None: |
| bucket["train_min"].append(float(summary["elapsed_seconds"]) / 60.0) |
| spe = summary.get("seconds_per_epoch") |
| if spe is not None: |
| bucket["epoch_sec"].append(float(spe)) |
| be = best_epoch_for(final_dir) |
| if be: |
| bucket["time_to_best_min"].append(be * float(spe) / 60.0) |
|
|
| return data |
|
|
|
|
| def plot_model(model: str, per_strategy: dict[int, dict[str, list[float]]], |
| out_dir: pathlib.Path) -> pathlib.Path | None: |
| strategies = [s for s in (2, 3) if per_strategy.get(s)] |
| if not strategies: |
| return None |
|
|
| n_phases = max((len(v.get("biou", [])) for v in per_strategy.values()), default=0) |
| fig, axes = plt.subplots(2, 3, figsize=(16, 8.5)) |
| fig.suptitle(f"{model} — Strategy 2 vs Strategy 3\n" |
| f"mean across {n_phases} phase(s), error bars = std across phases", |
| fontsize=14, fontweight="bold") |
|
|
| for ax, (key, title, ylabel, higher_better, fmt) in zip(axes.ravel(), PANELS): |
| xs, means, stds, labels, colors = [], [], [], [], [] |
| for i, s in enumerate(strategies): |
| vals = per_strategy[s].get(key, []) |
| if not vals: |
| continue |
| xs.append(i) |
| means.append(float(np.mean(vals))) |
| stds.append(float(np.std(vals)) if len(vals) > 1 else 0.0) |
| labels.append(STRATEGY_LABEL[s]) |
| colors.append(BAR_COLORS[s]) |
|
|
| if not means: |
| ax.set_title(f"{title} (no data)") |
| ax.axis("off") |
| continue |
|
|
| bars = ax.bar(xs, means, yerr=stds, capsize=5, color=colors, width=0.55) |
| ax.set_xticks(xs) |
| ax.set_xticklabels(labels, fontsize=9) |
| ax.set_ylabel(ylabel) |
| ax.set_title(f"{title} ({'higher' if higher_better else 'lower'} is better)", fontsize=11) |
| ax.grid(axis="y", alpha=0.3, linestyle="--") |
| ax.margins(y=0.18) |
|
|
| for b, mval in zip(bars, means): |
| ax.annotate(fmt.format(mval), (b.get_x() + b.get_width() / 2, b.get_height()), |
| textcoords="offset points", xytext=(0, 4), ha="center", fontsize=9) |
|
|
| if len(means) == 2: |
| delta = means[1] - means[0] |
| pct = (delta / means[0] * 100.0) if means[0] else 0.0 |
| good = (delta > 0) if higher_better else (delta < 0) |
| ax.text(0.5, 0.02, f"Δ(S3−S2) = {delta:+.4g} ({pct:+.1f}%)", |
| transform=ax.transAxes, ha="center", fontsize=9, |
| color=("green" if good else "red")) |
|
|
| fig.tight_layout(rect=(0, 0, 1, 0.93)) |
| out_dir.mkdir(parents=True, exist_ok=True) |
| out_path = out_dir / f"{model}__s2_vs_s3.png" |
| fig.savefig(out_path, dpi=150) |
| plt.close(fig) |
| return out_path |
|
|
|
|
| def main() -> int: |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--runs-root", default="runs") |
| args = ap.parse_args() |
|
|
| runs_root = pathlib.Path(args.runs_root).resolve() |
| if not runs_root.is_dir(): |
| print(f"[plot] runs root not found: {runs_root}") |
| return 1 |
|
|
| data = collect(runs_root) |
| if not data: |
| print(f"[plot] no evaluation.json found under {runs_root}") |
| return 1 |
|
|
| out_dir = runs_root / "_plots" |
| csv_rows = ["model,strategy,metric,mean,std,n_phases"] |
| made = [] |
|
|
| for model in sorted(data): |
| p = plot_model(model, data[model], out_dir) |
| if p: |
| made.append(p) |
| n = max((len(v.get("biou", [])) for v in data[model].values()), default=0) |
| print(f"[plot] {model:34s} n_phases={n:<3d} -> {p.name}") |
| for s in sorted(data[model]): |
| for key, *_ in PANELS: |
| vals = data[model][s].get(key, []) |
| if vals: |
| csv_rows.append( |
| f"{model},{s},{key},{np.mean(vals):.6f}," |
| f"{(np.std(vals) if len(vals) > 1 else 0.0):.6f},{len(vals)}" |
| ) |
|
|
| (out_dir / "summary_s2_vs_s3.csv").write_text("\n".join(csv_rows) + "\n", encoding="utf-8") |
| print(f"\n[plot] {len(made)} figure(s) + summary_s2_vs_s3.csv written to {out_dir}") |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
