Datasets:
File size: 3,174 Bytes
eb65bfd | 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 | """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()
|