I need pull

CLAUDE.md

@@ -3,17 +3,10 @@
 ## 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).
+✅ **Production Ready**
+- Fully supported by vLLM
+- Fast batch processing
+- Tested and working on HF Jobs
 
 ### LightOnOCR-2-1B (`lighton-ocr2.py`)
 ✅ **Production Ready** (Fixed 2026-01-29)
@@ -82,117 +75,90 @@ hf jobs uv run --flavor l4x1 \
 - 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.
+## Pending Development
 
-**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
+### DeepSeek-OCR-2 (Visual Causal Flow Architecture)
+
+**Status:** ⏳ Waiting for vLLM upstream support
+
+**Context:**
+DeepSeek-OCR-2 is the next generation OCR model (3B parameters) with Visual Causal Flow architecture offering improved quality. We attempted to create a UV script (`deepseek-ocr2-vllm.py`) but encountered a blocker.
+
+**Blocker:**
+vLLM does not yet support `DeepseekOCR2ForCausalLM` architecture in the official release.
+
+**PR to Watch:**
+🔗 https://github.com/vllm-project/vllm/pull/33165
+
+This PR adds DeepSeek-OCR-2 support but is currently:
+- ⚠️ **Open** (not merged)
+- Has unresolved review comments
+- Pre-commit checks failing
+- Issues: hardcoded parameters, device mismatch bugs, missing error handling
+
+**What's Needed:**
+1. PR #33165 needs to be reviewed, fixed, and merged
+2. vLLM needs to release a version including the merge
+3. Then we can add these dependencies to our script:
+   ```python
+   # dependencies = [
+   #     "datasets>=4.0.0",
+   #     "huggingface-hub",
+   #     "pillow",
+   #     "vllm",
+   #     "tqdm",
+   #     "toolz",
+   #     "torch",
+   #     "addict",
+   #     "matplotlib",
+   # ]
+   ```
+
+**Implementation Progress:**
+- ✅ Created `deepseek-ocr2-vllm.py` script
+- ✅ Fixed dependency issues (pyarrow, datasets>=4.0.0)
+- ✅ Tested script structure on HF Jobs
+- ❌ Blocked: vLLM doesn't recognize architecture
+
+**Partial Implementation:**
+The file `deepseek-ocr2-vllm.py` exists in this repo but is **not functional** until vLLM support lands. Consider it a draft.
+
+**Testing Evidence:**
+When we ran on HF Jobs, we got:
 ```
-
-**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
+ValidationError: Model architectures ['DeepseekOCR2ForCausalLM'] are not supported for now.
+Supported architectures: [...'DeepseekOCRForCausalLM'...]
 ```
 
-**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
-```
+**Next Steps (when PR merges):**
+1. Update `deepseek-ocr2-vllm.py` dependencies to include `addict` and `matplotlib`
+2. Test on HF Jobs with small dataset (10 samples)
+3. Verify output quality
+4. Update README.md with DeepSeek-OCR-2 section
+5. Document v1 vs v2 differences
 
-**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
+**Alternative Approaches (if urgent):**
+- Create transformers-based script (slower, no vLLM batching)
+- Use DeepSeek's official repo setup (complex, not UV-script compatible)
 
 **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
+- Resolution: (0-6)×768×768 + 1×1024×1024 patches
+- Key improvement: Visual Causal Flow architecture
+
+**Resolution Modes (for v2):**
+```python
+RESOLUTION_MODES = {
+    "tiny": {"base_size": 512, "image_size": 512, "crop_mode": False},
+    "small": {"base_size": 640, "image_size": 640, "crop_mode": False},
+    "base": {"base_size": 1024, "image_size": 768, "crop_mode": False},  # v2 optimized
+    "large": {"base_size": 1280, "image_size": 1024, "crop_mode": False},
+    "gundam": {"base_size": 1024, "image_size": 768, "crop_mode": True},  # v2 optimized
+}
+```
 
 ## Other OCR Scripts
 
@@ -242,314 +208,6 @@ uv run glm-ocr.py uv-scripts/ocr-smoke-test smoke-out --max-samples 5
 
 ---
 
-## 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
+**Last Updated:** 2026-02-12
 **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.
+- DeepSeek-OCR-2: https://github.com/vllm-project/vllm/pull/33165

README.md

@@ -7,7 +7,7 @@ tags: [uv-script, ocr, vision-language-model, document-processing, hf-jobs]
 
 > Part of [uv-scripts](https://huggingface.co/uv-scripts) - ready-to-run ML tools powered by UV and HuggingFace Jobs.
 
-19 OCR scripts covering models from 0.9B to 8B parameters. Pick a model, point at your dataset, get markdown — no setup required.
+14 OCR models from 0.9B to 8B parameters. Pick a model, point at your dataset, get markdown — no setup required.
 
 ## 🚀 Quick Start
 
@@ -43,12 +43,11 @@ That's it! The script will:
 | `dots-ocr.py` | [DoTS.ocr](https://huggingface.co/Tencent/DoTS.ocr) | 1.7B | vLLM | 100+ languages |
 | `firered-ocr.py` | [FireRed-OCR](https://huggingface.co/FireRedTeam/FireRed-OCR) | 2.1B | vLLM | Qwen3-VL fine-tune, Apache 2.0 |
 | `nanonets-ocr.py` | [Nanonets-OCR-s](https://huggingface.co/nanonets/Nanonets-OCR-s) | 2B | vLLM | LaTeX, tables, forms |
-| `dots-mocr.py` | [dots.mocr](https://huggingface.co/rednote-hilab/dots.mocr) | 3B | vLLM | 8 prompt modes incl. SVG generation, layout + bbox, 100+ languages |
+| `dots-ocr-1.5.py` | [DoTS.ocr-1.5](https://huggingface.co/Tencent/DoTS.ocr-1.5) | 3B | vLLM | Updated multilingual model |
 | `nanonets-ocr2.py` | [Nanonets-OCR2-3B](https://huggingface.co/nanonets/Nanonets-OCR2-s) | 3B | vLLM | Next-gen, Qwen2.5-VL base |
 | `deepseek-ocr-vllm.py` | [DeepSeek-OCR](https://huggingface.co/deepseek-ai/DeepSeek-OCR) | 4B | vLLM | 5 resolution + 5 prompt modes |
 | `deepseek-ocr.py` | [DeepSeek-OCR](https://huggingface.co/deepseek-ai/DeepSeek-OCR) | 4B | Transformers | Same model, Transformers backend |
 | `deepseek-ocr2-vllm.py` | [DeepSeek-OCR-2](https://huggingface.co/deepseek-ai/DeepSeek-OCR-2) | 3B | vLLM | Newer, requires nightly vLLM |
-| `qianfan-ocr.py` | [Qianfan-OCR](https://huggingface.co/baidu/Qianfan-OCR) | 4.7B | vLLM | #1 OmniDocBench v1.5 (93.12), Layout-as-Thought, 192 languages |
 | `olmocr2-vllm.py` | [olmOCR-2-7B](https://huggingface.co/allenai/olmOCR-2-7B-1025-FP8) | 7B | vLLM | 82.4% olmOCR-Bench |
 | `rolm-ocr.py` | [RolmOCR](https://huggingface.co/reducto/RolmOCR) | 7B | vLLM | Qwen2.5-VL based, general-purpose |
 | `numarkdown-ocr.py` | [NuMarkdown-8B](https://huggingface.co/numind/NuMarkdown-8B-Thinking) | 8B | vLLM | Reasoning-based OCR |
@@ -392,46 +391,7 @@ Advanced reasoning-based OCR using [numind/NuMarkdown-8B-Thinking](https://huggi
 - 🔍 **Multi-column Layouts** - Handles complex document structures
 - ✨ **Thinking Traces** - Optional inclusion of reasoning process with `--include-thinking`
 
-### dots.mocr (`dots-mocr.py`) — SVG generation + SOTA OCR
-
-Advanced multilingual OCR and SVG generation using [rednote-hilab/dots.mocr](https://huggingface.co/rednote-hilab/dots.mocr) with 3B parameters:
-
-- 🌍 **100+ Languages** - Extensive multilingual support
-- 📝 **Document OCR** - Clean text extraction (default mode)
-- 📊 **Layout Analysis** - Structured output with bboxes and categories
-- 📐 **Formula recognition** - LaTeX format support
-- 🖼️ **SVG generation** - Convert charts, UI layouts, figures to editable SVG code
-- 🔀 **8 prompt modes** - OCR, layout-all, layout-only, web-parsing, scene-spotting, grounding-ocr, svg, general
-- 📄 **[Paper](https://arxiv.org/abs/2603.13032)** - 83.9% on olmOCR-Bench
-
-**SVG variant:** Use `--model rednote-hilab/dots.mocr-svg` with `--prompt-mode svg` for best SVG results.
-
-**Quick start:**
-
-```bash
-# Basic OCR
-hf jobs uv run --flavor l4x1 \
-    -s HF_TOKEN \
-    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/dots-mocr.py \
-    your-input-dataset your-output-dataset \
-    --max-samples 100
-
-# SVG generation from charts/figures
-hf jobs uv run --flavor l4x1 \
-    -s HF_TOKEN \
-    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/dots-mocr.py \
-    your-charts svg-output \
-    --prompt-mode svg --model rednote-hilab/dots.mocr-svg
-
-# Layout analysis with bounding boxes
-hf jobs uv run --flavor l4x1 \
-    -s HF_TOKEN \
-    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/dots-mocr.py \
-    your-documents layout-output \
-    --prompt-mode layout-all
-```
-
-### DoTS.ocr v1 (`dots-ocr.py`)
+### DoTS.ocr (`dots-ocr.py`)
 
 Compact multilingual OCR using [rednote-hilab/dots.ocr](https://huggingface.co/rednote-hilab/dots.ocr) with only 1.7B parameters:
 
@@ -462,55 +422,6 @@ hf jobs uv run --flavor l4x1 \
     --max-samples 100
 ```
 
