Create scorer.py

scorer.py

@@ -0,0 +1,260 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from typing import Dict, List, Optional
+
+import pandas as pd
+
+
+REQUIRED_COLS = [
+    "row_id",
+    "series_id",
+    "timepoint_h",
+    "host_model",
+    "drug",
+    "plasma_conc_mg_L",
+    "csf_conc_mg_L",
+    "expected_csf_conc_mg_L",
+    "csf_deviation",
+    "bbb_penetration_ratio",
+    "expected_bbb_ratio",
+    "ratio_deviation",
+    "neuro_marker_index",
+    "neuro_coherence_index",
+    "exposure_index",
+    "stress_index",
+    "later_severe_neuro_flag",
+    "assay_method",
+    "source_type",
+    "neuro_threshold_shift_signal",
+    "earliest_neuro_threshold_shift",
+]
+
+
+@dataclass
+class Thresholds:
+    min_points: int = 3
+
+    stress_min: float = 0.80
+    exposure_min: float = 0.80
+
+    baseline_ratio_max: float = 0.12
+
+    coherence_max: float = 0.40
+    ratio_dev_min: float = 0.04
+    neuro_marker_min: float = 0.50
+    require_two_consecutive: bool = True
+
+    spike_ratio_dev_min: float = 0.08
+    snapback_ratio_dev_max: float = 0.003
+
+
+def _validate(df: pd.DataFrame) -> List[str]:
+    errs: List[str] = []
+    missing = [c for c in REQUIRED_COLS if c not in df.columns]
+    if missing:
+        errs.append(f"missing_columns: {missing}")
+
+    for c in ["exposure_index", "stress_index", "neuro_coherence_index", "neuro_marker_index"]:
+        if c in df.columns:
+            bad = ((df[c] < 0) | (df[c] > 1)).sum()
+            if bad:
+                errs.append(f"{c}_out_of_range count={int(bad)}")
+
+    for c in ["plasma_conc_mg_L", "csf_conc_mg_L", "expected_csf_conc_mg_L"]:
+        if c in df.columns:
+            bad = (df[c] <= 0).sum()
+            if bad:
+                errs.append(f"non_positive_values_in: {c} count={int(bad)}")
+
+    for c in ["later_severe_neuro_flag", "neuro_threshold_shift_signal", "earliest_neuro_threshold_shift"]:
+        if c in df.columns:
+            bad = (~df[c].isin([0, 1])).sum()
+            if bad:
+                errs.append(f"non_binary_values_in: {c} count={int(bad)}")
+
+    counts = df.groupby("series_id")["earliest_neuro_threshold_shift"].sum()
+    bad_series = counts[counts > 1].index.tolist()
+    if bad_series:
+        errs.append(f"multiple_earliest_neuro_threshold_shift_in_series: {bad_series}")
+
+    return errs
+
+
+def _flag_spike_snap(g: pd.DataFrame, t: Thresholds) -> pd.Series:
+    flag = pd.Series([0] * len(g), index=g.index)
+    if len(g) < 3:
+        return flag
+
+    g = g.sort_values("timepoint_h").copy()
+    for i in range(1, len(g) - 1):
+        idx = g.index[i]
+        next_idx = g.index[i + 1]
+        v = float(g.loc[idx, "ratio_deviation"])
+        next_v = float(g.loc[next_idx, "ratio_deviation"])
+        if v >= t.spike_ratio_dev_min and next_v <= t.snapback_ratio_dev_max:
+            flag.loc[idx] = 1
+    return flag
+
+
+def _f1(tp: int, fp: int, fn: int) -> float:
+    denom = 2 * tp + fp + fn
+    return 0.0 if denom == 0 else (2 * tp) / denom
+
+
+def score(path: str) -> Dict[str, object]:
+    df = pd.read_csv(path)
+    errors = _validate(df)
+    if errors:
+        return {"ok": False, "errors": errors}
+
+    t = Thresholds()
+
+    df = df.sort_values(["series_id", "timepoint_h"]).reset_index(drop=True)
+    df["pred_earliest_neuro_threshold_shift"] = 0
+    df["pred_neuro_threshold_shift_signal"] = 0
+    df["flag_ratio_spike"] = 0
+
+    series_rows: List[Dict[str, object]] = []
+
+    for sid, g in df.groupby("series_id"):
+        g = g.sort_values("timepoint_h").copy()
+        df.loc[g.index, "flag_ratio_spike"] = _flag_spike_snap(g, t).astype(int)
+
+        if len(g) < t.min_points:
+            series_rows.append(
+                {
+                    "series_id": sid,
+                    "y_nts": int(g["neuro_threshold_shift_signal"].max()),
+                    "p_nts": 0,
+                    "true_transition_row_id": (str(g[g["earliest_neuro_threshold_shift"] == 1].iloc[0]["row_id"]) if (g["earliest_neuro_threshold_shift"] == 1).any() else None),
+                    "pred_transition_row_id": None,
+                    "flags": ["too_few_points"],
+                }
+            )
+            continue
+
+        baseline_ratio = float(g.iloc[0]["bbb_penetration_ratio"])
+        if baseline_ratio > t.baseline_ratio_max:
+            series_rows.append(
+                {
+                    "series_id": sid,
+                    "y_nts": int(g["neuro_threshold_shift_signal"].max()),
+                    "p_nts": 0,
+                    "true_transition_row_id": (str(g[g["earliest_neuro_threshold_shift"] == 1].iloc[0]["row_id"]) if (g["earliest_neuro_threshold_shift"] == 1).any() else None),
+                    "pred_transition_row_id": None,
+                    "flags": ["baseline_ratio_high"],
+                }
+            )
+            continue
+
+        hit: Optional[int] = None
+        for i in range(1, len(g)):
+            idx = g.index[i]
+            if int(df.loc[idx, "flag_ratio_spike"]) == 1:
+                continue
+
+            if float(df.loc[idx, "stress_index"]) < t.stress_min:
+                continue
+            if float(df.loc[idx, "exposure_index"]) < t.exposure_min:
+                continue
+
+            coh = float(df.loc[idx, "neuro_coherence_index"])
+            rdev = float(df.loc[idx, "ratio_deviation"])
+            nmark = float(df.loc[idx, "neuro_marker_index"])
+
+            if coh > t.coherence_max:
+                continue
+            if rdev < t.ratio_dev_min:
+                continue
+            if nmark < t.neuro_marker_min:
+                continue
+
+            if t.require_two_consecutive:
+                if i + 1 >= len(g):
+                    continue
+                idx2 = g.index[i + 1]
+                if int(df.loc[idx2, "flag_ratio_spike"]) == 1:
+                    continue
+                if float(df.loc[idx2, "stress_index"]) < t.stress_min:
+                    continue
+                if float(df.loc[idx2, "exposure_index"]) < t.exposure_min:
+                    continue
+                coh2 = float(df.loc[idx2, "neuro_coherence_index"])
+                rdev2 = float(df.loc[idx2, "ratio_deviation"])
+                nmark2 = float(df.loc[idx2, "neuro_marker_index"])
+                if coh2 > t.coherence_max or rdev2 < t.ratio_dev_min or nmark2 < t.neuro_marker_min:
+                    continue
+
+            hit = idx
+            break
+
+        confirm = False
+        if hit is not None:
+            later = g[g.index > hit]
+            confirm = bool((later["later_severe_neuro_flag"] == 1).any())
+
+        if hit is not None and confirm:
+            df.loc[hit, "pred_earliest_neuro_threshold_shift"] = 1
+            df.loc[g[g.index >= hit].index, "pred_neuro_threshold_shift_signal"] = 1
+
+        y = int(g["neuro_threshold_shift_signal"].max())
+        p = int(df.loc[g.index, "pred_neuro_threshold_shift_signal"].max())
+
+        true_tr = g[g["earliest_neuro_threshold_shift"] == 1]
+        true_id: Optional[str] = None
+        if len(true_tr) == 1:
+            true_id = str(true_tr.iloc[0]["row_id"])
+
+        pred_tr_rows = df.loc[g.index][df.loc[g.index, "pred_earliest_neuro_threshold_shift"] == 1]
+        pred_id = str(pred_tr_rows.iloc[0]["row_id"]) if len(pred_tr_rows) == 1 else None
+
+        series_rows.append(
+            {
+                "series_id": sid,
+                "y_nts": y,
+                "p_nts": p,
+                "true_transition_row_id": true_id,
+                "pred_transition_row_id": pred_id,
+                "ratio_spike_flags": int(df.loc[g.index, "flag_ratio_spike"].sum()),
+            }
+        )
+
+    sr = pd.DataFrame(series_rows)
+
+    tp = int(((sr["y_nts"] == 1) & (sr["p_nts"] == 1)).sum())
+    fp = int(((sr["y_nts"] == 0) & (sr["p_nts"] == 1)).sum())
+    fn = int(((sr["y_nts"] == 1) & (sr["p_nts"] == 0)).sum())
+    tn = int(((sr["y_nts"] == 0) & (sr["p_nts"] == 0)).sum())
+
+    transition_hit = int(
+        (sr["true_transition_row_id"].notna() & (sr["true_transition_row_id"] == sr["pred_transition_row_id"])).sum()
+    )
+    transition_miss = int(
+        (sr["true_transition_row_id"].notna() & (sr["true_transition_row_id"] != sr["pred_transition_row_id"])).sum()
+    )
+
+    return {
+        "ok": True,
+        "path": path,
+        "counts": {"tp": tp, "fp": fp, "fn": fn, "tn": tn},
+        "metrics": {
+            "f1_series": _f1(tp, fp, fn),
+            "transition_hit": transition_hit,
+            "transition_miss": transition_miss,
+            "n_series": int(len(sr)),
+        },
+        "series_table": series_rows,
+    }
+
+
+if __name__ == "__main__":
+    import argparse
+
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--path", required=True)
+    args = ap.parse_args()
+
+    result = score(args.path)
+    print(json.dumps(result, indent=2))