Create scorer.py

scorer.py

@@ -0,0 +1,46 @@
+from dataclasses import dataclass
+from typing import Dict, Any, List
+
+@dataclass
+class ScoreResult:
+    score: float
+    details: Dict[str, Any]
+
+def _clamp01(x: float) -> float:
+    return max(0.0, min(1.0, x))
+
+def score(sample: Dict[str, Any], prediction: Dict[str, Any]) -> ScoreResult:
+    # Ground truth
+    true_tbr = float(sample.get("baseline_tbr", 0))
+    true_coh = float(sample.get("baseline_coherence_score", 0))
+    true_flag = int(sample.get("decoupling_flag", 0))
+
+    # Predictions
+    pred_tbr = float(prediction.get("baseline_tbr", 0))
+    pred_coh = float(prediction.get("baseline_coherence_score", 0))
+    pred_flag = int(prediction.get("decoupling_flag", 0))
+
+    # Accuracy components
+    tbr_err = abs(true_tbr - pred_tbr) / max(true_tbr, 1e-6)
+    coh_err = abs(true_coh - pred_coh)
+
+    tbr_acc = _clamp01(1.0 - tbr_err)
+    coh_acc = _clamp01(1.0 - coh_err)
+    flag_acc = 1.0 if true_flag == pred_flag else 0.0
+
+    total = 0.45 * tbr_acc + 0.35 * coh_acc + 0.20 * flag_acc
+
+    return ScoreResult(
+        score=total,
+        details={
+            "id": sample.get("id"),
+            "tbr_err": tbr_err,
+            "coh_err": coh_err,
+            "flag_acc": flag_acc
+        }
+    )
+
+def aggregate(results: List[ScoreResult]) -> Dict[str, Any]:
+    if not results:
+        return {"mean": 0.0, "n": 0}
+    return {"mean": sum(r.score for r in results) / len(results), "n": len(results)}