-### Qianfan-OCR (`qianfan-ocr.py`) — #1 on OmniDocBench v1.5
-
-End-to-end document intelligence using [baidu/Qianfan-OCR](https://huggingface.co/baidu/Qianfan-OCR) with 4.7B parameters:
-
-- **93.12 on OmniDocBench v1.5** — #1 end-to-end model
-- **79.8 on OlmOCR Bench** — #1 end-to-end model
-- 🧠 **Layout-as-Thought** — Optional reasoning phase for complex layouts (`--think`)
-- 🌍 **192 languages** — Latin, CJK, Arabic, Cyrillic, and more
-- 📝 **OCR mode** — Document parsing to markdown (default)
-- 📊 **Table mode** — HTML table extraction
-- 📐 **Formula mode** — LaTeX recognition
-- 📈 **Chart mode** — Chart understanding and analysis
-- 🔍 **Scene mode** — Scene text extraction
-- 🔑 **KIE mode** — Key information extraction with custom prompts
-
-**Prompt Modes:**
-
-- `ocr`: Document parsing to markdown (default)
-- `table`: Table extraction to HTML
-- `formula`: Formula recognition to LaTeX
-- `chart`: Chart understanding
-- `scene`: Scene text extraction
-- `kie`: Key information extraction (requires `--custom-prompt`)
-
-**Quick start:**
-
-```bash
-# Basic OCR
-hf jobs uv run --flavor l4x1 \
-    -s HF_TOKEN \
-    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/qianfan-ocr.py \
-    your-input-dataset your-output-dataset \
-    --max-samples 100
-
-# Layout-as-Thought for complex documents
-hf jobs uv run --flavor l4x1 \
-    -s HF_TOKEN \
-    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/qianfan-ocr.py \
-    your-input-dataset your-output-dataset \
-    --think --max-samples 50
-
-# Key information extraction
-hf jobs uv run --flavor l4x1 \
-    -s HF_TOKEN \
-    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/qianfan-ocr.py \
-    invoices extracted-fields \
-    --prompt-mode kie --custom-prompt "Extract: name, date, total. Output as JSON."
-```
-
 ### olmOCR2 (`olmocr2-vllm.py`)
 
 High-quality document OCR using [allenai/olmOCR-2-7B-1025-FP8](https://huggingface.co/allenai/olmOCR-2-7B-1025-FP8) optimized with GRPO reinforcement learning:

dots-mocr.py → dots-ocr-1.5.py

@@ -13,27 +13,23 @@
 # ///
 
 """
-Convert document images to markdown using dots.mocr with vLLM.
+Convert document images to markdown using DoTS.ocr-1.5 with vLLM.
 
-dots.mocr is a 3B multilingual document parsing model with SOTA performance
-on 100+ languages. It excels at converting structured graphics (charts, UI
-layouts, scientific figures) directly into SVG code. Core capabilities include
-grounding, recognition, semantic understanding, and interactive dialogue.
+DoTS.ocr-1.5 is a 3B multilingual document parsing model with SOTA performance
+on 100+ languages. Compared to v1 (1.7B), it adds web screen parsing, scene text
+spotting, SVG code generation, and stronger multilingual document parsing.
 
 Features:
 - Multilingual support (100+ languages)
 - Table extraction and formatting
 - Formula recognition
 - Layout-aware text extraction
-- Web screen parsing
-- Scene text spotting
-- SVG code generation (use --prompt-mode svg, or --model rednote-hilab/dots.mocr-svg for best results)
-
-Model: rednote-hilab/dots.mocr
-SVG variant: rednote-hilab/dots.mocr-svg
-vLLM: Officially integrated since v0.11.0
-GitHub: https://github.com/rednote-hilab/dots.mocr
-Paper: https://arxiv.org/abs/2603.13032
+- Web screen parsing (NEW in v1.5)
+- Scene text spotting (NEW in v1.5)
+- SVG code generation (requires dots.ocr-1.5-svg variant)
+
+Model: rednote-hilab/dots.ocr-1.5
+vLLM: Officially supported (same DotsOCRForCausalLM architecture as v1)
 """
 
 import argparse
@@ -60,8 +56,8 @@ logger = logging.getLogger(__name__)
 
 
 # ────────────────────────────────────────────────────────────────
-# dots.mocr Prompt Templates
-# Source: https://github.com/rednote-hilab/dots.mocr/blob/master/dots_mocr/utils/prompts.py
+# DoTS OCR 1.5 Prompt Templates (from official dots.ocr repo)
+# Source: https://github.com/rednote-hilab/dots.ocr/blob/master/dots_ocr/utils/prompts.py
 # ────────────────────────────────────────────────────────────────
 
 PROMPT_TEMPLATES = {
@@ -84,19 +80,11 @@ PROMPT_TEMPLATES = {
 
 5. Final Output: The entire output must be a single JSON object.
 """,
-    # NOTE: Bboxes from layout-all/layout-only are in the resized image coordinate
-    # space (Qwen2VLImageProcessor smart_resize: max_pixels=11289600, factor=28),
-    # NOT original image coordinates. To map back, compute:
-    #   resized_h, resized_w = smart_resize(orig_h, orig_w)
-    #   scale_x, scale_y = orig_w / resized_w, orig_h / resized_h
     "layout-only": """Please output the layout information from this PDF image, including each layout's bbox and its category. The bbox should be in the format [x1, y1, x2, y2]. The layout categories for the PDF document include ['Caption', 'Footnote', 'Formula', 'List-item', 'Page-footer', 'Page-header', 'Picture', 'Section-header', 'Table', 'Text', 'Title']. Do not output the corresponding text. The layout result should be in JSON format.""",
+    # NEW in v1.5:
     "web-parsing": """Parsing the layout info of this webpage image with format json:\n""",
     "scene-spotting": """Detect and recognize the text in the image.""",
     "grounding-ocr": """Extract text from the given bounding box on the image (format: [x1, y1, x2, y2]).\nBounding Box:\n""",
-    # SVG code generation — {width} and {height} are replaced with actual image dimensions.
-    # For best results, use --model rednote-hilab/dots.mocr-svg
-    # Uses higher temperature (0.9) and top_p (1.0) per official recommendation.
-    "svg": """Please generate the SVG code based on the image. viewBox="0 0 {width} {height}" """,
     "general": """ """,
 }
 
@@ -129,12 +117,6 @@ def make_ocr_message(
     # Convert to RGB
     pil_img = pil_img.convert("RGB")
 
-    # For SVG mode, inject actual image dimensions into the prompt
-    if "{width}" in prompt and "{height}" in prompt:
-        prompt = prompt.replace("{width}", str(pil_img.width)).replace(
-            "{height}", str(pil_img.height)
-        )
-
     # Convert to base64 data URI
     buf = io.BytesIO()
     pil_img.save(buf, format="PNG")
@@ -172,7 +154,7 @@ def create_dataset_card(
 tags:
 - ocr
 - document-processing
-- dots-mocr
+- dots-ocr-1.5
 - multilingual
 - markdown
 - uv-script
@@ -181,7 +163,7 @@ tags:
 
 # Document OCR using {model_name}
 
-This dataset contains OCR results from images in [{source_dataset}](https://huggingface.co/datasets/{source_dataset}) using dots.mocr, a 3B multilingual model with SOTA document parsing and SVG generation.
+This dataset contains OCR results from images in [{source_dataset}](https://huggingface.co/datasets/{source_dataset}) using DoTS.ocr-1.5, a 3B multilingual model with SOTA document parsing.
 
 ## Processing Details
 
@@ -204,14 +186,13 @@ This dataset contains OCR results from images in [{source_dataset}](https://hugg
 
 ## Model Information
 
-dots.mocr is a 3B multilingual document parsing model that excels at:
+DoTS.ocr-1.5 is a 3B multilingual document parsing model that excels at:
 - 100+ Languages — Multilingual document support
 - Table extraction — Structured data recognition
 - Formulas — Mathematical notation preservation
 - Layout-aware — Reading order and structure preservation
 - Web screen parsing — Webpage layout analysis
 - Scene text spotting — Text detection in natural scenes
-- SVG code generation — Charts, UI layouts, scientific figures to SVG
 
 ## Dataset Structure
 
@@ -241,10 +222,10 @@ for info in inference_info:
 
 ## Reproduction
 
-This dataset was generated using the [uv-scripts/ocr](https://huggingface.co/datasets/uv-scripts/ocr) dots.mocr script:
+This dataset was generated using the [uv-scripts/ocr](https://huggingface.co/datasets/uv-scripts/ocr) DoTS OCR 1.5 script:
 
 ```bash
-uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/dots-mocr.py \\
+uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/dots-ocr-1.5.py \\
     {source_dataset} \\
     <output-dataset> \\
     --image-column {image_column} \\
@@ -264,7 +245,7 @@ def main(
     output_dataset: str,
     image_column: str = "image",
     batch_size: int = 16,
-    model: str = "rednote-hilab/dots.mocr",
+    model: str = "rednote-hilab/dots.ocr-1.5",
     max_model_len: int = 24000,
     max_tokens: int = 24000,
     gpu_memory_utilization: float = 0.9,
@@ -283,7 +264,7 @@ def main(
     top_p: float = 0.9,
     verbose: bool = False,
 ):
-    """Process images from HF dataset through dots.mocr model."""
+    """Process images from HF dataset through DoTS.ocr-1.5 model."""
 
     # Check CUDA availability first
     check_cuda_availability()
@@ -334,12 +315,6 @@ def main(
         gpu_memory_utilization=gpu_memory_utilization,
     )
 
-    # SVG mode uses higher temperature/top_p per official recommendation
-    if prompt_mode == "svg" and temperature == 0.1 and top_p == 0.9:
-        logger.info("SVG mode: using recommended temperature=0.9, top_p=1.0")
-        temperature = 0.9
-        top_p = 1.0
-
     sampling_params = SamplingParams(
         temperature=temperature,
         top_p=top_p,
@@ -355,7 +330,7 @@ def main(
     for batch_indices in tqdm(
         partition_all(batch_size, range(len(dataset))),
         total=(len(dataset) + batch_size - 1) // batch_size,
-        desc="dots.mocr processing",
+        desc="DoTS.ocr-1.5 processing",
     ):
         batch_indices = list(batch_indices)
         batch_images = [dataset[i][image_column] for i in batch_indices]
@@ -364,12 +339,8 @@ def main(
             # Create messages for batch
             batch_messages = [make_ocr_message(img, prompt) for img in batch_images]
 
-            # Process with vLLM (dots.mocr needs "string" content format)
-            outputs = llm.chat(
-                batch_messages,
-                sampling_params,
-                chat_template_content_format="string",
-            )
+            # Process with vLLM
+            outputs = llm.chat(batch_messages, sampling_params)
 
             # Extract outputs
             for output in outputs:
@@ -392,7 +363,7 @@ def main(
     # Handle inference_info tracking (for multi-model comparisons)
     inference_entry = {
         "model_id": model,
-        "model_name": "dots.mocr",
+        "model_name": "DoTS.ocr-1.5",
         "column_name": output_column,
         "timestamp": datetime.now().isoformat(),
         "prompt_mode": prompt_mode if not custom_prompt else "custom",
@@ -473,7 +444,7 @@ def main(
     card = DatasetCard(card_content)
     card.push_to_hub(output_dataset, token=HF_TOKEN)
 
-    logger.info("dots.mocr processing complete!")
+    logger.info("DoTS.ocr-1.5 processing complete!")
     logger.info(
         f"Dataset available at: https://huggingface.co/datasets/{output_dataset}"
     )
@@ -495,83 +466,77 @@ if __name__ == "__main__":
     # Show example usage if no arguments
     if len(sys.argv) == 1:
         print("=" * 80)
-        print("dots.mocr Document Processing")
+        print("DoTS.ocr-1.5 Document Processing")
         print("=" * 80)
-        print("\n3B multilingual OCR model with SVG generation")
+        print("\n3B multilingual OCR model supporting 100+ languages")
         print("\nFeatures:")
         print("- Multilingual support (100+ languages)")
         print("- Fast processing with vLLM")
         print("- Table extraction and formatting")
         print("- Formula recognition")
         print("- Layout-aware text extraction")
-        print("- Web screen parsing")
-        print("- Scene text spotting")
-        print("- SVG code generation (charts, UI, figures)")
+        print("- Web screen parsing (NEW in v1.5)")
+        print("- Scene text spotting (NEW in v1.5)")
         print("\nPrompt modes:")
-        print("  ocr            - Text extraction (default)")
-        print("  layout-all     - Layout + bboxes + text (JSON)")
-        print("  layout-only    - Layout + bboxes only (JSON)")
-        print("  web-parsing    - Webpage layout analysis (JSON)")
+        print("  ocr           - Text extraction (default)")
+        print("  layout-all    - Layout + bboxes + text (JSON)")
+        print("  layout-only   - Layout + bboxes only (JSON)")
+        print("  web-parsing   - Webpage layout analysis (JSON)")
         print("  scene-spotting - Scene text detection")
-        print("  grounding-ocr  - Text from bounding box region")
-        print("  svg            - SVG code generation")
-        print("  general        - Free-form (use with --custom-prompt)")
+        print("  grounding-ocr - Text from bounding box region")
+        print("  general       - Free-form (use with --custom-prompt)")
         print("\nExample usage:")
         print("\n1. Basic OCR:")
-        print("   uv run dots-mocr.py input-dataset output-dataset")
-        print("\n2. SVG generation:")
-        print(
-            "   uv run dots-mocr.py charts svg-output --prompt-mode svg --model rednote-hilab/dots.mocr-svg"
-        )
-        print("\n3. Web screen parsing:")
-        print("   uv run dots-mocr.py screenshots parsed --prompt-mode web-parsing")
+        print("   uv run dots-ocr-1.5.py input-dataset output-dataset")
+        print("\n2. Web screen parsing:")
+        print("   uv run dots-ocr-1.5.py screenshots parsed --prompt-mode web-parsing")
+        print("\n3. Scene text spotting:")
+        print("   uv run dots-ocr-1.5.py photos detected --prompt-mode scene-spotting")
         print("\n4. Layout analysis with structure:")
-        print("   uv run dots-mocr.py papers analyzed --prompt-mode layout-all")
+        print("   uv run dots-ocr-1.5.py papers analyzed --prompt-mode layout-all")
         print("\n5. Running on HF Jobs:")
         print("   hf jobs uv run --flavor l4x1 \\")
         print("     -s HF_TOKEN \\")
         print(
-            "     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/dots-mocr.py \\"
+            "     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/dots-ocr-1.5.py \\"
         )
         print("       input-dataset output-dataset")
         print("\n" + "=" * 80)
-        print("\nFor full help, run: uv run dots-mocr.py --help")
+        print("\nFor full help, run: uv run dots-ocr-1.5.py --help")
         sys.exit(0)
 
     parser = argparse.ArgumentParser(
-        description="Document OCR using dots.mocr (3B multilingual model with SVG generation)",
+        description="Document OCR using DoTS.ocr-1.5 (3B multilingual model)",
         formatter_class=argparse.RawDescriptionHelpFormatter,
         epilog="""
-Prompt Modes (official dots.mocr prompts):
+Prompt Modes (official DoTS.ocr-1.5 prompts):
   ocr            - Simple text extraction (default)
   layout-all     - Layout analysis with bboxes, categories, and text (JSON output)
   layout-only    - Layout detection with bboxes and categories only (JSON output)
-  web-parsing    - Webpage layout analysis (JSON output)
-  scene-spotting - Scene text detection and recognition
-  grounding-ocr  - Extract text from bounding box region
-  svg            - SVG code generation (auto-injects image dimensions into viewBox)
-  general        - Free-form QA (use with --custom-prompt)
+  web-parsing    - Webpage layout analysis (JSON output) [NEW in v1.5]
+  scene-spotting - Scene text detection and recognition [NEW in v1.5]
+  grounding-ocr  - Extract text from bounding box region [NEW in v1.5]
+  general        - Free-form QA (use with --custom-prompt) [NEW in v1.5]
 
 SVG Code Generation:
-  Use --prompt-mode svg for SVG output. For best results, combine with
-  --model rednote-hilab/dots.mocr-svg (the SVG-optimized variant).
-  SVG mode automatically uses temperature=0.9, top_p=1.0 unless overridden.
+  For SVG output, use --model rednote-hilab/dots.ocr-1.5-svg with:
+  --custom-prompt 'Please generate the SVG code based on the image.'
 
 Examples:
   # Basic text OCR (default)
-  uv run dots-mocr.py my-docs analyzed-docs
-
-  # SVG generation with optimized variant
-  uv run dots-mocr.py charts svg-out --prompt-mode svg --model rednote-hilab/dots.mocr-svg
+  uv run dots-ocr-1.5.py my-docs analyzed-docs
 
   # Web screen parsing
-  uv run dots-mocr.py screenshots parsed --prompt-mode web-parsing
+  uv run dots-ocr-1.5.py screenshots parsed --prompt-mode web-parsing
+
+  # Scene text spotting
+  uv run dots-ocr-1.5.py photos spotted --prompt-mode scene-spotting
 
   # Full layout analysis with structure
-  uv run dots-mocr.py papers structured --prompt-mode layout-all
+  uv run dots-ocr-1.5.py papers structured --prompt-mode layout-all
 
   # Random sampling for testing
-  uv run dots-mocr.py large-dataset test --max-samples 50 --shuffle
+  uv run dots-ocr-1.5.py large-dataset test --max-samples 50 --shuffle
         """,
     )
 
@@ -590,8 +555,8 @@ Examples:
     )
     parser.add_argument(
         "--model",
-        default="rednote-hilab/dots.mocr",
-        help="Model to use (default: rednote-hilab/dots.mocr, or rednote-hilab/dots.mocr-svg for SVG)",
+        default="rednote-hilab/dots.ocr-1.5",
+        help="Model to use (default: rednote-hilab/dots.ocr-1.5)",
     )
     parser.add_argument(
         "--max-model-len",

firered-ocr.py

@@ -104,10 +104,10 @@ def make_ocr_message(
     # Convert to RGB
     pil_img = pil_img.convert("RGB")
 
-    # Convert to base64 data URI (JPEG is faster than PNG for encoding)
+    # Convert to base64 data URI
     buf = io.BytesIO()
-    pil_img.save(buf, format="JPEG", quality=95)
-    data_uri = f"data:image/jpeg;base64,{base64.b64encode(buf.getvalue()).decode()}"
+    pil_img.save(buf, format="PNG")
+    data_uri = f"data:image/png;base64,{base64.b64encode(buf.getvalue()).decode()}"
 
     # Return message in vLLM format
     return [
@@ -228,7 +228,7 @@ def main(
     image_column: str = "image",
     batch_size: int = 16,
     model: str = "FireRedTeam/FireRed-OCR",
-    max_model_len: int = 32768,
+    max_model_len: int = 8192,
     max_tokens: int = 8192,
     gpu_memory_utilization: float = 0.8,
     hf_token: str = None,
@@ -335,10 +335,7 @@ def main(
     processing_duration = datetime.now() - start_time
     processing_time_str = f"{processing_duration.total_seconds() / 60:.1f} min"
 
-    # Add output column to dataset (remove existing column if present)
-    if output_column in dataset.column_names:
-        logger.info(f"Removing existing '{output_column}' column before adding new results")
-        dataset = dataset.remove_columns([output_column])
+    # Add output column to dataset
     logger.info(f"Adding '{output_column}' column to dataset")
     dataset = dataset.add_column(output_column, all_outputs)
 
@@ -483,8 +480,8 @@ Examples:
     parser.add_argument(
         "--max-model-len",
         type=int,
-        default=32768,
-        help="Maximum model context length (default: 32768)",
+        default=8192,
+        help="Maximum model context length (default: 8192)",
     )
     parser.add_argument(
         "--max-tokens",

glm-ocr-bucket.py

@@ -1,364 +0,0 @@
-# /// script
-# requires-python = ">=3.11"
-# dependencies = [
-#     "pillow",
-#     "pymupdf",
-#     "vllm",
-#     "torch",
-# ]
-#
-# [[tool.uv.index]]
-# url = "https://wheels.vllm.ai/nightly/cu129"
-#
-# [tool.uv]
-# prerelease = "allow"
-# override-dependencies = ["transformers>=5.1.0"]
-# ///
-
-"""
-OCR images and PDFs from a directory using GLM-OCR, writing markdown files.
-
-Designed to work with HF Buckets mounted as volumes via `hf jobs uv run -v ...`
-(requires huggingface_hub with PR #3936 volume mounting support).
-
-The script reads images/PDFs from INPUT_DIR, runs GLM-OCR via vLLM, and writes
-one .md file per image (or per PDF page) to OUTPUT_DIR, preserving directory structure.
-
-Input:                          Output:
-  /input/page1.png        →      /output/page1.md
-  /input/report.pdf       →      /output/report/page_001.md
-  (3 pages)                       /output/report/page_002.md
-                                  /output/report/page_003.md
-  /input/sub/photo.jpg    →      /output/sub/photo.md
-
-Examples:
-
-  # Local test
-  uv run glm-ocr-bucket.py ./test-images ./test-output
-
-  # HF Jobs with bucket volumes (PR #3936)
-  hf jobs uv run --flavor l4x1 \\
-      -s HF_TOKEN \\
-      -v bucket/user/ocr-input:/input:ro \\
-      -v bucket/user/ocr-output:/output \\
-      glm-ocr-bucket.py /input /output
-
-Model: zai-org/GLM-OCR (0.9B, 94.62% OmniDocBench V1.5, MIT licensed)
-"""
-
-import argparse
-import base64
-import io
-import logging
-import sys
-import time
-from pathlib import Path
-
-import torch
-from PIL import Image
-from vllm import LLM, SamplingParams
-
-logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
-logger = logging.getLogger(__name__)
-
-MODEL = "zai-org/GLM-OCR"
-
-TASK_PROMPTS = {
-    "ocr": "Text Recognition:",
-    "formula": "Formula Recognition:",
-    "table": "Table Recognition:",
-}
-
-IMAGE_EXTENSIONS = {".png", ".jpg", ".jpeg", ".tiff", ".tif", ".bmp", ".webp"}
-
-
-def check_cuda_availability():
-    if not torch.cuda.is_available():
-        logger.error("CUDA is not available. This script requires a GPU.")
-        sys.exit(1)
-    logger.info(f"CUDA available. GPU: {torch.cuda.get_device_name(0)}")
-
-
-def make_ocr_message(image: Image.Image, task: str = "ocr") -> list[dict]:
-    """Create chat message for GLM-OCR from a PIL Image."""
-    image = image.convert("RGB")
-    buf = io.BytesIO()
-    image.save(buf, format="PNG")
-    data_uri = f"data:image/png;base64,{base64.b64encode(buf.getvalue()).decode()}"
-
-    return [
-        {
-            "role": "user",
-            "content": [
-                {"type": "image_url", "image_url": {"url": data_uri}},
-                {"type": "text", "text": TASK_PROMPTS.get(task, TASK_PROMPTS["ocr"])},
-            ],
-        }
-    ]
-
-
-def discover_files(input_dir: Path) -> list[Path]:
-    """Walk input_dir recursively, returning sorted list of image and PDF files."""
-    files = []
-    for path in sorted(input_dir.rglob("*")):
-        if not path.is_file():
-            continue
-        ext = path.suffix.lower()
-        if ext in IMAGE_EXTENSIONS or ext == ".pdf":
-            files.append(path)
-    return files
-
-
-def prepare_images(
-    files: list[Path], input_dir: Path, output_dir: Path, pdf_dpi: int
-) -> list[tuple[Image.Image, Path]]:
-    """
-    Convert discovered files into (PIL.Image, output_md_path) pairs.
-
-    Images map 1:1. PDFs expand to one image per page in a subdirectory.
-    """
-    import fitz  # pymupdf
-
-    items: list[tuple[Image.Image, Path]] = []
-
-    for file_path in files:
-        rel = file_path.relative_to(input_dir)
-        ext = file_path.suffix.lower()
-
-        if ext == ".pdf":
-            # PDF → one .md per page in a subdirectory named after the PDF
-            pdf_output_dir = output_dir / rel.with_suffix("")
-            try:
-                doc = fitz.open(file_path)
-                num_pages = len(doc)
-                logger.info(f"PDF: {rel} ({num_pages} pages)")
-                for page_num in range(num_pages):
-                    page = doc[page_num]
-                    # Render at specified DPI
-                    zoom = pdf_dpi / 72.0
-                    mat = fitz.Matrix(zoom, zoom)
-                    pix = page.get_pixmap(matrix=mat)
-                    img = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
-                    md_path = pdf_output_dir / f"page_{page_num + 1:03d}.md"
-                    items.append((img, md_path))
-                doc.close()
-            except Exception as e:
-                logger.error(f"Failed to open PDF {rel}: {e}")
-        else:
-            # Image → single .md
-            try:
-                img = Image.open(file_path).convert("RGB")
-                md_path = output_dir / rel.with_suffix(".md")
-                items.append((img, md_path))
-            except Exception as e:
-                logger.error(f"Failed to open image {rel}: {e}")
-
-    return items
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="OCR images/PDFs from a directory using GLM-OCR, output markdown files.",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Task modes:
-  ocr      Text recognition to markdown (default)
-  formula  LaTeX formula recognition
-  table    Table extraction (HTML)
-
-Examples:
-  uv run glm-ocr-bucket.py ./images ./output
-  uv run glm-ocr-bucket.py /input /output --task table --pdf-dpi 200
-
-HF Jobs with bucket volumes (requires huggingface_hub PR #3936):
-  hf jobs uv run --flavor l4x1 -s HF_TOKEN \\
-      -v bucket/user/input-bucket:/input:ro \\
-      -v bucket/user/output-bucket:/output \\
-      glm-ocr-bucket.py /input /output
-        """,
-    )
-    parser.add_argument("input_dir", help="Directory containing images and/or PDFs")
-    parser.add_argument("output_dir", help="Directory to write markdown output files")
-    parser.add_argument(
-        "--task",
-        choices=["ocr", "formula", "table"],
-        default="ocr",
-        help="OCR task mode (default: ocr)",
-    )
-    parser.add_argument(
-        "--batch-size", type=int, default=16, help="Batch size for vLLM (default: 16)"
-    )
-    parser.add_argument(
-        "--max-model-len",
-        type=int,
-        default=8192,
-        help="Max model context length (default: 8192)",
-    )
-    parser.add_argument(
-        "--max-tokens",
-        type=int,
-        default=8192,
-        help="Max output tokens (default: 8192)",
-    )
-    parser.add_argument(
-        "--gpu-memory-utilization",
-        type=float,
-        default=0.8,
-        help="GPU memory utilization (default: 0.8)",
-    )
-    parser.add_argument(
-        "--pdf-dpi",
-        type=int,
-        default=300,
-        help="DPI for PDF page rendering (default: 300)",
-    )
-    parser.add_argument(
-        "--temperature",
-        type=float,
-        default=0.01,
-        help="Sampling temperature (default: 0.01)",
-    )
-    parser.add_argument(
-        "--top-p", type=float, default=0.00001, help="Top-p sampling (default: 0.00001)"
-    )
-    parser.add_argument(
-        "--repetition-penalty",
-        type=float,
-        default=1.1,
-        help="Repetition penalty (default: 1.1)",
-    )
-    parser.add_argument(
-        "--verbose",
-        action="store_true",
-        help="Print resolved package versions",
-    )
-
-    args = parser.parse_args()
-
-    check_cuda_availability()
-
-    input_dir = Path(args.input_dir)
-    output_dir = Path(args.output_dir)
-
-    if not input_dir.is_dir():
-        logger.error(f"Input directory does not exist: {input_dir}")
-        sys.exit(1)
-
-    output_dir.mkdir(parents=True, exist_ok=True)
-
-    # Discover and prepare
-    start_time = time.time()
-
-    logger.info(f"Scanning {input_dir} for images and PDFs...")
-    files = discover_files(input_dir)
-    if not files:
-        logger.error(f"No image or PDF files found in {input_dir}")
-        sys.exit(1)
-
-    pdf_count = sum(1 for f in files if f.suffix.lower() == ".pdf")
-    img_count = len(files) - pdf_count
-    logger.info(f"Found {img_count} image(s) and {pdf_count} PDF(s)")
-
-    logger.info("Preparing images (rendering PDFs)...")
-    items = prepare_images(files, input_dir, output_dir, args.pdf_dpi)
-    if not items:
-        logger.error("No processable images after preparation")
-        sys.exit(1)
-
-    logger.info(f"Total images to OCR: {len(items)}")
-
-    # Init vLLM
-    logger.info(f"Initializing vLLM with {MODEL}...")
-    llm = LLM(
-        model=MODEL,
-        trust_remote_code=True,
-        max_model_len=args.max_model_len,
-        gpu_memory_utilization=args.gpu_memory_utilization,
-        limit_mm_per_prompt={"image": 1},
-    )
-
-    sampling_params = SamplingParams(
-        temperature=args.temperature,
-        top_p=args.top_p,
-        max_tokens=args.max_tokens,
-        repetition_penalty=args.repetition_penalty,
-    )
-
-    # Process in batches
-    errors = 0
-    processed = 0
-    total = len(items)
-
-    for batch_start in range(0, total, args.batch_size):
-        batch_end = min(batch_start + args.batch_size, total)
-        batch = items[batch_start:batch_end]
-        batch_num = batch_start // args.batch_size + 1
-        total_batches = (total + args.batch_size - 1) // args.batch_size
-
-        logger.info(f"Batch {batch_num}/{total_batches} ({processed}/{total} done)")
-
-        try:
-            messages = [make_ocr_message(img, task=args.task) for img, _ in batch]
-            outputs = llm.chat(messages, sampling_params)
-
-            for (_, md_path), output in zip(batch, outputs):
-                text = output.outputs[0].text.strip()
-                md_path.parent.mkdir(parents=True, exist_ok=True)
-                md_path.write_text(text, encoding="utf-8")
-                processed += 1
-
-        except Exception as e:
-            logger.error(f"Batch {batch_num} failed: {e}")
-            # Write error markers for failed batch
-            for _, md_path in batch:
-                md_path.parent.mkdir(parents=True, exist_ok=True)
-                md_path.write_text(f"[OCR ERROR: {e}]", encoding="utf-8")
-            errors += len(batch)
-            processed += len(batch)
-
-    elapsed = time.time() - start_time
-    elapsed_str = f"{elapsed / 60:.1f} min" if elapsed > 60 else f"{elapsed:.1f}s"
-
-    logger.info("=" * 50)
-    logger.info(f"Done! Processed {total} images in {elapsed_str}")
-    logger.info(f"  Output: {output_dir}")
-    logger.info(f"  Errors: {errors}")
-    if total > 0:
-        logger.info(f"  Speed: {total / elapsed:.2f} images/sec")
-
-    if args.verbose:
-        import importlib.metadata
-
-        logger.info("--- Package versions ---")
-        for pkg in ["vllm", "transformers", "torch", "pillow", "pymupdf"]:
-            try:
-                logger.info(f"  {pkg}=={importlib.metadata.version(pkg)}")
-            except importlib.metadata.PackageNotFoundError:
-                logger.info(f"  {pkg}: not installed")
-
-
-if __name__ == "__main__":
-    if len(sys.argv) == 1:
-        print("=" * 60)
-        print("GLM-OCR Bucket Script")
-        print("=" * 60)
-        print("\nOCR images/PDFs from a directory → markdown files.")
-        print("Designed for HF Buckets mounted as volumes (PR #3936).")
-        print()
-        print("Usage:")
-        print("  uv run glm-ocr-bucket.py INPUT_DIR OUTPUT_DIR")
-        print()
-        print("Examples:")
-        print("  uv run glm-ocr-bucket.py ./images ./output")
-        print("  uv run glm-ocr-bucket.py /input /output --task table")
-        print()
-        print("HF Jobs with bucket volumes:")
-        print("  hf jobs uv run --flavor l4x1 -s HF_TOKEN \\")
-        print("      -v bucket/user/ocr-input:/input:ro \\")
-        print("      -v bucket/user/ocr-output:/output \\")
-        print("      glm-ocr-bucket.py /input /output")
-        print()
-        print("For full help: uv run glm-ocr-bucket.py --help")
-        sys.exit(0)
-
-    main()

qianfan-ocr.py

@@ -1,628 +0,0 @@
-# /// script
-# requires-python = ">=3.11"
-# dependencies = [
-#     "datasets>=4.0.0",
-#     "huggingface-hub",
-#     "pillow",
-#     "vllm>=0.15.1",
-#     "tqdm",
-#     "toolz",
-#     "torch",
-# ]
-# ///
-
-"""
-Convert document images to markdown using Qianfan-OCR with vLLM.
-
-Qianfan-OCR is a 4.7B end-to-end document intelligence model from Baidu,
-built on InternVL architecture with Qianfan-ViT encoder + Qwen3-4B LLM.
-
-Features:
-- #1 end-to-end model on OmniDocBench v1.5 (93.12) and OlmOCR Bench (79.8)
-- Layout-as-Thought: optional reasoning phase for complex layouts via --think
-- 192 language support (Latin, CJK, Arabic, Cyrillic, and more)
-- Multiple task modes: OCR, table (HTML), formula (LaTeX), chart, scene text
-- Key information extraction with custom prompts
-- 1.024 PPS on A100 with W8A8 quantization
-
-Model: baidu/Qianfan-OCR
-License: Apache 2.0
-Paper: https://arxiv.org/abs/2603.13398
-"""
-
-import argparse
-import base64
-import io
-import json
-import logging
-import os
-import sys
-import time
-from datetime import datetime
-from typing import Any, Dict, List, Union
-
-import torch
-from datasets import load_dataset
-from huggingface_hub import DatasetCard, login
-from PIL import Image
-from toolz import partition_all
-from tqdm.auto import tqdm
-from vllm import LLM, SamplingParams
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-MODEL = "baidu/Qianfan-OCR"
-
-PROMPT_TEMPLATES = {
-    "ocr": "Parse this document to Markdown.",
-    "table": "Extract tables to HTML format.",
-    "formula": "Extract formulas to LaTeX.",
-    "chart": "What trends are shown in this chart?",
-    "scene": "Extract all visible text from the image.",
-    "kie": None,  # requires --custom-prompt
-}
-
-
-def check_cuda_availability():
-    """Check if CUDA is available and exit if not."""
-    if not torch.cuda.is_available():
-        logger.error("CUDA is not available. This script requires a GPU.")
-        sys.exit(1)
-    else:
-        logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
-
-
-def extract_content_from_thinking(text: str, include_thinking: bool = False) -> str:
-    """
-    Extract final content from Qianfan-OCR's Layout-as-Thought output.
-
-    When --think is enabled, the model generates layout analysis inside
-    <think>...</think> tags before the final markdown output.
-    """
-    if include_thinking:
-        return text.strip()
-
-    # If no thinking tags, return as-is
-    if "<think>" not in text:
-        return text.strip()
-
-    # Extract everything after </think>
-    think_end = text.find("</think>")
-    if think_end != -1:
-        return text[think_end + 8 :].strip()
-
-    # Thinking started but never closed — return full text
-    logger.warning("Found <think> but no </think>, returning full text")
-    return text.strip()
-
-
-def make_ocr_message(
-    image: Union[Image.Image, Dict[str, Any], str],
-    prompt: str,
-) -> List[Dict]:
-    """Create vLLM chat message with image and prompt."""
-    if isinstance(image, Image.Image):
-        pil_img = image
-    elif isinstance(image, dict) and "bytes" in image:
-        pil_img = Image.open(io.BytesIO(image["bytes"]))
-    elif isinstance(image, str):
-        pil_img = Image.open(image)
-    else:
-        raise ValueError(f"Unsupported image type: {type(image)}")
-
-    pil_img = pil_img.convert("RGB")
-
-    buf = io.BytesIO()
-    pil_img.save(buf, format="PNG")
-    data_uri = f"data:image/png;base64,{base64.b64encode(buf.getvalue()).decode()}"
-
-    return [
-        {
-            "role": "user",
-            "content": [
-                {"type": "image_url", "image_url": {"url": data_uri}},
-                {"type": "text", "text": prompt},
-            ],
-        }
-    ]
-
-
-def create_dataset_card(
-    source_dataset: str,
-    model: str,
-    num_samples: int,
-    processing_time: str,
-    batch_size: int,
-    max_model_len: int,
-    max_tokens: int,
-    gpu_memory_utilization: float,
-    prompt_mode: str,
-    think: bool,
-    include_thinking: bool,
-    image_column: str = "image",
-    split: str = "train",
-) -> str:
-    """Create a dataset card documenting the OCR process."""
-    model_name = model.split("/")[-1]
-
-    return f"""---
-tags:
-- ocr
-- document-processing
-- qianfan-ocr
-- markdown
-- uv-script
-- generated
----
-
-# Document OCR using {model_name}
-
-This dataset contains OCR results from [{source_dataset}](https://huggingface.co/datasets/{source_dataset}) using Qianfan-OCR, Baidu's 4.7B end-to-end document intelligence model.
-
-## Processing Details
-
-- **Source Dataset**: [{source_dataset}](https://huggingface.co/datasets/{source_dataset})
-- **Model**: [{model}](https://huggingface.co/{model})
-- **Number of Samples**: {num_samples:,}
-- **Processing Time**: {processing_time}
-- **Processing Date**: {datetime.now().strftime("%Y-%m-%d %H:%M UTC")}
-
-### Configuration
-
-- **Image Column**: `{image_column}`
-- **Output Column**: `markdown`
-- **Dataset Split**: `{split}`
-- **Batch Size**: {batch_size}
-- **Prompt Mode**: {prompt_mode}
-- **Layout-as-Thought**: {"Enabled" if think else "Disabled"}
-- **Thinking Traces**: {"Included" if include_thinking else "Excluded"}
-- **Max Model Length**: {max_model_len:,} tokens
-- **Max Output Tokens**: {max_tokens:,}
-- **GPU Memory Utilization**: {gpu_memory_utilization:.1%}
-
-## Model Information
-
-Qianfan-OCR key capabilities:
-- #1 end-to-end model on OmniDocBench v1.5 (93.12)
-- #1 on OlmOCR Bench (79.8)
-- 192 language support
-- Layout-as-Thought reasoning for complex documents
-- Document parsing, table extraction, formula recognition, chart understanding
-- Key information extraction
-
-## Dataset Structure
-
-The dataset contains all original columns plus:
-- `markdown`: The extracted text in markdown format
-- `inference_info`: JSON list tracking all OCR models applied
-
-## Reproduction
-
-```bash
-uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/qianfan-ocr.py \\
-    {source_dataset} \\
-    <output-dataset> \\
-    --image-column {image_column} \\
-    --prompt-mode {prompt_mode} \\
-    --batch-size {batch_size}{"  --think" if think else ""}
-```
-
-Generated with [UV Scripts](https://huggingface.co/uv-scripts)
-"""
-
-
-def main(
-    input_dataset: str,
-    output_dataset: str,
-    image_column: str = "image",
-    batch_size: int = 8,
-    max_model_len: int = 16384,
-    max_tokens: int = 8192,
-    temperature: float = 0.0,
-    top_p: float = 1.0,
-    gpu_memory_utilization: float = 0.85,
-    hf_token: str = None,
-    split: str = "train",
-    max_samples: int = None,
-    private: bool = False,
-    shuffle: bool = False,
-    seed: int = 42,
-    prompt_mode: str = "ocr",
-    think: bool = False,
-    include_thinking: bool = False,
-    custom_prompt: str = None,
-    output_column: str = "markdown",
-    config: str = None,
-    create_pr: bool = False,
-    verbose: bool = False,
-):
-    """Process images from HF dataset through Qianfan-OCR model."""
-
-    check_cuda_availability()
-    start_time = datetime.now()
-
-    HF_TOKEN = hf_token or os.environ.get("HF_TOKEN")
-    if HF_TOKEN:
-        login(token=HF_TOKEN)
-
-    # Build prompt
-    if custom_prompt:
-        prompt = custom_prompt
-        logger.info(f"Using custom prompt: {prompt[:80]}...")
-    else:
-        if prompt_mode == "kie":
-            logger.error("--prompt-mode kie requires --custom-prompt")
-            sys.exit(1)
-        prompt = PROMPT_TEMPLATES[prompt_mode]
-        logger.info(f"Using prompt mode: {prompt_mode}")
-
-    if think:
-        prompt = prompt + "<think>"
-        logger.info("Layout-as-Thought enabled (appending <think> to prompt)")
-
-    logger.info(f"Using model: {MODEL}")
-
-    # Load dataset
-    logger.info(f"Loading dataset: {input_dataset}")
-    dataset = load_dataset(input_dataset, split=split)
-
-    if image_column not in dataset.column_names:
-        raise ValueError(
-            f"Column '{image_column}' not found. Available: {dataset.column_names}"
-        )
-
-    if shuffle:
-        logger.info(f"Shuffling dataset with seed {seed}")
-        dataset = dataset.shuffle(seed=seed)
-
-    if max_samples:
-        dataset = dataset.select(range(min(max_samples, len(dataset))))
-        logger.info(f"Limited to {len(dataset)} samples")
-
-    # Initialize vLLM
-    logger.info("Initializing vLLM with Qianfan-OCR")
-    logger.info("This may take a few minutes on first run...")
-    llm = LLM(
-        model=MODEL,
-        trust_remote_code=True,
-        max_model_len=max_model_len,
-        gpu_memory_utilization=gpu_memory_utilization,
-        limit_mm_per_prompt={"image": 1},
-        enforce_eager=False,
-    )
-
-    sampling_params = SamplingParams(
-        temperature=temperature,
-        top_p=top_p,
-        max_tokens=max_tokens,
-    )
-
-    logger.info(f"Processing {len(dataset)} images in batches of {batch_size}")
-    logger.info(f"Output will be written to column: {output_column}")
-
-    # Process images in batches
-    all_outputs = []
-
-    for batch_indices in tqdm(
-        partition_all(batch_size, range(len(dataset))),
-        total=(len(dataset) + batch_size - 1) // batch_size,
-        desc="Qianfan-OCR processing",
-    ):
-        batch_indices = list(batch_indices)
-        batch_images = [dataset[i][image_column] for i in batch_indices]
-
-        try:
-            batch_messages = [make_ocr_message(img, prompt) for img in batch_images]
-            outputs = llm.chat(batch_messages, sampling_params)
-
-            for output in outputs:
-                text = output.outputs[0].text.strip()
-                if think:
-                    text = extract_content_from_thinking(text, include_thinking)
-                all_outputs.append(text)
-
-        except Exception as e:
-            logger.error(f"Error processing batch: {e}")
-            all_outputs.extend(["[OCR ERROR]"] * len(batch_images))
-
-    # Calculate processing time
-    processing_duration = datetime.now() - start_time
-    processing_time_str = f"{processing_duration.total_seconds() / 60:.1f} min"
-
-    # Add output column
-    logger.info(f"Adding '{output_column}' column to dataset")
-    dataset = dataset.add_column(output_column, all_outputs)
-
-    # Handle inference_info tracking
-    inference_entry = {
-        "model_id": MODEL,
-        "model_name": "Qianfan-OCR",
-        "column_name": output_column,
-        "timestamp": datetime.now().isoformat(),
-        "prompt_mode": prompt_mode if not custom_prompt else "custom",
-        "think": think,
-        "temperature": temperature,
-        "max_tokens": max_tokens,
-    }
-
-    if "inference_info" in dataset.column_names:
-        logger.info("Updating existing inference_info column")
-
-        def update_inference_info(example):
-            try:
-                existing_info = (
-                    json.loads(example["inference_info"])
-                    if example["inference_info"]
-                    else []
-                )
-            except (json.JSONDecodeError, TypeError):
-                existing_info = []
-            existing_info.append(inference_entry)
-            return {"inference_info": json.dumps(existing_info)}
-
-        dataset = dataset.map(update_inference_info)
-    else:
-        logger.info("Creating new inference_info column")
-        inference_list = [json.dumps([inference_entry])] * len(dataset)
-        dataset = dataset.add_column("inference_info", inference_list)
-
-    # Push to hub with retry and XET fallback
-    logger.info(f"Pushing to {output_dataset}")
-    commit_msg = f"Add Qianfan-OCR results ({len(dataset)} samples)" + (
-        f" [{config}]" if config else ""
-    )
-    max_retries = 3
-    for attempt in range(1, max_retries + 1):
-        try:
-            if attempt > 1:
-                logger.warning("Disabling XET (fallback to HTTP upload)")
-                os.environ["HF_HUB_DISABLE_XET"] = "1"
-            dataset.push_to_hub(
-                output_dataset,
-                private=private,
-                token=HF_TOKEN,
-                max_shard_size="500MB",
-                **({"config_name": config} if config else {}),
-                create_pr=create_pr,
-                commit_message=commit_msg,
-            )
-            break
-        except Exception as e:
-            logger.error(f"Upload attempt {attempt}/{max_retries} failed: {e}")
-            if attempt < max_retries:
-                delay = 30 * (2 ** (attempt - 1))
-                logger.info(f"Retrying in {delay}s...")
-                time.sleep(delay)
-            else:
-                logger.error("All upload attempts failed. OCR results are lost.")
-                sys.exit(1)
-
-    # Create and push dataset card (skip when creating PR to avoid conflicts)
-    if not create_pr:
-        logger.info("Creating dataset card")
-        card_content = create_dataset_card(
-            source_dataset=input_dataset,
-            model=MODEL,
-            num_samples=len(dataset),
-            processing_time=processing_time_str,
-            batch_size=batch_size,
-            max_model_len=max_model_len,
-            max_tokens=max_tokens,
-            gpu_memory_utilization=gpu_memory_utilization,
-            prompt_mode=prompt_mode if not custom_prompt else "custom",
-            think=think,
-            include_thinking=include_thinking,
-            image_column=image_column,
-            split=split,
-        )
-        card = DatasetCard(card_content)
-        card.push_to_hub(output_dataset, token=HF_TOKEN)
-
-    logger.info("Qianfan-OCR processing complete!")
-    logger.info(
-        f"Dataset available at: https://huggingface.co/datasets/{output_dataset}"
-    )
-    logger.info(f"Processing time: {processing_time_str}")
-    logger.info(
-        f"Processing speed: {len(dataset) / processing_duration.total_seconds():.2f} images/sec"
-    )
-
-    if verbose:
-        import importlib.metadata
-
-        logger.info("--- Resolved package versions ---")
-        for pkg in ["vllm", "transformers", "torch", "datasets", "pyarrow", "pillow"]:
-            try:
-                logger.info(f"  {pkg}=={importlib.metadata.version(pkg)}")
-            except importlib.metadata.PackageNotFoundError:
-                logger.info(f"  {pkg}: not installed")
-        logger.info("--- End versions ---")
-
-
-if __name__ == "__main__":
-    if len(sys.argv) == 1:
-        print("=" * 80)
-        print("Qianfan-OCR - End-to-End Document Intelligence")
-        print("=" * 80)
-        print("\n4.7B model from Baidu, #1 on OmniDocBench v1.5 (93.12)")
-        print("\nFeatures:")
-        print("- #1 end-to-end model on OmniDocBench v1.5 and OlmOCR Bench")
-        print("- Layout-as-Thought reasoning for complex documents (--think)")
-        print("- 192 language support")
-        print("- Multiple modes: OCR, table (HTML), formula (LaTeX), chart, scene text")
-        print("- Key information extraction with custom prompts")
-        print("\nExample usage:")
-        print("\n1. Basic OCR:")
-        print("   uv run qianfan-ocr.py input-dataset output-dataset")
-        print("\n2. With Layout-as-Thought (complex documents):")
-        print("   uv run qianfan-ocr.py docs output --think")
-        print("\n3. Table extraction:")
-        print("   uv run qianfan-ocr.py docs output --prompt-mode table")
-        print("\n4. Formula extraction:")
-        print("   uv run qianfan-ocr.py docs output --prompt-mode formula")
-        print("\n5. Key information extraction:")
-        print(
-            '   uv run qianfan-ocr.py invoices output --prompt-mode kie --custom-prompt "Extract: name, date, total. Output JSON."'
-        )
-        print("\n6. Running on HF Jobs:")
-        print("   hf jobs uv run --flavor l4x1 \\")
-        print("     -s HF_TOKEN \\")
-        print(
-            "     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/qianfan-ocr.py \\"
-        )
-        print("       input-dataset output-dataset --max-samples 10")
-        print("\nFor full help, run: uv run qianfan-ocr.py --help")
-        sys.exit(0)
-
-    parser = argparse.ArgumentParser(
-        description="Document OCR using Qianfan-OCR (4.7B, #1 on OmniDocBench v1.5)",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Prompt modes:
-  ocr       Document parsing to Markdown (default)
-  table     Table extraction to HTML format
-  formula   Formula recognition to LaTeX
-  chart     Chart understanding and analysis
-  scene     Scene text extraction
-  kie       Key information extraction (requires --custom-prompt)
-
-Examples:
-  uv run qianfan-ocr.py my-docs analyzed-docs
-  uv run qianfan-ocr.py docs output --think --max-samples 50
-  uv run qianfan-ocr.py docs output --prompt-mode table
-  uv run qianfan-ocr.py invoices data --prompt-mode kie --custom-prompt "Extract: name, date, total."
-        """,
-    )
-
-    parser.add_argument("input_dataset", help="Input dataset ID from Hugging Face Hub")
-    parser.add_argument("output_dataset", help="Output dataset ID for Hugging Face Hub")
-    parser.add_argument(
-        "--image-column",
-        default="image",
-        help="Column containing images (default: image)",
-    )
-    parser.add_argument(
-        "--batch-size",
-        type=int,
-        default=8,
-        help="Batch size for processing (default: 8)",
-    )
-    parser.add_argument(
-        "--max-model-len",
-        type=int,
-        default=16384,
-        help="Maximum model context length (default: 16384, reduce to 8192 if OOM on L4)",
-    )
-    parser.add_argument(
-        "--max-tokens",
-        type=int,
-        default=8192,
-        help="Maximum tokens to generate (default: 8192)",
-    )
-    parser.add_argument(
-        "--temperature",
-        type=float,
-        default=0.0,
-        help="Sampling temperature (default: 0.0, deterministic)",
-    )
-    parser.add_argument(
-        "--top-p",
-        type=float,
-        default=1.0,
-        help="Top-p sampling parameter (default: 1.0)",
-    )
-    parser.add_argument(
-        "--gpu-memory-utilization",
-        type=float,
-        default=0.85,
-        help="GPU memory utilization (default: 0.85)",
-    )
-    parser.add_argument("--hf-token", help="Hugging Face API token")
-    parser.add_argument(
-        "--split", default="train", help="Dataset split to use (default: train)"
-    )
-    parser.add_argument(
-        "--max-samples",
-        type=int,
-        help="Maximum number of samples to process (for testing)",
-    )
-    parser.add_argument(
-        "--private", action="store_true", help="Make output dataset private"
-    )
-    parser.add_argument(
-        "--shuffle", action="store_true", help="Shuffle dataset before processing"
-    )
-    parser.add_argument(
-        "--seed",
-        type=int,
-        default=42,
-        help="Random seed for shuffling (default: 42)",
-    )
-    parser.add_argument(
-        "--prompt-mode",
-        choices=list(PROMPT_TEMPLATES.keys()),
-        default="ocr",
-        help="Prompt mode (default: ocr)",
-    )
-    parser.add_argument(
-        "--think",
-        action="store_true",
-        help="Enable Layout-as-Thought reasoning (appends <think> to prompt)",
-    )
-    parser.add_argument(
-        "--include-thinking",
-        action="store_true",
-        help="Include thinking traces in output (default: only final content)",
-    )
-    parser.add_argument(
-        "--custom-prompt",
-        help="Custom prompt text (overrides --prompt-mode)",
-    )
-    parser.add_argument(
-        "--output-column",
-        default="markdown",
-        help="Column name for output text (default: markdown)",
-    )
-    parser.add_argument(
-        "--config",
-        help="Config/subset name when pushing to Hub (for benchmarking multiple models)",
-    )
-    parser.add_argument(
-        "--create-pr",
-        action="store_true",
-        help="Create a pull request instead of pushing directly",
-    )
-    parser.add_argument(
-        "--verbose",
-        action="store_true",
-        help="Log resolved package versions after processing",
-    )
-
-    args = parser.parse_args()
-
-    main(
-        input_dataset=args.input_dataset,
-        output_dataset=args.output_dataset,
-        image_column=args.image_column,
-        batch_size=args.batch_size,
-        max_model_len=args.max_model_len,
-        max_tokens=args.max_tokens,
-        temperature=args.temperature,
-        top_p=args.top_p,
-        gpu_memory_utilization=args.gpu_memory_utilization,
-        hf_token=args.hf_token,
-        split=args.split,
-        max_samples=args.max_samples,
-        private=args.private,
-        shuffle=args.shuffle,
-        seed=args.seed,
-        prompt_mode=args.prompt_mode,
-        think=args.think,
-        include_thinking=args.include_thinking,
-        custom_prompt=args.custom_prompt,
-        output_column=args.output_column,
-        config=args.config,
-        create_pr=args.create_pr,
-        verbose=args.verbose,
-    )