Create scorer.py

scorer.py

@@ -0,0 +1,69 @@
+import re
+from dataclasses import dataclass
+from typing import Dict, Any, List
+
+@dataclass
+class ScoreResult:
+    score: float
+    details: Dict[str, Any]
+
+def _has(text: str, pats: List[str]) -> bool:
+    t = (text or "").lower()
+    return any(re.search(p, t) for p in pats)
+
+def score(sample: Dict[str, Any], prediction: str) -> ScoreResult:
+    pred = (prediction or "").strip()
+    words = len([w for w in re.split(r"\s+", pred) if w])
+
+    max_words = 180
+    m = re.search(r"under\s+(\d+)\s+words", (sample.get("constraints") or "").lower())
+    if m:
+        max_words = int(m.group(1))
+    length_ok = 1 if words <= max_words else 0
+
+    # Requires explicit correspondence classification + mapping
+    classify = 1 if _has(pred, [r"\bunsupported\b", r"\bpartial\b", r"\bsupported\b"]) else 0
+
+    mapping_terms = [
+        r"\binclusion\b", r"\bexcluded\b", r"\bonly\b", r"\bnot studied\b",
+        r"\bage\b", r"\bseverity\b", r"\bsetting\b", r"\bsubgroup\b",
+        r"\bbiomarker\b", r"\bnyha\b", r"\blvef\b", r"\bsecond[- ]line\b",
+        r"\bnon[- ]inferior\b"
+    ]
+    mapping = 1 if _has(pred, mapping_terms) else 0
+
+    # Penalize approval-like language without caveats
+    overclaim_bad = [r"\bshould be indicated\b", r"\bapprove\b", r"\beffective in all\b"]
+    overclaim = 1 if _has(pred, overclaim_bad) else 0
+
+    # Suggested correction
+    action = 1 if _has(pred, [r"\bshould state\b", r"\brevise\b", r"\brestrict\b", r"\bwording\b"]) else 0
+
+    raw = (
+        0.30 * length_ok +
+        0.30 * classify +
+        0.25 * mapping +
+        0.10 * action +
+        0.05 * (0 if overclaim else 1)
+    )
+    final = max(0.0, min(1.0, raw))
+
+    return ScoreResult(
+        score=final,
+        details={
+            "word_count": words,
+            "max_words": max_words,
+            "length_ok": length_ok,
+            "classification": classify,
+            "mapping": mapping,
+            "action": action,
+            "overclaim_penalty": overclaim,
+            "correspondence_pressure": sample.get("correspondence_pressure"),
+            "domain": sample.get("domain"),
+        },
+    )
+
+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)}