Create scorer.py

scorer.py

@@ -0,0 +1,131 @@
+import csv
+import json
+import re
+from typing import Dict, Tuple
+
+ALLOWED_ERROR_TYPES = {
+    "no_error",
+    "low_confidence_region_overtrust",
+    "interdomain_orientation_overclaim",
+    "disorder_as_structure",
+    "loop_position_overtrust",
+    "complex_negation_from_monomer",
+    "interface_overconfidence",
+    "cofactor_absence_misread",
+    "low_complexity_as_domain",
+}
+
+def _norm(s: str) -> str:
+    return re.sub(r"\s+", " ", (s or "").strip().lower())
+
+def _token_set(s: str) -> set:
+    s = _norm(s)
+    s = re.sub(r"[^a-z0-9\s]", " ", s)
+    return {t for t in s.split(" ") if t}
+
+def _jaccard(a: str, b: str) -> float:
+    ta = _token_set(a)
+    tb = _token_set(b)
+    if not ta and not tb:
+        return 1.0
+    if not ta or not tb:
+        return 0.0
+    return len(ta & tb) / len(ta | tb)
+
+def _extract_json(text: str) -> Dict:
+    if text is None:
+        return {}
+    text = text.strip()
+    try:
+        return json.loads(text)
+    except Exception:
+        pass
+    m = re.search(r"\{.*\}", text, flags=re.DOTALL)
+    if not m:
+        return {}
+    try:
+        return json.loads(m.group(0))
+    except Exception:
+        return {}
+
+def load_refs(test_csv_path: str) -> Dict[str, Tuple[str, str, str]]:
+    refs = {}
+    with open(test_csv_path, newline="", encoding="utf-8") as f:
+        r = csv.DictReader(f)
+        for row in r:
+            refs[row["id"]] = (
+                _norm(row["gold_misinterpretation"]),
+                row["gold_error_type"].strip(),
+                row["gold_correction"].strip(),
+            )
+    return refs
+
+def score_predictions(predictions_path: str, test_csv_path: str) -> Dict[str, float]:
+    refs = load_refs(test_csv_path)
+
+    n = 0
+    mis_hits = 0
+    type_hits = 0
+    corr_sim_sum = 0.0
+    format_hits = 0
+
+    with open(predictions_path, encoding="utf-8") as f:
+        preds = [json.loads(line) for line in f if line.strip()]
+
+    for item in preds:
+        ex_id = item.get("id", "")
+        raw = item.get("prediction", "")
+        if ex_id not in refs:
+            continue
+
+        n += 1
+        parsed = _extract_json(raw)
+
+        pred_mis = _norm(parsed.get("misinterpretation", ""))
+        pred_type = (parsed.get("error_type") or "").strip()
+        pred_corr = (parsed.get("correction") or "").strip()
+
+        gold_mis, gold_type, gold_corr = refs[ex_id]
+
+        mis_hits += 1 if pred_mis == gold_mis else 0
+        type_hits += 1 if pred_type == gold_type else 0
+        corr_sim_sum += _jaccard(pred_corr, gold_corr)
+
+        has_keys = pred_mis in {"yes", "no"} and pred_type != "" and pred_corr != ""
+        type_allowed = pred_type in ALLOWED_ERROR_TYPES
+        consistency = (pred_mis == "no" and pred_type == "no_error") or (pred_mis == "yes" and pred_type != "no_error")
+        format_hits += 1 if (has_keys and type_allowed and consistency) else 0
+
+    if n == 0:
+        return {
+            "final_score": 0.0,
+            "misinterpretation_accuracy": 0.0,
+            "error_type_accuracy": 0.0,
+            "correction_similarity": 0.0,
+            "format_pass_rate": 0.0,
+            "n_scored": 0.0,
+        }
+
+    mis_acc = mis_hits / n
+    type_acc = type_hits / n
+    corr_sim = corr_sim_sum / n
+    fmt = format_hits / n
+
+    final = 0.4 * mis_acc + 0.3 * type_acc + 0.2 * corr_sim + 0.1 * fmt
+
+    return {
+        "final_score": float(final),
+        "misinterpretation_accuracy": float(mis_acc),
+        "error_type_accuracy": float(type_acc),
+        "correction_similarity": float(corr_sim),
+        "format_pass_rate": float(fmt),
+        "n_scored": float(n),
+    }
+
+if __name__ == "__main__":
+    import argparse
+    p = argparse.ArgumentParser()
+    p.add_argument("--predictions", required=True)
+    p.add_argument("--test_csv", required=True)
+    args = p.parse_args()
+    print(json.dumps(score_predictions(args.predictions, args.test_csv), indent=2))