Add leaderboard space support

.gitignore

@@ -0,0 +1,2 @@
+leaderboard/data/
+hf_eval_results/generated/

hf_eval_results/README.md

@@ -0,0 +1,87 @@
+# Hugging Face Eval Results Support
+
+This directory prepares Real5-OmniDocBench for Hugging Face's model-side
+`.eval_results/*.yaml` mechanism.
+
+## Current Support Status
+
+Not fully enabled on the Hub yet.
+
+Hugging Face Evaluation Results require:
+
+1. The dataset repo to have a root `eval.yaml`.
+2. The `evaluation_framework` in that file to be one of Hugging Face's supported framework identifiers.
+3. The benchmark dataset to be accepted by the beta allow-list.
+4. Model repos to submit `.eval_results/*.yaml` files that reference this dataset and task IDs.
+
+As of July 11, 2026, Hugging Face documents this feature as work in progress and benchmark registration as beta / allow-listed. The supported framework enum currently includes document-related frameworks such as `olmocr-bench`, `mdpbench`, and `parsebench`, but not a dedicated `real5-omnidocbench` or `omnidocbench` framework.
+
+For that reason, `eval.yaml.candidate` is intentionally not placed at the repository root yet. Move or copy it to `eval.yaml` only after Hugging Face confirms the framework choice and allow-list registration.
+
+## Dataset-Side Candidate
+
+`eval.yaml.candidate` defines six Hub leaderboard tasks:
+
+- `overall`
+- `scanning`
+- `warping`
+- `screen_photography`
+- `illumination`
+- `skew`
+
+These correspond to the six score columns in the README Overall table. All six are "higher is better" scores in the current benchmark presentation.
+
+## Model-Side Submission Format
+
+Model repositories should add a file like:
+
+```text
+.eval_results/real5_omnidocbench.yaml
+```
+
+Use `examples/model_eval_results.yaml` as the template.
+
+Each YAML list item reports one task:
+
+```yaml
+- dataset:
+    id: PaddlePaddle/Real5-OmniDocBench
+    task_id: overall
+  value: 93.19
+  date: "2026-05-28"
+  source:
+    url: https://huggingface.co/datasets/PaddlePaddle/Real5-OmniDocBench
+    name: Real5-OmniDocBench README
+    org: PaddlePaddle
+  notes: "PaddleOCR-VL-1.6; official reported result"
+```
+
+## Generate Files From Current README Data
+
+The static leaderboard data must already be generated from the external source file:
+
+```bash
+python leaderboard/scripts/build_from_source_data.py
+```
+
+Generate one YAML file per method:
+
+```bash
+python hf_eval_results/scripts/generate_model_eval_results.py
+```
+
+Generate only one method:
+
+```bash
+python hf_eval_results/scripts/generate_model_eval_results.py --method "PaddleOCR-VL-1.6"
+```
+
+Validate generated or submitted YAML:
+
+```bash
+python hf_eval_results/scripts/validate_eval_results.py hf_eval_results/generated
+```
+
+## Important Limitation
+
+The Hub `.eval_results` schema stores one numeric `value` per dataset task. It does not directly encode the full multi-metric rows from the README tables. This support therefore maps the Hub-native leaderboard to the six primary Overall-table scores. The richer scenario-level metrics such as `TextEdit`, `FormulaCDM`, `TableTEDS`, and `Reading OrderEdit` remain available in the Static Space leaderboard.

hf_eval_results/eval.yaml.candidate

@@ -0,0 +1,26 @@
+name: Real5-OmniDocBench
+description: >
+  Real5-OmniDocBench is a real-world document parsing robustness benchmark
+  covering five physical acquisition scenarios: Scanning, Warping,
+  Screen-Photography, Illumination, and Skew.
+evaluation_framework: olmocr-bench
+
+tasks:
+  - id: overall
+    config: default
+    split: test
+  - id: scanning
+    config: default
+    split: test
+  - id: warping
+    config: default
+    split: test
+  - id: screen_photography
+    config: default
+    split: test
+  - id: illumination
+    config: default
+    split: test
+  - id: skew
+    config: default
+    split: test

hf_eval_results/examples/model_eval_results.yaml

