CallOpeningDetX / score.py
SRK-CobuildX's picture
CallOpeningDetX v0.1
0dff23d verified
Raw History Blame Contribute Delete
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()