| """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() |
|
|
