Update scorer.py

scorer.py

@@ -2,7 +2,7 @@ import csv
 import json
 import re
 from dataclasses import dataclass
-from typing import Dict, List, Tuple, Optional
+from typing import Dict, List, Tuple, Optional, Any
 
 
 @dataclass
@@ -14,60 +14,192 @@ class ScoredItem:
     parsed_ok: int
 
 
+# Find A or B as a standalone token
 CHOICE_RE = re.compile(r"\b([AB])\b", re.IGNORECASE)
 
-def parse_choice(model_output: str) -> Tuple[Optional[str], int]:
+# Non-greedy JSON object extractor
+JSON_OBJ_RE = re.compile(r"\{.*?\}", re.DOTALL)
+
+
+def _extract_json_obj(text: str) -> Optional[Dict[str, Any]]:
+    """
+    Finds the first JSON object substring and tries to parse it.
+    Returns a dict if successful, else None.
+    """
+    m = JSON_OBJ_RE.search(text)
+    if not m:
+        return None
+    candidate = m.group(0).strip()
+    try:
+        obj = json.loads(candidate)
+        return obj if isinstance(obj, dict) else None
+    except Exception:
+        return None
+
+
+def parse_choice(model_output: Optional[str]) -> Tuple[Optional[str], int]:
+    """
+    Returns (choice, parsed_ok) where choice is "A" or "B".
+
+    Accepts:
+    - "A"
+    - "Answer: B"
+    - "I choose A because ..."
+    - JSON anywhere: {"choice":"A"} {"answer":"B"} {"selected":"A"} {"option":"B"}
+    """
     if model_output is None:
         return None, 0
 
-    text = model_output.strip()
-
-    if text.startswith("{") and text.endswith("}"):
-        try:
-            obj = json.loads(text)
-            for k in ["choice", "answer", "selected", "option"]:
-                if k in obj and isinstance(obj[k], str):
-                    c = obj[k].strip().upper()
-                    if c in ["A", "B"]:
-                        return c, 1
-        except Exception:
-            pass
+    text = str(model_output).strip()
+    if not text:
+        return None, 0
 
+    # 1) JSON object anywhere
+    obj = _extract_json_obj(text)
+    if obj is not None:
+        for k in ("choice", "answer", "selected", "option"):
+            v = obj.get(k)
+            if isinstance(v, str):
+                c = v.strip().upper()
+                if c in ("A", "B"):
+                    return c, 1
+
+    # 2) A/B token anywhere
     m = CHOICE_RE.search(text)
     if m:
         return m.group(1).upper(), 1
 
-    if text and text[0].upper() in ["A", "B"]:
-        return text[0].upper(), 1
+    # 3) Fallback first char
+    c0 = text[0].upper()
+    if c0 in ("A", "B"):
+        return c0, 1
 
     return None, 0
 
 
-def score_row(row: Dict[str, str], model_output: str) -> ScoredItem:
-    gold = row["correct_option"].strip().upper()
+def validate_row(row: Dict[str, str]) -> Tuple[str, str]:
+    """
+    Requires columns:
+    - sample_id
+    - correct_option  (A or B)
+    """
+    if "sample_id" not in row:
+        raise KeyError("CSV missing required column: sample_id")
+    if "correct_option" not in row:
+        raise KeyError("CSV missing required column: correct_option")
+
+    sample_id = (row.get("sample_id") or "").strip()
+    if not sample_id:
+        raise ValueError("Empty sample_id encountered")
+
+    gold = (row.get("correct_option") or "").strip().upper()
+    if gold not in ("A", "B"):
+        raise ValueError(f"Invalid correct_option for {sample_id}: {gold!r} (must be 'A' or 'B')")
+
+    return sample_id, gold
+
+
+def score_row(row: Dict[str, str], model_output: Optional[str]) -> ScoredItem:
+    sample_id, gold = validate_row(row)
     choice, ok = parse_choice(model_output)
