Download score.py from CobuildX-AI/CallOpeningDetX: direct link, hf CLI and curl.
- Browser
- Download file 9.76 kB
-
https://huggingface.co/datasets/CobuildX-AI/CallOpeningDetX/resolve/main/score.py
- Command line
-
hf download hf://datasets/CobuildX-AI/CallOpeningDetX/score.py
-
curl -L -o score.py https://huggingface.co/datasets/CobuildX-AI/CallOpeningDetX/resolve/main/score.py
9.76 kB
| # CallOpeningDetX v0.1. Licence: CDLA-Permissive-2.0 (see LICENSE). | |
| """Score predictions on CallOpeningDetX (Python standard library only). | |
| python score.py --gold data/test.jsonl --pred my_preds.jsonl [--out scores.json] [--bootstrap 1000] | |
| Prediction file: one JSON object per line, one per gold record: | |
| {"id": "...", "agent_identification": "present", "institution_identification": "present", | |
| "recording_notice": "possible_recording", "opening_coverage": "complete", | |
| "recording_purpose": ["quality", "training"], | |
| "spans": [{"start": 110, "end": 133, "type": "INST"}, ...]} # optional; offsets in render(record) | |
| Metrics, per subset and over the whole file: | |
| - all_fields_exact: share of calls with all four fields and the purpose set right (headline); | |
| - per field: accuracy and macro F1 (over the values present in gold or prediction); | |
| - purpose micro / macro F1, on calls where gold or prediction has a notice; | |
| - purpose and span metrics are null when there is nothing to measure (no notice anywhere; no span rows); | |
| - evidence spans, typed: F1 overlap (a span counts if it touches a gold span of the same type) and exact (same | |
| start and end); rows without span supervision are left out; | |
| - policy A / B agreement: the pass / fail / review decision from the prediction equals the one from gold | |
| (A accepts definite or possible recording, B only definite); | |
| - all_fields_exact per construction tag, and a 95% bootstrap interval for all_fields_exact (calls resampled). | |
| A missing prediction counts as wrong for every field ("<missing>"). | |
| """ | |
| import argparse | |
| import collections | |
| import json | |
| import random | |
| import sys | |
| from pathlib import Path | |
| sys.path.insert(0, str(Path(__file__).resolve().parent)) | |
| from render import gold_spans # noqa: E402 | |
| FIELDS = { | |
| "agent_identification": ["present", "absent", "unclear"], | |
| "institution_identification": ["present", "absent", "unclear"], | |
| "recording_notice": ["definite_recording", "possible_recording", "monitoring_only", "none", "unclear"], | |
| "opening_coverage": ["complete", "incomplete", "unknown"], | |
| } | |
| PURPOSES = ["quality", "training", "security", "other", "not_stated", "unclear"] | |
| NOTICE = {"definite_recording", "possible_recording", "monitoring_only"} | |
| SPAN_TYPES = ["AGENT", "INST", "NOTICE", "PURPOSE", "NEGATED", "DISTRACTOR"] | |
| MISSING = "<missing>" | |
| def policy(lab, accept): | |
| if lab["opening_coverage"] != "complete": | |
| return "review" | |
| vals = [lab["agent_identification"], lab["institution_identification"], lab["recording_notice"]] | |
| if "unclear" in vals: | |
| return "review" | |
| if "absent" in vals[:2] or lab["recording_notice"] in ("none", "monitoring_only"): | |
| return "fail" | |
| return "pass" if lab["recording_notice"] in accept else "review" | |
| def f1(tp, n_pred, n_gold): | |
| p = tp / n_pred if n_pred else 0.0 | |
| r = tp / n_gold if n_gold else 0.0 | |
| return 2 * p * r / (p + r) if p + r else 0.0 | |
| def macro_f1(gold, pred): | |
| out = [] | |
| for c in sorted(set(gold) | set(pred)): | |
| tp = sum(g == c and p == c for g, p in zip(gold, pred)) | |
| out.append(f1(tp, sum(p == c for p in pred), sum(g == c for g in gold))) | |
| return sum(out) / len(out) if out else 0.0 | |
| def exact(r, x): | |
| return all(r["labels"][f] == x.get(f) for f in FIELDS) and \ | |
| sorted(r["labels"]["recording_purpose"]) == sorted(x.get("recording_purpose") or []) | |
| def score(rows, preds): | |
| """rows: gold records; preds: prediction dicts in the same order.""" | |
| m = {"n": len(rows)} | |
| f1s = [] | |
| for f in FIELDS: | |
| g = [r["labels"][f] for r in rows] | |
| p = [x.get(f, MISSING) for x in preds] | |
| m[f"{f}_acc"] = sum(a == b for a, b in zip(g, p)) / len(g) | |
| m[f"{f}_macro_f1"] = macro_f1(g, p) | |
| f1s.append(m[f"{f}_macro_f1"]) | |
| m["field_macro_f1_mean"] = sum(f1s) / len(f1s) | |
| m["all_fields_exact"] = sum(exact(r, x) for r, x in zip(rows, preds)) / len(rows) | |
| tp, npred, ngold = collections.Counter(), collections.Counter(), collections.Counter() | |
| for r, x in zip(rows, preds): | |
| if r["labels"]["recording_notice"] in NOTICE or x.get("recording_notice") in NOTICE: | |
| g, p = set(r["labels"]["recording_purpose"]), set(x.get("recording_purpose") or []) | |
| for v in PURPOSES: | |
| tp[v] += v in g and v in p | |
| npred[v] += v in p | |
| ngold[v] += v in g | |
| m["purpose_micro_f1"] = f1(sum(tp.values()), sum(npred.values()), sum(ngold.values())) | |
| used = [v for v in PURPOSES if ngold[v] or npred[v]] | |
| m["purpose_macro_f1"] = sum(f1(tp[v], npred[v], ngold[v]) for v in used) / len(used) if used else 0.0 | |
| m["purpose_rows"] = sum(1 for r, x in zip(rows, preds) | |
| if r["labels"]["recording_notice"] in NOTICE or x.get("recording_notice") in NOTICE) | |
| if not m["purpose_rows"]: # no notice in gold or prediction: not measurable | |
| m["purpose_micro_f1"] = m["purpose_macro_f1"] = None | |
| ex = ov_p = ov_g = ng = npr = 0 | |
| by = collections.defaultdict(lambda: [0, 0, 0, 0]) | |
| span_rows = 0 | |
| for r, x in zip(rows, preds): | |
| if r.get("span_supervision") is False: | |
| continue | |
| span_rows += 1 | |
| gold = set(gold_spans(r)) | |
| pred = {(s["start"], s["end"], s["type"]) for s in x.get("spans") or []} | |
| ng += len(gold) | |
| npr += len(pred) | |
| ex += len(gold & pred) | |
| ov_p += sum(any(t == t2 and s < e2 and e > s2 for s2, e2, t2 in gold) for s, e, t in pred) | |
| ov_g += sum(any(t == t2 and s < e2 and e > s2 for s2, e2, t2 in pred) for s, e, t in gold) | |
| for t in {t for *_, t in gold | pred}: | |
| gt = [g for g in gold if g[2] == t] | |
| pt = [p for p in pred if p[2] == t] | |
| by[t][0] += sum(any(s < e2 and e > s2 for s2, e2, _ in gt) for s, e, _ in pt) | |
| by[t][1] += len(pt) | |
| by[t][2] += len(gt) | |
| by[t][3] += sum(any(s < e2 and e > s2 for s2, e2, _ in pt) for s, e, _ in gt) | |
| m["span_rows"] = span_rows | |
| m["span_f1_exact"] = f1(ex, npr, ng) | |
| pp, rr = (ov_p / npr if npr else 0.0), (ov_g / ng if ng else 0.0) | |
| m["span_f1_overlap"] = 2 * pp * rr / (pp + rr) if pp + rr else 0.0 | |
| m["span_f1_overlap_by_type"] = {} | |
| for t, (a, b, c, d) in sorted(by.items()): | |
| pp, rr = (a / b if b else 0.0), (d / c if c else 0.0) | |
| m["span_f1_overlap_by_type"][t] = 2 * pp * rr / (pp + rr) if pp + rr else 0.0 | |
| if not span_rows: | |
| m["span_f1_exact"] = m["span_f1_overlap"] = None | |
| for name, accept in (("A", {"definite_recording", "possible_recording"}), ("B", {"definite_recording"})): | |
| m[f"policy_{name}_agree"] = sum( | |
| policy(r["labels"], accept) == policy({f: x.get(f, MISSING) for f in FIELDS}, accept) | |
| for r, x in zip(rows, preds)) / len(rows) | |
| return m | |
| def bootstrap(rows, preds, n, random_state=13): | |
| if n <= 0: | |
| return None | |
| rng = random.Random(random_state) | |
| hits = [exact(r, x) for r, x in zip(rows, preds)] | |
| vals = sorted(sum(hits[rng.randrange(len(hits))] for _ in hits) / len(hits) for _ in range(n)) | |
| return [vals[int(0.025 * n)], vals[int(0.975 * n) - 1]] | |
| def rounded(v): | |
| if isinstance(v, float): | |
| return round(v, 4) | |
| if isinstance(v, dict): | |
| return {k: rounded(x) for k, x in v.items()} | |
| if isinstance(v, list): | |
| return [rounded(x) for x in v] | |
| return v | |
| def evaluate(rows, pred_by_id, n_boot=1000): | |
| preds = [pred_by_id.get(r["id"], {}) for r in rows] | |
| res = {"missing_predictions": sum(r["id"] not in pred_by_id for r in rows)} | |
| groups = {"all": list(range(len(rows)))} | |
| for i, r in enumerate(rows): | |
| groups.setdefault(r["subset"], []).append(i) | |
| for g, idx in groups.items(): | |
| rs, ps = [rows[i] for i in idx], [preds[i] for i in idx] | |
| res[g] = score(rs, ps) | |
| res[g]["all_fields_exact_ci95"] = bootstrap(rs, ps, n_boot) | |
| tags = collections.defaultdict(list) | |
| for i in idx: | |
| for t in rows[i]["construction"]: | |
| tags[t].append(i) | |
| res[g]["all_fields_exact_by_construction"] = { | |
| t: {"n": len(ii), "all_fields_exact": sum(exact(rows[i], preds[i]) for i in ii) / len(ii)} | |
| for t, ii in sorted(tags.items())} | |
| return rounded(res) | |
| def main(): | |
| ap = argparse.ArgumentParser(description=__doc__.split("\n")[0]) | |
| ap.add_argument("--gold", required=True) | |
| ap.add_argument("--pred", required=True) | |
| ap.add_argument("--out") | |
| ap.add_argument("--bootstrap", type=int, default=1000) | |
| a = ap.parse_args() | |
| rows = [json.loads(x) for x in open(a.gold, encoding="utf-8")] | |
| pred = {} | |
| for x in open(a.pred, encoding="utf-8"): | |
| x = json.loads(x) | |
| pred[x["id"]] = x | |
| res = evaluate(rows, pred, a.bootstrap) | |
| if a.out: | |
| Path(a.out).write_text(json.dumps(res, indent=1) + "\n") | |
| print(f"missing predictions: {res['missing_predictions']}") | |
| def v(x): | |
| return " n/a" if x is None else f"{x:6.3f}" | |
| print(f"{'subset':12s} {'n':>5s} {'exact':>6s} {'agent':>6s} {'inst':>6s} {'notice':>6s} {'cover':>6s} " | |
| f"{'purpF1':>6s} {'spanOv':>6s} {'spanEx':>6s} {'polA':>6s} {'polB':>6s}") | |
| for g, m in res.items(): | |
| if g == "missing_predictions": | |
| continue | |
| print(f"{g:12s} {m['n']:5d} {m['all_fields_exact']:6.3f} {m['agent_identification_acc']:6.3f} " | |
| f"{m['institution_identification_acc']:6.3f} {m['recording_notice_acc']:6.3f} " | |
| f"{m['opening_coverage_acc']:6.3f} {v(m['purpose_micro_f1'])} {v(m['span_f1_overlap'])} " | |
| f"{v(m['span_f1_exact'])} {m['policy_A_agree']:6.3f} {m['policy_B_agree']:6.3f}") | |
| if __name__ == "__main__": | |
| main() | |