Add files using upload-large-folder tool

.gitattributes

@@ -58,3 +58,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+manifest/source-manifest-2026-10-23.jsonl filter=lfs diff=lfs merge=lfs -text

LICENSE.md

@@ -0,0 +1,43 @@
+# ScreenProof license
+
+ScreenProof has parts under different terms. The `image_license` field of each row says which part an image is in.
+
+## 1. Labels, manifest and generated images: CC BY 4.0
+
+The labels (`label`, `follows`, `num_faults`, `fault`, `fault_group`, `human_check` and the other metadata fields), the
+source manifest in `manifest/`, the prompt in `prompt.txt`, and every image with `image_license = CC-BY-4.0`
+(`source = generated`) are licensed under the Creative Commons Attribution 4.0 International License:
+https://creativecommons.org/licenses/by/4.0/legalcode
+
+Attribution: cite the ScreenProof paper (see README.md).
+
+## 2. Third-party images: owners' terms, research use only
+
+Images with `image_license = third-party` are vendor screenshots (`source = vendor_screenshot`) and renders of public
+web pages, with their engine-made copies (`source = web_page`). Their copyright stays with their owners. The original
+URL is in `source_url`, and the terms recorded at collection are in the manifest. The CC BY 4.0 license above does
+not apply to them.
+
+They are included only so that the benchmark can be evaluated and studied. Use them only for non-commercial research.
+Do not redistribute them outside this dataset, and do not use them to identify or represent their owners.
+
+If you own one of these images and want it removed, contact huiming.sun1@innopeaktech.com. We remove it.
+
+## 3. Code: MIT License
+
+`evaluate.py`:
+
+Copyright (c) 2026 The ScreenProof authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -0,0 +1,146 @@
+---
+pretty_name: ScreenProof
+license: other
+license_name: cc-by-4.0-with-third-party-images
+license_link: LICENSE.md
+language:
+- en
+- zh
+task_categories:
+- image-text-to-text
+- object-detection
+tags:
+- gui
+- user-interface
+- mobile
+- screenshot
+- design-consistency
+- ui-critique
+- benchmark
+size_categories:
+- 10K<n<100K
+configs:
+- config_name: default
+  default: true
+  data_files:
+  - split: test
+    path: data/consistency_test-*.parquet
+  - split: train
+    path: data/train-*.parquet
+  - split: validation
+    path: data/validation-*.parquet
+- config_name: text_layout
+  data_files:
+  - split: test
+    path: data/text_layout_test-*.parquet
+---
+
+# ScreenProof: Where Is This Screen Wrong? Finding UI Faults Without a Reference
+
+ScreenProof is a benchmark and a training set for **reference-free UI critique** of phone screenshots.
+A critic gets one screenshot and no design file, no target brand and no second screen. It must say whether the
+screen is correct and put a box on each element that is wrong: a general UI fault (text overflow, overlap, low
+contrast, a small tap target and others) or an element that is inconsistent with the rest of the page (a component
+from another design language, or a local change of icon, accent colour, corner radius or material).
+
+- Project page and leaderboard: https://hms97.github.io/screenproof/
+- Paper: arXiv link to follow
+- Evaluation: `evaluate.py` in this repository (MIT License)
+
+## Splits
+
+| Config / split | Rows | Images | Content |
+|---|---:|---:|---|
+| `default` / `test` (consistency test) | 2,765 | 2,765 | 607 clean pages (120 real, 487 generated; 181 of them hard negatives), 920 general faults, 1,238 local style faults (662 transplanted components). One fault per faulty page. |
+| `text_layout` / `test` | 513 | 513 | 367 text layout faults, 75 clean pages, 71 hard negatives. English pages. |
+| `default` / `train` (ScreenProof-Train) | 17,285 | 11,424 | From 990 pages: 542 generated and 448 public web pages. A row is an image with its label; an image can appear in several rows. |
+| `default` / `validation` | 1,571 | 1,571 | Six held-out page requirements. Used to choose checkpoints and thresholds, never the test. |
+
+No test or validation page requirement occurs in the training set. Three page requirements per design language are
+held out for testing. The design languages are iOS, Material, One UI, HarmonyOS, ColorOS, MagicOS, OriginOS and
+HyperOS.
+
+```python
+from datasets import load_dataset
+
+test = load_dataset("HMSSS55/ScreenProof", split="test")                     # consistency test
+text = load_dataset("HMSSS55/ScreenProof", "text_layout", split="test")      # text layout test
+train = load_dataset("HMSSS55/ScreenProof", split="train")
+```
+
+## Fields
+
+| Field | Meaning |
+|---|---|
+| `id` | Stable row id (`ct-`, `tl-`, `tr-`, `va-` prefix). Predictions for `evaluate.py` use it. |
+| `image` | The screenshot (PNG or WebP, full resolution). |
+| `page` | The page the image comes from. Faulty copies of one page share it. |
+| `design_language` | `ios`, `material`, `oneui`, `harmonyos`, `coloros`, `magicos`, `originos`, `hyperos`; empty for public web pages. |
+| `source` | `generated` (our pages and their engine-made copies), `vendor_screenshot` (a vendor's public screenshot), `web_page` (a public web page rendered at phone size, and its engine-made copies). |
+| `source_url` | The original URL for `vendor_screenshot` and `web_page` rows. |
+| `image_license` | `CC-BY-4.0` or `third-party` (see License). |
+| `fault` | The engine's fault name, or `clean`. |
+| `fault_group` | Test sets: the fault group used in the paper (`display`, `overlap`, `two_selected`, `typeface`, `reordered_sections`, `low_contrast`, `small_tap_target`, `dropped_item`, `text_overflow`, `transplanted_component`, `icon`, `accent`, `material`, `corner_radius`, `text_layout`, `clean`, `hard_negative`). Train and validation: the training family (`clean`, `designed`, `multi`, `swap`, `local`, `text`, `page`, `general`). |
+| `follows` | `true` when the page has no fault. |
+| `num_faults` | Number of labelled boxes. |
+| `label` | JSON in the same form as a critic's answer (`prompt.txt`): `{"follows": bool, "inconsistencies": [{"element", "box", "kind", "aspect"}]}`. `kind` is `common` or `inconsistent`. Boxes are `[x0, y0, x1, y1]` in 0-1000 screen coordinates. |
+| `human_check` | Consistency test only: the verdict of a hand check, where one was made (`wrong` = the labelled fault is real, `clean` = the clean page is clean, `faulty`, `hidden`, `fine` = the label is not right, `unsure`). |
+
+A hard negative changes every sibling alike (for example all list rows), so the page stays consistent and a critic
+must stay silent.
+
+## How the labels are made
+
+Faults are made in HTML page code, so the edit is the label. The data engine makes exactly one change, reads the
+changed element's rendered box from the DOM, and re-renders the page identically. Clean labels rest on base pages
+that two model judges found on-spec. Clean test pages that both outside judges boxed at the same place were removed
+(106 pages). A hand check of 481 test items found 85 mislabelled; `evaluate.py --exclude-human-flagged` leaves them
+out (2,680 pages), and every F1 in the paper changes by at most 0.01.
+
+## Evaluation
+
+```bash
+python evaluate.py --split consistency_test --predictions preds.jsonl
+```
+
+`preds.jsonl` holds one line per screenshot: `{"id": "ct-00012", "answer": {...}}`, or `{"id": ..., "raw": "<model text>"}`.
+A reported box finds a fault when IoU >= 0.5, one-to-one and greedy by IoU (`--iou 0.3` for the loose table).
+Precision is over all reported boxes, clean pages included. The script also reports consistency recall, general
+recall and the share of clean real and clean generated pages that the critic flags. Send the prompt in `prompt.txt`
+with the image and nothing else.
+
+## Source manifest
+
+`manifest/source-manifest-2026-10-23.jsonl` is the frozen collection manifest: for each public image its source page,
+date of collection, terms of use, size and hash, and for files from public UI datasets their licence.
+
+## License
+
+- Labels, the source manifest and all `generated` images: [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/).
+- `vendor_screenshot` and `web_page` images (`image_license = third-party`): copyright stays with their owners.
+  They are included only for non-commercial research and the evaluation of this benchmark. See `LICENSE.md`.
+- `evaluate.py`: MIT License.
+
+If you own an image in this dataset and want it removed, write to the contact below and we remove it.
+
+## Intended use and limitations
+
+Intended use: evaluate and train critics that find UI faults on phone screenshots without a reference, and study when
+such a critic can serve as a first pass before human review.
+Out of scope: judging a designer's work or a brand's conformance without human review; use as a production gate on
+its own; screens with interaction or motion.
+Limitations: single phone screens only; the text layout test is English only; clean labels come from model judges.
+
+## Citation
+
+```bibtex
+@article{sun2026screenproof,
+  title   = {ScreenProof: Where Is This Screen Wrong? Finding UI Faults Without a Reference},
+  author  = {Sun, Huiming and Li, Yue and Yang, Kangning and Li, Ruineng and Cai, Jie and Fu, Lan and
+             Fu, Yunwan and Li, Jinlong and Shen, Jinglin},
+  journal = {arXiv preprint},
+  year    = {2026}
+}
+```
+
+Contact: Huiming Sun, huiming.sun1@innopeaktech.com

data/consistency_test-00000-of-00002.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0bc8682ae06cc2cdb2138b6fd2731b0b01c5e69332d571d4c19970fddf838c49
+size 309033142

data/consistency_test-00001-of-00002.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ef84fe761e5402bd0625475f2b3c81886248d499425867a940e133a604caa8c4
+size 334360661

data/text_layout_test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1e498ed509226c75c1803540a37774b1476afd7c8af79b0510a6984cafa098fa
+size 115054447

data/train-00000-of-00008.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a20d6bf59928fc4762ef796e102b7e80340a6c738a9c1a812d6da4020eb926b5
+size 414732609

data/train-00001-of-00008.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f9a3fbd0e86ff4d4d912ab95bcafaee6790f2e889e62468ca83cb4ce72b0b9a5
+size 431522119

data/train-00002-of-00008.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ba865975b0700effc48c0a61857f16b4ec8248934ef55192715d953fde9a1082
+size 445725727

data/train-00003-of-00008.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8ed723ce0e74b6142c9519bc0c332ff082837bac459a926ee6c5bb000d03a639
+size 427303329

data/train-00004-of-00008.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0f4ed30b607a41cb1751848fa76cd90066d0c44a428440cf52228931b12536b2
+size 445638393

data/train-00005-of-00008.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:15923a8ffad6516517806a7f5c2385739cb8e6eac2fb9beaa641dd4cc0877583
+size 429135599

data/train-00006-of-00008.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:038f3283750c0037e4a1cdcc9dc6f230882cbebc6258d65cf0cbc02cc5502843
+size 442170344

data/train-00007-of-00008.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0696666746326bec0418b49e57418ed05e21978be51da4fa89fa78688d609795
+size 429372225

data/validation-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f43fcdc213d21797bb8707a7682e33c1c9f08a040582944951354fcc79d74cf6
+size 399792551

evaluate.py

@@ -0,0 +1,143 @@
+"""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
+
+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")
+    a = ap.parse_args()
+
+    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")]
+    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 = {"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()

manifest/source-manifest-2026-10-23.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d53ad1486ad9189d54de8f7f96b0c6ec9b61117cf170d0a0f41af5fabff1c97b
+size 29061765

prompt.txt

@@ -0,0 +1,14 @@
+This is a phone UI screen. Check every visible element: title bar, bottom navigation, buttons,
+switches, list rows, cards, icons, text and spacing. List each element that is wrong. Two kinds of problems count:
+- "common": a UI error under any design language (text overflow or cut off, overlap, misalignment,
+  uneven spacing, low contrast, tap area too small, confused hierarchy, wrong order, missing element);
+- "inconsistent": the element does not match the style of the rest of this page, as if it came from another
+  app or design system; give its aspect: "component" (the component's style), "icon" (icon style), "colour",
+  "radius" (corner shape), "material" (surfaces, blur, depth) or "type" (typeface and type style).
+Judge each element against the rest of the page, not against any brand. A page whose elements all share one
+style and have no common problem follows.
+Give each one's bounding box as [x0, y0, x1, y1] in a 0-1000 coordinate system of the image
+(x to the right, y down; 0,0 is the top-left corner).
+Answer only with JSON: {"follows": true or false, "inconsistencies": [{"element": "short name",
+"box": [x0, y0, x1, y1], "kind": "common" or "inconsistent",
+"aspect": "component", "icon", "colour", "radius", "material", "type" or ""}]}

stats.json

@@ -0,0 +1,76 @@
+{
+ "consistency_test": {
+  "rows": 2765,
+  "images": 2765,
+  "by_source": {
+   "generated": 2586,
+   "vendor_screenshot": 67,
+   "web_page": 112
+  },
+  "by_fault_group": {
+   "transplanted_component": 662,
+   "clean": 426,
+   "display": 347,
+   "icon": 188,
+   "hard_negative": 181,
+   "accent": 179,
+   "material": 123,
+   "overlap": 115,
+   "two_selected": 111,
+   "corner_radius": 86,
+   "typeface": 77,
+   "low_contrast": 66,
+   "reordered_sections": 65,
+   "small_tap_target": 48,
+   "text_overflow": 47,
+   "dropped_item": 44
+  }
+ },
+ "text_layout_test": {
+  "rows": 513,
+  "images": 513,
+  "by_source": {
+   "generated": 513
+  },
+  "by_fault_group": {
+   "text_layout": 367,
+   "clean": 75,
+   "hard_negative": 71
+  }
+ },
+ "train": {
+  "rows": 17285,
+  "images": 11424,
+  "by_source": {
+   "generated": 16495,
+   "vendor_screenshot": 61,
+   "web_page": 729
+  },
+  "by_fault_group": {
+   "clean": 7193,
+   "multi": 2711,
+   "swap": 2110,
+   "local": 1609,
+   "general": 1542,
+   "text": 972,
+   "designed": 630,
+   "page": 518
+  }
+ },
+ "validation": {
+  "rows": 1571,
+  "images": 1571,
+  "by_source": {
+   "generated": 1557,
+   "vendor_screenshot": 14
+  },
+  "by_fault_group": {
+   "clean": 398,
+   "multi": 319,
+   "local": 288,
+   "swap": 256,
+   "general": 235,
+   "page": 75
+  }
+ }
+}