File size: 3,882 Bytes
ccc941d |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 |
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))
|