Create scorer.py

scorer.py

@@ -0,0 +1,74 @@
+from dataclasses import dataclass
+from typing import Dict, Any, List
+import re
+
+@dataclass
+class ScoreResult:
+    score: float
+    details: Dict[str, Any]
+
+def _extract_horizon(text: str) -> int:
+    m = re.search(r"(horizon|cycles)\s*[:=]?\s*(\d+)", (text or "").lower())
+    if m:
+        return int(m.group(2))
+    return -1
+
+def _extract_risk(text: str) -> float:
+    m = re.search(r"(risk|cd).*?([0]\.\d+|1\.0)", (text or "").lower())
+    if m:
+        try:
+            return float(m.group(2))
+        except:
+            return -1.0
+    return -1.0
+
+def _extract_action(text: str) -> str:
+    t = (text or "").lower()
+    for k in [
+        "none","retune_timing","pulse_shape_adjust","pre_pulse_boost",
+        "stability_tune","source_recalibration","power_derate",
+        "full_timing_reset","shutdown_prepare","halt_source"
+    ]:
+        if k in t:
+            return k
+    return ""
+
+def score(sample: Dict[str, Any], prediction: str) -> ScoreResult:
+    p = prediction or ""
+    horizon = _extract_horizon(p)
+    risk = _extract_risk(p)
+    action = _extract_action(p)
+
+    true_h_raw = sample.get("event_horizon_cycles", "")
+    true_r_raw = sample.get("cd_uniformity_risk_score", "")
+    true_a_raw = (sample.get("intervention_action", "") or "").lower()
+
+    # If no ground truth in test row → structure check only
+    if true_h_raw in ("", None) and true_r_raw in ("", None) and true_a_raw == "":
+        s = 0.0
+        s += 0.4 * int(horizon > 0)
+        s += 0.3 * int(0.0 <= risk <= 1.0)
+        s += 0.3 * int(action != "")
+        return ScoreResult(score=s, details={"mode": "format_only", "horizon": horizon, "risk": risk, "action": action})
+
+    try:
+        true_h = int(true_h_raw)
+    except:
+        true_h = -1
+
+    try:
+        true_r = float(true_r_raw)
+    except:
+        true_r = -1.0
+
+    h_score = 1.0 if horizon > 0 and true_h > 0 else 0.0
+    r_score = 1.0 - abs(risk - true_r) if true_r >= 0 and 0 <= risk <= 1 else 0.0
+    a_score = 1.0 if action == true_a_raw else 0.0
+
+    final = 0.4 * h_score + 0.4 * max(0.0, r_score) + 0.2 * a_score
+    return ScoreResult(score=max(0.0, min(1.0, final)), details={"h": horizon, "r": risk, "a": action})
+
+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)}