| |
| """Pointerbench-Pro 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-element-type, per-app-category, |
| per-platform, and per-app 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": "pbp_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" |
|
|
| AXES = ("element_type", "app_category", "platform", "app") |
|
|
|
|
| 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 = {axis: defaultdict(lambda: [0, 0]) for axis in AXES} |
| 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 AXES: |
| cell = by[axis][ex.get(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())} |
|
|
| report = { |
| "n": n, |
| "accuracy": round(hits / n, 4) if n else 0.0, |
| "hits": hits, |
| "missing_predictions": missing, |
| } |
| for axis in AXES: |
| report[f"by_{axis}"] = table(axis) |
| return report |
|
|
|
|
| def _print(report: dict) -> None: |
| print(f"\nPointerbench-Pro: {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)") |
| titles = {"element_type": "By target type", "app_category": "By app category", |
| "platform": "By platform", "app": "By app"} |
| for axis in AXES: |
| rows = report[f"by_{axis}"] |
| if axis == "app": |
| continue |
| print(f"\n{titles[axis]}:") |
| for k, v in rows.items(): |
| print(f" {k:24s} {v['acc'] * 100:5.2f}% (n={v['n']})") |
| print("\n(per-app breakdown is in the --json report)\n") |
|
|
|
|
| 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() |
|
|