-    pred = choice if choice else ""
+    pred = choice or ""
     is_correct = 1 if choice == gold else 0
-    return ScoredItem(row["sample_id"], gold, pred, is_correct, ok)
+    return ScoredItem(sample_id, gold, pred, is_correct, ok)
 
 
 def score_file(gold_csv_path: str, predictions: Dict[str, str]) -> Dict[str, float]:
+    """
+    predictions: {sample_id: model_output_string}
+
+    Returns:
+    - accuracy
+    - parse_rate
+    - n
+    - missing_predictions
+    """
     scored: List[ScoredItem] = []
+    missing_predictions = 0
+
     with open(gold_csv_path, "r", newline="", encoding="utf-8") as f:
-        for row in csv.DictReader(f):
-            scored.append(score_row(row, predictions.get(row["sample_id"], "")))
+        reader = csv.DictReader(f)
+        if not reader.fieldnames:
+            return {"accuracy": 0.0, "parse_rate": 0.0, "n": 0, "missing_predictions": 0}
+
+        for row in reader:
+            sid, _ = validate_row(row)
+            if sid not in predictions:
+                missing_predictions += 1
+            scored.append(score_row(row, predictions.get(sid, "")))
 
     n = len(scored)
     if n == 0:
-        return {"accuracy": 0.0, "parse_rate": 0.0, "n": 0}
+        return {"accuracy": 0.0, "parse_rate": 0.0, "n": 0, "missing_predictions": 0}
 
     return {
         "accuracy": sum(s.is_correct for s in scored) / n,
         "parse_rate": sum(s.parsed_ok for s in scored) / n,
         "n": n,
+        "missing_predictions": missing_predictions,
     }
 
 
+def load_predictions_csv(pred_csv_path: str) -> Dict[str, str]:
+    """
+    Optional helper.
+    Predictions CSV must have columns:
+    - sample_id
+    - output
+    """
+    preds: Dict[str, str] = {}
+    with open(pred_csv_path, "r", newline="", encoding="utf-8") as f:
+        reader = csv.DictReader(f)
+        if not reader.fieldnames:
+            return preds
+        if "sample_id" not in reader.fieldnames or "output" not in reader.fieldnames:
+            raise KeyError("Predictions CSV must include columns: sample_id, output")
+
+        for row in reader:
+            sid = (row.get("sample_id") or "").strip()
+            out = row.get("output") or ""
+            if sid:
+                preds[sid] = out
+
+    return preds
+
+
+def write_detailed_results(gold_csv_path: str, predictions: Dict[str, str], out_csv_path: str) -> None:
+    """
+    Optional helper for auditing.
+    Writes per-item rows:
+    sample_id,gold,pred,is_correct,parsed_ok
+    """
+    with open(gold_csv_path, "r", newline="", encoding="utf-8") as f_in:
+        reader = csv.DictReader(f_in)
+        fieldnames = ["sample_id", "gold", "pred", "is_correct", "parsed_ok"]
+
+        with open(out_csv_path, "w", newline="", encoding="utf-8") as f_out:
+            writer = csv.DictWriter(f_out, fieldnames=fieldnames)
+            writer.writeheader()
+
+            for row in reader:
+                sid, _ = validate_row(row)
+                item = score_row(row, predictions.get(sid, ""))
+                writer.writerow(
+                    {
+                        "sample_id": item.sample_id,
+                        "gold": item.gold,
+                        "pred": item.pred,
+                        "is_correct": item.is_correct,
+                        "parsed_ok": item.parsed_ok,
+                    }
+                )
+
+
 if __name__ == "__main__":
-    preds = {"CVSC-0001": "A", "CVSC-0002": "Answer: A"}
+    # Minimal smoke test. Replace IDs with ones from your dataset.
+    preds = {
+        "CDGC-0001": "A",
+        "CDGC-0002": "Answer: A",
+        "CDGC-0003": '{"choice":"B"}',
+    }
     print(score_file("data/train.csv", preds))