Create scorer.py

scorer.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+import csv
+import json
+import sys
+from pathlib import Path
+from typing import Dict, List, Tuple
+
+
+PREDICTION_COLUMN_CANDIDATES = [
+    "prediction",
+    "pred",
+    "predicted_label",
+    "label",
+]
+
+
+def _to_int(value: str) -> int:
+    value = str(value).strip()
+    return 1 if value in {"1", "1.0", "true", "True"} else 0
+
+
+def _load_csv(path: Path) -> List[Dict[str, str]]:
+    with path.open("r", encoding="utf-8", newline="") as f:
+        return list(csv.DictReader(f))
+
+
+def _find_label_column(rows: List[Dict[str, str]]) -> str:
+    if not rows:
+        raise ValueError("Ground truth file is empty.")
+    label_cols = [c for c in rows[0].keys() if c.startswith("label_")]
+    if len(label_cols) == 1:
+        return label_cols[0]
+    raise ValueError(f"Expected one label column, found: {label_cols}")
+
+
+def _find_prediction_column(rows: List[Dict[str, str]]) -> str:
+    if not rows:
+        raise ValueError("Prediction file is empty.")
+
+    available = set(rows[0].keys())
+
+    for col in PREDICTION_COLUMN_CANDIDATES:
+        if col in available:
+            return col
+
+    label_like_cols = [c for c in rows[0].keys() if c.startswith("label_")]
+    if len(label_like_cols) == 1:
+        return label_like_cols[0]
+
+    raise ValueError(
+        "No prediction column found. Expected one of "
+        f"{PREDICTION_COLUMN_CANDIDATES} or a single label_* column."
+    )
+
+
+def _confusion(y_true: List[int], y_pred: List[int]) -> Tuple[int, int, int, int]:
+    tp = fp = tn = fn = 0
+    for yt, yp in zip(y_true, y_pred):
+        if yt == 1 and yp == 1:
+            tp += 1
+        elif yt == 0 and yp == 1:
+            fp += 1
+        elif yt == 0 and yp == 0:
+            tn += 1
+        elif yt == 1 and yp == 0:
+            fn += 1
+    return tp, fp, tn, fn
+
+
+def _safe_div(n: float, d: float) -> float:
+    return n / d if d else 0.0
+
+
+def score(ground_truth_path: str, prediction_path: str) -> Dict[str, object]:
+    gt_rows = _load_csv(Path(ground_truth_path))
+    pred_rows = _load_csv(Path(prediction_path))
+
+    if len(gt_rows) != len(pred_rows):
+        raise ValueError(
+            f"Row count mismatch: ground truth has {len(gt_rows)} rows, "
+            f"predictions have {len(pred_rows)} rows."
+        )
+
+    label_column = _find_label_column(gt_rows)
+    pred_col = _find_prediction_column(pred_rows)
+
+    y_true = [_to_int(row[label_column]) for row in gt_rows]
+    y_pred = [_to_int(row[pred_col]) for row in pred_rows]
+
+    tp, fp, tn, fn = _confusion(y_true, y_pred)
+
+    accuracy = _safe_div(tp + tn, tp + tn + fp + fn)
+    precision = _safe_div(tp, tp + fp)
+    recall_boundary_detection = _safe_div(tp, tp + fn)
+    false_safe_rate = _safe_div(fn, fn + tp)
+    f1 = _safe_div(
+        2 * precision * recall_boundary_detection,
+        precision + recall_boundary_detection,
+    )
+
+    return {
+        "label_column": label_column,
+        "prediction_column": pred_col,
+        "accuracy": round(accuracy, 6),
+        "precision": round(precision, 6),
+        "recall_boundary_detection": round(recall_boundary_detection, 6),
+        "false_safe_rate": round(false_safe_rate, 6),
+        "f1": round(f1, 6),
+        "confusion_matrix": {
+            "tp": tp,
+            "fp": fp,
+            "tn": tn,
+            "fn": fn,
+        },
+        "primary_metric": "recall_boundary_detection",
+        "secondary_metric": "false_safe_rate",
+    }
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 3:
+        raise SystemExit("Usage: python scorer.py <ground_truth.csv> <predictions.csv>")
+
+    results = score(sys.argv[1], sys.argv[2])
+    print(json.dumps(results, indent=2))