# 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 (""). """ 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 = "" 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()