docking_pipeline/metrics.py

from __future__ import annotations

import math
import json
import csv
from pathlib import Path


def roc_auc(scores: list[float], labels: list[int]) -> float:
    pairs = [(float(s), int(y)) for s, y in zip(scores, labels)]
    pos = [s for s, y in pairs if y == 1]
    neg = [s for s, y in pairs if y == 0]
    if not pos or not neg:
        return float("nan")
    wins = 0.0
    for p in pos:
        wins += sum(1.0 for n in neg if p < n)
        wins += 0.5 * sum(1.0 for n in neg if p == n)
    return float(wins / (len(pos) * len(neg)))


def enrichment_factor(scores: list[float], labels: list[int], fraction: float) -> float:
    pairs = [(float(s), int(y)) for s, y in zip(scores, labels)]
    n = len(pairs)
    total_actives = sum(y for _, y in pairs)
    if n == 0 or total_actives == 0:
        return float("nan")
    k = max(1, int(math.ceil(n * fraction)))
    top = sorted(pairs, key=lambda item: item[0])[:k]
    hit_rate_top = float(sum(y for _, y in top)) / float(k)
    hit_rate_all = float(total_actives) / float(n)
    return float(hit_rate_top / hit_rate_all) if hit_rate_all > 0 else float("nan")


def bedroc(scores: list[float], labels: list[int], alpha: float = 20.0) -> float:
    pairs = sorted([(float(s), int(y)) for s, y in zip(scores, labels)], key=lambda item: item[0])
    n = len(pairs)
    n_act = sum(y for _, y in pairs)
    if n == 0 or n_act == 0 or n_act == n:
        return float("nan")
    ranks = [idx + 1 for idx, (_, y) in enumerate(pairs) if y == 1]
    denom = (1 - math.exp(-alpha)) / (math.exp(alpha / n) - 1)
    rie = (n / n_act) * sum(math.exp(-alpha * rank / n) for rank in ranks) / denom
    rie_min = (n / n_act) * sum(math.exp(-alpha * rank / n) for rank in range(n - n_act + 1, n + 1)) / denom
    rie_max = (n / n_act) * sum(math.exp(-alpha * rank / n) for rank in range(1, n_act + 1)) / denom
    return float((rie - rie_min) / (rie_max - rie_min))


def enrichment_rows(scores: list[float], labels: list[int]) -> list[dict[str, float]]:
    rows = []
    for frac in (0.01, 0.05, 0.10, 0.20):
        rows.append({"fraction": frac, "enrichment_factor": enrichment_factor(scores, labels, frac)})
    return rows


def validation_metrics_from_rows(rows: list[dict[str, object]], score_col: str = "SCORE", label_col: str = "label") -> dict[str, float]:
    scores = [float(row[score_col]) for row in rows]
    labels = [int(float(row.get(label_col, 0) or 0)) for row in rows]
    return {
        "roc_auc": roc_auc(scores, labels),
        "ef1": enrichment_factor(scores, labels, 0.01),
        "ef5": enrichment_factor(scores, labels, 0.05),
        "ef10": enrichment_factor(scores, labels, 0.10),
        "ef20": enrichment_factor(scores, labels, 0.20),
        "bedroc20": bedroc(scores, labels, alpha=20.0),
    }


def write_metrics(rows: list[dict[str, object]], metrics_json: str | Path, enrichment_csv: str | Path) -> dict[str, float]:
    metrics = validation_metrics_from_rows(rows)
    Path(metrics_json).parent.mkdir(parents=True, exist_ok=True)
    Path(metrics_json).write_text(json.dumps(metrics, indent=2), encoding="utf-8")
    scores = [float(row["SCORE"]) for row in rows]
    labels = [int(float(row.get("label", 0) or 0)) for row in rows]
    with Path(enrichment_csv).open("w", encoding="utf-8", newline="") as handle:
        writer = csv.DictWriter(handle, fieldnames=["fraction", "enrichment_factor"])
        writer.writeheader()
        writer.writerows(enrichment_rows(scores, labels))
    return metrics


validation_metrics_from_table = validation_metrics_from_rows
enrichment_table = enrichment_rows