@@ -0,0 +1,72 @@
+# Copy this file into a model repository as:
+# .eval_results/real5_omnidocbench.yaml
+#
+# Each entry reports one leaderboard task. The value is the score shown in the
+# Real5-OmniDocBench README / leaderboard data. Higher is better for these
+# six tasks.
+
+- dataset:
+    id: PaddlePaddle/Real5-OmniDocBench
+    task_id: overall
+  value: 93.19
+  date: "2026-05-28"
+  source:
+    url: https://huggingface.co/datasets/PaddlePaddle/Real5-OmniDocBench
+    name: Real5-OmniDocBench README
+    org: PaddlePaddle
+  notes: "PaddleOCR-VL-1.6; official reported result"
+
+- dataset:
+    id: PaddlePaddle/Real5-OmniDocBench
+    task_id: scanning
+  value: 94.74
+  date: "2026-05-28"
+  source:
+    url: https://huggingface.co/datasets/PaddlePaddle/Real5-OmniDocBench
+    name: Real5-OmniDocBench README
+    org: PaddlePaddle
+  notes: "PaddleOCR-VL-1.6; official reported result"
+
+- dataset:
+    id: PaddlePaddle/Real5-OmniDocBench
+    task_id: warping
+  value: 92.48
+  date: "2026-05-28"
+  source:
+    url: https://huggingface.co/datasets/PaddlePaddle/Real5-OmniDocBench
+    name: Real5-OmniDocBench README
+    org: PaddlePaddle
+  notes: "PaddleOCR-VL-1.6; official reported result"
+
+- dataset:
+    id: PaddlePaddle/Real5-OmniDocBench
+    task_id: screen_photography
+  value: 92.78
+  date: "2026-05-28"
+  source:
+    url: https://huggingface.co/datasets/PaddlePaddle/Real5-OmniDocBench
+    name: Real5-OmniDocBench README
+    org: PaddlePaddle
+  notes: "PaddleOCR-VL-1.6; official reported result"
+
+- dataset:
+    id: PaddlePaddle/Real5-OmniDocBench
+    task_id: illumination
+  value: 93.28
+  date: "2026-05-28"
+  source:
+    url: https://huggingface.co/datasets/PaddlePaddle/Real5-OmniDocBench
+    name: Real5-OmniDocBench README
+    org: PaddlePaddle
+  notes: "PaddleOCR-VL-1.6; official reported result"
+
+- dataset:
+    id: PaddlePaddle/Real5-OmniDocBench
+    task_id: skew
+  value: 92.66
+  date: "2026-05-28"
+  source:
+    url: https://huggingface.co/datasets/PaddlePaddle/Real5-OmniDocBench
+    name: Real5-OmniDocBench README
+    org: PaddlePaddle
+  notes: "PaddleOCR-VL-1.6; official reported result"

hf_eval_results/scripts/generate_model_eval_results.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+"""Generate model-side .eval_results YAML files from Space leaderboard data."""
+
+from __future__ import annotations
+
+import argparse
+import re
+from pathlib import Path
+
+import yaml
+
+
+DEFAULT_DATA = Path(__file__).resolve().parents[2] / "leaderboard" / "data" / "leaderboard_data.json"
+DEFAULT_OUT_DIR = Path(__file__).resolve().parents[1] / "generated"
+DEFAULT_DATASET_ID = "PaddlePaddle/Real5-OmniDocBench"
+DEFAULT_SOURCE_URL = "https://huggingface.co/datasets/PaddlePaddle/Real5-OmniDocBench"
+
+TASK_COLUMNS = {
+    "overall": "overall",
+    "scanning": "scanning",
+    "warping": "warping",
+    "screen_photography": "screen_photography",
+    "illumination": "illumination",
+    "skew": "skew",
+}
+
+
+def slugify(value: str) -> str:
+    value = value.strip().lower()
+    value = re.sub(r"[^a-z0-9]+", "-", value)
+    return value.strip("-") or "model"
+
+
+def load_overall_rows(path: Path) -> list[dict[str, object]]:
+    import json
+
+    payload = json.loads(path.read_text(encoding="utf-8"))
+    for table in payload["tables"]:
+        if table["name"] == "Overall":
+            return table["rows"]
+    raise ValueError("Overall table not found")
+
+
+def make_entries(row: dict[str, object], args: argparse.Namespace) -> list[dict[str, object]]:
+    method = str(row["method"])
+    entries: list[dict[str, object]] = []
+    for task_id, column in TASK_COLUMNS.items():
+        value = row.get(column)
+        if not isinstance(value, (int, float)):
+            continue
+        entry: dict[str, object] = {
+            "dataset": {
+                "id": args.dataset_id,
+                "task_id": task_id,
+            },
+            "value": round(float(value), 6),
+        }
+        if args.date:
+            entry["date"] = args.date
+        if args.source_url:
+            entry["source"] = {
+                "url": args.source_url,
+                "name": args.source_name,
+                "org": args.source_org,
+            }
+        entry["notes"] = f"{method}; generated from Real5-OmniDocBench README"
+        entries.append(entry)
+    return entries
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--data", type=Path, default=DEFAULT_DATA)
+    parser.add_argument("--out-dir", type=Path, default=DEFAULT_OUT_DIR)
+    parser.add_argument("--method", help="Generate only one method by exact name.")
+    parser.add_argument("--dataset-id", default=DEFAULT_DATASET_ID)
+    parser.add_argument("--date", help="Optional ISO-8601 evaluation date.")
+    parser.add_argument("--source-url", default=DEFAULT_SOURCE_URL)
+    parser.add_argument("--source-name", default="Real5-OmniDocBench README")
+    parser.add_argument("--source-org", default="PaddlePaddle")
+    args = parser.parse_args()
+
+    rows = load_overall_rows(args.data)
+    if args.method:
+        rows = [row for row in rows if row["method"] == args.method]
+        if not rows:
+            raise SystemExit(f"Method not found: {args.method}")
+
+    args.out_dir.mkdir(parents=True, exist_ok=True)
+    for row in rows:
+        method = str(row["method"])
+        entries = make_entries(row, args)
+        out_file = args.out_dir / f"{slugify(method)}.yaml"
+        out_file.write_text(
+            yaml.safe_dump(entries, sort_keys=False, allow_unicode=False),
+            encoding="utf-8",
+        )
+        print(f"Wrote {out_file}")
+
+
+if __name__ == "__main__":
+    main()

