Create scorer.py

scorer.py

@@ -0,0 +1,89 @@
+from dataclasses import dataclass
+from typing import Dict, Any, List
+import re
+
+REQ_FIELDS = [
+    "axis_status_map",
+    "cross_axis_decoherence_flag",
+    "decoherence_pattern",
+    "severity_score",
+    "drift_stage",
+    "horizon_turns",
+    "minimal_fix",
+]
+
+DRIFT_STAGES = {"baseline", "early", "mid", "late"}
+FLAGS = {"yes", "no"}
+
+@dataclass
+class ScoreResult:
+    score: float
+    details: Dict[str, Any]
+
+def _has_field(p: str, name: str) -> bool:
+    return (re.search(rf'\b{name}\b\s*[:=]', p) is not None) or (f'"{name}"' in p)
+
+def _parse_enum(p: str, key: str):
+    m = re.search(rf"\b{key}\b\s*[:=]\s*([a-zA-Z_\-]+)", p)
+    if not m:
+        m = re.search(rf'"{key}"\s*:\s*"([^"]+)"', p)
+    return m.group(1).strip().lower() if m else None
+
+def _parse_float(p: str, key: str):
+    m = re.search(rf"\b{key}\b\s*[:=]\s*([0-9]*\.?[0-9]+)", p)
+    if not m:
+        m = re.search(rf'"{key}"\s*:\s*([0-9]*\.?[0-9]+)', p)
+    return float(m.group(1)) if m else None
+
+def _parse_int(p: str, key: str):
+    m = re.search(rf"\b{key}\b\s*[:=]\s*([0-9]{{1,6}})", p)
+    if not m:
+        m = re.search(rf'"{key}"\s*:\s*([0-9]{{1,6}})', p)
+    return int(m.group(1)) if m else None
+
+def score(sample: Dict[str, Any], prediction: str) -> ScoreResult:
+    p = (prediction or "").strip()
+    pl = p.lower()
+
+    field_hits = sum(1 for f in REQ_FIELDS if _has_field(pl, f))
+    field_score = field_hits / len(REQ_FIELDS)
+
+    drift = _parse_enum(pl, "drift_stage")
+    drift_ok = 1 if (drift in DRIFT_STAGES) else 0
+
+    flag = _parse_enum(pl, "cross_axis_decoherence_flag")
+    flag_ok = 1 if (flag in FLAGS) else 0
+
+    sev = _parse_float(pl, "severity_score")
+    sev_ok = 1 if (sev is not None and 0.0 <= sev <= 1.0) else 0
+
+    hz = _parse_int(pl, "horizon_turns")
+    hz_ok = 1 if (hz is not None and 0 <= hz <= 100000) else 0
+
+    concise_ok = 1 if len(pl.split()) <= 160 else 0
+
+    raw = (
+        0.50 * field_score +
+        0.12 * drift_ok +
+        0.10 * flag_ok +
+        0.10 * sev_ok +
+        0.10 * hz_ok +
+        0.08 * concise_ok
+    )
+
+    return ScoreResult(
+        score=min(1.0, raw),
+        details={
+            "id": sample.get("id"),
+            "field_hits": field_hits,
+            "drift_stage": drift,
+            "flag": flag,
+            "severity": sev,
+            "horizon": hz,
+        }
+    )
+
+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)}