plot_s2_vs_s3.py

"""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"}

# key, title, ylabel, higher_is_better, value format
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"])

    # fallback: argmax of the selection metric recorded in history
    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())