scripts/compute_extra_metrics.py

"""Post-hoc compute additional binary classification metrics from a
test_predictions CSV produced by BaseMethod._dump_test_predictions.

Metrics computed
----------------
  acc          : threshold-0.5 accuracy (recomputed from score, label).
  auc          : ROC-AUC.
  ap           : Average Precision (area under PR curve).
  acc_at_eer   : accuracy at the threshold where FPR == FNR (Equal Error Rate).
                 Found by scanning the ROC curve for the operating point that
                 minimizes |FPR - FNR|.

Output
------
Default: a single line of `key=value key=value ...` to stdout, easy to grep
from a shell script. Pass --json to emit a JSON object instead.

Returns code 0 on success even if the CSV has only a single class — in that
case AUC is reported as NaN. Returns rc=2 if the CSV is missing or empty.

Usage
-----
  python3 scripts/compute_extra_metrics.py /path/to/test_predictions.csv
  python3 scripts/compute_extra_metrics.py /path/to/test_predictions.csv --json
"""
from __future__ import annotations

import argparse
import csv
import json
import math
import sys
from pathlib import Path
from typing import List, Tuple


def _numpy_roc_pr(scores: List[float], labels: List[int]):
    """Fallback ROC/PR computation using only the standard library + numpy.

    Returns (auc, ap, fpr_list, tpr_list, thr_list) sorted by descending
    threshold, mirroring sklearn.metrics.roc_curve's output ordering.
    """
    # Pair-and-sort by descending score. Ties: count carefully via run-length.
    order = sorted(range(len(scores)), key=lambda i: -scores[i])
    s_sorted = [scores[i] for i in order]
    y_sorted = [labels[i] for i in order]
    P = sum(1 for y in labels if y == 1)
    N = len(labels) - P

    # Walk through unique thresholds in descending order, accumulating TP/FP.
    fpr_list: List[float] = [0.0]
    tpr_list: List[float] = [0.0]
    thr_list: List[float] = [float("inf")]
    tp = 0
    fp = 0
    i = 0
    n = len(s_sorted)
    # PR curve: precision @ each recall step (for AP via step-AUC, the
    # "interpolated" form sklearn uses for average_precision_score).
    prev_recall = 0.0
    ap = 0.0
    while i < n:
        j = i
        while j < n and s_sorted[j] == s_sorted[i]:
            if y_sorted[j] == 1:
                tp += 1
            else:
                fp += 1
            j += 1
        thr = float(s_sorted[i])
        tpr = tp / P if P else 0.0
        fpr = fp / N if N else 0.0
        fpr_list.append(fpr)
        tpr_list.append(tpr)
        thr_list.append(thr)
        # AP increment: precision * (recall - prev_recall)
        precision = tp / (tp + fp) if (tp + fp) > 0 else 1.0
        ap += precision * (tpr - prev_recall)
        prev_recall = tpr
        i = j

    # AUC via trapezoidal integration over fpr (already sorted ascending in
    # the appended list because thresholds are descending → fpr only grows).
    auc = 0.0
    for k in range(1, len(fpr_list)):
        auc += (fpr_list[k] - fpr_list[k - 1]) * (tpr_list[k] + tpr_list[k - 1]) / 2.0

    return auc, ap, fpr_list, tpr_list, thr_list


def load_scores_labels(csv_path: Path) -> Tuple[List[float], List[int]]:
    scores: List[float] = []
    labels: List[int] = []
    with open(csv_path, "r", newline="") as f:
        reader = csv.DictReader(f)
        if reader.fieldnames is None or "score" not in reader.fieldnames or "label" not in reader.fieldnames:
            raise ValueError(
                f"CSV {csv_path} missing required columns 'score' and 'label'. "
                f"Found: {reader.fieldnames}"
            )
        for row in reader:
            try:
                s = float(row["score"])
                y = int(row["label"])
            except (TypeError, ValueError):
                continue
            scores.append(s)
            labels.append(y)
    return scores, labels