hf_eval_results/scripts/validate_eval_results.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+"""Validate Real5-OmniDocBench model-side .eval_results YAML files."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+import yaml
+
+
+DEFAULT_DATASET_ID = "PaddlePaddle/Real5-OmniDocBench"
+VALID_TASK_IDS = {
+    "overall",
+    "scanning",
+    "warping",
+    "screen_photography",
+    "illumination",
+    "skew",
+}
+
+
+def validate_file(path: Path, dataset_id: str) -> list[str]:
+    errors: list[str] = []
+    payload = yaml.safe_load(path.read_text(encoding="utf-8"))
+    if not isinstance(payload, list):
+        return [f"{path}: top-level YAML must be a list"]
+
+    seen: set[str] = set()
+    for index, entry in enumerate(payload, start=1):
+        prefix = f"{path}: entry {index}"
+        if not isinstance(entry, dict):
+            errors.append(f"{prefix}: must be a mapping")
+            continue
+
+        dataset = entry.get("dataset")
+        if not isinstance(dataset, dict):
+            errors.append(f"{prefix}: missing dataset mapping")
+            continue
+
+        if dataset.get("id") != dataset_id:
+            errors.append(f"{prefix}: dataset.id must be {dataset_id!r}")
+
+        task_id = dataset.get("task_id")
+        if task_id not in VALID_TASK_IDS:
+            errors.append(f"{prefix}: invalid task_id {task_id!r}")
+        else:
+            seen.add(str(task_id))
+
+        value = entry.get("value")
+        if not isinstance(value, (int, float)):
+            errors.append(f"{prefix}: value must be numeric")
+        elif not 0 <= float(value) <= 100:
+            errors.append(f"{prefix}: value should be in [0, 100]")
+
+        source = entry.get("source")
+        if source is not None:
+            if not isinstance(source, dict) or not source.get("url"):
+                errors.append(f"{prefix}: source.url is required when source is present")
+
+    missing = VALID_TASK_IDS - seen
+    if missing:
+        errors.append(f"{path}: missing task_id entries: {', '.join(sorted(missing))}")
+    return errors
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("paths", nargs="+", type=Path)
+    parser.add_argument("--dataset-id", default=DEFAULT_DATASET_ID)
+    args = parser.parse_args()
+
+    all_errors: list[str] = []
+    files: list[Path] = []
+    for path in args.paths:
+        if path.is_dir():
+            files.extend(sorted(path.glob("*.yaml")))
+            files.extend(sorted(path.glob("*.yml")))
+        else:
+            files.append(path)
+
+    if not files:
+        raise SystemExit("No YAML files found")
+
+    for path in files:
+        all_errors.extend(validate_file(path, args.dataset_id))
+
+    if all_errors:
+        print("\n".join(all_errors))
+        raise SystemExit(1)
+
+    print(f"Validated {len(files)} file(s)")
+
+
+if __name__ == "__main__":
+    main()

leaderboard/DEPLOY.md

@@ -0,0 +1,54 @@
+# Deploying the Leaderboard on Hugging Face
+
+Hugging Face supports benchmark leaderboards in two practical ways.
+
+## Recommended: Static Space
+
+Use this for the current Real5-OmniDocBench README tables. It is simple, keeps the dataset card unchanged, and does not require backend dependencies.
+
+1. Create a new Hugging Face Space.
+2. Select **Static HTML** as the SDK, or keep the metadata in `leaderboard/README.md`:
+
+```yaml
+sdk: static
+app_file: index.html
+```
+
+3. Push the contents of the `leaderboard/` directory to the Space repository:
+
+```bash
+cd leaderboard
+git init
+git remote add origin git@hf.co:spaces/<org-or-user>/Real5-OmniDocBench-Leaderboard
+git add README.md index.html data scripts DEPLOY.md
+git commit -m "Add Real5-OmniDocBench leaderboard"
+git push -u origin main
+```
+
+4. When benchmark scores change in `/paddle/project/wild_omnidocbench/dataset_new/leaderboard_data.json`, regenerate the Space data:
+
+```bash
+python leaderboard/scripts/build_from_source_data.py
+```
+
+The dataset repository ignores `leaderboard/data/`. For a Space deployment, copy or generate `leaderboard/data/leaderboard_data.json` into the Space repository and push it there.
+
+## Hub Benchmark / Eval Results
+
+Hugging Face also has a Hub-level Evaluation Results feature. In that flow:
+
+1. The dataset repository is registered as a benchmark with an `eval.yaml` file.
+2. Each model repository publishes scores in `.eval_results/*.yaml`.
+3. Hugging Face aggregates the model results back onto the benchmark dataset page.
+
+This is better for decentralized community submissions, but it requires model repositories to publish result files and the benchmark feature is currently marked as work in progress / beta allow-listed in the official docs.
+
+For this benchmark, the current README already has complete published tables, so the Static Space is the lowest-friction path.
+
+The repository also includes `hf_eval_results/` with:
+
+- `eval.yaml.candidate` for the dataset-side benchmark registration.
+- `examples/model_eval_results.yaml` for model repositories.
+- scripts to generate and validate `.eval_results/*.yaml` files from the README-derived leaderboard data.
+
+Do not move `hf_eval_results/eval.yaml.candidate` to the dataset repository root as `eval.yaml` until Hugging Face confirms the benchmark allow-list and evaluation framework choice.

leaderboard/README.md

@@ -0,0 +1,32 @@
+---
+title: Real5-OmniDocBench Leaderboard
+colorFrom: indigo
+colorTo: green
+sdk: static
+pinned: false
+app_file: index.html
+datasets:
+- PaddlePaddle/Real5-OmniDocBench
+tags:
+- leaderboard
+- model-benchmarking
+- document-parsing
+- ocr
+---
+
+# Real5-OmniDocBench Leaderboard
+
+This Space renders Real5-OmniDocBench benchmark results as a searchable, sortable leaderboard.
+
+Update workflow:
+
+1. Keep the latest source data at `/paddle/project/wild_omnidocbench/dataset_new/leaderboard_data.json`.
+2. Run `python leaderboard/scripts/build_from_source_data.py`.
+3. Push the `leaderboard/` directory to a Hugging Face Space.
+
+The generated `leaderboard/data/` directory is ignored by the dataset repository. Include it only as a Space deployment artifact.
+
+Hugging Face supports leaderboard-style presentation in two relevant ways:
+
+- Community managed leaderboards live on Spaces and are appropriate for benchmark pages with custom tables and filters.
+- Evaluation Results are a Hub-level benchmark feature where a dataset repo defines `eval.yaml` and model repos publish `.eval_results/*.yaml`; this is currently marked as work in progress and beta allow-listed.

leaderboard/index.html

@@ -0,0 +1,740 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Real5-OmniDocBench Leaderboard</title>
+    <style>
+      :root {
+        color-scheme: light;
+        --bg: #f7f8fb;
+        --panel: #ffffff;
+        --panel-subtle: #f1f4f8;
+        --line: #d9e0e8;
+        --line-strong: #b8c2cc;
+        --text: #172033;
+        --muted: #647084;
+        --accent: #1d7a68;
+        --accent-strong: #145b50;
+        --accent-soft: #e0f3ee;
+        --blue: #245ca8;
+        --gold: #946200;
+        --danger: #a73b37;
+        --shadow: 0 10px 30px rgba(23, 32, 51, 0.08);
+      }
+
+      * {
+        box-sizing: border-box;
+      }
+
+      body {
+        margin: 0;
+        background: var(--bg);
+        color: var(--text);
+        font-family:
+          Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont,
+          "Segoe UI", sans-serif;
+        line-height: 1.5;
+      }
+
+      a {
+        color: var(--accent-strong);
+      }
+
+      .page {
+        max-width: 1440px;
+        margin: 0 auto;
+        padding: 24px;
+      }
+
+      .topbar {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 16px;
+        align-items: flex-end;
+        justify-content: space-between;
+        margin-bottom: 18px;
+      }
+
+      .title-block {
+        max-width: 820px;
+      }
+
+      h1 {
+        margin: 0 0 8px;
+        font-size: clamp(28px, 4vw, 44px);
+        line-height: 1.08;
+        letter-spacing: 0;
+      }
+
+      .subtitle {
+        margin: 0;
+        color: var(--muted);
+        font-size: 16px;
+      }
+
+      .links {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 8px;
+      }
+
+      .link-button {
+        display: inline-flex;
+        min-height: 36px;
+        align-items: center;
+        justify-content: center;
+        gap: 8px;
+        border: 1px solid var(--line);
+        border-radius: 8px;
+        background: var(--panel);
+        color: var(--text);
+        padding: 7px 12px;
+        text-decoration: none;
+        font-weight: 650;
+        font-size: 14px;
+      }
+
+      .summary {
+        display: grid;
+        grid-template-columns: repeat(4, minmax(0, 1fr));
+        gap: 12px;
+        margin-bottom: 18px;
+      }
+
+      .stat {
+        border: 1px solid var(--line);
+        border-radius: 8px;
+        background: var(--panel);
+        padding: 14px 16px;
+        box-shadow: var(--shadow);
+      }
+
+      .stat-label {
+        display: block;
+        color: var(--muted);
+        font-size: 13px;
+      }
+
+      .stat-value {
+        display: block;
+        margin-top: 4px;
+        font-size: 24px;
+        line-height: 1.1;
+        font-weight: 760;
+      }
+
+      .controls {
+        display: grid;
+        grid-template-columns: minmax(220px, 1.4fr) minmax(180px, 0.8fr) minmax(180px, 0.8fr);
+        gap: 12px;
+        align-items: end;
+        border: 1px solid var(--line);
+        border-radius: 8px;
+        background: var(--panel);
+        padding: 14px;
+        margin-bottom: 14px;
+        box-shadow: var(--shadow);
+      }
+
+      .field {
+        display: flex;
+        min-width: 0;
+        flex-direction: column;
+        gap: 6px;
+      }
+
+      label {
+        color: var(--muted);
+        font-size: 12px;
+        font-weight: 700;
+        text-transform: uppercase;
+      }
+
+      input,
+      select {
+        min-height: 40px;
+        width: 100%;
+        border: 1px solid var(--line-strong);
+        border-radius: 8px;
+        background: #fff;
+        color: var(--text);
+        padding: 8px 10px;
+        font: inherit;
+      }
+
+      input:focus,
+      select:focus {
+        outline: 2px solid var(--accent-soft);
+        border-color: var(--accent);
+      }
+
+      .tabs {
+        display: flex;
+        gap: 6px;
+        overflow-x: auto;
+        border-bottom: 1px solid var(--line);
+        margin-bottom: 0;
+      }
+
+      .tab {
+        flex: 0 0 auto;
+        border: 1px solid transparent;
+        border-bottom: 0;
+        border-radius: 8px 8px 0 0;
+        background: transparent;
+        color: var(--muted);
+        padding: 10px 14px;
+        font: inherit;
+        font-weight: 750;
+        cursor: pointer;
+      }
+
+      .tab.active {
+        background: var(--panel);
+        color: var(--accent-strong);
+        border-color: var(--line);
+      }
+
+      .table-panel {
+        border: 1px solid var(--line);
+        border-top: 0;
+        border-radius: 0 0 8px 8px;
+        background: var(--panel);
+        box-shadow: var(--shadow);
+        overflow: hidden;
+      }
+
+      .table-meta {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 10px;
+        justify-content: space-between;
+        align-items: center;
+        padding: 12px 14px;
+        border-bottom: 1px solid var(--line);
+        background: var(--panel-subtle);
+      }
+
+      .meta-text {
+        color: var(--muted);
+        font-size: 14px;
+      }
+
+      .hint {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 6px;
+      }
+
+      .chip {
+        display: inline-flex;
+        align-items: center;
+        min-height: 24px;
+        border-radius: 999px;
+        background: var(--accent-soft);
+        color: var(--accent-strong);
+        padding: 2px 8px;
+        font-size: 12px;
+        font-weight: 760;
+      }
+
+      .table-wrap {
+        overflow: auto;
+        max-height: 72vh;
+      }
+
+      table {
+        width: 100%;
+        min-width: 980px;
+        border-collapse: separate;
+        border-spacing: 0;
+      }
+
+      th,
+      td {
+        border-bottom: 1px solid var(--line);
+        padding: 10px 12px;
+        text-align: right;
+        white-space: nowrap;
+        font-variant-numeric: tabular-nums;
+      }
+
+      th {
+        position: sticky;
+        top: 0;
+        z-index: 2;
+        background: #eef3f7;
+        color: #334054;
+        font-size: 12px;
+        text-transform: uppercase;
+        cursor: pointer;
+        user-select: none;
+      }
+
+      th:first-child,
+      td:first-child {
+        position: sticky;
+        left: 0;
+        z-index: 1;
+        background: inherit;
+      }
+
+      th:first-child {
+        z-index: 3;
+        background: #eef3f7;
+      }
+
+      td {
+        background: var(--panel);
+      }
+
+      tr:nth-child(even) td {
+        background: #fbfcfd;
+      }
+
+      th.text,
+      td.text {
+        text-align: left;
+      }
+
+      .rank {
+        color: var(--muted);
+        font-weight: 750;
+      }
+
+      .method {
+        font-weight: 760;
+      }
+
+      .best {
+        color: var(--accent-strong);
+        font-weight: 820;
+      }
+
+      .second {
+        color: var(--gold);
+        font-weight: 780;
+      }
+
+      .model-type {
+        display: inline-flex;
+        align-items: center;
+        border-radius: 6px;
+        background: #e9edf5;
+        color: #34415a;
+        padding: 2px 7px;
+        font-size: 12px;
+        font-weight: 760;
+      }
+
+      .empty {
+        padding: 32px;
+        color: var(--muted);
+        text-align: center;
+      }
+
+      .footer {
+        margin: 18px 0 0;
+        color: var(--muted);
+        font-size: 13px;
+      }
+
+      .error {
+        border: 1px solid #efb8b2;
+        border-radius: 8px;
+        background: #fff4f2;
+        color: var(--danger);
+        padding: 16px;
+        font-weight: 650;
+      }
+
+      @media (max-width: 900px) {
+        .page {
+          padding: 18px;
+        }
+
+        .summary {
+          grid-template-columns: repeat(2, minmax(0, 1fr));
+        }
+
+        .controls {
+          grid-template-columns: 1fr;
+        }
+      }
+
+      @media (max-width: 560px) {
+        .page {
+          padding: 14px;
+        }
+
+        .summary {
+          grid-template-columns: 1fr;
+        }
+
+        .link-button {
+          width: 100%;
+        }
+      }
+    </style>
+  </head>
+  <body>
+    <main class="page">
+      <div class="topbar">
+        <div class="title-block">
+          <h1>Real5-OmniDocBench Leaderboard</h1>
+          <p class="subtitle">
+            Searchable benchmark results for real-world document parsing across Scanning,
+            Warping, Screen-Photography, Illumination, and Skew scenarios.
+          </p>
+        </div>
+        <nav class="links" aria-label="Resources">
+          <a class="link-button" href="https://huggingface.co/datasets/PaddlePaddle/Real5-OmniDocBench">Dataset</a>
+          <a class="link-button" href="https://arxiv.org/abs/2603.04205">Paper</a>
+          <a class="link-button" href="https://github.com/opendatalab/OmniDocBench">Eval Protocol</a>
+        </nav>
+      </div>
+
+      <section class="summary" aria-label="Summary">
+        <div class="stat">
+          <span class="stat-label">Best Overall</span>
+          <span class="stat-value" id="best-overall">-</span>
+        </div>
+        <div class="stat">
+          <span class="stat-label">Best Method</span>
+          <span class="stat-value" id="best-method">-</span>
+        </div>
+        <div class="stat">
+          <span class="stat-label">Methods</span>
+          <span class="stat-value" id="method-count">-</span>
+        </div>
+        <div class="stat">
+          <span class="stat-label">Tables</span>
+          <span class="stat-value" id="table-count">-</span>
+        </div>
+      </section>
+
+      <section class="controls" aria-label="Filters">
+        <div class="field">
+          <label for="search">Search</label>
+          <input id="search" type="search" placeholder="Filter by method, type, or parameter size" />
+        </div>
+        <div class="field">
+          <label for="model-type">Model Type</label>
+          <select id="model-type">
+            <option value="">All model types</option>
+          </select>
+        </div>
+        <div class="field">
+          <label for="sort-by">Sort By</label>
+          <select id="sort-by"></select>
+        </div>
+      </section>
+
+      <section>
+        <div class="tabs" id="tabs" role="tablist" aria-label="Benchmark tables"></div>
+        <div class="table-panel">
+          <div class="table-meta">
+            <div class="meta-text" id="table-title"></div>
+            <div class="hint">
+              <span class="chip">Click headers to sort</span>
+          <span class="chip">higher is better</span>
+          <span class="chip">lower is better</span>
+            </div>
+          </div>
+          <div class="table-wrap" id="table-wrap"></div>
+        </div>
+      </section>
+
+      <p class="footer">
+        Data is built from the external leaderboard source JSON.
+        To update this Space data locally, run <code>python leaderboard/scripts/build_from_source_data.py</code>.
+      </p>
+    </main>
+
+    <script>
+      const STATE = {
+        data: null,
+        activeTable: "Overall",
+        query: "",
+        modelType: "",
+        sortKey: "overall",
+        sortDirection: "desc",
+      };
+
+      const TEXT_COLUMNS = new Set(["model_type", "method", "parameters"]);
+      const CORE_COLUMNS = ["rank", "model_type", "method", "parameters"];
+      const LABELS = {
+        model_type: "Model Type",
+        method: "Methods",
+        parameters: "Parameters",
+        overall: "Overall",
+        scanning: "Scanning",
+        warping: "Warping",
+        screen_photography: "Screen-Photography",
+        illumination: "Illumination",
+        skew: "Skew",
+        text_edit: "TextEdit",
+        formula_cdm: "FormulaCDM",
+        table_teds: "TableTEDS",
+        reading_order_edit: "Reading OrderEdit",
+      };
+
+      const $ = (id) => document.getElementById(id);
+
+      function formatValue(value) {
+        if (typeof value === "number") {
+          return value < 1 ? value.toFixed(3) : value.toFixed(2);
+        }
+        return value ?? "";
+      }
+
+      function metricDirection(key) {
+        return STATE.data?.metrics?.[key]?.direction || "higher";
+      }
+
+      function defaultSortDirection(key) {
+        return metricDirection(key) === "lower" ? "asc" : "desc";
+      }
+
+      function currentTable() {
+        return STATE.data.tables.find((table) => table.name === STATE.activeTable);
+      }
+
+      function numericColumns(table) {
+        return table.headers.filter((key) => !TEXT_COLUMNS.has(key));
+      }
+
+      function buildSummary() {
+        const overall = STATE.data.tables.find((table) => table.name === "Overall");
+        const rows = overall.rows.slice().sort((a, b) => Number(b.overall) - Number(a.overall));
+        const best = rows[0];
+        $("best-overall").textContent = formatValue(best.overall);
+        $("best-method").textContent = best.method;
+        $("method-count").textContent = String(overall.rows.length);
+        $("table-count").textContent = String(STATE.data.tables.length);
+      }
+
+      function buildTabs() {
+        const tabs = $("tabs");
+        tabs.innerHTML = "";
+        STATE.data.tables.forEach((table) => {
+          const button = document.createElement("button");
+          button.className = `tab${table.name === STATE.activeTable ? " active" : ""}`;
+          button.type = "button";
+          button.role = "tab";
+          button.textContent = table.name;
+          button.setAttribute("aria-selected", table.name === STATE.activeTable ? "true" : "false");
+          button.addEventListener("click", () => {
+            STATE.activeTable = table.name;
+            const defaultKey = table.headers.includes("overall") ? "overall" : numericColumns(table)[0];
+            STATE.sortKey = defaultKey;
+            STATE.sortDirection = defaultSortDirection(defaultKey);
+            buildTabs();
+            buildSortOptions();
+            render();
+          });
+          tabs.appendChild(button);
+        });
+      }
+
+      function buildFilters() {
+        const allTypes = new Set();
+        STATE.data.tables.forEach((table) => {
+          table.rows.forEach((row) => allTypes.add(row.model_type));
+        });
+
+        const select = $("model-type");
+        [...allTypes].sort().forEach((type) => {
+          const option = document.createElement("option");
+          option.value = type;
+          option.textContent = type;
+          select.appendChild(option);
+        });
+      }
+
+      function buildSortOptions() {
+        const table = currentTable();
+        const select = $("sort-by");
+        select.innerHTML = "";
+        table.headers.forEach((key) => {
+          const option = document.createElement("option");
+          option.value = key;
+          option.textContent = LABELS[key] || key;
+          select.appendChild(option);
+        });
+        select.value = STATE.sortKey;
+      }
+
+      function sortRows(rows) {
+        const key = STATE.sortKey;
+        const direction = STATE.sortDirection === "asc" ? 1 : -1;
+        return rows.slice().sort((a, b) => {
+          const left = a[key];
+          const right = b[key];
+          if (typeof left === "number" && typeof right === "number") {
+            return (left - right) * direction;
+          }
+          return String(left).localeCompare(String(right)) * direction;
+        });
+      }
+
+      function filterRows(rows) {
+        const query = STATE.query.trim().toLowerCase();
+        return rows.filter((row) => {
+          if (STATE.modelType && row.model_type !== STATE.modelType) {
+            return false;
+          }
+          if (!query) {
+            return true;
+          }
+          return [row.model_type, row.method, row.parameters].some((value) =>
+            String(value).toLowerCase().includes(query),
+          );
+        });
+      }
+
+      function bestValues(rows, headers) {
+        const values = {};
+        headers.forEach((key) => {
+          if (TEXT_COLUMNS.has(key)) {
+            return;
+          }
+          const nums = rows.map((row) => row[key]).filter((value) => typeof value === "number");
+          const unique = [...new Set(nums)].sort((a, b) =>
+            metricDirection(key) === "lower" ? a - b : b - a,
+          );
+          values[key] = {
+            best: unique[0],
+            second: unique[1],
+          };
+        });
+        return values;
+      }
+
+      function cellClass(row, key, values) {
+        if (key === "method") {
+          return "text method";
+        }
+        if (TEXT_COLUMNS.has(key)) {
+          return "text";
+        }
+        const cls = [];
+        if (row[key] === values[key]?.best) {
+          cls.push("best");
+        } else if (row[key] === values[key]?.second) {
+          cls.push("second");
+        }
+        return cls.join(" ");
+      }
+
+      function headerLabel(key) {
+        if (key === STATE.sortKey) {
+          return `${LABELS[key] || key} ${STATE.sortDirection === "asc" ? "asc" : "desc"}`;
+        }
+        const direction = metricDirection(key);
+        if (!TEXT_COLUMNS.has(key)) {
+          return `${LABELS[key] || key} (${direction === "lower" ? "lower" : "higher"})`;
+        }
+        return LABELS[key] || key;
+      }
+
+      function render() {
+        const table = currentTable();
+        const filtered = filterRows(table.rows);
+        const rows = sortRows(filtered);
+        const values = bestValues(table.rows, table.headers);
+        $("table-title").textContent = `${table.name}: ${rows.length} of ${table.rows.length} methods shown`;
+
+        const wrap = $("table-wrap");
+        if (!rows.length) {
+          wrap.innerHTML = '<div class="empty">No matching results.</div>';
+          return;
+        }
+
+        const columns = ["rank", ...table.headers];
+        const html = [
+          "<table>",
+          "<thead><tr>",
+          ...columns.map((key) => {
+            const cls = key === "rank" || TEXT_COLUMNS.has(key) ? ' class="text"' : "";
+            const label = key === "rank" ? "Rank" : headerLabel(key);
+            return `<th${cls} data-key="${key}">${label}</th>`;
+          }),
+          "</tr></thead><tbody>",
+          ...rows.map((row, index) => {
+            const rank = `<td class="text rank">${index + 1}</td>`;
+            const cells = table.headers
+              .map((key) => {
+                if (key === "model_type") {
+                  return `<td class="text"><span class="model-type">${row[key]}</span></td>`;
+                }
+                const cls = cellClass(row, key, values);
+                const classAttr = cls ? ` class="${cls}"` : "";
+                return `<td${classAttr}>${formatValue(row[key])}</td>`;
+              })
+              .join("");
+            return `<tr>${rank}${cells}</tr>`;
+          }),
+          "</tbody></table>",
+        ].join("");
+        wrap.innerHTML = html;
+
+        wrap.querySelectorAll("th[data-key]").forEach((th) => {
+          th.addEventListener("click", () => {
+            const key = th.dataset.key;
+            if (key === "rank") {
+              return;
+            }
+            if (STATE.sortKey === key) {
+              STATE.sortDirection = STATE.sortDirection === "asc" ? "desc" : "asc";
+            } else {
+              STATE.sortKey = key;
+              STATE.sortDirection = defaultSortDirection(key);
+              $("sort-by").value = key;
+            }
+            render();
+          });
+        });
+      }
+
+      async function init() {
+        try {
+          const response = await fetch("data/leaderboard_data.json", { cache: "no-store" });
+          if (!response.ok) {
+            throw new Error(`Failed to load data/leaderboard_data.json: ${response.status}`);
+          }
+          STATE.data = await response.json();
+          STATE.activeTable = "Overall";
+          STATE.sortKey = "overall";
+          STATE.sortDirection = defaultSortDirection("overall");
+
+          buildSummary();
+          buildTabs();
+          buildFilters();
+          buildSortOptions();
+          render();
+
+          $("search").addEventListener("input", (event) => {
+            STATE.query = event.target.value;
+            render();
+          });
+          $("model-type").addEventListener("change", (event) => {
+            STATE.modelType = event.target.value;
+            render();
+          });
+          $("sort-by").addEventListener("change", (event) => {
+            STATE.sortKey = event.target.value;
+            STATE.sortDirection = defaultSortDirection(STATE.sortKey);
+            render();
+          });
+        } catch (error) {
+          document.querySelector(".page").innerHTML =
+            `<div class="error">${error.message}</div>`;
+        }
+      }
+
+      init();
+    </script>
+  </body>
+</html>

leaderboard/scripts/build_from_source_data.py

@@ -0,0 +1,184 @@
+#!/usr/bin/env python3
+"""Build Space leaderboard data from the external source JSON."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+
+DEFAULT_SOURCE = Path("/paddle/project/wild_omnidocbench/dataset_new/leaderboard_data.json")
+DEFAULT_OUT_DIR = Path(__file__).resolve().parents[1] / "data"
+
+TABLE_ORDER = [
+    ("overall", "Overall"),
+    ("scanning", "Scanning"),
+    ("warping", "Warping"),
+    ("screen-photography", "Screen-Photography"),
+    ("illumination", "Illumination"),
+    ("skew", "Skew"),
+]
+
+SCENARIO_KEY_MAP = {
+    "screen-photography": "screen_photography",
+}
+
+MODEL_TYPE_LABELS = {
+    "pipeline": "Pipeline Tools",
+    "general": "General VLMs",
+    "specialized": "Specialized VLMs",
+}
+
+METRIC_DIRECTIONS = {
+    "overall": "higher",
+    "scanning": "higher",
+    "warping": "higher",
+    "screen_photography": "higher",
+    "illumination": "higher",
+    "skew": "higher",
+    "text": "higher",
+    "formula": "higher",
+    "table": "higher",
+    "read_order": "higher",
+}
+
+METRIC_LABELS = {
+    "overall": "Overall",
+    "scanning": "Scanning",
+    "warping": "Warping",
+    "screen_photography": "Screen-Photography",
+    "illumination": "Illumination",
+    "skew": "Skew",
+    "text": "Text",
+    "formula": "Formula",
+    "table": "Table",
+    "read_order": "ReadOrder",
+}
+
+
+def normalize_key(key: str) -> str:
+    key = SCENARIO_KEY_MAP.get(key, key)
+    return key.replace("-", "_")
+
+
+def model_type_label(value: object) -> str:
+    text = str(value or "-").strip()
+    return MODEL_TYPE_LABELS.get(text.lower(), text)
+
+
+def normalize_overall_row(row: dict[str, object]) -> dict[str, object]:
+    return {
+        "model_type": model_type_label(row.get("type")),
+        "method": row.get("model", ""),
+        "parameters": row.get("params", "-"),
+        "overall": row.get("overall", ""),
+        "scanning": row.get("scanning", ""),
+        "warping": row.get("warping", ""),
+        "screen_photography": row.get("screen-photography", ""),
+        "illumination": row.get("illumination", ""),
+        "skew": row.get("skew", ""),
+    }
+
+
+def normalize_scenario_row(
+    row: dict[str, object],
+    overall_lookup: dict[str, dict[str, object]],
+) -> dict[str, object]:
+    method = str(row.get("model", ""))
+    metadata = overall_lookup.get(method, {})
+    return {
+        "model_type": model_type_label(metadata.get("type")),
+        "method": method,
+        "parameters": metadata.get("params", "-"),
+        "overall": row.get("overall", ""),
+        "text": row.get("Text", ""),
+        "formula": row.get("Formula", ""),
+        "table": row.get("Table", ""),
+        "read_order": row.get("ReadOrder", ""),
+    }
+
+
+def build_payload(source: dict[str, object]) -> dict[str, object]:
+    overall_rows = source.get("overall")
+    if not isinstance(overall_rows, list):
+        raise ValueError("Source JSON must contain an 'overall' list")
+    overall_lookup = {str(row.get("model", "")): row for row in overall_rows if isinstance(row, dict)}
+
+    tables: list[dict[str, object]] = []
+    for source_key, title in TABLE_ORDER:
+        rows = source.get(source_key)
+        if not isinstance(rows, list):
+            raise ValueError(f"Source JSON must contain a {source_key!r} list")
+
+        if source_key == "overall":
+            headers = [
+                "model_type",
+                "method",
+                "parameters",
+                "overall",
+                "scanning",
+                "warping",
+                "screen_photography",
+                "illumination",
+                "skew",
+            ]
+            normalized_rows = [normalize_overall_row(row) for row in rows if isinstance(row, dict)]
+        else:
+            headers = [
+                "model_type",
+                "method",
+                "parameters",
+                "overall",
+                "text",
+                "formula",
+                "table",
+                "read_order",
+            ]
+            normalized_rows = [
+                normalize_scenario_row(row, overall_lookup) for row in rows if isinstance(row, dict)
+            ]
+
+        tables.append(
+            {
+                "name": title,
+                "slug": normalize_key(source_key),
+                "headers": headers,
+                "rows": normalized_rows,
+            }
+        )
+
+    return {
+        "benchmark": "Real5-OmniDocBench",
+        "source": str(DEFAULT_SOURCE),
+        "tables": tables,
+        "metrics": {
+            key: {"label": METRIC_LABELS[key], "direction": direction}
+            for key, direction in METRIC_DIRECTIONS.items()
+        },
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--source", type=Path, default=DEFAULT_SOURCE)
+    parser.add_argument("--out-dir", type=Path, default=DEFAULT_OUT_DIR)
+    args = parser.parse_args()
+
+    source = json.loads(args.source.read_text(encoding="utf-8"))
+    payload = build_payload(source)
+
+    args.out_dir.mkdir(parents=True, exist_ok=True)
+    out_file = args.out_dir / "leaderboard_data.json"
+    out_file.write_text(
+        json.dumps(payload, ensure_ascii=False, indent=2) + "\n",
+        encoding="utf-8",
+    )
+
+    tables = payload["tables"]
+    total_rows = sum(len(table["rows"]) for table in tables if isinstance(table, dict))
+    print(f"Wrote {len(tables)} tables and {total_rows} rows to {out_file}")
+
+
+if __name__ == "__main__":
+    main()