Datasets:
File size: 4,520 Bytes
90e79ee | 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 | #!/usr/bin/env python3
"""Pointerbench-Sheets official scorer.
Metric: **point-in-bbox accuracy** (the ScreenSpot standard). A prediction is
correct when the predicted click point falls inside the target's ground-truth
bounding box. Reports overall accuracy plus per-category, per-UI-style, and
per-data-type breakdowns. Pure standard library, no dependencies.
Ground truth is read from `data/test/metadata.jsonl` (shipped with the repo).
Predictions file: JSONL or JSON list, one object per example, e.g.
{"id": "pbs_0001", "point": [612, 388]}
Accepted point keys: "point" / "pred" / "coordinate", or flat "x" and "y".
Coordinates are absolute pixels on the 1024x768 image.
Usage:
python eval.py --predictions preds.jsonl
python eval.py --predictions preds.jsonl --json report.json
"""
from __future__ import annotations
import argparse
import json
from collections import defaultdict
from pathlib import Path
ROOT = Path(__file__).resolve().parent
GT_PATH = ROOT / "data" / "test" / "metadata.jsonl"
def _load_jsonl(path: Path) -> list[dict]:
text = path.read_text(encoding="utf-8").strip()
if not text:
return []
if text[0] == "[": # tolerate a JSON array too
return json.loads(text)
return [json.loads(ln) for ln in text.splitlines() if ln.strip()]
def _point(rec: dict) -> tuple[float, float] | None:
for key in ("point", "pred", "coordinate", "prediction"):
v = rec.get(key)
if isinstance(v, (list, tuple)) and len(v) >= 2:
return float(v[0]), float(v[1])
if "x" in rec and "y" in rec:
return float(rec["x"]), float(rec["y"])
return None
def _in_bbox(pt: tuple[float, float], bbox: list[int]) -> bool:
x0, y0, x1, y1 = bbox
return min(x0, x1) <= pt[0] <= max(x0, x1) and min(y0, y1) <= pt[1] <= max(y0, y1)
def evaluate(gt: list[dict], preds: dict[str, dict]) -> dict:
by = {"category": defaultdict(lambda: [0, 0]),
"ui_style": defaultdict(lambda: [0, 0]),
"data_type": defaultdict(lambda: [0, 0])}
hits = missing = 0
for ex in gt:
pred = preds.get(ex["id"])
pt = _point(pred) if pred else None
if pt is None:
missing += 1
ok = False
else:
ok = _in_bbox(pt, ex["bbox"])
hits += ok
for axis in by:
cell = by[axis][ex[axis]]
cell[0] += ok
cell[1] += 1
n = len(gt)
def table(axis: str) -> dict:
return {k: {"acc": round(v[0] / v[1], 4), "n": v[1]}
for k, v in sorted(by[axis].items())}
return {
"n": n,
"accuracy": round(hits / n, 4) if n else 0.0,
"hits": hits,
"missing_predictions": missing,
"by_category": table("category"),
"by_ui_style": table("ui_style"),
"by_data_type": table("data_type"),
}
def _print(report: dict) -> None:
print(f"\nPointerbench-Sheets: {report['n']} examples")
print("=" * 44)
print(f"Accuracy: {report['accuracy'] * 100:5.2f}% "
f"({report['hits']}/{report['n']})")
if report["missing_predictions"]:
print(f" ! {report['missing_predictions']} examples had no prediction "
f"(counted as wrong)")
for axis, title in (("by_category", "By category"),
("by_ui_style", "By UI style"),
("by_data_type", "By data type")):
print(f"\n{title}:")
for k, v in report[axis].items():
print(f" {k:18s} {v['acc'] * 100:5.2f}% (n={v['n']})")
print()
def main() -> None:
ap = argparse.ArgumentParser(description=__doc__,
formatter_class=argparse.RawDescriptionHelpFormatter)
ap.add_argument("--predictions", required=True, type=Path,
help="JSONL/JSON predictions: {id, point:[x,y]} per example")
ap.add_argument("--gt", type=Path, default=GT_PATH,
help=f"ground-truth metadata (default: {GT_PATH})")
ap.add_argument("--json", type=Path, default=None,
help="also write the full report to this JSON path")
args = ap.parse_args()
gt = _load_jsonl(args.gt)
preds = {r["id"]: r for r in _load_jsonl(args.predictions) if "id" in r}
report = evaluate(gt, preds)
_print(report)
if args.json:
args.json.write_text(json.dumps(report, indent=2), encoding="utf-8")
print(f"report -> {args.json}")
if __name__ == "__main__":
main()
|