| |
| """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 --show-system-prompt |
| 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" |
|
|
| DEFAULT_SYSTEM_PROMPT = ( |
| "You are evaluating Pointerbench, a GUI grounding benchmark. " |
| "You will receive one 1024x768 screenshot and one task instruction. " |
| "Use absolute pixel coordinates with origin at the top-left of the image. " |
| "Do not return normalized coordinates. Do not crop or resize the coordinate frame. " |
| "For point tasks, return JSON like {\"point\": [x, y]}. " |
| "For bounding-box tasks, return JSON like {\"bbox\": [x0, y0, x1, y1]}." |
| ) |
|
|
|
|
| def _load_jsonl(path: Path) -> list[dict]: |
| text = path.read_text(encoding="utf-8").strip() |
| if not text: |
| return [] |
| if text[0] == "[": |
| 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("--show-system-prompt", action="store_true", |
| help="print the recommended inference system prompt and exit") |
| ap.add_argument("--predictions", 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() |
|
|
| if args.show_system_prompt: |
| print(DEFAULT_SYSTEM_PROMPT) |
| return |
| if args.predictions is None: |
| ap.error("--predictions is required unless --show-system-prompt is used") |
|
|
| 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() |
|
|
