CLAUDE.md

# OCR Scripts - Development Notes

## Active Scripts

### DeepSeek-OCR v1 (`deepseek-ocr-vllm.py`)
✅ **Production Ready** (Fixed 2026-02-12)
- Uses official vLLM offline pattern: `llm.generate()` with PIL images
- `NGramPerReqLogitsProcessor` prevents repetition on complex documents
- Resolution modes removed (handled by vLLM's multimodal processor)
- See: https://docs.vllm.ai/projects/recipes/en/latest/DeepSeek/DeepSeek-OCR.html

**Known issue (vLLM nightly, 2026-02-12):** Some images trigger a crop dimension validation error:
```
ValueError: images_crop dim[2] expected 1024, got 640. Expected shape: ('bnp', 3, 1024, 1024), but got torch.Size([0, 3, 640, 640])
```
This is a vLLM bug: the preprocessor defaults to gundam mode (image_size=640), but the tensor validator expects 1024x1024 even when the crop batch is empty (dim 0). Hit 2/10 on `davanstrien/ufo-ColPali`, 0/10 on NLS Medical History. Likely depends on image aspect ratios. No upstream issue filed yet. Related feature request: [vllm#28160](https://github.com/vllm-project/vllm/issues/28160) (no way to control resolution mode via mm-processor-kwargs).

### LightOnOCR-2-1B (`lighton-ocr2.py`)
✅ **Production Ready** (Fixed 2026-01-29)

**Status:** Working with vLLM nightly

**What was fixed:**
- Root cause was NOT vLLM - it was the deprecated `HF_HUB_ENABLE_HF_TRANSFER=1` env var
- The script was setting this env var but `hf_transfer` package no longer exists
- This caused download failures that manifested as "Can't load image processor" errors
- Fix: Removed the `HF_HUB_ENABLE_HF_TRANSFER=1` setting from the script

**Test results (2026-01-29):**
- 10/10 samples processed successfully
- Clean markdown output with proper headers and paragraphs
- Output dataset: `davanstrien/lighton-ocr2-test-v4`

**Example usage:**
```bash
hf jobs uv run --flavor a100-large \
    -s HF_TOKEN \
    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lighton-ocr2.py \
    davanstrien/ufo-ColPali output-dataset \
    --max-samples 10 --shuffle --seed 42
```

**Model Info:**
- Model: `lightonai/LightOnOCR-2-1B`
- Architecture: Pixtral ViT encoder + Qwen3 LLM
- Training: RLVR (Reinforcement Learning with Verifiable Rewards)
- Performance: 83.2% on OlmOCR-Bench, 42.8 pages/sec on H100

### PaddleOCR-VL-1.5 (`paddleocr-vl-1.5.py`)
✅ **Production Ready** (Added 2026-01-30)

**Status:** Working with transformers

**Note:** Uses transformers backend (not vLLM) because PaddleOCR-VL only supports vLLM in server mode, which doesn't fit the single-command UV script pattern. Images are processed one at a time for stability.

**Test results (2026-01-30):**
- 10/10 samples processed successfully
- Processing time: ~50s per image on L4 GPU
- Output dataset: `davanstrien/paddleocr-vl15-final-test`

**Example usage:**
```bash
hf jobs uv run --flavor l4x1 \
    -s HF_TOKEN \
    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/paddleocr-vl-1.5.py \
    davanstrien/ufo-ColPali output-dataset \
    --max-samples 10 --shuffle --seed 42
```

**Task modes:**
- `ocr` (default): General text extraction to markdown
- `table`: Table extraction to HTML format
- `formula`: Mathematical formula recognition to LaTeX
- `chart`: Chart and diagram analysis
- `spotting`: Text spotting with localization (uses higher resolution)
- `seal`: Seal and stamp recognition

**Model Info:**
- Model: `PaddlePaddle/PaddleOCR-VL-1.5`
- Size: 0.9B parameters (ultra-compact)
- Performance: 94.5% SOTA on OmniDocBench v1.5
- Backend: Transformers (single image processing)
- Requires: `transformers>=5.0.0`

### DoTS.ocr-1.5 (`dots-ocr-1.5.py`)
✅ **Production Ready** (Fixed 2026-03-14)

**Status:** Working with vLLM 0.17.1 stable

**Model availability:** The v1.5 model is NOT on HF from the original authors. We mirrored it from ModelScope to `davanstrien/dots.ocr-1.5`. Original: https://modelscope.cn/models/rednote-hilab/dots.ocr-1.5. License: MIT-based (with supplementary terms for responsible use).

**Key fix (2026-03-14):** Must pass `chat_template_content_format="string"` to `llm.chat()`. The model's `tokenizer_config.json` chat template expects string content (not openai-format lists). Without this, the model generates empty output (~1 token then EOS). The separate `chat_template.json` file handles multimodal content but vLLM uses the tokenizer_config template by default.

**Bbox coordinate system (layout modes):**
Bounding boxes from `layout-all` and `layout-only` modes are in the **resized image coordinate space**, not original image coordinates. The model uses `Qwen2VLImageProcessor` which resizes images via `smart_resize()`:
- `max_pixels=11,289,600`, `factor=28` (patch_size=14 × merge_size=2)
- Images are scaled down so `w×h ≤ max_pixels`, dims rounded to multiples of 28
- To map bboxes back to original image coordinates:
```python
import math

def smart_resize(height, width, factor=28, min_pixels=3136, max_pixels=11289600):
    h_bar = max(factor, round(height / factor) * factor)
    w_bar = max(factor, round(width / factor) * factor)
    if h_bar * w_bar > max_pixels:
        beta = math.sqrt((height * width) / max_pixels)
        h_bar = math.floor(height / beta / factor) * factor
        w_bar = math.floor(width / beta / factor) * factor
    elif h_bar * w_bar < min_pixels:
        beta = math.sqrt(min_pixels / (height * width))
        h_bar = math.ceil(height * beta / factor) * factor
        w_bar = math.ceil(width * beta / factor) * factor
    return h_bar, w_bar

resized_h, resized_w = smart_resize(orig_h, orig_w)
scale_x = orig_w / resized_w
scale_y = orig_h / resized_h
# Then: orig_x = bbox_x * scale_x, orig_y = bbox_y * scale_y
```

**Test results (2026-03-14):**
- 3/3 samples on L4: OCR mode working, ~147 toks/s output
- 3/3 samples on L4: layout-all mode working, structured JSON with bboxes
- 10/10 samples on A100: layout-only mode on NLS Highland News, ~670 toks/s output
- Output datasets: `davanstrien/dots-ocr-1.5-smoke-test-v3`, `davanstrien/dots-ocr-1.5-layout-test`, `davanstrien/dots-ocr-1.5-nls-layout-test`

**Prompt modes:**
- `ocr` — text extraction (default)
- `layout-all` — layout + bboxes + categories + text (JSON)
- `layout-only` — layout + bboxes + categories only (JSON)
- `web-parsing` — webpage layout analysis (JSON) [new in v1.5]
- `scene-spotting` — scene text detection [new in v1.5]
- `grounding-ocr` — text from bounding box region [new in v1.5]
- `general` — free-form (use with `--custom-prompt`) [new in v1.5]

**Example usage:**
```bash
hf jobs uv run --flavor l4x1 \
    -s HF_TOKEN \
    /path/to/dots-ocr-1.5.py \
    davanstrien/ufo-ColPali output-dataset \
    --model davanstrien/dots.ocr-1.5 \
    --max-samples 10 --shuffle --seed 42
```

**Model Info:**
- Original: `rednote-hilab/dots.ocr-1.5` (ModelScope only)
- Mirror: `davanstrien/dots.ocr-1.5` (HF)
- Parameters: 3B (1.2B vision encoder + 1.7B language model)
- Architecture: DotsOCRForCausalLM (custom code, trust_remote_code required)
- Precision: BF16
- GitHub: https://github.com/rednote-hilab/dots.ocr

---

## Pending Development

### DeepSeek-OCR-2 (`deepseek-ocr2-vllm.py`)
✅ **Production Ready** (2026-02-12)

**Status:** Working with vLLM nightly (requires nightly for `DeepseekOCR2ForCausalLM` support, not yet in stable 0.15.1)

**What was done:**
- Rewrote the broken draft script (which used base64/llm.chat/resolution modes)
- Uses the same proven pattern as v1: `llm.generate()` with PIL images + `NGramPerReqLogitsProcessor`
- Key v2 addition: `limit_mm_per_prompt={"image": 1}` in LLM init
- Added `addict` and `matplotlib` as dependencies (required by model's HF custom code)

**Test results (2026-02-12):**
- 10/10 samples processed successfully on L4 GPU
- Processing time: 6.4 min (includes model download + warmup)
- Model: 6.33 GiB, ~475 toks/s input, ~246 toks/s output
- Output dataset: `davanstrien/deepseek-ocr2-nls-test`

**Example usage:**
```bash
hf jobs uv run --flavor l4x1 \
    -s HF_TOKEN \
    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/deepseek-ocr2-vllm.py \
    NationalLibraryOfScotland/medical-history-of-british-india output-dataset \
    --max-samples 10 --shuffle --seed 42
```

**Important notes:**
- Requires vLLM **nightly** (stable 0.15.1 does NOT include DeepSeek-OCR-2 support)
- The nightly index (`https://wheels.vllm.ai/nightly`) occasionally has transient build issues (e.g., only ARM wheels). If this happens, wait and retry.
- Uses same API pattern as v1: `NGramPerReqLogitsProcessor`, `SamplingParams(temperature=0, skip_special_tokens=False)`, `extra_args` for ngram settings

**Model Information:**
- Model ID: `deepseek-ai/DeepSeek-OCR-2`
- Model Card: https://huggingface.co/deepseek-ai/DeepSeek-OCR-2
- GitHub: https://github.com/deepseek-ai/DeepSeek-OCR-2
- Parameters: 3B
- Architecture: Visual Causal Flow
- Resolution: (0-6)x768x768 + 1x1024x1024 patches

## Other OCR Scripts

### Nanonets OCR (`nanonets-ocr.py`, `nanonets-ocr2.py`)
✅ Both versions working

### PaddleOCR-VL (`paddleocr-vl.py`)
✅ Working

---

## Future: OCR Smoke Test Dataset

**Status:** Idea (noted 2026-02-12)

Build a small curated dataset (`uv-scripts/ocr-smoke-test`?) with ~2-5 samples from diverse sources. Purpose: fast CI-style verification that scripts still work after dep updates, without downloading full datasets.

**Design goals:**
- Tiny (~20-30 images total) so download is seconds not minutes
- Covers the axes that break things: document type, image quality, language, layout complexity
- Has ground truth text where possible for quality regression checks
- All permissively licensed (CC0/CC-BY preferred)

**Candidate sources:**

| Source | What it covers | Why |
|--------|---------------|-----|
| `NationalLibraryOfScotland/medical-history-of-british-india` | Historical English, degraded scans | Has hand-corrected `text` column for comparison. CC0. Already tested with GLM-OCR. |
| `davanstrien/ufo-ColPali` | Mixed modern documents | Already used as our go-to test set. Varied layouts. |
| Something with **tables** | Structured data extraction | Tests `--task table` modes. Maybe a financial report or census page. |
| Something with **formulas/LaTeX** | Math notation | Tests `--task formula`. arXiv pages or textbook scans. |
| Something **multilingual** (CJK, Arabic, etc.) | Non-Latin scripts | GLM-OCR claims zh/ja/ko support. Good to verify. |
| Something **handwritten** | Handwriting recognition | Edge case that reveals model limits. |

**How it would work:**
```bash
# Quick smoke test for any script
uv run glm-ocr.py uv-scripts/ocr-smoke-test smoke-out --max-samples 5
# Or a dedicated test runner that checks all scripts against it
```

**Open questions:**
- Build as a proper HF dataset, or just a folder of images in the repo?
- Should we include expected output for regression testing (fragile if models change)?
- Could we add a `--smoke-test` flag to each script that auto-uses this dataset?
- Worth adding to HF Jobs scheduled runs for ongoing monitoring?

---

## OCR Benchmark Coordinator (`ocr-bench-run.py`)

**Status:** Working end-to-end (2026-02-14)

Launches N OCR models on the same dataset via `run_uv_job()`, each pushing to a shared repo as a separate config via `--config/--create-pr`. Eval done separately with `ocr-elo-bench.py`.

### Model Registry (4 models)

| Slug | Model ID | Size | Default GPU | Notes |
|------|----------|------|-------------|-------|
| `glm-ocr` | `zai-org/GLM-OCR` | 0.9B | l4x1 | |
| `deepseek-ocr` | `deepseek-ai/DeepSeek-OCR` | 4B | l4x1 | Auto-passes `--prompt-mode free` (no grounding tags) |
| `lighton-ocr-2` | `lightonai/LightOnOCR-2-1B` | 1B | a100-large | |
| `dots-ocr` | `rednote-hilab/dots.ocr` | 1.7B | l4x1 | Stable vLLM (>=0.9.1) |

Each model entry has a `default_args` list for model-specific flags (e.g., DeepSeek uses `["--prompt-mode", "free"]`).

### Workflow
```bash
# Launch all 4 models on same data
uv run ocr-bench-run.py source-dataset --output my-bench --max-samples 50

# Evaluate directly from PRs (no merge needed)
uv run ocr-elo-bench.py my-bench --from-prs --mode both

# Or merge + evaluate
uv run ocr-elo-bench.py my-bench --from-prs --merge-prs --mode both

# Other useful flags
uv run ocr-bench-run.py --list-models          # Show registry table
uv run ocr-bench-run.py ... --dry-run           # Preview without launching
uv run ocr-bench-run.py ... --wait              # Poll until complete
uv run ocr-bench-run.py ... --models glm-ocr dots-ocr  # Subset of models
```

### Eval script features (`ocr-elo-bench.py`)
- `--from-prs`: Auto-discovers open PRs on the dataset repo, extracts config names from PR title `[config-name]` suffix, loads data from `refs/pr/N` without merging
- `--merge-prs`: Auto-merges discovered PRs via `api.merge_pull_request()` before loading
- `--configs`: Manually specify which configs to load (for merged repos)
- `--mode both`: Runs pairwise ELO + pointwise scoring
- Flat mode (original behavior) still works when `--configs`/`--from-prs` not used

### Scripts pushed to Hub
All 4 scripts have been pushed to `uv-scripts/ocr` on the Hub with `--config`/`--create-pr` support:
- `glm-ocr.py` ✅
- `deepseek-ocr-vllm.py` ✅
- `lighton-ocr2.py` ✅
- `dots-ocr.py` ✅

### Benchmark Results

#### Run 1: NLS Medical History (2026-02-14) — Pilot

**Dataset:** `NationalLibraryOfScotland/medical-history-of-british-india` (10 samples, shuffled, seed 42)
**Output repo:** `davanstrien/ocr-bench-test` (4 open PRs)
**Judge:** `Qwen/Qwen2.5-VL-72B-Instruct` via HF Inference Providers
**Content:** Historical English, degraded scans of medical texts

**ELO (pairwise, 5 samples evaluated):**
1. DoTS.ocr — 1540 (67% win rate)
2. DeepSeek-OCR — 1539 (57%)
3. LightOnOCR-2 — 1486 (50%)
4. GLM-OCR — 1436 (29%)

**Pointwise (5 samples):**
1. DeepSeek-OCR — 5.0/5.0
2. GLM-OCR — 4.6
3. LightOnOCR-2 — 4.4
4. DoTS.ocr — 4.2

**Key finding:** DeepSeek-OCR's `--prompt-mode document` produces grounding tags (`<|ref|>`, `<|det|>`) that the judge penalizes heavily. Switching to `--prompt-mode free` (now the default in the registry) made it jump from last place to top 2.

**Caveat:** 5 samples is far too few for stable rankings. The judge VLM is called once per comparison (pairwise) or once per model-sample (pointwise) via HF Inference Providers API.

#### Run 2: Rubenstein Manuscript Catalog (2026-02-15) — First Full Benchmark

**Dataset:** `biglam/rubenstein-manuscript-catalog` (50 samples, shuffled, seed 42)
**Output repo:** `davanstrien/ocr-bench-rubenstein` (4 PRs)
**Judge:** Jury of 2 via `ocr-vllm-judge.py` — `Qwen/Qwen2.5-VL-7B-Instruct` + `Qwen/Qwen3-VL-8B-Instruct` on A100
**Content:** ~48K typewritten + handwritten manuscript catalog cards from Duke University (CC0)

**ELO (pairwise, 50 samples, 300 comparisons, 0 parse failures):**

| Rank | Model | ELO | W | L | T | Win% |
|------|-------|-----|---|---|---|------|
| 1 | LightOnOCR-2-1B | 1595 | 100 | 50 | 0 | 67% |
| 2 | DeepSeek-OCR | 1497 | 73 | 77 | 0 | 49% |
| 3 | GLM-OCR | 1471 | 57 | 93 | 0 | 38% |
| 4 | dots.ocr | 1437 | 70 | 80 | 0 | 47% |

**OCR job times** (all 50 samples each):
- dots-ocr: 5.3 min (L4)
- deepseek-ocr: 5.6 min (L4)
- glm-ocr: 5.7 min (L4)
- lighton-ocr-2: 6.4 min (A100)

**Key findings:**
- **LightOnOCR-2-1B dominates** on manuscript catalog cards (67% win rate, 100-point ELO gap over 2nd place) — a very different result from the NLS pilot where it placed 3rd
- **Rankings are dataset-dependent**: NLS historical medical texts favored DoTS.ocr and DeepSeek-OCR; Rubenstein typewritten/handwritten cards favor LightOnOCR-2
- **Jury of small models works well**: 0 parse failures on 300 comparisons thanks to vLLM structured output (xgrammar). Majority voting between 2 judges provides robustness
- **50 samples gives meaningful separation**: Clear ELO gaps (1595 → 1497 → 1471 → 1437) unlike the noisy 5-sample pilot
- This validates the multi-dataset benchmark approach — no single dataset tells the whole story

#### Run 3: UFO-ColPali (2026-02-15) — Cross-Dataset Validation

**Dataset:** `davanstrien/ufo-ColPali` (50 samples, shuffled, seed 42)
**Output repo:** `davanstrien/ocr-bench-ufo` (4 PRs)
**Judge:** `Qwen/Qwen3-VL-30B-A3B-Instruct` via `ocr-vllm-judge.py` on A100 (updated prompt)
**Content:** Mixed modern documents (invoices, reports, forms, etc.)

**ELO (pairwise, 50 samples, 294 comparisons):**

| Rank | Model | ELO | W | L | T | Win% |
|------|-------|-----|---|---|---|------|
| 1 | DeepSeek-OCR | 1827 | 130 | 17 | 0 | 88% |
| 2 | dots.ocr | 1510 | 64 | 83 | 0 | 44% |
| 3 | LightOnOCR-2-1B | 1368 | 77 | 70 | 0 | 52% |
| 4 | GLM-OCR | 1294 | 23 | 124 | 0 | 16% |

**Human validation (30 comparisons):** DeepSeek-OCR #1 (same as judge), LightOnOCR-2 #3 (same). Middle pack (GLM-OCR #2 human / #4 judge, dots.ocr #4 human / #2 judge) shuffled.

#### Cross-Dataset Comparison (Human-Validated)

| Model | Rubenstein Human | Rubenstein Kimi | UFO Human | UFO 30B |
|-------|:---------------:|:---------------:|:---------:|:-------:|
| DeepSeek-OCR | **#1** | **#1** | **#1** | **#1** |
| GLM-OCR | #2 | #3 | #2 | #4 |
| LightOnOCR-2 | #4 | #2 | #3 | #3 |
| dots.ocr | #3 | #4 | #4 | #2 |

**Conclusion:** DeepSeek-OCR is consistently #1 across datasets and evaluation methods. Middle-pack rankings are dataset-dependent. Updated prompt fixed the LightOnOCR-2 overrating seen with old prompt/small judges.

*Note: NLS pilot results (5 samples, 72B API judge) omitted — not comparable with newer methodology.*

### Known Issues / Next Steps

1. ✅ **More samples needed** — Done. Rubenstein run (2026-02-15) used 50 samples and produced clear ELO separation across all 4 models.
2. ✅ **Smaller judge model** — Tested with Qwen VL 7B + Qwen3 VL 8B via `ocr-vllm-judge.py`. Works well with structured output (0 parse failures). Jury of small models compensates for individual model weakness. See "Offline vLLM Judge" section below.
3. **Auto-merge in coordinator** — `--wait` could auto-merge PRs after successful jobs. Not yet implemented.
4. **Adding more models** — `rolm-ocr.py` exists but needs `--config`/`--create-pr` added. `deepseek-ocr2-vllm.py`, `paddleocr-vl-1.5.py`, etc. could also be added to the registry.
5. **Leaderboard Space** — See future section below.
6. ✅ **Result persistence** — `ocr-vllm-judge.py` now has `--save-results REPO_ID` flag. First dataset: `davanstrien/ocr-bench-rubenstein-judge`.
7. **More diverse datasets** — Rankings are dataset-dependent (LightOnOCR-2 wins on Rubenstein, DoTS.ocr won pilot on NLS). Need benchmarks on tables, formulas, multilingual, and modern documents for a complete picture.
8. ✅ **Human validation** — `ocr-human-eval.py` completed on Rubenstein (30/30). Tested 3 judge configs. **Kimi K2.5 (170B) via Novita + updated prompt = best human agreement** (only judge to match human's #1). Now default in `ocr-jury-bench.py`. See `OCR-BENCHMARK.md` for full comparison.

---

## Offline vLLM Judge (`ocr-vllm-judge.py`)

**Status:** Working end-to-end (2026-02-15)

Runs pairwise OCR quality comparisons using a local VLM judge via vLLM's offline `LLM()` pattern. Supports jury mode (multiple models vote sequentially on the same GPU) with majority voting.

### Why use this over the API judge (`ocr-jury-bench.py`)?

| | API judge (`ocr-jury-bench.py`) | Offline judge (`ocr-vllm-judge.py`) |
|---|---|---|
| Parse failures | Needs retries for malformed JSON | 0 failures — vLLM structured output guarantees valid JSON |
| Network | Rate limits, timeouts, transient errors | Zero network calls |
| Cost | Per-token API pricing | Just GPU time |
| Judge models | Limited to Inference Providers catalog | Any vLLM-supported VLM |
| Jury mode | Sequential API calls per judge | Sequential model loading, batch inference per judge |
| Best for | Quick spot-checks, access to 72B models | Batch evaluation (50+ samples), reproducibility |

**Pushed to Hub:** `uv-scripts/ocr` as `ocr-vllm-judge.py` (2026-02-15)

### Test Results (2026-02-15)

**Test 1 — Single judge, 1 sample, L4:**
- Qwen2.5-VL-7B-Instruct, 6/6 comparisons, 0 parse failures
- Total time: ~3 min (including model download + warmup)

**Test 2 — Jury of 2, 3 samples, A100:**
- Qwen2.5-VL-7B + Qwen3-VL-8B, 15/15 comparisons, 0 parse failures
- GPU cleanup between models: successful (nanobind warnings are cosmetic)
- Majority vote aggregation working (`[2/2]` unanimous, `[1/2]` split)
- Total time: ~4 min (including both model downloads)

**Test 3 — Full benchmark, 50 samples, A100 (Rubenstein Manuscript Catalog):**
- Qwen2.5-VL-7B + Qwen3-VL-8B jury, 300/300 comparisons, 0 parse failures
- Input: `davanstrien/ocr-bench-rubenstein` (4 PRs from `ocr-bench-run.py`)
- Produced clear ELO rankings with meaningful separation
- See "Benchmark Results → Run 2" in the OCR Benchmark Coordinator section above

### Usage

```bash
# Single judge on L4
hf jobs uv run --flavor l4x1 -s HF_TOKEN \
    ocr-vllm-judge.py davanstrien/ocr-bench-nls-50 --from-prs \
    --judge-model Qwen/Qwen2.5-VL-7B-Instruct --max-samples 10

# Jury of 2 on A100 (recommended for jury mode)
hf jobs uv run --flavor a100-large -s HF_TOKEN \
    ocr-vllm-judge.py davanstrien/ocr-bench-nls-50 --from-prs \
    --judge-model Qwen/Qwen2.5-VL-7B-Instruct \
    --judge-model Qwen/Qwen3-VL-8B-Instruct \
    --max-samples 50
```

### Implementation Notes
- Comparisons built upfront on CPU as `NamedTuple`s, then batched to vLLM in single `llm.chat()` call
- Structured output via compatibility shim: `StructuredOutputsParams` (vLLM >= 0.12) → `GuidedDecodingParams` (older) → prompt-based fallback
- GPU cleanup between jury models: `destroy_model_parallel()` + `gc.collect()` + `torch.cuda.empty_cache()`
- Position bias mitigation: A/B order randomized per comparison
- A100 recommended for jury mode; L4 works for single 7B judge

### Next Steps
1. ✅ **Scale test** — Completed on Rubenstein Manuscript Catalog (50 samples, 300 comparisons, 0 parse failures). Rankings differ from API-based pilot (different dataset + judge), validating multi-dataset approach.
2. ✅ **Result persistence** — Added `--save-results REPO_ID` flag. Pushes 3 configs to HF Hub: `comparisons` (one row per pairwise comparison), `leaderboard` (ELO + win/loss/tie per model), `metadata` (source dataset, judge models, seed, timestamp). First dataset: `davanstrien/ocr-bench-rubenstein-judge`.
3. **Integrate into `ocr-bench-run.py`** — Add `--eval` flag that auto-runs vLLM judge after OCR jobs complete

---

## Blind Human Eval (`ocr-human-eval.py`)

**Status:** Working (2026-02-15)

Gradio app for blind A/B comparison of OCR outputs. Shows document image + two anonymized OCR outputs, human picks winner or tie. Computes ELO rankings from human annotations and optionally compares against automated judge results.

### Usage

```bash
# Basic — blind human eval only
uv run ocr-human-eval.py davanstrien/ocr-bench-rubenstein --from-prs --max-samples 5

# With judge comparison — loads automated judge results for agreement analysis
uv run ocr-human-eval.py davanstrien/ocr-bench-rubenstein --from-prs \
    --judge-results davanstrien/ocr-bench-rubenstein-judge --max-samples 5
```

### Features
- **Blind evaluation**: Two-tab design — Evaluate tab never shows model names, Results tab reveals rankings
- **Position bias mitigation**: A/B order randomly swapped per comparison
- **Resume support**: JSON annotations saved atomically after each vote; restart app to resume where you left off
- **Live agreement tracking**: Per-vote feedback shows running agreement with automated judge (when `--judge-results` provided)
- **Split-jury prioritization**: Comparisons where automated judges disagreed ("1/2" agreement) shown first — highest annotation value per vote
- **Image variety**: Round-robin interleaving by sample so you don't see the same document image repeatedly
- **Soft/hard disagreement analysis**: Distinguishes between harmless ties-vs-winner disagreements and genuine opposite-winner errors

### First Validation Results (Rubenstein, 30 annotations)

Tested 3 judge configs against 30 human annotations. **Kimi K2.5 (170B) via Novita** is the only judge to match human's #1 pick (DeepSeek-OCR). Small models (7B/8B/30B) all overrate LightOnOCR-2 due to bias toward its commentary style. Updated prompt (prioritized faithfulness > completeness > accuracy) helps but model size is the bigger factor.

Full results and analysis in `OCR-BENCHMARK.md` → "Human Validation" section.

### Next Steps
1. **Second dataset** — Run on NLS Medical History for cross-dataset human validation
2. **Multiple annotators** — Currently single-user; could support annotator ID for inter-annotator agreement
3. **Remaining LightOnOCR-2 gap** — Still #2 (Kimi) vs #4 (human). May need to investigate on more samples or strip commentary in preprocessing

---

## Future: Leaderboard HF Space

**Status:** Idea (noted 2026-02-14)

Build a Hugging Face Space with a persistent leaderboard that gets updated after each benchmark run. This would give a public-facing view of OCR model quality.

**Design ideas:**
- Gradio or static Space displaying ELO ratings + pointwise scores
- `ocr-elo-bench.py` could push results to a dataset that the Space reads
- Or the Space itself could run evaluation on demand
- Show per-document comparisons (image + side-by-side OCR outputs)
- Historical tracking — how scores change across model versions
- Filter by document type (historical, modern, tables, formulas, multilingual)

**Open questions:**
- Should the eval script push structured results to a dataset (e.g., `uv-scripts/ocr-leaderboard-data`)?
- Static leaderboard (updated by CI/scheduled job) vs interactive (evaluate on demand)?
- Include sample outputs for qualitative comparison?
- How to handle different eval datasets (NLS medical history vs UFO vs others)?

---

## Incremental Uploads / Checkpoint Strategy — ON HOLD

**Status:** Waiting on HF Hub Buckets (noted 2026-02-20)

**Current state:**
- `glm-ocr.py` (v1): Simple batch-then-push. Works fine for most jobs.
- `glm-ocr-v2.py`: Adds CommitScheduler-based incremental uploads + checkpoint/resume. ~400 extra lines. Works but has tradeoffs (commit noise, `--create-pr` incompatible, complex resume metadata).

**Decision: Do NOT port v2 pattern to other scripts.** Wait for HF Hub Buckets instead.

**Why:** Two open PRs will likely make the v2 CommitScheduler approach obsolete:
- [huggingface_hub#3673](https://github.com/huggingface/huggingface_hub/pull/3673) — Buckets API: S3-like mutable object storage on HF, no git versioning overhead
- [huggingface_hub#3807](https://github.com/huggingface/huggingface_hub/pull/3807) — HfFileSystem support for buckets: fsspec-compatible, so pyarrow/pandas/datasets can read/write `hf://buckets/` paths directly

**What Buckets would replace:** Once landed, incremental saves become one line per batch:
```python
batch_ds.to_parquet(f"hf://buckets/{user}/ocr-scratch/shard-{batch_num:05d}.parquet")
```
No CommitScheduler, no CleanupScheduler, no resume metadata, no completed batch scanning. Just write to the bucket path via fsspec. Final step: read back from bucket, `push_to_hub` to a clean dataset repo (compatible with `--create-pr`).

**Action items when Buckets ships:**
1. Test `hf://buckets/` fsspec writes on one script (glm-ocr is the guinea pig)
2. Verify: write performance, atomicity (partial writes visible?), auth propagation in HF Jobs
3. If it works, adopt as the standard pattern for all scripts — simple enough to inline (~20 lines)
4. Retire `glm-ocr-v2.py` CommitScheduler approach

**Until then:** v1 scripts stay as-is. `glm-ocr-v2.py` exists if someone needs resume on a very large job today.

---

**Last Updated:** 2026-02-20
**Watch PRs:**
- **HF Hub Buckets API** ([#3673](https://github.com/huggingface/huggingface_hub/pull/3673)): Core buckets support. Will enable simpler incremental upload pattern for all scripts.
- **HfFileSystem Buckets** ([#3807](https://github.com/huggingface/huggingface_hub/pull/3807)): fsspec support for `hf://buckets/` paths. Key for zero-boilerplate writes from scripts.
- DeepSeek-OCR-2 stable vLLM release: Currently only in nightly. Watch for vLLM 0.16.0 stable release on PyPI to remove nightly dependency.
- nanobind leak warnings in vLLM structured output (xgrammar): Cosmetic only, does not affect results. May be fixed in future xgrammar release.