Datasets:
File size: 7,048 Bytes
00eb20a 701692e 00eb20a 701692e 00eb20a 701692e 00eb20a 701692e 00eb20a 701692e 00eb20a | 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 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 | """Score a critic's answers on ScreenProof (MIT License).
Predictions: a JSONL file, one line per screenshot: {"id": "ct-00012", "answer": {...}} or {"id": ..., "raw": "<text>"}.
An answer has the form of prompt.txt: {"follows": bool, "inconsistencies": [{"element", "box", "kind", "aspect"}]},
boxes as [x0, y0, x1, y1] in 0-1000 screen coordinates. A missing or unparsable answer counts as finding nothing.
Matching: one-to-one, greedy by IoU, a reported box finds a fault when IoU >= 0.5 (--iou 0.3 for the loose table).
precision = matched boxes / all reported boxes (clean pages included)
recall = matched faults / all faults; F1 from both
consistency recall = recall on "inconsistent" faults (transplanted components, local style faults)
general recall = recall on "common" faults
false alarm = share of clean pages that the critic flags (follows false, or any box), real and generated apart
python evaluate.py --split consistency_test --predictions preds.jsonl [--data-dir .] [--exclude-human-flagged]
--exclude-human-flagged leaves out the pages that the label check marked faulty, hidden or fine (the "human" table).
Note: the paper's runs sent prompt.txt with its JSON braces doubled ({{ }}); this script reads either form.
"""
from __future__ import annotations
import argparse
import glob
import json
import os
import re
from pathlib import Path
import pyarrow.parquet as pq
def parse(raw):
if isinstance(raw, dict) or raw is None:
return raw
raw = re.sub(r"<think>.*?</think>", "", str(raw), flags=re.S)
start = raw.find("{")
if start < 0:
return None
for text in (raw[start:], raw[start:].replace("{{", "{").replace("}}", "}")):
try:
return json.JSONDecoder().raw_decode(text)[0]
except json.JSONDecodeError:
continue
return None
def box(b):
if not isinstance(b, (list, tuple)) or len(b) != 4:
return None
try:
x0, y0, x1, y1 = (float(v) for v in b)
except (TypeError, ValueError):
return None
return [min(x0, x1), min(y0, y1), max(x0, x1), max(y0, y1)]
def iou(a, b):
ix = max(0.0, min(a[2], b[2]) - max(a[0], b[0]))
iy = max(0.0, min(a[3], b[3]) - max(a[1], b[1]))
inter = ix * iy
union = (a[2] - a[0]) * (a[3] - a[1]) + (b[2] - b[0]) * (b[3] - b[1]) - inter
return inter / union if union > 0 else 0.0
def match(items, truths, thr):
reps = [box(i.get("box")) for i in items]
tbs = [box(t.get("box")) for t in truths]
cand = sorted(((iou(r, t), i, j) for i, r in enumerate(reps) if r for j, t in enumerate(tbs) if t
if iou(r, t) >= thr), reverse=True)
used_i, used_t, pairs = set(), set(), []
for _, i, j in cand:
if i not in used_i and j not in used_t:
used_i.add(i)
used_t.add(j)
pairs.append((i, j))
return pairs
def load_split(data_dir, split):
files = sorted(glob.glob(os.path.join(data_dir, "data", f"{split}-*.parquet")))
if not files:
raise SystemExit(f"no parquet files for {split} in {data_dir}/data")
cols = ["id", "source", "label", "human_check"]
rows = []
for f in files:
rows += pq.read_table(f, columns=cols).to_pylist()
return rows
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--split", default="consistency_test", choices=["consistency_test", "text_layout_test", "validation"])
ap.add_argument("--predictions", required=True)
ap.add_argument("--data-dir", default=os.path.dirname(os.path.abspath(__file__)))
ap.add_argument("--iou", type=float, default=0.5)
ap.add_argument("--exclude-human-flagged", action="store_true")
ap.add_argument("--subset", default="published", choices=["published", "audit_excluded", "structural_quarantine", "convention_sensitivity"])
a = ap.parse_args()
if a.subset != "published" and (a.split != "consistency_test" or a.exclude_human_flagged):
ap.error("--subset requires consistency_test and cannot be combined with --exclude-human-flagged")
rows = load_split(a.data_dir, a.split)
if a.exclude_human_flagged:
rows = [r for r in rows if r["human_check"] not in ("faulty", "hidden", "fine")]
if a.subset != "published":
root = Path(a.data_dir) / "robustness"
protocol = json.loads((root / "protocol.json").read_text())
records = {r["id"]: r for r in map(json.loads, (root / "records.jsonl").read_text().splitlines()) if r["in_original_release"]}
if set(records) != {r["id"] for r in rows}:
raise SystemExit("Subset manifest does not match this dataset revision")
flags = protocol["pool_exclusions"][a.subset]
rows = [r for r in rows if not any(records[r["id"]][f] for f in flags)]
preds = {}
with open(a.predictions, encoding="utf-8") as fh:
for line in fh:
if line.strip():
p = json.loads(line)
ans = parse(p["answer"]) if "answer" in p else parse(p.get("raw"))
if ans is not None or p["id"] not in preds:
preds[p["id"]] = ans
c = dict.fromkeys(["boxes", "matched", "faults", "con_truth", "con_hit", "gen_truth", "gen_hit", "unparsed",
"clean_real", "fa_real", "clean_gen", "fa_gen"], 0)
for r in rows:
truths = json.loads(r["label"])["inconsistencies"] or []
ans = preds.get(r["id"])
if not isinstance(ans, dict):
c["unparsed"] += 1
ans = {"follows": True, "inconsistencies": []}
items = [i for i in (ans.get("inconsistencies") or []) if isinstance(i, dict)]
pairs = match(items, truths, a.iou)
c["boxes"] += len(items)
c["matched"] += len(pairs)
c["faults"] += len(truths)
hit = {j for _, j in pairs}
for j, t in enumerate(truths):
k = "con" if t.get("kind") == "inconsistent" else "gen"
c[f"{k}_truth"] += 1
c[f"{k}_hit"] += j in hit
if not truths:
s = "gen" if r["source"] == "generated" else "real"
c[f"clean_{s}"] += 1
c[f"fa_{s}"] += ans.get("follows") is False or bool(items)
p = c["matched"] / c["boxes"] if c["boxes"] else 0.0
rec = c["matched"] / c["faults"] if c["faults"] else 0.0
out = {"protocol": "eval-2026-11-10", "subset": "audit_excluded" if a.exclude_human_flagged else a.subset, "pages": len(rows), "precision": round(p, 4), "recall": round(rec, 4),
"f1": round(2 * p * rec / (p + rec), 4) if p + rec else 0.0,
"consistency_recall": round(c["con_hit"] / max(1, c["con_truth"]), 4),
"general_recall": round(c["gen_hit"] / max(1, c["gen_truth"]), 4),
"false_alarm_real": round(c["fa_real"] / max(1, c["clean_real"]), 4),
"false_alarm_generated": round(c["fa_gen"] / max(1, c["clean_gen"]), 4),
"unparsed": c["unparsed"], "iou": a.iou}
print(json.dumps(out, indent=1))
if __name__ == "__main__":
main()
|