| import csv |
| import json |
| import re |
| from typing import Dict, Tuple |
|
|
| 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 load_refs(test_csv_path: str) -> Dict[str, Tuple[int, 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"]] = ( |
| int(row["gold_debt_level"]), |
| row["gold_debt_item"].strip(), |
| row["gold_paydown_step"].strip(), |
| ) |
| return refs |
|
|
| 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 _level_score(pred_level: int, gold_level: int) -> float: |
| |
| d = abs(pred_level - gold_level) |
| if d == 0: |
| return 1.0 |
| if d == 1: |
| return 0.6 |
| if d == 2: |
| return 0.2 |
| return 0.0 |
|
|
| def score_predictions(predictions_path: str, test_csv_path: str) -> Dict[str, float]: |
| refs = load_refs(test_csv_path) |
|
|
| n = 0 |
| level_sum = 0.0 |
| item_sim_sum = 0.0 |
| paydown_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_level_raw = parsed.get("inference_debt_level", None) |
| pred_item = (parsed.get("debt_item") or "").strip() |
| pred_paydown = (parsed.get("paydown_step") or "").strip() |
|
|
| gold_level, gold_item, gold_paydown = refs[ex_id] |
|
|
| try: |
| pred_level = int(pred_level_raw) |
| except Exception: |
| pred_level = -999 |
|
|
| if pred_level < 0 or pred_level > 3: |
| pred_level = -999 |
|
|
| level_sum += _level_score(pred_level if pred_level != -999 else 999, gold_level) |
| item_sim_sum += _jaccard(pred_item, gold_item) |
| paydown_sim_sum += _jaccard(pred_paydown, gold_paydown) |
|
|
| has_keys = pred_level_raw is not None and pred_item != "" and pred_paydown != "" |
| format_hits += 1 if has_keys else 0 |
|
|
| if n == 0: |
| return { |
| "final_score": 0.0, |
| "debt_level_score": 0.0, |
| "debt_item_similarity": 0.0, |
| "paydown_step_similarity": 0.0, |
| "format_pass_rate": 0.0, |
| "n_scored": 0.0, |
| } |
|
|
| level_score = level_sum / n |
| item_sim = item_sim_sum / n |
| paydown_sim = paydown_sim_sum / n |
| fmt = format_hits / n |
|
|
| final = 0.4 * level_score + 0.2 * item_sim + 0.3 * paydown_sim + 0.1 * fmt |
|
|
| return { |
| "final_score": float(final), |
| "debt_level_score": float(level_score), |
| "debt_item_similarity": float(item_sim), |
| "paydown_step_similarity": float(paydown_sim), |
| "format_pass_rate": float(fmt), |
| "n_scored": float(n), |
| } |
|
|
| if __name__ == "__main__": |
| import argparse |
| p = argparse.ArgumentParser() |
| p.add_argument("--predictions", required=True, help="Path to predictions.jsonl") |
| p.add_argument("--test_csv", required=True, help="Path to data/test.csv") |
| args = p.parse_args() |
| print(json.dumps(score_predictions(args.predictions, args.test_csv), indent=2)) |
|
|
