score.py

"""Reference scorer for the Doc-Split Benchmark — self-contained (only needs `datasets`).

Boundary page-F1 (internal positions, page 0 forced) + Cohen's kappa + WindowDiff + Pk.

Usage:
  python score.py --pred preds.json [--config our200]
  preds.json = {stream_id: [0/1, ...]}  (one label per page, in position order; index 0 may be omitted/ignored)
"""
import argparse, json
from collections import defaultdict


def _counts(gold, pred):
    tp = fp = fn = tn = 0
    for g, p in zip(gold[1:], pred[1:]):            # skip page 0 (forced boundary for both)
        if g and p: tp += 1
        elif p and not g: fp += 1
        elif g and not p: fn += 1
        else: tn += 1
    return tp, fp, fn, tn


def _seg(b):
    out, c = [], 0
    for x in b:
        c += 1 if x else 0; out.append(c)
    return out


def _k(ref):
    n = len(ref); ns = max(1, sum(ref)); return max(1, round((n / ns) / 2))


def windowdiff(g, p):
    gg, pp = g[1:], p[1:]; m = len(gg)
    if m == 0: return 0.0
    k = min(_k(g), m); n = m - k + 1
    if n <= 0: return float(sum(gg) != sum(pp))
    return sum(1 for i in range(n) if sum(gg[i:i+k]) != sum(pp[i:i+k])) / n


def pk(g, p):
    n = len(g)
    if n < 2: return 0.0
    k = min(_k(g), n - 1); sg, sp = _seg(g), _seg(p); t = n - k
    if t <= 0: return 0.0
    return sum(1 for i in range(t) if (sg[i] == sg[i+k]) != (sp[i] == sp[i+k])) / t


def aggregate(streams):
    TP = FP = FN = TN = 0; em = wd = pkv = 0.0; n = len(streams)
    for s in streams:
        g, p = s["gold"], s["pred"]
        tp, fp, fn, tn = _counts(g, p); TP += tp; FP += fp; FN += fn; TN += tn
        em += 1.0 if list(g[1:]) == list(p[1:]) else 0.0
        wd += windowdiff(g, p); pkv += pk(g, p)
    prec = TP / (TP + FP) if TP + FP else 1.0
    rec = TP / (TP + FN) if TP + FN else 1.0
    f1 = 2 * prec * rec / (prec + rec) if prec + rec else 0.0
    tot = TP + FP + FN + TN
    po = (TP + TN) / tot if tot else 0.0
    pe = ((TP + FP) / tot) * ((TP + FN) / tot) + ((FN + TN) / tot) * ((FP + TN) / tot) if tot else 0.0
    kappa = (po - pe) / (1 - pe) if (1 - pe) > 1e-12 else 0.0
    return {"f1": round(f1, 4), "precision": round(prec, 4), "recall": round(rec, 4),
            "kappa": round(kappa, 4), "windowdiff": round(wd / n, 4), "pk": round(pkv / n, 4),
            "exact_match": round(em / n, 4), "n_streams": n}


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--pred", required=True); ap.add_argument("--config", default="our200")
    a = ap.parse_args()
    from datasets import load_dataset
    ds = load_dataset("nutrientdocs/doc-split-benchmark", a.config, split="test")
    gold = defaultdict(list)
    for r in ds:
        gold[r["stream_id"]].append((r["position"], int(r["boundary"])))
    preds = json.load(open(a.pred))
    streams = []
    for sid, pg in gold.items():
        g = [b for _, b in sorted(pg)]
        p = preds.get(sid)
        if p is None:
            p = [1] + [0] * (len(g) - 1)            # missing prediction -> forced page-0 only
        streams.append({"gold": g, "pred": list(p)[:len(g)]})
    print(json.dumps(aggregate(streams), indent=2))


if __name__ == "__main__":
    main()