legex/analysis/plots.py

"""Paper-ready figures from `data/analysis/*.csv`.

Reads the CSVs that `legex-analysis` emits and writes four PNGs into
``data/analysis/figures/``:

  - ``hallucination_by_country.png`` — grouped bar, models side-by-side.
  - ``recall_by_country.png`` — grouped bar, models side-by-side.
  - ``per_variable_heatmap.png`` — variable × {accuracy, recall, hallu., F1}, one panel per model.
  - ``hallu_vs_recall.png`` — scatter on the cost block, one marker per (cc, model).
"""

import argparse
import csv
import logging
import sys
from collections import defaultdict
from pathlib import Path

import matplotlib.pyplot as plt
import numpy as np

log = logging.getLogger(__name__)


def _read_csv(path: Path) -> list[dict[str, str]]:
    with open(path, encoding="utf-8", newline="") as f:
        return list(csv.DictReader(f))


def _models_in(rows: list[dict[str, str]]) -> list[str]:
    return sorted({r["model"] for r in rows})


def _short_model(m: str) -> str:
    return m.split("/")[-1]


def _grouped_bar(
    rows: list[dict[str, str]], metric: str, title: str, ylabel: str, out: Path,
) -> None:
    """Grouped-bar chart: one bar per (country, model) pair."""
    countries = sorted({r["country"] for r in rows})
    models = _models_in(rows)
    values: dict[str, dict[str, float]] = defaultdict(dict)
    for r in rows:
        values[r["country"]][r["model"]] = float(r[metric])

    x = np.arange(len(countries))
    width = 0.8 / max(1, len(models))
    fig, ax = plt.subplots(figsize=(max(10, 0.55 * len(countries)), 4.5))
    for i, model in enumerate(models):
        ys = [values[cc].get(model, np.nan) * 100 for cc in countries]
        ax.bar(x + (i - (len(models) - 1) / 2) * width, ys, width, label=_short_model(model))
    ax.set_xticks(x)
    ax.set_xticklabels([cc.upper() for cc in countries], rotation=45, ha="right")
    ax.set_ylabel(ylabel)
    ax.set_title(title)
    ax.set_ylim(0, 100)
    ax.grid(axis="y", alpha=0.3)
    ax.legend(frameon=False)
    fig.tight_layout()
    fig.savefig(out, dpi=150)
    plt.close(fig)
    log.info(f"wrote {out}")


def _heatmap(
    rows: list[dict[str, str]], out: Path,
) -> None:
    """Variable × {accuracy, recall_when_filled, hallucination_rate, f1} for each model."""
    metrics = [
        ("accuracy", "Accuracy"),
        ("recall_when_filled", "Recall$_{filled}$"),
        ("hallucination_rate", "Hallu. rate"),
        ("f1", "F1"),
    ]
    models = _models_in(rows)
    columns = sorted({r["column"] for r in rows})

    fig, axes = plt.subplots(1, len(models), figsize=(5 * len(models), max(5, 0.32 * len(columns))))
    if len(models) == 1:
        axes = [axes]
    for ax, model in zip(axes, models):
        grid = np.full((len(columns), len(metrics)), np.nan)
        for r in rows:
            if r["model"] != model:
                continue
            i = columns.index(r["column"])
            for j, (key, _label) in enumerate(metrics):
                grid[i, j] = float(r[key])
        im = ax.imshow(grid, aspect="auto", cmap="RdYlGn", vmin=0, vmax=1)
        ax.set_xticks(range(len(metrics)))
        ax.set_xticklabels([m[1] for m in metrics], rotation=30, ha="right")
        ax.set_yticks(range(len(columns)))
        ax.set_yticklabels(columns, fontsize=8)
        ax.set_title(_short_model(model), fontsize=10)
        for i in range(len(columns)):
            for j in range(len(metrics)):
                v = grid[i, j]
                if not np.isnan(v):
                    ax.text(j, i, f"{v:.2f}", ha="center", va="center", fontsize=7,
                            color="black" if 0.25 < v < 0.75 else "white")
    fig.colorbar(im, ax=axes, shrink=0.8, label="value")
    fig.suptitle("Per-variable metrics (summed across jurisdictions)")
    fig.savefig(out, dpi=150, bbox_inches="tight")
    plt.close(fig)
    log.info(f"wrote {out}")


def _scatter(rows: list[dict[str, str]], out: Path) -> None:
    """Hallucination vs recall on the cost block. One marker per (cc, model)."""
    models = _models_in(rows)
    markers = dict(zip(models, ("o", "s", "^", "D", "v", "P", "X")))
    colors = plt.cm.tab20.colors

    fig, ax = plt.subplots(figsize=(7, 6))
    for r in rows:
        m = r["model"]
        x = float(r["cost_hallucination_rate"]) * 100
        y = float(r["cost_recall_when_filled"]) * 100
        cc = r["country"]
        c = colors[hash(cc) % len(colors)]
        ax.scatter(x, y, marker=markers.get(m, "o"), color=c, s=70, alpha=0.85, edgecolor="black", linewidth=0.4)
        ax.annotate(cc.upper(), (x, y), fontsize=7, xytext=(3, 3), textcoords="offset points")
    ax.set_xlabel("Cost-block hallucination rate (%)")
    ax.set_ylabel("Cost-block recall when filled (%)")
    ax.set_title("Cost extraction: recall vs hallucination, by jurisdiction × model")
    ax.set_xlim(-2, 100)
    ax.set_ylim(-2, 100)
    ax.grid(alpha=0.3)
    handles = [
        plt.Line2D([], [], marker=mk, linestyle="", color="grey", label=_short_model(m))
        for m, mk in markers.items()
    ]
    ax.legend(handles=handles, frameon=False, loc="lower right")
    fig.tight_layout()
    fig.savefig(out, dpi=150)
    plt.close(fig)
    log.info(f"wrote {out}")


def make_all(analysis_dir: Path, out_dir: Path) -> None:
    out_dir.mkdir(parents=True, exist_ok=True)
    per_country = _read_csv(analysis_dir / "per_country.csv")
    per_column = _read_csv(analysis_dir / "per_column.csv")

    _grouped_bar(
        per_country, "hallucination_rate",
        "Hallucination rate by jurisdiction (cells where the expert recorded nothing)",
        "Hallucination rate (%)",
        out_dir / "hallucination_by_country.png",
    )
    _grouped_bar(
        per_country, "recall_when_filled",
        "Accuracy when the expert recorded a value",
        "Accuracy (%)",
        out_dir / "recall_by_country.png",
    )
    _heatmap(per_column, out_dir / "per_variable_heatmap.png")
    _scatter(per_country, out_dir / "hallu_vs_recall.png")


def main() -> None:
    logging.basicConfig(
        level=logging.INFO,
        format="%(asctime)s [%(levelname)s] %(message)s",
        handlers=[logging.StreamHandler(sys.stderr)],
    )
    parser = argparse.ArgumentParser(
        prog="legex-plots",
        description="Render paper-ready figures from data/analysis/*.csv.",
    )
    parser.add_argument("--in", dest="in_dir", type=Path, default=Path("data/analysis"))
    parser.add_argument("--out", dest="out_dir", type=Path, default=Path("data/analysis/figures"))
    args = parser.parse_args()
    make_all(args.in_dir, args.out_dir)


if __name__ == "__main__":
    main()