Datasets:
File size: 7,715 Bytes
90e79ee e52aaf1 90e79ee e52aaf1 90e79ee e52aaf1 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 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 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 | # Pointerbench-Sheets
**A 500-example GUI grounding benchmark for spreadsheets.** Given a spreadsheet
screenshot and a short instruction (e.g. *"Click cell E33"*, *"Click the orange
cell"*, *"Click the Revenue column header"*, *"Drag to resize column C"*), a model must output the pixel
coordinate to click. Scored exactly like [ScreenSpot](https://github.com/njucckevin/SeeClick):
**a click is correct if it lands inside the target's bounding box.**
## Why spreadsheets?
General GUI-grounding suites (ScreenSpot, ScreenSpot-v2, ScreenSpot-Pro) are
broad but **thin on spreadsheets**, yet spreadsheets are where grounding is
hardest: hundreds of near-identical small cells, dense grids, colored fills,
header rows, scroll positions that rarely start at `A1`, and click targets that
are not ordinary objects at all. Resizing a column means clicking the thin line
between columns; selecting a cell corner means landing on one grid intersection;
following "three cells below A5" means reasoning over grid coordinates, not OCR
tokens. Pointerbench-Sheets isolates this spreadsheet-specific
grounding skill across four real spreadsheet UI skins plus a chrome-free grid.
## What's inside
- **500** examples, one instruction per image.
- **1024×768** PNG screenshots, fully synthetic (no scraping, no PII).
- **5 UI styles**: Excel, Excel (white), Google Sheets, LibreOffice Calc, and a
bare chrome-free grid.
- **16 task categories**:
| category | data_type | instruction example |
| ------------------ | --------- | ------------------------------------------ |
| `cell_ref` | cell | *Click cell C12.* |
| `cell_ref_content` | cell | *Click cell C12 containing "Madrid".* |
| `cell_content` | cell | *Click the cell containing "Madrid".* |
| `col_header` | header | *Click the column D header.* |
| `row_header` | header | *Click the row 18 header.* |
| `cell_color` | color | *Click the orange cell.* |
| `col_resize_handle`| edge | *Click the divider after column D.* |
| `row_resize_handle`| edge | *Click the lower border of row 18.* |
| `cell_right_edge` | edge | *Click the right edge of cell C12.* |
| `cell_bottom_edge` | edge | *Click the bottom edge of cell C12.* |
| `cell_top_left_corner` | corner | *Click the top-left corner of cell C12.* |
| `cell_top_right_corner` | corner | *Click the top-right corner of cell C12.* |
| `cell_bottom_left_corner` | corner | *Click the bottom-left corner of cell C12.* |
| `cell_bottom_right_corner` | corner | *Click the bottom-right corner of cell C12.* |
| `cell_relative_row` | relative | *Click the cell 3 rows below D18.* |
| `cell_relative_offset` | relative | *From B7, move 3 columns right and 1 row down.* |
- Randomized realism: per-sheet font family/size, per-column text color / bold /
alignment, colored fills (single cell / row / column / stripe), banded rows, a
selected-cell distractor, and **random row + column scroll offsets** (the
window does not always start at `A1`).
- ~10% of instructions are in German (`language` field), the rest English.
## Schema
Each line of `data/test/metadata.jsonl` (HuggingFace `imagefolder` layout):
```json
{
"file_name": "0000.png",
"id": "pbs_0000",
"instruction": "Click cell E33.",
"bbox": [596, 376, 681, 395],
"point": [638, 385],
"data_type": "cell",
"category": "cell_ref",
"ui_style": "excel",
"language": "en",
"image_size": [1024, 768]
}
```
- **`bbox`**: ground-truth target, **`[x1, y1, x2, y2]` in absolute pixels**
(top-left, bottom-right) on the 1024×768 image. A prediction is correct iff it
lands inside this box.
- **`point`**: the box center (a convenient single-point reference).
- **`data_type`**: coarse ScreenSpot-style class (`cell` / `header` / `color` / `edge` / `corner` / `relative`).
- **`category`**: the fine-grained task kind.
- **`ui_style`**: the rendered app skin.
## Quickstart
### Load the data
Via 🤗 `datasets` (after the set is pushed to the Hub):
```python
from datasets import load_dataset
ds = load_dataset("YOUR_ORG/pointerbench-sheets", split="test")
ex = ds[0]
ex["image"] # PIL.Image, 1024x768
ex["instruction"] # "Click cell E33."
ex["bbox"] # [x1, y1, x2, y2]
```
Or locally with the imagefolder loader:
```python
from datasets import load_dataset
ds = load_dataset("imagefolder", data_dir="data", split="test")
```
Or with no dependencies at all, read `data/test/metadata.jsonl` and open the
sibling PNGs yourself.
### Evaluate
1. Print the recommended system prompt with `python eval.py --show-system-prompt`,
or edit it for your inference stack while keeping the 1024x768 coordinate
frame fixed.
2. Run your model on every example's `instruction` + image and collect a
predicted click point (absolute pixels on the 1024×768 image).
3. Write predictions as JSONL, one object per example:
```json
{"id": "pbs_0000", "point": [612, 388]}
```
4. Score (pure standard library, no dependencies):
```bash
python eval.py --predictions preds.jsonl
```
```
Pointerbench-Sheets: 500 examples
============================================
Accuracy: 73.40% (367/500)
By category:
cell_color 61.11% (n=72)
cell_ref 81.46% (n=178)
...
```
The scorer reports overall accuracy plus per-category, per-UI-style, and
per-data-type breakdowns. `--json report.json` writes the full report.
### Turning model output into a point
Models emit clicks in many shapes; map them to `[x, y]` pixels before scoring.
For example, a `<click>x,y</click>` tag or a normalized `0-1` / `0-999` point:
```python
import re
def to_point(text, w=1024, h=768):
m = re.search(r"(-?\d+(?:\.\d+)?)\s*[,\s]\s*(-?\d+(?:\.\d+)?)", text)
x, y = float(m.group(1)), float(m.group(2))
if max(x, y) <= 1.0: x, y = x * w, y * h # normalized 0-1
elif max(x, y) <= 999: x, y = x / 999 * w, y / 999 * h # 0-999 grid
return [round(x), round(y)]
```
## Baselines
| Model | Accuracy | Notes |
| ----------------------------- | -------- | ------------------------- |
| Center-click (512, 384) | 0.6% | sanity floor |
| _your model here_ | n/a | open a PR |
## Construction & reproducibility
Examples are rendered programmatically (pure PIL, no browser, no real files),
so every ground-truth box is pixel-exact. The set is **held out**: it is built
with a generation seed disjoint from any training data, so no benchmark sheet is
reused for training. The generator and the exact build command live in the
[source repo](https://github.com/YOUR_ORG/YOUR_GENERATOR_REPO); see
[`REPRODUCE.md`](REPRODUCE.md).
## Limitations
- Fully synthetic: realistic but not screenshots of real workbooks.
- Fixed 1024×768 resolution; instructions in English/German only.
- Targets are cells, headers, colored regions, grid/resize edges, cell corners,
and relative cell offsets, not in-sheet charts, shapes, or app chrome
(menus/toolbars are decorative and never targets).
## Citation
```bibtex
@misc{pointerbench_sheets_2026,
title = {Pointerbench-Sheets: A GUI Grounding Benchmark for Spreadsheets},
author = {Pointerbench-Sheets contributors},
year = {2026},
url = {https://github.com/YOUR_ORG/pointerbench-sheets}
}
```
## License
- **Data** (images + annotations): [CC BY 4.0](LICENSE).
- **Code** (`eval.py`): MIT.
|