Create scorer.py

scorer.py

@@ -0,0 +1,328 @@
+import csv
+import json
+import sys
+from typing import Dict, List, Optional, Tuple
+
+
+DEFAULT_REFERENCE_PATH = "data/tester.csv"
+DEFAULT_PREDICTIONS_PATH = "predictions.csv"
+
+
+def _safe_float(value, default: float = 0.0) -> float:
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return default
+
+
+def _normalize_binary(value) -> int:
+    value_str = str(value).strip().lower()
+    if value_str in {"1", "true", "yes", "y", "positive", "fail", "failure"}:
+        return 1
+    return 0
+
+
+def _read_csv(path: str) -> List[Dict[str, str]]:
+    with open(path, "r", encoding="utf-8") as f:
+        return list(csv.DictReader(f))
+
+
+def _find_label_column(fieldnames: List[str]) -> str:
+    label_candidates = [col for col in fieldnames if col.startswith("label_")]
+    if len(label_candidates) == 1:
+        return label_candidates[0]
+    if not label_candidates:
+        raise ValueError("No label column found. Expected a column starting with 'label_'.")
+    raise ValueError(
+        f"Multiple label columns found: {label_candidates}. Expected exactly one label column."
+    )
+
+
+def _find_prediction_columns(fieldnames: List[str]) -> Tuple[Optional[str], Optional[str]]:
+    pred_label_candidates = [
+        "prediction",
+        "pred",
+        "predicted_label",
+        "prediction_label",
+        "label_pred",
+        "y_pred",
+        "output",
+    ]
+    pred_score_candidates = [
+        "prediction_score",
+        "pred_score",
+        "score",
+        "probability",
+        "prob",
+        "confidence",
+        "risk_score",
+        "y_score",
+    ]
+
+    pred_label_col = next((c for c in pred_label_candidates if c in fieldnames), None)
+    pred_score_col = next((c for c in pred_score_candidates if c in fieldnames), None)
+    return pred_label_col, pred_score_col
+
+
+def _index_prediction_rows(rows: List[Dict[str, str]], id_column: Optional[str]) -> Dict[str, Dict[str, str]]:
+    if not id_column:
+        return {str(i): row for i, row in enumerate(rows)}
+    return {str(row[id_column]): row for row in rows}
+
+
+def _detect_join_key(reference_fields: List[str], prediction_fields: List[str]) -> Optional[str]:
+    preferred_keys = ["id", "row_id", "sample_id", "case_id", "record_id"]
+    for key in preferred_keys:
+        if key in reference_fields and key in prediction_fields:
+            return key
+    return None
+
+
+def _build_y_true_y_pred(
+    reference_rows: List[Dict[str, str]],
+    prediction_rows: List[Dict[str, str]],
+    label_col: str,
+    pred_label_col: Optional[str],
+    pred_score_col: Optional[str],
+    threshold: float,
+) -> Tuple[List[int], List[int], List[float], Dict[str, int], List[Dict[str, str]]]:
+    if not prediction_rows:
+        raise ValueError("Predictions file is empty.")
+
+    ref_fields = list(reference_rows[0].keys())
+    pred_fields = list(prediction_rows[0].keys())
+    join_key = _detect_join_key(ref_fields, pred_fields)
+    pred_index = _index_prediction_rows(prediction_rows, join_key)
+
+    y_true: List[int] = []
+    y_pred: List[int] = []
+    y_score: List[float] = []
+    matched_reference_rows: List[Dict[str, str]] = []
+
+    matched_rows = 0
+    missing_predictions = 0
+
+    for i, ref_row in enumerate(reference_rows):
+        ref_lookup = str(ref_row[join_key]) if join_key else str(i)
+        pred_row = pred_index.get(ref_lookup)
+
+        if pred_row is None:
+            missing_predictions += 1
+            continue
+
+        true_label = _normalize_binary(ref_row.get(label_col, 0))
+
+        if pred_label_col and pred_label_col in pred_row:
+            pred_label = _normalize_binary(pred_row.get(pred_label_col, 0))
+            pred_score = float(pred_label)
+        elif pred_score_col and pred_score_col in pred_row:
+            pred_score = _safe_float(pred_row.get(pred_score_col, 0.0))
+            pred_label = 1 if pred_score >= threshold else 0
+        else:
+            raise ValueError(
+                "No usable prediction column found. Provide a binary prediction column "
+                "or a score column such as prediction_score."
+            )
+
+        y_true.append(true_label)
+        y_pred.append(pred_label)
+        y_score.append(pred_score)
+        matched_reference_rows.append(ref_row)
+        matched_rows += 1
+
+    support = {
+        "reference_rows": len(reference_rows),
+        "prediction_rows": len(prediction_rows),
+        "matched_rows": matched_rows,
+        "missing_predictions": missing_predictions,
+        "join_key_used": 0 if join_key is None else 1,
+    }
+
+    if matched_rows == 0:
+        raise ValueError("No rows could be matched between reference and prediction files.")
+
+    return y_true, y_pred, y_score, support, matched_reference_rows
+
+
+def _confusion_matrix(y_true: List[int], y_pred: List[int]) -> Dict[str, int]:
+    tp = tn = fp = fn = 0
+    for truth, pred in zip(y_true, y_pred):
+        if truth == 1 and pred == 1:
+            tp += 1
+        elif truth == 0 and pred == 0:
+            tn += 1
+        elif truth == 0 and pred == 1:
+            fp += 1
+        elif truth == 1 and pred == 0:
+            fn += 1
+    return {"tp": tp, "tn": tn, "fp": fp, "fn": fn}
+
+
+def _accuracy(tp: int, tn: int, fp: int, fn: int) -> float:
+    denom = tp + tn + fp + fn
+    return (tp + tn) / denom if denom else 0.0
+
+
+def _precision(tp: int, fp: int) -> float:
+    denom = tp + fp
+    return tp / denom if denom else 0.0
+
+
+def _recall(tp: int, fn: int) -> float:
+    denom = tp + fn
+    return tp / denom if denom else 0.0
+
+
+def _f1(precision: float, recall: float) -> float:
+    denom = precision + recall
+    return 2 * precision * recall / denom if denom else 0.0
+
+
+def _trajectory_diagnostics(
+    reference_rows: List[Dict[str, str]],
+    y_true: List[int],
+    y_pred: List[int],
+) -> Dict[str, float]:
+    if not reference_rows or "drift_gradient" not in reference_rows[0]:
+        return {
+            "trajectory_positive_support": 0,
+            "recall_trajectory_deterioration_detection": 0.0,
+            "false_stable_trajectory_rate": 0.0,
+            "trajectory_label_alignment_rate": 0.0,
+        }
+
+    trajectory_positive_support = 0
+    trajectory_detected_tp = 0
+    trajectory_false_stable = 0
+    trajectory_alignment_hits = 0
+
+    for row, truth, pred in zip(reference_rows, y_true, y_pred):
+        drift_gradient = _safe_float(row.get("drift_gradient", 0.0))
+        worsening_trajectory = 1 if drift_gradient > 0 else 0
+
+        if worsening_trajectory == 1:
+            trajectory_positive_support += 1
+            if pred == 1:
+                trajectory_detected_tp += 1
+            if pred == 0:
+                trajectory_false_stable += 1
+
+        if worsening_trajectory == truth:
+            trajectory_alignment_hits += 1
+
+    recall_trajectory_deterioration_detection = (
+        trajectory_detected_tp / trajectory_positive_support
+        if trajectory_positive_support
+        else 0.0
+    )
+
+    false_stable_trajectory_rate = (
+        trajectory_false_stable / trajectory_positive_support
+        if trajectory_positive_support
+        else 0.0
+    )
+
+    trajectory_label_alignment_rate = (
+        trajectory_alignment_hits / len(reference_rows)
+        if reference_rows
+        else 0.0
+    )
+
+    return {
+        "trajectory_positive_support": trajectory_positive_support,
+        "recall_trajectory_deterioration_detection": recall_trajectory_deterioration_detection,
+        "false_stable_trajectory_rate": false_stable_trajectory_rate,
+        "trajectory_label_alignment_rate": trajectory_label_alignment_rate,
+    }
+
+
+def score(
+    reference_path: str = DEFAULT_REFERENCE_PATH,
+    predictions_path: str = DEFAULT_PREDICTIONS_PATH,
+    threshold: float = 0.5,
+) -> Dict[str, object]:
+    reference_rows = _read_csv(reference_path)
+    prediction_rows = _read_csv(predictions_path)
+
+    if not reference_rows:
+        raise ValueError("Reference file is empty.")
+
+    label_col = _find_label_column(list(reference_rows[0].keys()))
+    pred_label_col, pred_score_col = _find_prediction_columns(list(prediction_rows[0].keys()))
+
+    y_true, y_pred, y_score, support, matched_reference_rows = _build_y_true_y_pred(
+        reference_rows=reference_rows,
+        prediction_rows=prediction_rows,
+        label_col=label_col,
+        pred_label_col=pred_label_col,
+        pred_score_col=pred_score_col,
+        threshold=threshold,
+    )
+
+    cm = _confusion_matrix(y_true, y_pred)
+    precision = _precision(cm["tp"], cm["fp"])
+    recall = _recall(cm["tp"], cm["fn"])
+    accuracy = _accuracy(cm["tp"], cm["tn"], cm["fp"], cm["fn"])
+    f1 = _f1(precision, recall)
+
+    trajectory_metrics = _trajectory_diagnostics(
+        reference_rows=matched_reference_rows,
+        y_true=y_true,
+        y_pred=y_pred,
+    )
+
+    return {
+        "label_column": label_col,
+        "prediction_label_column": pred_label_col,
+        "prediction_score_column": pred_score_col,
+        "primary_metric": "recall_trajectory_deterioration_detection",
+        "secondary_metric": "false_stable_trajectory_rate",
+        "threshold_transparency": {
+            "score_threshold_used": threshold if pred_score_col else None,
+            "threshold_applied_to_score_column": pred_score_col,
+            "predictions_interpreted_as": (
+                "binary labels from prediction column"
+                if pred_label_col
+                else "binary labels thresholded from score column"
+            ),
+        },
+        "support": {
+            **support,
+            "positive_label_support": sum(y_true),
+            "negative_label_support": len(y_true) - sum(y_true),
+            "predicted_positive_support": sum(y_pred),
+            "predicted_negative_support": len(y_pred) - sum(y_pred),
+        },
+        "metrics": {
+            "accuracy": round(accuracy, 4),
+            "precision": round(precision, 4),
+            "recall": round(recall, 4),
+            "f1": round(f1, 4),
+            "recall_trajectory_deterioration_detection": round(
+                trajectory_metrics["recall_trajectory_deterioration_detection"], 4
+            ),
+            "false_stable_trajectory_rate": round(
+                trajectory_metrics["false_stable_trajectory_rate"], 4
+            ),
+            "trajectory_label_alignment_rate": round(
+                trajectory_metrics["trajectory_label_alignment_rate"], 4
+            ),
+        },
+        "confusion_matrix": cm,
+        "trajectory_support": {
+            "trajectory_positive_support": trajectory_metrics["trajectory_positive_support"],
+        },
+    }
+
+
+if __name__ == "__main__":
+    reference_path = sys.argv[1] if len(sys.argv) > 1 else DEFAULT_REFERENCE_PATH
+    predictions_path = sys.argv[2] if len(sys.argv) > 2 else DEFAULT_PREDICTIONS_PATH
+    threshold = float(sys.argv[3]) if len(sys.argv) > 3 else 0.5
+
+    output = score(
+        reference_path=reference_path,
+        predictions_path=predictions_path,
+        threshold=threshold,
+    )
+    print(json.dumps(output, indent=2))