def compute_metrics(scores: List[float], labels: List[int]) -> dict:
    n = len(scores)
    if n == 0:
        return {"n": 0, "acc": float("nan"), "auc": float("nan"),
                "ap": float("nan"), "acc_at_eer": float("nan"), "eer_threshold": float("nan")}

    # threshold-0.5 accuracy
    correct = sum(1 for s, y in zip(scores, labels) if int(s > 0.5) == int(y))
    acc = correct / n

    # Need both classes for AUC / AP / EER
    pos = sum(1 for y in labels if y == 1)
    neg = n - pos
    if pos == 0 or neg == 0:
        return {
            "n": n, "n_pos": pos, "n_neg": neg,
            "acc": acc,
            "auc": float("nan"), "ap": float("nan"),
            "acc_at_eer": float("nan"), "eer_threshold": float("nan"),
        }

    # Use sklearn for AUC / AP / ROC curve when available; fall back to a
    # pure-numpy implementation otherwise. The project's requirements.txt
    # pins scikit-learn>=1.3, so on a fully bootstrapped server sklearn
    # is available and we follow the canonical implementation.
    try:
        from sklearn.metrics import roc_auc_score, average_precision_score, roc_curve
        auc = float(roc_auc_score(labels, scores))
        ap = float(average_precision_score(labels, scores))
        fpr, tpr, thr = roc_curve(labels, scores)
        fpr = list(map(float, fpr))
        tpr = list(map(float, tpr))
        thr = list(map(float, thr))
    except ImportError:
        auc, ap, fpr, tpr, thr = _numpy_roc_pr(scores, labels)

    fnr = [1.0 - t for t in tpr]
    diffs = [abs(a - b) for a, b in zip(fpr, fnr)]
    idx = min(range(len(diffs)), key=lambda i: diffs[i])
    eer_threshold = float(thr[idx])
    # NB: sklearn occasionally inserts a sentinel threshold of +inf at idx 0.
    if not math.isfinite(eer_threshold):
        ranked = sorted(range(len(diffs)), key=lambda i: diffs[i])
        for j in ranked:
            if math.isfinite(float(thr[j])):
                idx = j
                eer_threshold = float(thr[j])
                break

    # acc at that threshold (predict positive iff score >= threshold)
    correct_eer = sum(
        1 for s, y in zip(scores, labels)
        if int(float(s) >= eer_threshold) == int(y)
    )
    acc_at_eer = correct_eer / n

    return {
        "n": n,
        "n_pos": pos,
        "n_neg": neg,
        "acc": acc,
        "auc": auc,
        "ap": ap,
        "acc_at_eer": acc_at_eer,
        "eer_threshold": eer_threshold,
    }


def format_kv(metrics: dict) -> str:
    parts = []
    for k, v in metrics.items():
        if isinstance(v, float):
            parts.append(f"{k}={v:.6f}")
        else:
            parts.append(f"{k}={v}")
    return " ".join(parts)


def main() -> int:
    p = argparse.ArgumentParser(description=__doc__)
    p.add_argument("csv_path", help="Path to test_predictions CSV.")
    p.add_argument("--json", action="store_true", help="Emit JSON instead of key=value.")
    args = p.parse_args()

    csv_path = Path(args.csv_path)
    if not csv_path.exists():
        print(f"[compute_extra_metrics] CSV not found: {csv_path}", file=sys.stderr)
        return 2

    scores, labels = load_scores_labels(csv_path)
    if not scores:
        print(f"[compute_extra_metrics] CSV is empty: {csv_path}", file=sys.stderr)
        return 2

    metrics = compute_metrics(scores, labels)

    if args.json:
        print(json.dumps(metrics))
    else:
        print(format_kv(metrics))
    return 0


if __name__ == "__main__":
    raise SystemExit(main())