I need pull

AGENTS.md

@@ -1,92 +0,0 @@
-# For coding agents
-
-This repo is a curated collection of ready-to-run OCR scripts — each one self-contained
-via UV inline metadata, runnable over the network via `hf jobs uv run`. No clone, no
-install, no setup.
-
-## Don't rely on this doc — discover the current state
-
-This file will go stale. Prefer these sources of truth:
-
-- `hf jobs uv run --help` — job submission flags (volumes, secrets, flavors, timeouts)
-- `hf jobs hardware` — current GPU flavors and pricing
-- `hf auth whoami` — check HF token is set
-- `hf jobs ps` / `hf jobs logs <id>` — monitor running jobs
-- `ls` the repo to see which scripts actually exist (bucket variants especially)
-- [README.md](./README.md) — the table of scripts with model sizes and notes
-
-## Picking a script
-
-The [README.md](./README.md) table lists every script with model size, backend, and
-a short note. Axes that matter:
-
-- **Model size** vs accuracy vs GPU cost. Smaller = cheaper per doc.
-- **Backend**: vLLM scripts are usually fastest at scale. `transformers` and
-  `falcon-perception` are alternatives for specific models.
-- **Task support**: most scripts do plain text; some expose `--task-mode`
-  (table, formula, layout, etc.) — check the script's own docstring.
-
-For the authoritative benchmark numbers on any model in the table, query the model
-card programmatically — every OCR model publishes eval results on its card:
-
-    from huggingface_hub import HfApi
-    info = HfApi().model_info("tiiuae/Falcon-OCR", expand=["evalResults"])
-    for r in info.eval_results:
-        print(r.dataset_id, r.value)
-
-See the [leaderboard data guide](https://huggingface.co/docs/hub/en/leaderboard-data-guide)
-for the full API. This is more reliable than any markdown table that might drift.
-
-## Getting help from a specific script
-
-Each script has a docstring at the top with a description and usage examples. To read it
-without downloading:
-
-    curl -s https://huggingface.co/datasets/uv-scripts/ocr/raw/main/<script>.py | head -100
-
-Or open the URL in a browser. Running `uv run <url> --help` locally may fail if the
-script has GPU-only dependencies — reading the docstring is more reliable.
-
-## The main pattern: dataset → dataset
-
-Most scripts take an input HF dataset ID and push results to an output HF dataset ID:
-
-    hf jobs uv run --flavor l4x1 -s HF_TOKEN \
-      https://huggingface.co/datasets/uv-scripts/ocr/raw/main/<script>.py \
-      <input-dataset-id> <output-dataset-id> [--max-samples N] [--shuffle]
-
-The script adds a `markdown` column to the input dataset and pushes the merged result
-to the output dataset ID on the Hub.
-
-## Alternative: directory → directory (bucket variants)
-
-A couple of scripts have `-bucket.py` variants (currently `falcon-ocr-bucket.py` and
-`glm-ocr-bucket.py`) that read from a mounted directory and write one `.md` per image
-(or per PDF page). Useful with HF Buckets via `-v`:
-
-    hf jobs uv run --flavor l4x1 -s HF_TOKEN \
-      -v hf://buckets/<user>/<input>:/input:ro \
-      -v hf://buckets/<user>/<output>:/output \
-      https://huggingface.co/datasets/uv-scripts/ocr/raw/main/<script>-bucket.py \
-      /input /output
-
-`ls` the repo to check whether a `-bucket.py` variant exists for the model you want
-before assuming it's available.
-
-## Common flags across dataset-mode scripts
-
-Most scripts support: `--max-samples`, `--shuffle`, `--seed`, `--split`, `--image-column`,
-`--output-column`, `--private`, `--config`, `--create-pr`, `--verbose`. Read the script's
-docstring for the authoritative list — individual scripts may add model-specific options
-like `--task-mode`.
-
-## Gotchas
-
-- **Secrets**: pass `-s HF_TOKEN` to forward the user's token into the job.
-- **GPU required**: all scripts exit if CUDA isn't available. `l4x1` is the cheapest
-  GPU flavor and works for models up to ~3B. Check `hf jobs hardware` for current options.
-- **First run is slow**: model download + `torch.compile` / vLLM warmup dominates small
-  runs. Cost per doc drops sharply past a few hundred images — test with `--max-samples 10`
-  first, then scale.
-- **Don't poll jobs**: jobs run async. Submit once, check status later with
-  `hf jobs ps` or `hf jobs logs <id>`.

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

@@ -1,17 +1,15 @@
 ---
 viewer: false
-tags: [uv-script, ocr, extraction, vision-language-model, document-processing, hf-jobs]
+tags: [uv-script, ocr, vision-language-model, document-processing, hf-jobs]
 ---
 
 # OCR UV Scripts
 
-<a href="https://huggingface.co/uv-scripts"><picture><source media="(prefers-color-scheme: dark)" srcset="https://huggingface.co/datasets/huggingface/badges/resolve/main/follow-us-on-hf-md-dark.svg"><img src="https://huggingface.co/datasets/huggingface/badges/resolve/main/follow-us-on-hf-md.svg" alt="Follow uv-scripts on Hugging Face"></picture></a>
+> Part of [uv-scripts](https://huggingface.co/uv-scripts) - ready-to-run ML tools powered by UV and HuggingFace Jobs.
 
-> Part of [uv-scripts](https://huggingface.co/uv-scripts) — self-contained UV scripts you run on Hugging Face Jobs in one command.
+14 OCR models from 0.9B to 8B parameters. Pick a model, point at your dataset, get markdown — no setup required.
 
-A model zoo of OCR scripts — one per model — that add a `markdown` column to an image dataset. Pick a model from the table below, point it at your dataset, and run it on a GPU with one command. A few recipes do **structured extraction** instead — image *or* text → JSON given a schema (see [Structured extraction](#structured-extraction-image-or-text--json) below). Two more companions sit alongside: `pp-doclayout.py` detects layout regions (bboxes for text/title/table/figure/…) instead of text, and `ocr-vllm-judge.py` compares model outputs head-to-head.
-
-## Quick Start
+## 🚀 Quick Start
 
 Run OCR on any dataset without needing your own GPU:
 
@@ -24,220 +22,589 @@ hf jobs uv run --flavor l4x1 \
     --max-samples 10
 ```
 
-This will:
+That's it! The script will:
 
-- Process the first 10 images from your dataset
+- Process first 10 images from your dataset
 - Add OCR results as a new `markdown` column
 - Push the results to a new dataset
 - View results at: `https://huggingface.co/datasets/[your-output-dataset]`
 
-## Models at a glance
-
-**Start here:** for a quick first run, try **`lighton-ocr2.py`** (1B, very fast) or **`paddleocr-vl-1.6.py`** (0.9B, current OmniDocBench SOTA); for the smallest footprint, **`falcon-ocr.py`** (0.3B, strong on tables). Reach for a 7–8B model only when quality demands it. Several of these models sit on the public [olmOCR-Bench](https://huggingface.co/datasets/allenai/olmOCR-bench) — pull the live ranking from your terminal in one command:
-
-```bash
-hf datasets leaderboard allenai/olmOCR-bench
-```
-
-But which model wins on *your* documents is still document-dependent — so [ocr-bench](https://github.com/davanstrien/ocr-bench) builds a **per-collection leaderboard** for your own data (pairwise VLM-as-judge, optionally human-validated), using these scripts under the hood.
-
-_Sorted by model size:_
+<details><summary>All scripts at a glance (sorted by model size)</summary>
 
 | Script | Model | Size | Backend | Notes |
 |--------|-------|------|---------|-------|
-| `falcon-ocr.py` | [Falcon-OCR](https://huggingface.co/tiiuae/Falcon-OCR) | 0.3B | falcon-perception | Smallest in collection. #1 on multi-column docs and tables (olmOCR), Apache 2.0 |
 | `smoldocling-ocr.py` | [SmolDocling](https://huggingface.co/ds4sd/SmolDocling-256M-preview) | 256M | Transformers | DocTags structured output |
 | `glm-ocr.py` | [GLM-OCR](https://huggingface.co/zai-org/GLM-OCR) | 0.9B | vLLM | 94.62% OmniDocBench V1.5 |
 | `paddleocr-vl.py` | [PaddleOCR-VL](https://huggingface.co/PaddlePaddle/PaddleOCR-VL) | 0.9B | Transformers | 4 task modes (ocr/table/formula/chart) |
 | `paddleocr-vl-1.5.py` | [PaddleOCR-VL-1.5](https://huggingface.co/PaddlePaddle/PaddleOCR-VL-1.5) | 0.9B | Transformers | 94.5% OmniDocBench, 6 task modes |
-| `paddleocr-vl-1.6.py` | [PaddleOCR-VL-1.6](https://huggingface.co/PaddlePaddle/PaddleOCR-VL-1.6) | 0.9B | vLLM | **96.33% OmniDocBench v1.6** (SOTA), drop-in upgrade of 1.5 |
 | `lighton-ocr.py` | [LightOnOCR-1B](https://huggingface.co/lightonai/LightOnOCR-1B-1025) | 1B | vLLM | Fast, 3 vocab sizes |
 | `lighton-ocr2.py` | [LightOnOCR-2-1B](https://huggingface.co/lightonai/LightOnOCR-2-1B) | 1B | vLLM | 7× faster than v1, RLVR trained |
 | `hunyuan-ocr.py` | [HunyuanOCR](https://huggingface.co/tencent/HunyuanOCR) | 1B | vLLM | Lightweight VLM |
 | `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 |
-| `abot-ocr.py` | [ABot-OCR](https://huggingface.co/acvlab/ABot-OCR) | 2B | vLLM | Qwen3-VL based, doc→Markdown (text/LaTeX/HTML tables). Needs `vllm/vllm-openai` image. [paper](https://arxiv.org/abs/2605.27978) |
 | `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; needs nightly vLLM **+ the `vllm/vllm-openai` image** ([why](#if-a-vllm-script-crashes-at-startup-the-nvcc--nvrtc-error)) |
-| `nuextract3.py` | [NuExtract3](https://huggingface.co/numind/NuExtract3) | 4B | vLLM | Markdown OCR **+ schema-guided JSON extraction** (template/Pydantic). Needs `vllm/vllm-openai` image |
-| `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 |
+| `deepseek-ocr2-vllm.py` | [DeepSeek-OCR-2](https://huggingface.co/deepseek-ai/DeepSeek-OCR-2) | 3B | vLLM | Newer, requires nightly vLLM |
 | `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 |
 
-**Variants & tools** (same models, different I/O): `glm-ocr-v2.py` adds checkpoint/resume for very large jobs · `glm-ocr-bucket.py` and `falcon-ocr-bucket.py` read images/PDFs from a mounted bucket and write one `.md` per page · `ocr-vllm-judge.py` runs pairwise OCR-quality comparisons.
+</details>
 
-## Structured extraction (image or text → JSON)
+## Common Options
 
-Most scripts here output markdown. These take a **schema** and return **structured data** instead — give them the fields you want, they fill them in:
+All scripts accept the same core flags. Model-specific defaults (batch size, context length, temperature) are tuned per model based on model card recommendations and can be overridden.
 
-| Script | Model | Size | Input | Output |
-|--------|-------|------|-------|--------|
-| `lfm2-vl-extract.py` | [LFM2.5-VL-1.6B-Extract](https://huggingface.co/LiquidAI/LFM2.5-VL-1.6B-Extract) | 1.6B | image | JSON |
-| `nuextract3.py` | [NuExtract3](https://huggingface.co/numind/NuExtract3) | 4B | image | markdown **or** JSON |
-| `lfm2-extract.py` | [LFM2-1.2B-Extract](https://huggingface.co/LiquidAI/LFM2-1.2B-Extract) | 1.2B | **text** | JSON / XML / YAML |
+| Option | Description |
+|--------|-------------|
+| `--image-column` | Column containing images (default: `image`) |
+| `--output-column` | Output column name (default: `markdown`) |
+| `--split` | Dataset split (default: `train`) |
+| `--max-samples` | Limit number of samples (useful for testing) |
+| `--private` | Make output dataset private |
+| `--shuffle` | Shuffle dataset before processing |
+| `--seed` | Random seed for shuffling (default: `42`) |
+| `--batch-size` | Images per batch (default varies per model) |
+| `--max-model-len` | Max context length (default varies per model) |
+| `--max-tokens` | Max output tokens (default varies per model) |
+| `--gpu-memory-utilization` | GPU memory fraction (default: `0.8`) |
+| `--config` | Config name for Hub push (for benchmarking) |
+| `--create-pr` | Push as PR instead of direct commit |
+| `--verbose` | Log resolved package versions after run |
 
-Pass `--schema` (inline JSON, a URL, or a file path). The LFM models are small and fast; run them on the `vllm/vllm-openai` image so the CUDA toolkit is present (each script's docstring has the exact command). Because `lfm2-extract.py` works on a **text** column, you can **chain it after OCR**: a recipe above turns a page into `markdown`, then `lfm2-extract.py` turns that markdown into fields.
+Every script supports `--help` to see all available options:
 
 ```bash
-# image → JSON directly
-hf jobs uv run --flavor l4x1 --secrets HF_TOKEN \
-    --image vllm/vllm-openai --python /usr/bin/python3 \
-    -e PYTHONPATH=/usr/local/lib/python3.12/dist-packages \
-    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lfm2-vl-extract.py \
-    my-images my-fields --schema '{"title": "the document title", "date": "any date shown"}'
+uv run glm-ocr.py --help
 ```
 
-## Layout detection (not OCR)
+## Example: GLM-OCR
 
-`pp-doclayout.py` runs PaddleOCR's [PP-DocLayout-L](https://huggingface.co/PaddlePaddle/PP-DocLayout-L) (or M / S / plus-L) and emits per-image **bounding boxes + region classes** (text, title, table, figure, formula, list, header, footer, ...) — it does NOT extract text. Useful for filtering pages, cropping regions for downstream OCR, dataset analysis, and training-data prep.
-
-| Script | Model | Size | Backend | Notes |
-|--------|-------|------|---------|-------|
-| `pp-doclayout.py` | [PP-DocLayout-L](https://huggingface.co/PaddlePaddle/PP-DocLayout-L) | 123M | paddleocr | Layout bboxes (no text). Bucket support: incremental parquet shards, resumable. |
+[GLM-OCR](https://huggingface.co/zai-org/GLM-OCR) (0.9B) scores 94.62% on OmniDocBench V1.5 and supports OCR, formula, and table extraction:
 
 ```bash
+# Basic OCR
 hf jobs uv run --flavor l4x1 -s HF_TOKEN \
-    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/pp-doclayout.py \
-    your-dataset your-layout-output --max-samples 10
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/glm-ocr.py \
+    my-documents my-ocr-output
+
+# Table extraction
+hf jobs uv run --flavor l4x1 -s HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/glm-ocr.py \
+    my-documents my-tables --task table
+
+# Test on 10 samples first
+hf jobs uv run --flavor l4x1 -s HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/glm-ocr.py \
+    my-documents my-test --max-samples 10
 ```
 
-Source/sink can be either an HF dataset repo OR an `hf://buckets/...` URL (auto-detected). Bucket output writes incremental zstd parquet shards via the buckets API — resumable across runs (snapshot-backed source listing) and no git/commit overhead. See the script's `--help` for all flags.
+<details><summary>Detailed per-model documentation</summary>
+
+### PaddleOCR-VL-1.5 (`paddleocr-vl-1.5.py`) — 6 task modes
+
+OCR using [PaddlePaddle/PaddleOCR-VL-1.5](https://huggingface.co/PaddlePaddle/PaddleOCR-VL-1.5) with 94.5% accuracy:
+
+- **94.5% on OmniDocBench v1.5** (0.9B parameters)
+- 🧩 **Ultra-compact** - Only 0.9B parameters
+- 📝 **OCR mode** - General text extraction to markdown
+- 📊 **Table mode** - HTML table recognition
+- 📐 **Formula mode** - LaTeX mathematical notation
+- 📈 **Chart mode** - Chart and diagram analysis
+- 🔍 **Spotting mode** - Text spotting with localization (higher resolution)
+- 🔖 **Seal mode** - Seal and stamp recognition
+- 🌍 **Multilingual** - Support for multiple languages
 
-## If a vLLM script crashes at startup (the `nvcc` / `nvrtc` error)
+**Task Modes:**
 
-The vLLM recipes run on the **default** Jobs image and carry a guard (`VLLM_USE_FLASHINFER_SAMPLER=0`) so they work there with the plain command. But some — especially nightly-vLLM ones — JIT-compile a CUDA kernel at engine init and crash on the default image with one of:
+- `ocr`: General text extraction (default)
+- `table`: Table extraction to HTML
+- `formula`: Mathematical formula to LaTeX
+- `chart`: Chart and diagram analysis
+- `spotting`: Text spotting with localization
+- `seal`: Seal and stamp recognition
 
+**Quick start:**
+
+```bash
+# Basic OCR mode
+hf jobs uv run --flavor l4x1 \
+    -s HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/paddleocr-vl-1.5.py \
+    your-input-dataset your-output-dataset \
+    --max-samples 100
+
+# Table extraction
+hf jobs uv run --flavor l4x1 \
+    -s HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/paddleocr-vl-1.5.py \
+    documents tables-extracted \
+    --task-mode table
+
+# Seal recognition
+hf jobs uv run --flavor l4x1 \
+    -s HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/paddleocr-vl-1.5.py \
+    documents seals-extracted \
+    --task-mode seal
 ```
-RuntimeError: Could not find nvcc and default cuda_home='/usr/local/cuda' doesn't exist
-nvrtc: error: failed to open libnvrtc-builtins.so...
+
+### PaddleOCR-VL (`paddleocr-vl.py`) 🎯 Smallest model with task-specific modes!
+
+Ultra-compact OCR using [PaddlePaddle/PaddleOCR-VL](https://huggingface.co/PaddlePaddle/PaddleOCR-VL) with only 0.9B parameters:
+
+- 🎯 **Smallest model** - Only 0.9B parameters (even smaller than LightOnOCR!)
+- 📝 **OCR mode** - General text extraction to markdown
+- 📊 **Table mode** - HTML table recognition and extraction
+- 📐 **Formula mode** - LaTeX mathematical notation
+- 📈 **Chart mode** - Structured chart and diagram analysis
+- 🌍 **Multilingual** - Support for multiple languages
+- ⚡ **Fast initialization** - Tiny model size for quick startup
+- 🔧 **ERNIE-4.5 based** - Different architecture from Qwen models
+
+**Task Modes:**
+
+- `ocr`: General text extraction (default)
+- `table`: Table extraction to HTML
+- `formula`: Mathematical formula to LaTeX
+- `chart`: Chart and diagram analysis
+
+**Quick start:**
+
+```bash
+# Basic OCR mode
+hf jobs uv run --flavor l4x1 \
+    -s HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/paddleocr-vl.py \
+    your-input-dataset your-output-dataset \
+    --max-samples 100
+
+# Table extraction
+hf jobs uv run --flavor l4x1 \
+    -s HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/paddleocr-vl.py \
+    documents tables-extracted \
+    --task-mode table \
+    --batch-size 32
 ```
 
-Run those on the **`vllm/vllm-openai` image**, which ships the full CUDA toolkit. Add these flags to any recipe — they point `import vllm` at the image's CUDA-matched build:
+### GLM-OCR (`glm-ocr.py`) 🏆 SOTA on OmniDocBench V1.5!
+
+Compact high-performance OCR using [zai-org/GLM-OCR](https://huggingface.co/zai-org/GLM-OCR) with 0.9B parameters:
+
+- 🏆 **94.62% on OmniDocBench V1.5** - #1 overall ranking
+- 🧠 **Multi-Token Prediction** - MTP loss + stable full-task RL for quality
+- 📝 **Text recognition** - Clean markdown output
+- 📐 **Formula recognition** - LaTeX mathematical notation
+- 📊 **Table recognition** - Structured table extraction
+- 🌍 **Multilingual** - zh, en, fr, es, ru, de, ja, ko
+- ⚡ **Compact** - Only 0.9B parameters, MIT licensed
+- 🔧 **CogViT + GLM** - Visual encoder with efficient token downsampling
+
+**Task Modes:**
+
+- `ocr`: Text recognition (default)
+- `formula`: LaTeX formula recognition
+- `table`: Table extraction
+
+**Quick start:**
 
 ```bash
-hf jobs uv run --flavor l4x1 --secrets HF_TOKEN \
-    --image vllm/vllm-openai --python /usr/bin/python3 \
-    -e PYTHONPATH=/usr/local/lib/python3.12/dist-packages \
-    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/<script>.py \
-    INPUT OUTPUT --max-samples 10
+# Basic OCR
+hf jobs uv run --flavor l4x1 \
+    -s HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/glm-ocr.py \
+    your-input-dataset your-output-dataset \
+    --max-samples 100
+
+# Formula recognition
+hf jobs uv run --flavor l4x1 \
+    -s HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/glm-ocr.py \
+    scientific-papers formulas-extracted \
+    --task formula
+
+# Table extraction
+hf jobs uv run --flavor l4x1 \
+    -s HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/glm-ocr.py \
+    documents tables-extracted \
+    --task table
 ```
 
-This is **required** for a few scripts (e.g. `deepseek-ocr2-vllm.py`, `abot-ocr.py`, `nuextract3.py`) and a safe fallback for any vLLM recipe that crashes at startup. (It's also the more robust way to run any vLLM recipe — full CUDA toolkit, ABI-matched build. It isn't a speed-up: uv still reinstalls the script's deps either way.)
+### LightOnOCR (`lighton-ocr.py`) ⚡ Good one to test first since it's small and fast!
 
-## Common Options
+Fast and compact OCR using [lightonai/LightOnOCR-1B-1025](https://huggingface.co/lightonai/LightOnOCR-1B-1025):
 
-The scripts aim to expose a **consistent interface**: every OCR model script takes `input-dataset output-dataset` as positional arguments, accepts the shared core flags below, and writes a `markdown` column — so switching models is usually just swapping the script URL. Models differ where they need to, though: some add their own flags (task modes, resolution presets, `--think`, vocab sizes), a few need a specific Docker image, and per-model defaults (batch size, context length, temperature) are tuned to each model card. Always check a script's `--help` for its specifics.
+- ⚡ **Fastest**: 5.71 pages/sec on H100, ~6.25 images/sec on A100 with batch_size=4096
+- 🎯 **Compact**: Only 1B parameters - quick to download and initialize
+- 🌍 **Multilingual**: 3 vocabulary sizes for different use cases
+- 📐 **LaTeX formulas**: Mathematical notation in LaTeX format
+- 📊 **Table extraction**: Markdown table format
+- 📝 **Document structure**: Preserves hierarchy and layout
+- 🚀 **Production-ready**: 76.1% benchmark score, used in production
 
-| Option | Description |
-|--------|-------------|
-| `--image-column` | Column containing images (default: `image`) |
-| `--output-column` | Output column name (default: `markdown`) |
-| `--split` | Dataset split (default: `train`) |
-| `--max-samples` | Limit number of samples (useful for testing) |
-| `--private` | Make output dataset private |
-| `--shuffle` | Shuffle dataset before processing |
-| `--seed` | Random seed for shuffling (default: `42`) |
-| `--batch-size` | Images per batch (default varies per model) |
-| `--max-model-len` | Max context length (default varies per model) |
-| `--max-tokens` | Max output tokens (default varies per model) |
-| `--gpu-memory-utilization` | GPU memory fraction (default: `0.8`) |
-| `--config` | Config name for Hub push (for benchmarking) |
-| `--create-pr` | Push as PR instead of direct commit |
-| `--verbose` | Log resolved package versions after run |
+**Vocabulary sizes:**
 
-Every script supports `--help` to see all available options:
+- `151k`: Full vocabulary, all languages (default)
+- `32k`: European languages, ~12% faster decoding
+- `16k`: European languages, ~12% faster decoding
+
+**Quick start:**
 
 ```bash
-uv run glm-ocr.py --help
+# Test on 100 samples with English text (32k vocab is fastest for European languages)
+hf jobs uv run --flavor l4x1 \
+    -s HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lighton-ocr.py \
+    your-input-dataset your-output-dataset \
+    --vocab-size 32k \
+    --batch-size 32 \
+    --max-samples 100
+
+# Full production run on A100 (can handle huge batches!)
+hf jobs uv run --flavor a100-large \
+    -s HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lighton-ocr.py \
+    your-input-dataset your-output-dataset \
+    --vocab-size 32k \
+    --batch-size 4096 \
+    --temperature 0.0
 ```
 
-## NuExtract3: markdown OCR + structured extraction
+### LightOnOCR-2 (`lighton-ocr2.py`) ⚡ Fastest OCR model!
 
-[NuExtract3](https://huggingface.co/numind/NuExtract3) (4B, Apache-2.0) is the one script here that does both document-to-markdown OCR *and* schema-guided JSON extraction. Give it a template (or a JSON Schema / Pydantic model) and it returns JSON shaped to match.
+Next-generation fast OCR using [lightonai/LightOnOCR-2-1B](https://huggingface.co/lightonai/LightOnOCR-2-1B) with RLVR training:
 
-> **Run it with the `vllm/vllm-openai` image.** NuExtract3's Qwen3.5 architecture needs the image's prebuilt CUDA kernels — the default uv-script image lacks `nvcc`, so flashinfer's JIT compile fails at engine warmup. Use `--image vllm/vllm-openai:latest --python /usr/bin/python3 -e PYTHONPATH=/usr/local/lib/python3.12/dist-packages` on `a100-large`.
+- ⚡ **7× faster than v1**: 42.8 pages/sec on H100 (vs 5.71 for v1)
+- 🎯 **Higher accuracy**: 83.2% on OlmOCR-Bench (+7.1% vs v1)
+- 🧠 **RLVR trained**: Eliminates repetition loops and formatting errors
+- 📚 **Better dataset**: 2.5× larger training data with cleaner annotations
+- 🌍 **Multilingual**: Optimized for European languages
+- 📐 **LaTeX formulas**: Mathematical notation support
+- 📊 **Table extraction**: Markdown table format
+- 💪 **Production-ready**: Outperforms models 9× larger
+
+**Quick start:**
 
 ```bash
-# Markdown OCR (default mode)
+# Test on 100 samples
 hf jobs uv run --flavor a100-large \
-    --image vllm/vllm-openai:latest \
-    --python /usr/bin/python3 \
-    -e PYTHONPATH=/usr/local/lib/python3.12/dist-packages \
     -s HF_TOKEN \
-    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/nuextract3.py \
-    my-documents my-markdown --max-samples 10
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lighton-ocr2.py \
+    your-input-dataset your-output-dataset \
+    --batch-size 32 \
+    --max-samples 100
 
-# Structured extraction with an inline template
+# Full production run
 hf jobs uv run --flavor a100-large \
-    --image vllm/vllm-openai:latest \
-    --python /usr/bin/python3 \
-    -e PYTHONPATH=/usr/local/lib/python3.12/dist-packages \
     -s HF_TOKEN \
-    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/nuextract3.py \
-    receipts extracted \
-    --template '{"store": "verbatim-string", "date": "date", "total": "number"}'
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lighton-ocr2.py \
+    your-input-dataset your-output-dataset \
+    --batch-size 32
+```
+
+### DeepSeek-OCR (`deepseek-ocr-vllm.py`)
+
+Advanced document OCR using [deepseek-ai/DeepSeek-OCR](https://huggingface.co/deepseek-ai/DeepSeek-OCR) with visual-text compression:
+
+- 📐 **LaTeX equations** - Mathematical formulas in LaTeX format
+- 📊 **Tables** - Extracted as HTML/markdown
+- 📝 **Document structure** - Headers, lists, formatting preserved
+- 🖼️ **Image grounding** - Spatial layout with bounding boxes
+- 🔍 **Complex layouts** - Multi-column and hierarchical structures
+- 🌍 **Multilingual** - Multiple language support
+- 🎚️ **Resolution modes** - 5 presets for speed/quality trade-offs
+- 💬 **Prompt modes** - 5 presets for different OCR tasks
+- ⚡ **Fast batch processing** - vLLM acceleration
+
+**Resolution Modes:**
+
+- `tiny` (512×512): Fast, 64 vision tokens
+- `small` (640×640): Balanced, 100 vision tokens
+- `base` (1024×1024): High quality, 256 vision tokens
+- `large` (1280×1280): Maximum quality, 400 vision tokens
+- `gundam` (dynamic): Adaptive multi-tile (default)
+
+**Prompt Modes:**
+
+- `document`: Convert to markdown with grounding (default)
+- `image`: OCR any image with grounding
+- `free`: Fast OCR without layout
+- `figure`: Parse figures from documents
+- `describe`: Detailed image descriptions
+
+### RolmOCR (`rolm-ocr.py`)
+
+Fast general-purpose OCR using [reducto/RolmOCR](https://huggingface.co/reducto/RolmOCR) based on Qwen2.5-VL-7B:
+
+- 🚀 **Fast extraction** - Optimized for speed and efficiency
+- 📄 **Plain text output** - Clean, natural text representation
+- 💪 **General-purpose** - Works well on various document types
+- 🔥 **Large context** - Handles up to 16K tokens
+- ⚡ **Batch optimized** - Efficient processing with vLLM
+
+### Nanonets OCR (`nanonets-ocr.py`)
+
+State-of-the-art document OCR using [nanonets/Nanonets-OCR-s](https://huggingface.co/nanonets/Nanonets-OCR-s) that handles:
+
+- 📐 **LaTeX equations** - Mathematical formulas preserved
+- 📊 **Tables** - Extracted as HTML format
+- 📝 **Document structure** - Headers, lists, formatting maintained
+- 🖼️ **Images** - Captions and descriptions included
+- ☑️ **Forms** - Checkboxes rendered as ☐/☑
+
+### Nanonets OCR2 (`nanonets-ocr2.py`)
+
+Next-generation Nanonets OCR using [nanonets/Nanonets-OCR2-3B](https://huggingface.co/nanonets/Nanonets-OCR2-3B) with improved accuracy:
+
+- 🎯 **Enhanced quality** - 3.75B parameters for superior OCR accuracy
+- 📐 **LaTeX equations** - Mathematical formulas preserved in LaTeX format
+- 📊 **Advanced tables** - Improved HTML table extraction
+- 📝 **Document structure** - Headers, lists, formatting maintained
+- 🖼️ **Smart image captions** - Intelligent descriptions and captions
+- ☑️ **Forms** - Checkboxes rendered as ☐/☑
+- 🌍 **Multilingual** - Enhanced language support
+- 🔧 **Based on Qwen2.5-VL** - Built on state-of-the-art vision-language model
+
+### SmolDocling (`smoldocling-ocr.py`)
+
+Ultra-compact document understanding using [ds4sd/SmolDocling-256M-preview](https://huggingface.co/ds4sd/SmolDocling-256M-preview) with only 256M parameters:
+
+- 🏷️ **DocTags format** - Efficient XML-like representation
+- 💻 **Code blocks** - Preserves indentation and syntax
+- 🔢 **Formulas** - Mathematical expressions with layout
+- 📊 **Tables & charts** - Structured data extraction
+- 📐 **Layout preservation** - Bounding boxes and spatial info
+- ⚡ **Ultra-fast** - Tiny model size for quick inference
+
+### NuMarkdown (`numarkdown-ocr.py`)
+
+Advanced reasoning-based OCR using [numind/NuMarkdown-8B-Thinking](https://huggingface.co/numind/NuMarkdown-8B-Thinking) that analyzes documents before converting to markdown:
+
+- 🧠 **Reasoning Process** - Thinks through document layout before generation
+- 📊 **Complex Tables** - Superior table extraction and formatting
+- 📐 **Mathematical Formulas** - Accurate LaTeX/math notation preservation
+- 🔍 **Multi-column Layouts** - Handles complex document structures
+- ✨ **Thinking Traces** - Optional inclusion of reasoning process with `--include-thinking`
+
+### 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:
+
+- 🌍 **100+ Languages** - Extensive multilingual support
+- 📝 **Simple OCR** - Clean text extraction (default mode)
+- 📊 **Layout Analysis** - Optional structured output with bboxes and categories
+- 📐 **Formula recognition** - LaTeX format support
+- 🎯 **Compact** - Only 1.7B parameters, efficient on smaller GPUs
+- 🔀 **Flexible prompts** - Switch between OCR, layout-all, and layout-only modes
+
+### FireRed-OCR (`firered-ocr.py`)
+
+Document OCR using [FireRedTeam/FireRed-OCR](https://huggingface.co/FireRedTeam/FireRed-OCR), a 2.1B model fine-tuned from Qwen3-VL-2B-Instruct:
+
+- 📝 **Structured Markdown** - Preserves headings, paragraphs, lists
+- 📐 **LaTeX formulas** - Inline and block math support
+- 📊 **HTML tables** - Table extraction with `<table>` tags
+- 🪶 **Lightweight** - 2.1B parameters, runs on L4 GPU
+- 📜 **Apache 2.0** - Permissive license
+
+**Quick start:**
+
+```bash
+hf jobs uv run --flavor l4x1 \
+    -s HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/firered-ocr.py \
+    your-input-dataset your-output-dataset \
+    --max-samples 100
+```
+
+### 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:
+
+- 🎯 **High accuracy** - 82.4 ± 1.1 on olmOCR-Bench (84.9% on math)
+- 📐 **LaTeX equations** - Mathematical formulas in LaTeX format
+- 📊 **Table extraction** - Structured table recognition
+- 📑 **Multi-column layouts** - Complex document structures
+- 🗜️ **FP8 quantized** - Efficient 8B model for faster inference
+- 📜 **Degraded scans** - Works well on old/historical documents
+- 📝 **Long text extraction** - Headers, footers, and full document content
+- 🧩 **YAML metadata** - Structured front matter (language, rotation, content type)
+- 🚀 **Based on Qwen2.5-VL-7B** - Fine-tuned with reinforcement learning
+
+## 🆕 New Features
+
+### Multi-Model Comparison Support
+
+All scripts now include `inference_info` tracking for comparing multiple OCR models:
+
+```bash
+# First model
+uv run rolm-ocr.py my-dataset my-dataset --max-samples 100
+
+# Second model (appends to same dataset)
+uv run nanonets-ocr.py my-dataset my-dataset --max-samples 100
+
+# View all models used
+python -c "import json; from datasets import load_dataset; ds = load_dataset('my-dataset'); print(json.loads(ds[0]['inference_info']))"
 ```
 
-**Templates** (`--template`) and **JSON Schemas** (`--schema`) each accept **inline JSON, a URL, or a file path**, so a schema can be hosted once and reused. Add `--enable-thinking` for harder layouts (slower; reasoning trace stored in a `<output-column>_reasoning` column). Template field names act as the model's extraction instructions, so name them descriptively — overly leading names can prompt over-generation, so verify against a few examples.
+### Random Sampling
+
+Get representative samples with the new `--shuffle` flag:
 
-## Model-specific modes & flags
+```bash
+# Random 50 samples instead of first 50
+uv run rolm-ocr.py ordered-dataset output --max-samples 50 --shuffle
 
-Beyond the shared flags, some models add their own. Run `--help` on any script for the full list; the common ones:
+# Reproducible random sampling
+uv run nanonets-ocr.py dataset output --max-samples 100 --shuffle --seed 42
+```
 
-| Script | Extra options |
-|--------|---------------|
-| `glm-ocr.py` | `--task ocr\|formula\|table` |
-| `paddleocr-vl.py` | `--task-mode ocr\|table\|formula\|chart` |
-| `paddleocr-vl-1.5.py` | `--task-mode ocr\|table\|formula\|chart\|spotting\|seal` |
-| `paddleocr-vl-1.6.py` | `--task-mode ocr\|table\|formula` |
-| `lighton-ocr.py` | `--vocab-size 151k\|32k\|16k` (smaller = faster on European languages) |
-| `deepseek-ocr-vllm.py` | `--resolution-mode tiny\|small\|base\|large\|gundam`, `--prompt-mode document\|image\|free\|figure\|describe`; pass `-e UV_TORCH_BACKEND=auto` |
-| `dots-ocr.py` | `--prompt-mode ocr\|layout-all\|layout-only` |
-| `dots-mocr.py` | `--prompt-mode` (8: ocr, layout-all, layout-only, web-parsing, scene-spotting, grounding-ocr, svg, general); SVG: `--model rednote-hilab/dots.mocr-svg --prompt-mode svg` |
-| `qianfan-ocr.py` | `--prompt-mode ocr\|table\|formula\|chart\|scene\|kie`, `--think` (Layout-as-Thought); `kie` needs `--custom-prompt` |
-| `numarkdown-ocr.py` | `--include-thinking` (store the reasoning trace) |
-| `nuextract3.py` | `--template` / `--schema` / `--enable-thinking` — see the NuExtract3 section above |
+### Automatic Dataset Cards
 
-**Image-mode models** — `abot-ocr.py` and `nuextract3.py` (Qwen3.5 architecture) need the `vllm/vllm-openai` image because the default uv-script image lacks `nvcc`. Add `--image vllm/vllm-openai:latest --python /usr/bin/python3 -e PYTHONPATH=/usr/local/lib/python3.12/dist-packages` (see the NuExtract3 example above for the full command).
+Every OCR run now generates comprehensive dataset documentation including:
 
-## Output & features
+- Model configuration and parameters
+- Processing statistics
+- Column descriptions
+- Reproduction instructions
 
-- **Markdown column** — each run adds an `--output-column` (default `markdown`) with the OCR result.
-- **Multi-model comparison** — every script records `inference_info`, so you can run several models into the *same* dataset and compare. Point a second model at the same output repo:
-  ```bash
-  uv run rolm-ocr.py     my-dataset my-dataset --max-samples 100
-  uv run nanonets-ocr.py my-dataset my-dataset --max-samples 100   # appends
-  ```
-- **Reproducible sampling** — `--shuffle` (with `--seed`, default 42) draws a representative sample instead of the first N rows.
-- **Automatic dataset cards** — every run writes a card with the model config, processing stats, column descriptions, and a reproduction command.
+## 💻 Usage Examples
 
-## More examples
+### Run on HuggingFace Jobs (Recommended)
+
+No GPU? No problem! Run on HF infrastructure:
 
 ```bash
-# DeepSeek-OCR on historical scans, large resolution mode
-hf jobs uv run --flavor a100-large -s HF_TOKEN -e UV_TORCH_BACKEND=auto \
+# PaddleOCR-VL - Smallest model (0.9B) with task modes
+hf jobs uv run --flavor l4x1 \
+    --secrets HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/paddleocr-vl.py \
+    your-input-dataset your-output-dataset \
+    --task-mode ocr \
+    --max-samples 100
+
+# PaddleOCR-VL - Extract tables from documents
+hf jobs uv run --flavor l4x1 \
+    --secrets HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/paddleocr-vl.py \
+    documents tables-dataset \
+    --task-mode table
+
+# PaddleOCR-VL - Formula recognition
+hf jobs uv run --flavor l4x1 \
+    --secrets HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/paddleocr-vl.py \
+    scientific-papers formulas-extracted \
+    --task-mode formula \
+    --batch-size 32
+
+# GLM-OCR - SOTA 0.9B model (94.62% OmniDocBench)
+hf jobs uv run --flavor l4x1 \
+    -s HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/glm-ocr.py \
+    your-input-dataset your-output-dataset \
+    --batch-size 16 \
+    --max-samples 100
+
+# DeepSeek-OCR - Real-world example (National Library of Scotland handbooks)
+hf jobs uv run --flavor a100-large \
+    -s HF_TOKEN \
+    -e UV_TORCH_BACKEND=auto \
     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/deepseek-ocr-vllm.py \
-    NationalLibraryOfScotland/Britain-and-UK-Handbooks-Dataset out \
-    --max-samples 100 --shuffle --resolution-mode large
+    NationalLibraryOfScotland/Britain-and-UK-Handbooks-Dataset \
+    davanstrien/handbooks-deep-ocr \
+    --max-samples 100 \
+    --shuffle \
+    --resolution-mode large
 
-# dots.mocr — 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
+# DeepSeek-OCR - Fast testing with tiny mode
+hf jobs uv run --flavor l4x1 \
+    -s HF_TOKEN \
+    -e UV_TORCH_BACKEND=auto \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/deepseek-ocr-vllm.py \
+    your-input-dataset your-output-dataset \
+    --max-samples 10 \
+    --resolution-mode tiny
 
-# Qianfan — 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."
+# DeepSeek-OCR - Parse figures from scientific papers
+hf jobs uv run --flavor a100-large \
+    -s HF_TOKEN \
+    -e UV_TORCH_BACKEND=auto \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/deepseek-ocr-vllm.py \
+    scientific-papers figures-extracted \
+    --prompt-mode figure
+
+# Basic OCR job with Nanonets
+hf jobs uv run --flavor l4x1 \
+    --secrets HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/nanonets-ocr.py \
+    your-input-dataset your-output-dataset
+
+# DoTS.ocr - Multilingual OCR with compact 1.7B model
+hf jobs uv run --flavor a100-large \
+    --secrets HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/dots-ocr.py \
+    davanstrien/ufo-ColPali \
+    your-username/ufo-ocr \
+    --batch-size 256 \
+    --max-samples 1000 \
+    --shuffle
+
+# Real example with UFO dataset 🛸
+hf jobs uv run \
+    --flavor a10g-large \
+    --secrets HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/nanonets-ocr.py \
+    davanstrien/ufo-ColPali \
+    your-username/ufo-ocr \
+    --image-column image \
+    --max-model-len 16384 \
+    --batch-size 128
+
+# Nanonets OCR2 - Next-gen quality with 3B model
+hf jobs uv run \
+    --flavor l4x1 \
+    --secrets HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/nanonets-ocr2.py \
+    your-input-dataset \
+    your-output-dataset \
+    --batch-size 16
+
+# NuMarkdown with reasoning traces for complex documents
+hf jobs uv run \
+    --flavor l4x4 \
+    --secrets HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/numarkdown-ocr.py \
+    your-input-dataset your-output-dataset \
+    --max-samples 50 \
+    --include-thinking \
+    --shuffle
+
+# olmOCR2 - High-quality OCR with YAML metadata
+hf jobs uv run \
+    --flavor a100-large \
+    --secrets HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/olmocr2-vllm.py \
+    your-input-dataset your-output-dataset \
+    --batch-size 16 \
+    --max-samples 100
+
+# Private dataset with custom settings
+hf jobs uv run --flavor l40sx1 \
+    --secrets HF_TOKEN \
+    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/nanonets-ocr.py \
+    private-input private-output \
+    --private \
+    --batch-size 32
 ```
 
-**Python API:**
+### Python API
 
 ```python
 from huggingface_hub import run_uv_job
@@ -245,17 +612,36 @@ from huggingface_hub import run_uv_job
 job = run_uv_job(
     "https://huggingface.co/datasets/uv-scripts/ocr/raw/main/nanonets-ocr.py",
     args=["input-dataset", "output-dataset", "--batch-size", "16"],
-    flavor="l4x1",
+    flavor="l4x1"
 )
 ```
 
-**Run locally** (needs your own GPU) — same scripts, run directly from the URL:
+### Run Locally (Requires GPU)
 
 ```bash
-uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/glm-ocr.py \
+# Clone and run
+git clone https://huggingface.co/datasets/uv-scripts/ocr
+cd ocr
+uv run nanonets-ocr.py input-dataset output-dataset
+
+# Or run directly from URL
+uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/nanonets-ocr.py \
     input-dataset output-dataset
+
+# PaddleOCR-VL for task-specific OCR (smallest model!)
+uv run paddleocr-vl.py documents extracted --task-mode ocr
+uv run paddleocr-vl.py papers tables --task-mode table  # Extract tables
+uv run paddleocr-vl.py textbooks formulas --task-mode formula  # LaTeX formulas
+
+# RolmOCR for fast text extraction
+uv run rolm-ocr.py documents extracted-text
+uv run rolm-ocr.py images texts --shuffle --max-samples 100  # Random sample
+
+# Nanonets OCR2 for highest quality
+uv run nanonets-ocr2.py documents ocr-results
+
 ```
 
----
+</details>
 
-Works with any Hugging Face dataset containing images — documents, forms, receipts, books, handwriting.
+Works with any HuggingFace dataset containing images — documents, forms, receipts, books, handwriting.

abot-ocr.py

@@ -1,560 +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 ABot-OCR with vLLM.
-
-ABot-OCR (acvlab/ABot-OCR) is a compact Qwen3-VL-based document OCR model that
-converts PDF/document page images into structured Markdown, including:
-- Text with original document structure (headings, paragraphs, lists)
-- Mathematical formulas in LaTeX (inline \\( \\) and block \\[ \\])
-- Tables in HTML (<table>…</table>)
-
-Model:  https://huggingface.co/acvlab/ABot-OCR
-Paper:  https://arxiv.org/abs/2605.27978
-Code:   https://github.com/amap-cvlab/ABot-OCR
-
-HF Jobs note: ABot-OCR (Qwen3-VL) uses vLLM's flashinfer sampler, which needs CUDA
-kernels the default uv-script image can't build ("Could not find nvcc"). Run on Jobs
-with the pre-built vLLM image so the kernels are reused (same image-mode pattern as
-nuextract3.py / paddleocr-vl-1.6.py):
-    --image vllm/vllm-openai:latest
-    --python /usr/bin/python3 -e PYTHONPATH=/usr/local/lib/python3.12/dist-packages
-"""
-
-import argparse
-import base64
-import io
-import json
-import logging
-import os
-import sys
-from typing import Any, Dict, List, Union
-from datetime import datetime
-
-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
-# Disable vLLM's FlashInfer sampler: it JIT-compiles a CUDA kernel needing nvcc, which the
-# default uv-script image lacks (engine init then crashes). Greedy OCR doesn't use it; this
-# lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
-from vllm import LLM, SamplingParams
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# ABot-OCR's recommended document→Markdown prompt (from the model's reference
-# inference script; LaTeX delimiters de-mangled to proper \( \) and \[ \]).
-DEFAULT_PROMPT = r"""You are an AI assistant specialized in converting PDF images to Markdown format. Please follow these instructions for the conversion:
-
-1. Text Processing:
-- Accurately recognize all text content in the PDF image without guessing or inferring.
-- Convert the recognized text into Markdown format.
-- Maintain the original document structure, including headings, paragraphs, lists, etc.
-
-2. Mathematical Formula Processing:
-- Convert all mathematical formulas to LaTeX format.
-- Enclose inline formulas with \( \). For example: This is an inline formula \( E = mc^2 \)
-- Enclose block formulas with \[ \]. For example: \[ \frac{-b \pm \sqrt{b^2 - 4ac}}{2a} \]
-
-3. Table Processing:
-- Convert tables to HTML format.
-- Wrap the entire table with <table> and </table>.
-
-4. Figure Handling:
-- Ignore figures content in the PDF image. Do not attempt to describe or convert images.
-
-5. Output Format:
-- Ensure the output Markdown document has a clear structure with appropriate line breaks between elements.
-- For complex layouts, try to maintain the original document's structure and format as closely as possible.
-
-Please strictly follow these guidelines to ensure accuracy and consistency in the conversion. Your task is to accurately convert the content of the PDF image into Markdown format without adding any extra explanations or comments."""
-
-
-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.")
-        logger.error("Please run on a machine with a CUDA-capable GPU.")
-        sys.exit(1)
-    else:
-        logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
-
-
-def post_process_text(text: str, threshold: int = 8000) -> str:
-    """Trim runaway repetition loops that VLM OCR can fall into on dense pages.
-
-    Mirrors ABot-OCR's reference post-processing: if the tail of a long output
-    repeats the same short substring many times, collapse it to a single copy.
-    """
-    n = len(text)
-    if n < threshold:
-        return text
-    for length in range(2, n // 10 + 1):
-        candidate = text[-length:]
-        count = 0
-        i = n - length
-        while i >= 0 and text[i:i + length] == candidate:
-            count += 1
-            i -= length
-        if count >= 10:
-            return text[: n - length * (count - 1)]
-    return text
-
-
-def make_ocr_message(
-    image: Union[Image.Image, Dict[str, Any], str],
-    prompt: str = DEFAULT_PROMPT,
-) -> List[Dict]:
-    """Create a vLLM chat message for OCR processing."""
-    # Convert to PIL Image if needed
-    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)}")
-
-    if pil_img.mode != "RGB":
-        pil_img = pil_img.convert("RGB")
-
-    # Convert to base64 data URI
-    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,
-    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
-- abot
-- abot-ocr
-- markdown
-- uv-script
-- generated
----
-
-# Document OCR using {model_name}
-
-This dataset contains Markdown-formatted OCR results from images in [{source_dataset}](https://huggingface.co/datasets/{source_dataset}) using [ABot-OCR](https://huggingface.co/{model}).
-
-## Processing Details
-
-- **Source Dataset**: [{source_dataset}](https://huggingface.co/datasets/{source_dataset})
-- **Model**: [{model}](https://huggingface.co/{model})
-- **Paper**: [arxiv.org/abs/2605.27978](https://arxiv.org/abs/2605.27978)
-- **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}
-- **Max Model Length**: {max_model_len:,} tokens
-- **Max Output Tokens**: {max_tokens:,}
-- **GPU Memory Utilization**: {gpu_memory_utilization:.1%}
-
-## Model Information
-
-ABot-OCR is a compact Qwen3-VL-based document OCR model that converts page images to Markdown:
-- 📐 **LaTeX equations** — inline `\\( \\)` and block `\\[ \\]`
-- 📊 **Tables** — extracted as HTML (`<table>…</table>`)
-- 📝 **Document structure** — headings, paragraphs, and lists preserved
-
-## Dataset Structure
-
-The dataset contains all original columns plus:
-- `markdown`: The extracted text in Markdown format with preserved structure
-- `inference_info`: JSON list tracking all OCR models applied to this dataset
-
-## Usage
-
-```python
-from datasets import load_dataset
-
-dataset = load_dataset("{{{{output_dataset_id}}}}", split="{split}")
-for example in dataset:
-    print(example["markdown"])
-    break
-```
-
-## Reproduction
-
-This dataset was generated using the [uv-scripts/ocr](https://huggingface.co/datasets/uv-scripts/ocr) ABot-OCR script:
-
-```bash
-uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/abot-ocr.py \\
-    {source_dataset} \\
-    <output-dataset> \\
-    --image-column {image_column} \\
-    --batch-size {batch_size} \\
-    --max-model-len {max_model_len} \\
-    --max-tokens {max_tokens} \\
-    --gpu-memory-utilization {gpu_memory_utilization}
-```
-
-Generated with 🤖 [UV Scripts](https://huggingface.co/uv-scripts)
-"""
-
-
-def main(
-    input_dataset: str,
-    output_dataset: str,
-    image_column: str = "image",
-    batch_size: int = 16,
-    model: str = "acvlab/ABot-OCR",
-    max_model_len: int = 16384,
-    max_tokens: int = 8192,
-    gpu_memory_utilization: float = 0.8,
-    hf_token: str = None,
-    split: str = "train",
-    max_samples: int = None,
-    private: bool = False,
-    shuffle: bool = False,
-    seed: int = 42,
-    verbose: bool = False,
-):
-    """Process images from a HF dataset through the ABot-OCR model."""
-
-    # Check CUDA availability first
-    check_cuda_availability()
-
-    # Track processing start time
-    start_time = datetime.now()
-
-    # Enable high-performance Xet downloads
-    os.environ["HF_XET_HIGH_PERFORMANCE"] = "1"
-
-    # Login to HF if token provided
-    HF_TOKEN = hf_token or os.environ.get("HF_TOKEN")
-    if HF_TOKEN:
-        login(token=HF_TOKEN)
-
-    # Load dataset
-    logger.info(f"Loading dataset: {input_dataset}")
-    dataset = load_dataset(input_dataset, split=split)
-
-    # Validate image column
-    if image_column not in dataset.column_names:
-        raise ValueError(
-            f"Column '{image_column}' not found. Available: {dataset.column_names}"
-        )
-
-    # Shuffle if requested
-    if shuffle:
-        logger.info(f"Shuffling dataset with seed {seed}")
-        dataset = dataset.shuffle(seed=seed)
-
-    # Limit samples if requested
-    if max_samples:
-        dataset = dataset.select(range(min(max_samples, len(dataset))))
-        logger.info(f"Limited to {len(dataset)} samples")
-
-    # Initialize vLLM
-    logger.info(f"Initializing vLLM with model: {model}")
-    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=True,  # avoid warmup kernel compilation (no nvcc in the image)
-    )
-
-    sampling_params = SamplingParams(
-        temperature=0.0,  # Deterministic for OCR
-        max_tokens=max_tokens,
-    )
-
-    # Process images in batches
-    all_markdown = []
-
-    logger.info(f"Processing {len(dataset)} images in batches of {batch_size}")
-
-    for batch_indices in tqdm(
-        partition_all(batch_size, range(len(dataset))),
-        total=(len(dataset) + batch_size - 1) // batch_size,
-        desc="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) for img in batch_images]
-            outputs = llm.chat(batch_messages, sampling_params)
-            for output in outputs:
-                markdown_text = post_process_text(output.outputs[0].text.strip())
-                all_markdown.append(markdown_text)
-        except Exception as e:
-            logger.error(f"Error processing batch: {e}")
-            all_markdown.extend(["[OCR FAILED]"] * len(batch_images))
-
-    # Add markdown column to dataset
-    logger.info("Adding markdown column to dataset")
-    dataset = dataset.add_column("markdown", all_markdown)
-
-    # Handle inference_info tracking
-    logger.info("Updating inference_info...")
-
-    inference_entry = {
-        "model_id": model,
-        "model_name": "ABot-OCR",
-        "column_name": "markdown",
-        "timestamp": datetime.now().isoformat(),
-        "batch_size": batch_size,
-        "max_tokens": max_tokens,
-        "gpu_memory_utilization": gpu_memory_utilization,
-        "max_model_len": max_model_len,
-        "script": "abot-ocr.py",
-        "script_url": "https://huggingface.co/datasets/uv-scripts/ocr/raw/main/abot-ocr.py",
-    }
-
-    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
-    logger.info(f"Pushing to {output_dataset}")
-    dataset.push_to_hub(output_dataset, private=private, token=HF_TOKEN)
-
-    # Calculate processing time
-    end_time = datetime.now()
-    processing_duration = end_time - start_time
-    processing_time = f"{processing_duration.total_seconds() / 60:.1f} minutes"
-
-    # Create and push dataset card
-    logger.info("Creating dataset card...")
-    card_content = create_dataset_card(
-        source_dataset=input_dataset,
-        model=model,
-        num_samples=len(dataset),
-        processing_time=processing_time,
-        batch_size=batch_size,
-        max_model_len=max_model_len,
-        max_tokens=max_tokens,
-        gpu_memory_utilization=gpu_memory_utilization,
-        image_column=image_column,
-        split=split,
-    )
-
-    card = DatasetCard(card_content)
-    card.push_to_hub(output_dataset, token=HF_TOKEN)
-    logger.info("✅ Dataset card created and pushed!")
-
-    logger.info("✅ OCR conversion complete!")
-    logger.info(
-        f"Dataset available at: https://huggingface.co/datasets/{output_dataset}"
-    )
-
-    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__":
-    # Show example usage if no arguments
-    if len(sys.argv) == 1:
-        print("=" * 80)
-        print("ABot-OCR to Markdown Converter")
-        print("=" * 80)
-        print("\nConverts document images to structured Markdown using the")
-        print("ABot-OCR model (Qwen3-VL based) with vLLM acceleration.")
-        print("\nFeatures:")
-        print("- Document structure preserved (headings, paragraphs, lists)")
-        print("- LaTeX equation recognition (inline \\( \\) and block \\[ \\])")
-        print("- Table extraction as HTML")
-        print("\nExample usage:")
-        print("\n1. Basic OCR conversion:")
-        print("   uv run abot-ocr.py document-images markdown-docs")
-        print("\n2. Process a subset for testing:")
-        print("   uv run abot-ocr.py large-dataset test-output --max-samples 10")
-        print("\n3. Running on HF Jobs (use the pre-built vLLM image for flashinfer kernels):")
-        print("   hf jobs uv run --flavor l4x1 \\")
-        print("     --image vllm/vllm-openai:latest \\")
-        print(
-            "     --python /usr/bin/python3 -e PYTHONPATH=/usr/local/lib/python3.12/dist-packages \\"
-        )
-        print("     -s HF_TOKEN \\")
-        print(
-            "     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/abot-ocr.py \\"
-        )
-        print("       your-document-dataset \\")
-        print("       your-markdown-output \\")
-        print("       --max-samples 10")
-        print("\n" + "=" * 80)
-        print("\nFor full help, run: uv run abot-ocr.py --help")
-        sys.exit(0)
-
-    parser = argparse.ArgumentParser(
-        description="OCR images to Markdown using ABot-OCR (Qwen3-VL)",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-  # Basic usage
-  uv run abot-ocr.py my-images-dataset ocr-results
-
-  # With specific image column
-  uv run abot-ocr.py documents extracted-text --image-column scan
-
-  # Process subset for testing
-  uv run abot-ocr.py large-dataset test-output --max-samples 100
-
-  # Random sample from ordered dataset
-  uv run abot-ocr.py ordered-dataset random-sample --max-samples 50 --shuffle
-        """,
-    )
-
-    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=16,
-        help="Batch size for processing (default: 16)",
-    )
-    parser.add_argument(
-        "--model",
-        default="acvlab/ABot-OCR",
-        help="Model to use (default: acvlab/ABot-OCR)",
-    )
-    parser.add_argument(
-        "--max-model-len",
-        type=int,
-        default=16384,
-        help="Maximum model context length (default: 16384)",
-    )
-    parser.add_argument(
-        "--max-tokens",
-        type=int,
-        default=8192,
-        help="Maximum tokens to generate (default: 8192)",
-    )
-    parser.add_argument(
-        "--gpu-memory-utilization",
-        type=float,
-        default=0.8,
-        help="GPU memory utilization (default: 0.8)",
-    )
-    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 the dataset before processing (useful for random sampling)",
-    )
-    parser.add_argument(
-        "--seed",
-        type=int,
-        default=42,
-        help="Random seed for shuffling (default: 42)",
-    )
-    parser.add_argument(
-        "--verbose",
-        action="store_true",
-        help="Log resolved package versions after processing (useful for pinning deps)",
-    )
-
-    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,
-        model=args.model,
-        max_model_len=args.max_model_len,
-        max_tokens=args.max_tokens,
-        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,
-        verbose=args.verbose,
-    )

deepseek-ocr-vllm.py

@@ -48,10 +48,6 @@ from huggingface_hub import DatasetCard, login
 from PIL import Image
 from toolz import partition_all
 from tqdm.auto import tqdm
-# Disable vLLM's FlashInfer sampler: it JIT-compiles a CUDA kernel needing nvcc, which the
-# default uv-script image lacks (engine init then crashes). Greedy OCR doesn't use it; this
-# lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
 from vllm import LLM, SamplingParams
 from vllm.model_executor.models.deepseek_ocr import NGramPerReqLogitsProcessor
 

deepseek-ocr2-vllm.py

@@ -59,10 +59,6 @@ from huggingface_hub import DatasetCard, login
 from PIL import Image
 from toolz import partition_all
 from tqdm.auto import tqdm
-# Disable vLLM's FlashInfer sampler: it JIT-compiles a CUDA kernel needing nvcc, which the
-# default uv-script image lacks (engine init then crashes). Greedy OCR doesn't use it; this
-# lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
 from vllm import LLM, SamplingParams
 from vllm.model_executor.models.deepseek_ocr import NGramPerReqLogitsProcessor
 

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
@@ -50,13 +46,9 @@ from typing import Any, Dict, List, Union
 import torch
 from datasets import load_dataset
 from huggingface_hub import DatasetCard, login
-from PIL import Image, UnidentifiedImageError
+from PIL import Image
 from toolz import partition_all
 from tqdm.auto import tqdm
-# Disable vLLM's FlashInfer sampler: it JIT-compiles a CUDA kernel needing nvcc, which the
-# default uv-script image lacks (engine init then crashes). Greedy OCR doesn't use it; this
-# lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
 from vllm import LLM, SamplingParams
 
 logging.basicConfig(level=logging.INFO)
@@ -64,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 = {
@@ -88,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": """ """,
 }
 
@@ -133,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")
@@ -176,7 +154,7 @@ def create_dataset_card(
 tags:
 - ocr
 - document-processing
-- dots-mocr
+- dots-ocr-1.5
 - multilingual
 - markdown
 - uv-script
@@ -185,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
 
@@ -208,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
 
@@ -245,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} \\
@@ -268,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,
@@ -287,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()
@@ -338,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,
@@ -359,35 +330,17 @@ 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)
-
-        # Fetch images first, with per-batch fallback for unreadable files.
-        # One corrupt image used to take down the entire run via the list
-        # comprehension; now we mark the whole batch as skipped and continue.
-        try:
-            batch_images = [dataset[i][image_column] for i in batch_indices]
-        except (UnidentifiedImageError, OSError) as e:
-            logger.warning(
-                f"Skipping batch of {len(batch_indices)} — unreadable image "
-                f"in batch: {type(e).__name__}: {e}"
-            )
-            all_outputs.extend(
-                ["[OCR SKIPPED — UNREADABLE IMAGE]"] * len(batch_indices)
-            )
-            continue
+        batch_images = [dataset[i][image_column] for i in batch_indices]
 
         try:
             # 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:
@@ -410,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",
@@ -491,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}"
     )
@@ -513,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
         """,
     )
 
@@ -608,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",

dots-ocr.py

@@ -45,10 +45,6 @@ from huggingface_hub import DatasetCard, login
 from PIL import Image
 from toolz import partition_all
 from tqdm.auto import tqdm
-# Disable vLLM's FlashInfer sampler: it JIT-compiles a CUDA kernel needing nvcc, which the
-# default uv-script image lacks (engine init then crashes). Greedy OCR doesn't use it; this
-# lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
 from vllm import LLM, SamplingParams
 
 logging.basicConfig(level=logging.INFO)

examples/nls-index-card-v2.json

@@ -1,13 +0,0 @@
-{
-  "image_type": ["index_card", "verso", "cover", "blank", "other"],
-  "heading": "verbatim-string",
-  "heading_type": ["person", "family", "corporate", "geographic", "subject"],
-  "epithet": "string",
-  "entries": [
-    {
-      "ms_no": "verbatim-string",
-      "folios": ["verbatim-string"],
-      "description": "string"
-    }
-  ]
-}

examples/nls-index-card-verbose.json

@@ -1,13 +0,0 @@
-{
-  "image_type": ["index_card", "verso", "cover", "blank", "other"],
-  "main_heading_name": "verbatim-string",
-  "heading_category": ["person", "family", "corporate", "geographic", "subject"],
-  "epithet_title_or_occupation": "string",
-  "manuscript_references": [
-    {
-      "manuscript_number": "verbatim-string",
-      "folio_references": ["verbatim-string"],
-      "entry_description_with_date": "string"
-    }
-  ]
-}

falcon-ocr-bucket.py

@@ -1,303 +0,0 @@
-# /// script
-# requires-python = ">=3.11"
-# dependencies = [
-#     "pillow",
-#     "pymupdf",
-#     "torch>=2.5",
-#     "torchvision",
-#     "falcon-perception[ocr]",
-# ]
-# ///
-
-"""
-OCR images and PDFs from a directory using Falcon OCR, writing markdown files.
-
-Designed to work with HF Buckets mounted as volumes via `hf jobs uv run -v ...`.
-Reads images/PDFs from INPUT_DIR, runs Falcon OCR via the optimized falcon-perception
-engine (CUDA graphs + paged inference), 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 falcon-ocr-bucket.py ./test-images ./test-output
-
-  # HF Jobs with bucket volumes
-  hf jobs uv run --flavor l4x1 \\
-      -s HF_TOKEN \\
-      -v hf://buckets/user/ocr-input:/input:ro \\
-      -v hf://buckets/user/ocr-output:/output \\
-      https://huggingface.co/datasets/uv-scripts/ocr/raw/main/falcon-ocr-bucket.py \\
-      /input /output
-
-Model: tiiuae/Falcon-OCR (0.3B, 80.3% olmOCR, Apache 2.0)
-Backend: falcon-perception (OCRInferenceEngine with CUDA graphs)
-"""
-
-import argparse
-import logging
-import sys
-import time
-from pathlib import Path
-
-import torch
-from PIL import Image
-
-logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
-logger = logging.getLogger(__name__)
-
-MODEL_ID = "tiiuae/Falcon-OCR"
-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 discover_files(input_dir: Path, limit: int | None = None) -> list[Path]:
-    """Discover image and PDF files under input_dir.
-
-    Without `limit`, returns the full sorted list (deterministic order).
-    With `limit`, stops scanning once `limit` matching files are found
-    and returns them in filesystem order (much faster on huge mounted
-    buckets, but ordering is not deterministic).
-    """
-    files = []
-    iterator = (
-        input_dir.rglob("*") if limit is not None else sorted(input_dir.rglob("*"))
-    )
-    for path in iterator:
-        if not path.is_file():
-            continue
-        ext = path.suffix.lower()
-        if ext in IMAGE_EXTENSIONS or ext == ".pdf":
-            files.append(path)
-            if limit is not None and len(files) >= limit:
-                break
-    return files
-
-
-def prepare_images(
-    files: list[Path], input_dir: Path, output_dir: Path, pdf_dpi: int
-) -> list[tuple[Image.Image, Path]]:
-    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_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]
-                    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:
-            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 Falcon OCR, output markdown files.",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog=__doc__,
-    )
-    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(
-        "--batch-size", type=int, default=8, help="Images per batch (default: 8)",
-    )
-    parser.add_argument(
-        "--pdf-dpi", type=int, default=300,
-        help="DPI for PDF page rendering (default: 300)",
-    )
-    parser.add_argument(
-        "--no-compile", action="store_true", help="Disable torch.compile",
-    )
-    parser.add_argument(
-        "--no-cudagraph", action="store_true", help="Disable CUDA graph capture",
-    )
-    parser.add_argument(
-        "--max-samples", type=int, default=None,
-        help="Limit number of input files to discover. Stops scanning early "
-             "once the limit is reached (much faster on large mounted buckets). "
-             "Applied before PDF page expansion. With --max-samples set, file "
-             "ordering is filesystem-dependent rather than sorted.",
-    )
-    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)
-
-    start_time = time.time()
-
-    # Discover files
-    if args.max_samples is not None:
-        logger.info(
-            f"Scanning {input_dir} for up to {args.max_samples} images/PDFs "
-            f"(early termination, --max-samples)..."
-        )
-    else:
-        logger.info(f"Scanning {input_dir} for images and PDFs...")
-    files = discover_files(input_dir, limit=args.max_samples)
-    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)")
-
-    # Prepare images
-    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)}")
-
-    # Load model
-    logger.info(f"Loading {MODEL_ID} via falcon-perception engine...")
-    from falcon_perception import load_and_prepare_model
-    from falcon_perception.data import ImageProcessor
-    from falcon_perception.paged_ocr_inference import OCRInferenceEngine
-
-    do_compile = not args.no_compile
-    do_cudagraph = not args.no_cudagraph
-
-    model, tokenizer, model_args = load_and_prepare_model(
-        hf_model_id=MODEL_ID,
-        device="cuda",
-        dtype="bfloat16",
-        compile=do_compile,
-    )
-
-    image_processor = ImageProcessor(patch_size=16, merge_size=1)
-    engine = OCRInferenceEngine(
-        model, tokenizer, image_processor, capture_cudagraph=do_cudagraph
-    )
-    logger.info(f"Engine loaded. compile={do_compile}, cudagraph={do_cudagraph}")
-
-    # Process in batches
-    errors = 0
-    processed = 0
-    total = len(items)
-    batch_size = args.batch_size
-
-    for batch_start in range(0, total, batch_size):
-        batch_end = min(batch_start + batch_size, total)
-        batch = items[batch_start:batch_end]
-        batch_num = batch_start // batch_size + 1
-        total_batches = (total + batch_size - 1) // batch_size
-
-        logger.info(f"Batch {batch_num}/{total_batches} ({processed}/{total} done)")
-
-        try:
-            batch_images = [img for img, _ in batch]
-            texts = engine.generate_plain(images=batch_images, use_tqdm=False)
-
-            for (_, md_path), text in zip(batch, texts):
-                md_path.parent.mkdir(parents=True, exist_ok=True)
-                md_path.write_text(text.strip(), encoding="utf-8")
-                processed += 1
-
-        except Exception as e:
-            logger.error(f"Batch {batch_num} failed: {e}")
-            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 ["falcon-perception", "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("Falcon OCR Bucket Script")
-        print("=" * 60)
-        print(f"\nModel: {MODEL_ID} (0.3B, Apache 2.0)")
-        print("OCR images/PDFs from a directory -> markdown files.")
-        print("Designed for HF Buckets mounted as volumes.")
-        print()
-        print("Usage:")
-        print("  uv run falcon-ocr-bucket.py INPUT_DIR OUTPUT_DIR")
-        print()
-        print("Examples:")
-        print("  uv run falcon-ocr-bucket.py ./images ./output")
-        print()
-        print("HF Jobs with bucket volumes:")
-        print("  hf jobs uv run --flavor l4x1 -s HF_TOKEN \\")
-        print("      -v hf://buckets/user/ocr-input:/input:ro \\")
-        print("      -v hf://buckets/user/ocr-output:/output \\")
-        print(
-            "      https://huggingface.co/datasets/uv-scripts/ocr/raw/main/falcon-ocr-bucket.py \\"
-        )
-        print("      /input /output")
-        print()
-        print("For full help: uv run falcon-ocr-bucket.py --help")
-        sys.exit(0)
-
-    main()

falcon-ocr.py

@@ -1,433 +0,0 @@
-# /// script
-# requires-python = ">=3.11"
-# dependencies = [
-#     "datasets",
-#     "huggingface-hub",
-#     "pillow",
-#     "torch>=2.5",
-#     "torchvision",
-#     "falcon-perception",
-# ]
-# ///
-
-"""
-Convert document images to text using Falcon OCR with the falcon-perception engine.
-
-Uses the optimized OCRInferenceEngine with CUDA graphs and paged inference
-for much faster throughput than the raw transformers API.
-
-Features:
-- Compact: Only 0.3B parameters
-- Fast: Optimized inference with CUDA graphs
-- Multi-format: Plain text, LaTeX formulas, HTML tables
-- Layout-aware: Optional 2-stage pipeline (layout detection + per-region OCR)
-
-Model: tiiuae/Falcon-OCR
-Backend: falcon-perception (OCRInferenceEngine)
-License: Apache 2.0
-
-Examples:
-    # Basic text OCR
-    uv run falcon-ocr.py input-dataset output-dataset
-
-    # Test with small sample
-    uv run falcon-ocr.py dataset test --max-samples 5 --shuffle
-
-    # Run on HF Jobs with GPU
-    hf jobs uv run --flavor l4x1 \\
-        -s HF_TOKEN \\
-        falcon-ocr.py \\
-        input-dataset output-dataset --max-samples 10
-"""
-
-import argparse
-import io
-import json
-import logging
-import os
-import sys
-import time
-from datetime import datetime
-from typing import Any, Dict, Union
-
-import torch
-from datasets import load_dataset
-from huggingface_hub import DatasetCard, login
-from PIL import Image
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-MODEL_ID = "tiiuae/Falcon-OCR"
-
-TASK_MODES = {
-    "plain": "Full-page text extraction",
-}
-
-
-def check_cuda_availability():
-    if not torch.cuda.is_available():
-        logger.error("CUDA is not available. This script requires a GPU.")
-        logger.error("For cloud execution, use HF Jobs with --flavor l4x1 or similar.")
-        sys.exit(1)
-    else:
-        logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
-
-
-def prepare_image(image: Union[Image.Image, Dict[str, Any], str]) -> Image.Image:
-    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)}")
-    return pil_img.convert("RGB")
-
-
-def create_dataset_card(
-    source_dataset: str,
-    task_mode: str,
-    num_samples: int,
-    processing_time: str,
-    image_column: str = "image",
-    split: str = "train",
-) -> str:
-    task_description = TASK_MODES[task_mode]
-    return f"""---
-tags:
-- ocr
-- document-processing
-- falcon-ocr
-- {task_mode}
-- uv-script
-- generated
----
-
-# Document Processing using Falcon OCR ({task_mode} mode)
-
-This dataset contains OCR results from images in [{source_dataset}](https://huggingface.co/datasets/{source_dataset}) using [Falcon OCR](https://huggingface.co/tiiuae/Falcon-OCR), a 0.3B early-fusion vision-language model.
-
-## Processing Details
-
-- **Source Dataset**: [{source_dataset}](https://huggingface.co/datasets/{source_dataset})
-- **Model**: [{MODEL_ID}](https://huggingface.co/{MODEL_ID})
-- **Task Mode**: `{task_mode}` - {task_description}
-- **Number of Samples**: {num_samples:,}
-- **Processing Time**: {processing_time}
-- **Processing Date**: {datetime.now().strftime("%Y-%m-%d %H:%M UTC")}
-- **Backend**: falcon-perception (OCRInferenceEngine)
-
-## Reproduction
-
-```bash
-uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/falcon-ocr.py \\
-    {source_dataset} \\
-    <output-dataset> \\
-    --task-mode {task_mode} \\
-    --image-column {image_column}
-```
-
-Generated with [UV Scripts](https://huggingface.co/uv-scripts)
-"""
-
-
-def main(
-    input_dataset: str,
-    output_dataset: str,
-    image_column: str = "image",
-    task_mode: str = "plain",
-    hf_token: str = None,
-    split: str = "train",
-    max_samples: int = None,
-    private: bool = False,
-    shuffle: bool = False,
-    seed: int = 42,
-    output_column: str = "markdown",
-    config: str = None,
-    create_pr: bool = False,
-    compile: bool = True,
-    cudagraph: bool = True,
-    progress: bool = False,
-    verbose: bool = False,
-):
-    check_cuda_availability()
-    start_time = datetime.now()
-
-    HF_TOKEN = hf_token or os.environ.get("HF_TOKEN")
-    if HF_TOKEN:
-        login(token=HF_TOKEN)
-
-    if task_mode not in TASK_MODES:
-        raise ValueError(
-            f"Invalid task_mode '{task_mode}'. Choose from: {list(TASK_MODES.keys())}"
-        )
-
-    logger.info(f"Task mode: {task_mode} - {TASK_MODES[task_mode]}")
-    logger.info(f"Output column: {output_column}")
-
-    # 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")
-
-    # Load model using falcon-perception
-    logger.info(f"Loading model: {MODEL_ID} via falcon-perception engine")
-    from falcon_perception import load_and_prepare_model
-    from falcon_perception.data import ImageProcessor
-    from falcon_perception.paged_ocr_inference import OCRInferenceEngine
-
-    model, tokenizer, model_args = load_and_prepare_model(
-        hf_model_id=MODEL_ID,
-        device="cuda",
-        dtype="bfloat16",
-        compile=compile,
-    )
-
-    image_processor = ImageProcessor(patch_size=16, merge_size=1)
-    engine = OCRInferenceEngine(
-        model, tokenizer, image_processor, capture_cudagraph=cudagraph
-    )
-    logger.info(f"Engine loaded. compile={compile}, cudagraph={cudagraph}")
-
-    # Prepare all images
-    logger.info(f"Processing {len(dataset)} images...")
-    all_outputs = []
-
-    # Batch plain OCR for better throughput
-    batch_size = 8
-    total_batches = (len(dataset) + batch_size - 1) // batch_size
-    for batch_idx, batch_start in enumerate(range(0, len(dataset), batch_size), 1):
-        batch_end = min(batch_start + batch_size, len(dataset))
-        logger.info(f"Batch {batch_idx}/{total_batches} ({batch_start}/{len(dataset)} done)")
-        batch_images = []
-        for i in range(batch_start, batch_end):
-            try:
-                batch_images.append(prepare_image(dataset[i][image_column]))
-            except Exception as e:
-                logger.error(f"Error preparing image {i}: {e}")
-                batch_images.append(Image.new("RGB", (100, 100)))
-
-        try:
-            texts = engine.generate_plain(
-                images=batch_images, use_tqdm=progress
-            )
-            all_outputs.extend(texts)
-        except Exception as e:
-            logger.error(f"Error processing batch {batch_start}-{batch_end}: {e}")
-            all_outputs.extend(
-                [f"[OCR ERROR: {str(e)[:200]}]"] * 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)
-
-    # Track inference info
-    inference_entry = {
-        "model_id": MODEL_ID,
-        "model_name": "Falcon-OCR",
-        "model_size": "0.3B",
-        "task_mode": task_mode,
-        "column_name": output_column,
-        "timestamp": datetime.now().isoformat(),
-        "backend": "falcon-perception",
-    }
-
-    if "inference_info" in dataset.column_names:
-        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:
-        inference_list = [json.dumps([inference_entry])] * len(dataset)
-        dataset = dataset.add_column("inference_info", inference_list)
-
-    # Push to hub
-    logger.info(f"Pushing to {output_dataset}")
-    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=f"Add {MODEL_ID} OCR results ({len(dataset)} samples)"
-                + (f" [{config}]" if config else ""),
-            )
-            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
-    logger.info("Creating dataset card")
-    card_content = create_dataset_card(
-        source_dataset=input_dataset,
-        task_mode=task_mode,
-        num_samples=len(dataset),
-        processing_time=processing_time_str,
-        image_column=image_column,
-        split=split,
-    )
-    card = DatasetCard(card_content)
-    card.push_to_hub(output_dataset, token=HF_TOKEN)
-
-    logger.info("Falcon 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"Speed: {len(dataset) / processing_duration.total_seconds():.2f} images/sec"
-    )
-
-    if verbose:
-        import importlib.metadata
-
-        logger.info("--- Resolved package versions ---")
-        for pkg in [
-            "falcon-perception", "transformers", "torch", "datasets", "pillow"
-        ]:
-            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("=" * 70)
-        print("Falcon OCR - 0.3B Document OCR (falcon-perception engine)")
-        print("=" * 70)
-        print(f"\nModel: {MODEL_ID}")
-        print("License: Apache 2.0")
-        print("\nTask Modes:")
-        for mode, description in TASK_MODES.items():
-            print(f"  {mode:10} - {description}")
-        print("\nExamples:")
-        print("  uv run falcon-ocr.py input-dataset output-dataset")
-        print("  uv run falcon-ocr.py dense-docs output --task-mode layout")
-        print("\nFor full help: uv run falcon-ocr.py --help")
-        sys.exit(0)
-
-    parser = argparse.ArgumentParser(
-        description="Document OCR using Falcon OCR (0.3B, falcon-perception engine)",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog=__doc__,
-    )
-
-    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(
-        "--task-mode", choices=list(TASK_MODES.keys()), default="plain",
-        help="Task type: plain (default), layout",
-    )
-    parser.add_argument("--hf-token", help="Hugging Face API token")
-    parser.add_argument(
-        "--split", default="train", help="Dataset split (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(
-        "--output-column", default="markdown",
-        help="Column name for output text (default: markdown)",
-    )
-    parser.add_argument(
-        "--config",
-        help="Config/subset name for 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(
-        "--no-compile", action="store_true",
-        help="Disable torch.compile",
-    )
-    parser.add_argument(
-        "--no-cudagraph", action="store_true",
-        help="Disable CUDA graph capture",
-    )
-    parser.add_argument(
-        "--progress", action="store_true",
-        help="Show per-image progress bar from the inference engine",
-    )
-    parser.add_argument(
-        "--verbose", action="store_true", help="Log resolved package versions",
-    )
-
-    args = parser.parse_args()
-
-    main(
-        input_dataset=args.input_dataset,
-        output_dataset=args.output_dataset,
-        image_column=args.image_column,
-        task_mode=args.task_mode,
-        hf_token=args.hf_token,
-        split=args.split,
-        max_samples=args.max_samples,
-        private=args.private,
-        shuffle=args.shuffle,
-        seed=args.seed,
-        output_column=args.output_column,
-        config=args.config,
-        create_pr=args.create_pr,
-        compile=not args.no_compile,
-        cudagraph=not args.no_cudagraph,
-        progress=args.progress,
-        verbose=args.verbose,
-    )

firered-ocr.py

@@ -39,10 +39,6 @@ from huggingface_hub import DatasetCard, login
 from PIL import Image
 from toolz import partition_all
 from tqdm.auto import tqdm
-# Disable vLLM's FlashInfer sampler: it JIT-compiles a CUDA kernel needing nvcc, which the
-# default uv-script image lacks (engine init then crashes). Greedy OCR doesn't use it; this
-# lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
 from vllm import LLM, SamplingParams
 
 logging.basicConfig(level=logging.INFO)
@@ -108,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 [
@@ -232,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,
@@ -339,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)
 
@@ -487,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,369 +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
-import os
-# Disable vLLM's FlashInfer sampler: it JIT-compiles a CUDA kernel needing nvcc, which the
-# default uv-script image lacks (engine init then crashes). Greedy OCR doesn't use it; this
-# lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
-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()

glm-ocr-v2.py

@@ -69,10 +69,6 @@ from datasets import load_dataset
 from huggingface_hub import CommitScheduler, DatasetCard, HfApi, login
 from PIL import Image
 from toolz import partition_all
-# Disable vLLM's FlashInfer sampler: it JIT-compiles a CUDA kernel needing nvcc, which the
-# default uv-script image lacks (engine init then crashes). Greedy OCR doesn't use it; this
-# lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
 from vllm import LLM, SamplingParams
 
 logging.basicConfig(level=logging.INFO)

glm-ocr.py

@@ -60,10 +60,6 @@ from datasets import load_dataset
 from huggingface_hub import DatasetCard, login
 from PIL import Image
 from toolz import partition_all
-# Disable vLLM's FlashInfer sampler: it JIT-compiles a CUDA kernel needing nvcc, which the
-# default uv-script image lacks (engine init then crashes). Greedy OCR doesn't use it; this
-# lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
 from vllm import LLM, SamplingParams
 
 logging.basicConfig(level=logging.INFO)

hunyuan-ocr.py

@@ -49,10 +49,6 @@ from huggingface_hub import DatasetCard, login
 from PIL import Image
 from toolz import partition_all
 from tqdm.auto import tqdm
-# Disable vLLM's FlashInfer sampler: it JIT-compiles a CUDA kernel needing nvcc, which the
-# default uv-script image lacks (engine init then crashes). Greedy OCR doesn't use it; this
-# lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
 from vllm import LLM, SamplingParams
 
 logging.basicConfig(level=logging.INFO)

lfm2-extract.py

@@ -1,293 +0,0 @@
-# /// script
-# requires-python = ">=3.11"
-# dependencies = [
-#     "datasets>=4.0.0",
-#     "huggingface-hub",
-#     "vllm",
-#     "transformers",
-#     "tqdm",
-#     "toolz",
-#     "torch",
-# ]
-# ///
-"""
-Extract structured data (JSON / XML / YAML) from text using LiquidAI's LFM2-1.2B-Extract.
-
-LFM2-1.2B-Extract is a compact 1.2B text-only model purpose-built for turning unstructured
-documents into structured data: give it a schema, it returns JSON, XML, or YAML. It reports
-beating Gemma 3 27B (22x larger) on syntax validity / format accuracy / faithfulness, and
-is multilingual (en, ar, zh, fr, de, ja, ko, pt, es).
-
-This is the *text* counterpart to `lfm2-vl-extract.py` (which extracts from images). Pair them:
-OCR a page to markdown with one of the OCR recipes, then extract fields from that text here.
-
-Pass `--schema` as inline text/JSON, a URL, or a file path describing the structure to extract:
-
-    --schema '{"invoice_number": "string", "total": "number", "line_items": "array"}'
-
-Model:  https://huggingface.co/LiquidAI/LFM2-1.2B-Extract
-Docs:   https://docs.liquid.ai/deployment/gpu-inference/vllm
-
-HF Jobs note: run on the vLLM image so the CUDA toolkit + prebuilt FlashInfer kernels are
-present and startup is fast (it reuses the image's CUDA-matched vLLM build):
-
-    hf jobs uv run --flavor l4x1 --secrets HF_TOKEN \
-        --image vllm/vllm-openai --python /usr/bin/python3 \
-        -e PYTHONPATH=/usr/local/lib/python3.12/dist-packages \
-        https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lfm2-extract.py \
-        INPUT OUTPUT --text-column text --schema '{"field": "description"}'
-
-It also runs on the default uv image, just with a slower first-time vLLM build. Deps are left
-unpinned so uv resolves a recent vLLM; FlashInfer sampling is disabled (see below) so the engine
-never JIT-compiles a kernel that needs nvcc — absent from the default image.
-"""
-
-import argparse
-import json
-import logging
-import os
-import sys
-from datetime import datetime, timezone
-from typing import List, Optional
-from urllib.request import urlopen
-
-# Disable vLLM's FlashInfer sampler before the engine starts: it JIT-compiles at warmup and
-# needs nvcc (absent from the default uv image). Harmless for greedy decoding.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
-
-import torch
-from datasets import load_dataset
-from huggingface_hub import DatasetCard, login
-from toolz import partition_all
-from tqdm import tqdm
-from vllm import LLM, SamplingParams
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-DEFAULT_MODEL = "LiquidAI/LFM2-1.2B-Extract"
-FORMATS = {"json": "JSON", "xml": "XML", "yaml": "YAML"}
-
-
-def check_cuda_availability() -> None:
-    if not torch.cuda.is_available():
-        logger.error("CUDA is not available. This script requires a GPU.")
-        logger.error("Run on Hugging Face Jobs with: hf jobs uv run --flavor l4x1 ...")
-        sys.exit(1)
-    logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name()}")
-
-
-def load_text_arg(value: str) -> str:
-    """Resolve --schema (inline text/JSON, URL, or file path) into a string."""
-    text = value.strip()
-    if text.startswith("http://") or text.startswith("https://"):
-        logger.info(f"Loading schema from URL: {text}")
-        return urlopen(text).read().decode("utf-8").strip()
-    if os.path.exists(text):
-        logger.info(f"Loading schema from file: {text}")
-        with open(text) as f:
-            return f.read().strip()
-    return text
-
-
-def build_system_prompt(schema_text: str, fmt: str) -> str:
-    return f"Return data as a {FORMATS[fmt]} object with the following schema:\n\n{schema_text}"
-
-
-def parse_output(text: str, fmt: str) -> tuple[str, bool]:
-    """Strip code fences; for JSON, validate. Returns (cleaned_text, is_valid)."""
-    stripped = text.strip()
-    if stripped.startswith("```"):
-        stripped = stripped.split("\n", 1)[-1]
-        if stripped.endswith("```"):
-            stripped = stripped.rsplit("```", 1)[0]
-    stripped = stripped.strip()
-    if fmt == "json":
-        try:
-            return json.dumps(json.loads(stripped), ensure_ascii=False), True
-        except (json.JSONDecodeError, ValueError):
-            return stripped, False
-    return stripped, True  # xml/yaml: store as-is (no strict validator)
-
-
-def main(
-    input_dataset: str,
-    output_dataset: str,
-    schema: str,
-    text_column: str = "text",
-    output_column: str = "extraction",
-    output_format: str = "json",
-    split: str = "train",
-    max_samples: Optional[int] = None,
-    shuffle: bool = False,
-    seed: int = 42,
-    batch_size: int = 32,
-    model: str = DEFAULT_MODEL,
-    max_model_len: int = 8192,
-    max_tokens: int = 4096,
-    private: bool = False,
-    hf_token: Optional[str] = None,
-) -> None:
-    check_cuda_availability()
-    if output_format not in FORMATS:
-        logger.error(f"--format must be one of {list(FORMATS)}; got {output_format}")
-        sys.exit(1)
-
-    HF_TOKEN = hf_token or os.environ.get("HF_TOKEN")
-    if HF_TOKEN:
-        login(token=HF_TOKEN)
-
-    schema_text = load_text_arg(schema)
-    system_prompt = build_system_prompt(schema_text, output_format)
-
-    logger.info(f"Loading dataset: {input_dataset} (split={split})")
-    dataset = load_dataset(input_dataset, split=split)
-    if shuffle:
-        dataset = dataset.shuffle(seed=seed)
-    if max_samples:
-        dataset = dataset.select(range(min(max_samples, len(dataset))))
-    logger.info(f"Processing {len(dataset)} examples; format={output_format}")
-
-    if text_column not in dataset.column_names:
-        logger.error(f"Text column '{text_column}' not found. Columns: {dataset.column_names}")
-        sys.exit(1)
-
-    logger.info(f"Loading model: {model}")
-    llm = LLM(model=model, max_model_len=max_model_len, enforce_eager=True)
-    sampling_params = SamplingParams(temperature=0.0, max_tokens=max_tokens)
-
-    all_outputs: List[str] = []
-    n_valid = 0
-    texts = dataset[text_column]
-    for batch in tqdm(list(partition_all(batch_size, texts)), desc="Extracting"):
-        batch_messages = [
-            [
-                {"role": "system", "content": system_prompt},
-                {"role": "user", "content": str(doc)},
-            ]
-            for doc in batch
-        ]
-        outputs = llm.chat(batch_messages, sampling_params)
-        for out in outputs:
-            cleaned, ok = parse_output(out.outputs[0].text, output_format)
-            n_valid += int(ok)
-            all_outputs.append(cleaned)
-
-    logger.info(f"Valid {output_format.upper()}: {n_valid}/{len(all_outputs)}")
-    dataset = dataset.add_column(output_column, all_outputs)
-
-    inference_entry = {
-        "model": model,
-        "column_name": output_column,
-        "task": "structured extraction",
-        "format": output_format,
-        "timestamp": datetime.now(timezone.utc).isoformat(),
-        "script": "lfm2-extract.py",
-    }
-    if "inference_info" in dataset.column_names:
-        def update_info(example):
-            try:
-                existing = json.loads(example["inference_info"]) if example["inference_info"] else []
-            except (json.JSONDecodeError, TypeError):
-                existing = []
-            existing.append(inference_entry)
-            return {"inference_info": json.dumps(existing)}
-        dataset = dataset.map(update_info)
-    else:
-        dataset = dataset.add_column(
-            "inference_info", [json.dumps([inference_entry])] * len(dataset)
-        )
-
-    logger.info(f"Pushing to {output_dataset}")
-    dataset.push_to_hub(output_dataset, private=private, token=HF_TOKEN)
-
-    card_text = f"""---
-tags:
-- uv-script
-- extraction
-- lfm2
-- {output_format}
----
-
-# Structured extraction with LFM2-1.2B-Extract
-
-`{output_format.upper()}` extracted from the `{text_column}` column of
-[{input_dataset}](https://huggingface.co/datasets/{input_dataset})
-using [{model}](https://huggingface.co/{model}).
-
-- **Source**: `{input_dataset}` (split `{split}`, column `{text_column}`)
-- **Model**: `{model}`
-- **Format**: `{output_format}`
-- **Output column**: `{output_column}`
-- **Valid {output_format.upper()}**: {n_valid}/{len(all_outputs)}
-- **Date**: {datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M UTC")}
-
-Generated with the [uv-scripts/ocr](https://huggingface.co/datasets/uv-scripts/ocr) `lfm2-extract.py` script.
-"""
-    try:
-        DatasetCard(card_text).push_to_hub(output_dataset, token=HF_TOKEN)
-    except Exception as e:
-        logger.warning(f"Could not push dataset card: {e}")
-
-    logger.info("Done! Extraction complete.")
-    logger.info(f"Dataset: https://huggingface.co/datasets/{output_dataset}")
-
-
-if __name__ == "__main__":
-    if len(sys.argv) == 1:
-        print("LFM2-1.2B-Extract — structured extraction (JSON/XML/YAML) from text")
-        print("\nUsage:")
-        print("  uv run lfm2-extract.py INPUT OUTPUT --schema SCHEMA [--text-column text] [--format json]")
-        print("\nExample:")
-        print('  uv run lfm2-extract.py my-docs my-fields \\')
-        print('    --text-column markdown \\')
-        print('    --schema \'{"title": "the title", "date": "any date", "summary": "one sentence"}\'')
-        print("\n  --schema accepts inline text/JSON, a URL, or a file path.")
-        print("\nFor full help: uv run lfm2-extract.py --help")
-        sys.exit(0)
-
-    parser = argparse.ArgumentParser(
-        description="Structured extraction (JSON/XML/YAML) from text using LFM2-1.2B-Extract",
-    )
-    parser.add_argument("input_dataset", help="Input dataset ID (with a text column)")
-    parser.add_argument("output_dataset", help="Output dataset ID")
-    parser.add_argument(
-        "--schema", required=True,
-        help="Structure to extract: inline text/JSON, a URL, or a file path",
-    )
-    parser.add_argument("--text-column", default="text", help="Text column (default: text)")
-    parser.add_argument("--output-column", default="extraction", help="Output column (default: extraction)")
-    parser.add_argument(
-        "--format", dest="output_format", default="json", choices=list(FORMATS),
-        help="Output format (default: json)",
-    )
-    parser.add_argument("--split", default="train", help="Dataset split (default: train)")
-    parser.add_argument("--max-samples", type=int, help="Limit number of samples")
-    parser.add_argument("--shuffle", action="store_true", help="Shuffle before sampling")
-    parser.add_argument("--seed", type=int, default=42, help="Shuffle seed (default: 42)")
-    parser.add_argument("--batch-size", type=int, default=32, help="Batch size (default: 32)")
-    parser.add_argument("--model", default=DEFAULT_MODEL, help=f"Model (default: {DEFAULT_MODEL})")
-    parser.add_argument("--max-model-len", type=int, default=8192, help="Max context length (default: 8192)")
-    parser.add_argument("--max-tokens", type=int, default=4096, help="Max output tokens (default: 4096)")
-    parser.add_argument("--private", action="store_true", help="Make output dataset private")
-    parser.add_argument("--hf-token", help="HF token (or set HF_TOKEN)")
-    args = parser.parse_args()
-
-    main(
-        input_dataset=args.input_dataset,
-        output_dataset=args.output_dataset,
-        schema=args.schema,
-        text_column=args.text_column,
-        output_column=args.output_column,
-        output_format=args.output_format,
-        split=args.split,
-        max_samples=args.max_samples,
-        shuffle=args.shuffle,
-        seed=args.seed,
-        batch_size=args.batch_size,
-        model=args.model,
-        max_model_len=args.max_model_len,
-        max_tokens=args.max_tokens,
-        private=args.private,
-        hf_token=args.hf_token,
-    )

lfm2-vl-extract.py

@@ -1,324 +0,0 @@
-# /// script
-# requires-python = ">=3.11"
-# dependencies = [
-#     "datasets>=4.0.0",
-#     "huggingface-hub",
-#     "pillow",
-#     "vllm",
-#     "transformers",
-#     "tqdm",
-#     "toolz",
-#     "torch",
-# ]
-# ///
-"""
-Extract structured JSON from images using LiquidAI's LFM2.5-VL-1.6B-Extract with vLLM.
-
-LFM2.5-VL-1.6B-Extract (1.6B = LFM2 1.2B LM + SigLIP2 0.4B vision) is a compact
-vision-language model purpose-built for *schema-guided* extraction: you give it a
-list of fields, it returns a flat JSON object with those fields filled from the image.
-It reports 99.6 JSON-validity / F1 on its benchmark, beating similarly-sized VLMs.
-
-Unlike the markdown-OCR scripts here, this one needs a SCHEMA (a field list). Pass
-`--schema` as inline JSON, a URL, or a file path, mapping field names to short
-descriptions:
-
-    --schema '{"invoice_number": "the invoice number", "total": "the total amount"}'
-
-Model:  https://huggingface.co/LiquidAI/LFM2.5-VL-1.6B-Extract
-Docs:   https://docs.liquid.ai/deployment/gpu-inference/vllm
-
-HF Jobs note: run on the vLLM image so the CUDA toolkit + prebuilt FlashInfer kernels
-are present and startup is fast (it reuses the image's CUDA-matched vLLM build):
-
-    hf jobs uv run --flavor l4x1 --secrets HF_TOKEN \
-        --image vllm/vllm-openai --python /usr/bin/python3 \
-        -e PYTHONPATH=/usr/local/lib/python3.12/dist-packages \
-        https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lfm2-vl-extract.py \
-        INPUT OUTPUT --schema '{"title": "the document title", "date": "any date shown"}'
-
-It also runs on the default uv image, just with a slower first-time vLLM build. Deps are
-left unpinned so uv resolves a vLLM that supports the LFM2-VL (transformers 5) architecture,
-and FlashInfer sampling is disabled (VLLM_USE_FLASHINFER_SAMPLER=0, see below) so the engine
-never JIT-compiles a kernel that needs nvcc — absent from the default image.
-"""
-
-import argparse
-import base64
-import io
-import json
-import logging
-import os
-import sys
-from datetime import datetime, timezone
-from typing import Any, Dict, List, Optional, Union
-from urllib.request import urlopen
-
-# Disable vLLM's FlashInfer top-k/top-p sampler before the engine starts: it JIT-compiles
-# at warmup and needs nvcc (absent from the default uv image). Harmless for greedy decoding.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
-
-import torch
-from datasets import load_dataset
-from huggingface_hub import DatasetCard, login
-from PIL import Image
-from toolz import partition_all
-from tqdm import tqdm
-from vllm import LLM, SamplingParams
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-DEFAULT_MODEL = "LiquidAI/LFM2.5-VL-1.6B-Extract"
-
-
-def check_cuda_availability() -> None:
-    if not torch.cuda.is_available():
-        logger.error("CUDA is not available. This script requires a GPU.")
-        logger.error("Run on Hugging Face Jobs with: hf jobs uv run --flavor l4x1 ...")
-        sys.exit(1)
-    logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name()}")
-
-
-def load_schema_arg(value: str) -> Dict[str, str]:
-    """Resolve --schema (inline JSON, URL, or file path) into a {field: description} dict."""
-    text = value.strip()
-    if text.startswith("http://") or text.startswith("https://"):
-        logger.info(f"Loading schema from URL: {text}")
-        text = urlopen(text).read().decode("utf-8")
-    elif not text.startswith("{") and not text.startswith("["):
-        if os.path.exists(text):
-            logger.info(f"Loading schema from file: {text}")
-            with open(text) as f:
-                text = f.read()
-    parsed = json.loads(text)
-    # Accept {"field": "description"} or ["field1", "field2"]
-    if isinstance(parsed, list):
-        return {str(field): "" for field in parsed}
-    if isinstance(parsed, dict):
-        return {str(k): str(v) for k, v in parsed.items()}
-    raise ValueError("--schema must be a JSON object {field: description} or a JSON list of field names.")
-
-
-def build_system_prompt(schema: Dict[str, str]) -> str:
-    """LFM2.5-VL-Extract prompt: a field list in the system message → flat JSON out."""
-    lines = []
-    for field, desc in schema.items():
-        lines.append(f"{field}: {desc}" if desc else field)
-    fields_block = "\n".join(lines)
-    return (
-        f"Extract the following from the image:\n\n{fields_block}\n\n"
-        "Respond with only a JSON object."
-    )
-
-
-def image_to_data_uri(image: Union[Image.Image, Dict[str, Any], str]) -> str:
-    if isinstance(image, dict) and "bytes" in image:
-        image = Image.open(io.BytesIO(image["bytes"]))
-    elif isinstance(image, str):
-        image = Image.open(image)
-    if image.mode != "RGB":
-        image = image.convert("RGB")
-    buf = io.BytesIO()
-    image.save(buf, format="PNG")
-    return f"data:image/png;base64,{base64.b64encode(buf.getvalue()).decode()}"
-
-
-def make_message(image: Any, system_prompt: str) -> List[Dict]:
-    data_uri = image_to_data_uri(image)
-    return [
-        {"role": "system", "content": system_prompt},
-        {"role": "user", "content": [{"type": "image_url", "image_url": {"url": data_uri}}]},
-    ]
-
-
-def parse_json_output(text: str) -> tuple[Optional[Any], bool]:
-    """Return (parsed, ok). Strips ```json fences if present."""
-    stripped = text.strip()
-    if stripped.startswith("```"):
-        stripped = stripped.split("\n", 1)[-1]
-        if stripped.endswith("```"):
-            stripped = stripped.rsplit("```", 1)[0]
-    stripped = stripped.strip()
-    try:
-        return json.loads(stripped), True
-    except (json.JSONDecodeError, ValueError):
-        return None, False
-
-
-def main(
-    input_dataset: str,
-    output_dataset: str,
-    schema: str,
-    image_column: str = "image",
-    output_column: str = "extraction",
-    split: str = "train",
-    max_samples: Optional[int] = None,
-    shuffle: bool = False,
-    seed: int = 42,
-    batch_size: int = 16,
-    model: str = DEFAULT_MODEL,
-    max_model_len: int = 4096,
-    max_tokens: int = 1024,
-    private: bool = False,
-    hf_token: Optional[str] = None,
-) -> None:
-    check_cuda_availability()
-
-    HF_TOKEN = hf_token or os.environ.get("HF_TOKEN")
-    if HF_TOKEN:
-        login(token=HF_TOKEN)
-
-    schema_dict = load_schema_arg(schema)
-    system_prompt = build_system_prompt(schema_dict)
-    logger.info(f"Extraction fields: {list(schema_dict.keys())}")
-
-    logger.info(f"Loading dataset: {input_dataset} (split={split})")
-    dataset = load_dataset(input_dataset, split=split)
-    if shuffle:
-        dataset = dataset.shuffle(seed=seed)
-    if max_samples:
-        dataset = dataset.select(range(min(max_samples, len(dataset))))
-    logger.info(f"Processing {len(dataset)} examples")
-
-    if image_column not in dataset.column_names:
-        logger.error(f"Image column '{image_column}' not found. Columns: {dataset.column_names}")
-        sys.exit(1)
-
-    logger.info(f"Loading model: {model}")
-    llm = LLM(
-        model=model,
-        max_model_len=max_model_len,
-        limit_mm_per_prompt={"image": 1},
-        enforce_eager=True,
-    )
-    sampling_params = SamplingParams(temperature=0.0, max_tokens=max_tokens)
-
-    all_outputs: List[str] = []
-    n_valid = 0
-    images = dataset[image_column]
-    for batch in tqdm(list(partition_all(batch_size, images)), desc="Extracting"):
-        batch_messages = [make_message(img, system_prompt) for img in batch]
-        outputs = llm.chat(batch_messages, sampling_params)
-        for out in outputs:
-            text = out.outputs[0].text.strip()
-            parsed, ok = parse_json_output(text)
-            if ok:
-                n_valid += 1
-                all_outputs.append(json.dumps(parsed, ensure_ascii=False))
-            else:
-                all_outputs.append(text)  # keep raw on parse failure
-
-    logger.info(f"Valid JSON: {n_valid}/{len(all_outputs)}")
-
-    dataset = dataset.add_column(output_column, all_outputs)
-
-    inference_entry = {
-        "model": model,
-        "column_name": output_column,
-        "task": "schema-guided extraction",
-        "fields": list(schema_dict.keys()),
-        "timestamp": datetime.now(timezone.utc).isoformat(),
-        "script": "lfm2-vl-extract.py",
-    }
-    if "inference_info" in dataset.column_names:
-        def update_info(example):
-            try:
-                existing = json.loads(example["inference_info"]) if example["inference_info"] else []
-            except (json.JSONDecodeError, TypeError):
-                existing = []
-            existing.append(inference_entry)
-            return {"inference_info": json.dumps(existing)}
-        dataset = dataset.map(update_info)
-    else:
-        dataset = dataset.add_column(
-            "inference_info", [json.dumps([inference_entry])] * len(dataset)
-        )
-
-    logger.info(f"Pushing to {output_dataset}")
-    dataset.push_to_hub(output_dataset, private=private, token=HF_TOKEN)
-
-    card_text = f"""---
-tags:
-- uv-script
-- extraction
-- lfm2-vl
-- json
----
-
-# Structured extraction with LFM2.5-VL-1.6B-Extract
-
-JSON fields extracted from images in [{input_dataset}](https://huggingface.co/datasets/{input_dataset})
-using [{model}](https://huggingface.co/{model}).
-
-- **Source**: `{input_dataset}` (split `{split}`)
-- **Model**: `{model}`
-- **Fields**: {", ".join(f"`{k}`" for k in schema_dict.keys())}
-- **Output column**: `{output_column}` (JSON string per row)
-- **Valid JSON**: {n_valid}/{len(all_outputs)}
-- **Date**: {datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M UTC")}
-
-Generated with the [uv-scripts/ocr](https://huggingface.co/datasets/uv-scripts/ocr) `lfm2-vl-extract.py` script.
-"""
-    try:
-        card = DatasetCard(card_text)
-        card.push_to_hub(output_dataset, token=HF_TOKEN)
-    except Exception as e:
-        logger.warning(f"Could not push dataset card: {e}")
-
-    logger.info("Done! Extraction complete.")
-    logger.info(f"Dataset: https://huggingface.co/datasets/{output_dataset}")
-
-
-if __name__ == "__main__":
-    if len(sys.argv) == 1:
-        print("LFM2.5-VL-1.6B-Extract — schema-guided JSON extraction from images")
-        print("\nUsage:")
-        print("  uv run lfm2-vl-extract.py INPUT OUTPUT --schema SCHEMA [options]")
-        print("\nExample:")
-        print('  uv run lfm2-vl-extract.py my-images my-extractions \\')
-        print('    --schema \'{"title": "the document title", "date": "any date shown"}\'')
-        print("\n  --schema accepts inline JSON, a URL, or a file path.")
-        print("\nFor full help: uv run lfm2-vl-extract.py --help")
-        sys.exit(0)
-
-    parser = argparse.ArgumentParser(
-        description="Schema-guided JSON extraction from images using LFM2.5-VL-1.6B-Extract",
-    )
-    parser.add_argument("input_dataset", help="Input dataset ID (with images)")
-    parser.add_argument("output_dataset", help="Output dataset ID")
-    parser.add_argument(
-        "--schema", required=True,
-        help="Fields to extract: inline JSON {field: description}, a URL, or a file path",
-    )
-    parser.add_argument("--image-column", default="image", help="Image column (default: image)")
-    parser.add_argument("--output-column", default="extraction", help="Output column (default: extraction)")
-    parser.add_argument("--split", default="train", help="Dataset split (default: train)")
-    parser.add_argument("--max-samples", type=int, help="Limit number of samples")
-    parser.add_argument("--shuffle", action="store_true", help="Shuffle before sampling")
-    parser.add_argument("--seed", type=int, default=42, help="Shuffle seed (default: 42)")
-    parser.add_argument("--batch-size", type=int, default=16, help="Batch size (default: 16)")
-    parser.add_argument("--model", default=DEFAULT_MODEL, help=f"Model (default: {DEFAULT_MODEL})")
-    parser.add_argument("--max-model-len", type=int, default=4096, help="Max context length (default: 4096)")
-    parser.add_argument("--max-tokens", type=int, default=1024, help="Max output tokens (default: 1024)")
-    parser.add_argument("--private", action="store_true", help="Make output dataset private")
-    parser.add_argument("--hf-token", help="HF token (or set HF_TOKEN)")
-    args = parser.parse_args()
-
-    main(
-        input_dataset=args.input_dataset,
-        output_dataset=args.output_dataset,
-        schema=args.schema,
-        image_column=args.image_column,
-        output_column=args.output_column,
-        split=args.split,
-        max_samples=args.max_samples,
-        shuffle=args.shuffle,
-        seed=args.seed,
-        batch_size=args.batch_size,
-        model=args.model,
-        max_model_len=args.max_model_len,
-        max_tokens=args.max_tokens,
-        private=args.private,
-        hf_token=args.hf_token,
-    )

lighton-ocr.py

@@ -57,10 +57,6 @@ from huggingface_hub import DatasetCard, login
 from PIL import Image
 from toolz import partition_all
 from tqdm.auto import tqdm
-# Disable vLLM's FlashInfer sampler: it JIT-compiles a CUDA kernel needing nvcc, which the
-# default uv-script image lacks (engine init then crashes). Greedy OCR doesn't use it; this
-# lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
 from vllm import LLM, SamplingParams
 
 logging.basicConfig(level=logging.INFO)

lighton-ocr2.py

@@ -53,10 +53,6 @@ from huggingface_hub import DatasetCard, login
 from PIL import Image
 from toolz import partition_all
 from tqdm.auto import tqdm
-# Disable vLLM's FlashInfer sampler: it JIT-compiles a CUDA kernel needing nvcc, which the
-# default uv-script image lacks (engine init then crashes). Greedy OCR doesn't use it; this
-# lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
 from vllm import LLM, SamplingParams
 
 logging.basicConfig(level=logging.INFO)

nanonets-ocr.py

@@ -40,10 +40,6 @@ from huggingface_hub import DatasetCard, login
 from PIL import Image
 from toolz import partition_all
 from tqdm.auto import tqdm
-# Disable vLLM's FlashInfer sampler: it JIT-compiles a CUDA kernel needing nvcc, which the
-# default uv-script image lacks (engine init then crashes). Greedy OCR doesn't use it; this
-# lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
 from vllm import LLM, SamplingParams
 from datetime import datetime
 

nanonets-ocr2.py

@@ -44,10 +44,6 @@ from huggingface_hub import DatasetCard, login
 from PIL import Image
 from toolz import partition_all
 from tqdm.auto import tqdm
-# Disable vLLM's FlashInfer sampler: it JIT-compiles a CUDA kernel needing nvcc, which the
-# default uv-script image lacks (engine init then crashes). Greedy OCR doesn't use it; this
-# lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
 from vllm import LLM, SamplingParams
 
 logging.basicConfig(level=logging.INFO)

nuextract3.py

@@ -1,749 +0,0 @@
-# /// script
-# requires-python = ">=3.11"
-# dependencies = [
-#     "datasets>=3.1.0",
-#     "huggingface-hub",
-#     "pillow",
-#     "vllm",
-#     "toolz",
-#     "torch",
-#     "numind",
-# ]
-# ///
-
-"""
-Convert document images to markdown OR extract structured JSON using NuExtract3 with vLLM.
-
-NuExtract3 is a 4B Qwen3.5-based VLM for document understanding. It does two things:
-
-1. Document-to-Markdown OCR (default): images -> clean markdown with HTML tables,
-   LaTeX math, and <figure> tags.
-2. Schema-guided structured extraction: images + a JSON template -> JSON output
-   shaped exactly like the template. Useful for invoices, receipts, forms, contracts.
-
-Modes are selected via flags:
-- (no flags)         -> markdown OCR
-- --mode content     -> plain-content extraction
-- --template SOURCE  -> structured extraction with a NuExtract template
-- --schema SOURCE    -> structured extraction with a JSON Schema
-                        (auto-converted via numind.nuextract_utils)
-- --instructions STR -> free-text guidance passed through to the model
-                        (output-format rules, branch routing, etc.).
-                        Combines with any of the modes above.
-                        See https://huggingface.co/numind/NuExtract3#instructions
-
---template / --schema each accept inline JSON, a URL, or a local file path, so a
-schema can be hosted (e.g. on an HF dataset's raw URL) and reused across jobs:
-    --template https://huggingface.co/datasets/ORG/REPO/raw/main/card.json
-
-HF Jobs invocation (recommended): use the vllm/vllm-openai:latest image so the
-pre-built CUDA kernels (flashinfer etc.) are reused — the default uv-script
-image lacks nvcc and flashinfer's JIT compile fails at engine warmup.
-
-    hf jobs uv run \\
-        --image vllm/vllm-openai:latest \\
-        --flavor a100-large \\
-        --python /usr/bin/python3 \\
-        -e PYTHONPATH=/usr/local/lib/python3.12/dist-packages \\
-        -s HF_TOKEN \\
-        https://huggingface.co/datasets/uv-scripts/ocr/raw/main/nuextract3.py \\
-        INPUT_DATASET OUTPUT_DATASET --max-samples 5 --shuffle --seed 42
-
-Model: numind/NuExtract3
-License: Apache-2.0
-"""
-
-import argparse
-import base64
-import io
-import json
-import logging
-import os
-import sys
-import time
-from datetime import datetime
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Union
-
-import torch
-from datasets import load_dataset
-from huggingface_hub import DatasetCard, login
-from PIL import Image
-from toolz import partition_all
-# Disable vLLM's FlashInfer sampler: it JIT-compiles a CUDA kernel needing nvcc, which the
-# default uv-script image lacks (engine init then crashes). Greedy OCR doesn't use it; this
-# lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
-from vllm import LLM, SamplingParams
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-MODEL_DEFAULT = "numind/NuExtract3"
-MODEL_NAME = "NuExtract3"
-
-
-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.")
-        logger.error("Please run on a machine with a CUDA-capable GPU.")
-        sys.exit(1)
-    else:
-        logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
-
-
-def load_template_arg(value: Optional[str]) -> Optional[Dict[str, Any]]:
-    """Load a NuExtract template/JSON Schema from inline JSON, a URL, or a file path."""
-    if value is None:
-        return None
-    text = value
-    if value.startswith(("http://", "https://")):
-        import urllib.request
-
-        with urllib.request.urlopen(value) as resp:  # noqa: S310
-            text = resp.read().decode("utf-8")
-    elif "{" not in value:
-        # Inline JSON often exceeds the OS filename limit, so only probe the
-        # filesystem when the value doesn't look like JSON; treat OSError as
-        # "not a path".
-        try:
-            candidate_path = Path(value)
-            if candidate_path.is_file():
-                text = candidate_path.read_text()
-        except OSError:
-            pass
-    try:
-        return json.loads(text)
-    except json.JSONDecodeError as e:
-        raise ValueError(
-            f"Could not parse template/schema as JSON (tried URL/path/inline): {e}"
-        ) from e
-
-
-def resolve_template(
-    template_arg: Optional[str],
-    schema_arg: Optional[str],
-) -> Optional[Dict[str, Any]]:
-    """Resolve --template / --schema into a NuExtract template dict, or None."""
-    if template_arg and schema_arg:
-        raise ValueError("--template and --schema are mutually exclusive.")
-
-    if template_arg is not None:
-        return load_template_arg(template_arg)
-
-    if schema_arg is not None:
-        schema = load_template_arg(schema_arg)
-        try:
-            from numind.nuextract_utils import convert_json_schema_to_nuextract_template
-        except ImportError as e:
-            raise RuntimeError(
-                "--schema requires the `numind` package. "
-                "It should be listed in this script's PEP 723 dependencies."
-            ) from e
-        template, dropped = convert_json_schema_to_nuextract_template(schema)
-        if dropped:
-            logger.warning(
-                f"numind dropped {len(dropped)} unsupported branches from the JSON Schema: "
-                f"{dropped}"
-            )
-        return template
-
-    return None
-
-
-def image_to_data_uri(image: Union[Image.Image, Dict[str, Any], str]) -> str:
-    """Normalize an HF dataset image cell to a PNG data URI."""
-    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")
-    return f"data:image/png;base64,{base64.b64encode(buf.getvalue()).decode()}"
-
-
-def make_message(image: Union[Image.Image, Dict[str, Any], str]) -> List[Dict]:
-    """Build an OpenAI-format chat message containing one image."""
-    data_uri = image_to_data_uri(image)
-    return [
-        {
-            "role": "user",
-            "content": [
-                {"type": "image_url", "image_url": {"url": data_uri}},
-            ],
-        }
-    ]
-
-
-def split_thinking(text: str) -> tuple[Optional[str], str]:
-    """Return (reasoning, answer) if <think>...</think> is present, else (None, text)."""
-    if "<think>" in text and "</think>" in text:
-        reasoning = text.split("<think>", 1)[1].split("</think>", 1)[0].strip()
-        answer = text.split("</think>", 1)[1].strip()
-        return reasoning, answer
-    return None, text.strip()
-
-
-def parse_json_output(text: str) -> tuple[Optional[Any], bool]:
-    """Parse an extraction output; strip ``` fences as the model card describes.
-
-    Returns (parsed_value, parse_error). On failure, parsed_value is None.
-    """
-    stripped = text.strip()
-    if stripped.startswith("```"):
-        stripped = stripped.split("\n", 1)[-1] if "\n" in stripped else stripped[3:]
-        if stripped.endswith("```"):
-            stripped = stripped[:-3].rstrip()
-    try:
-        return json.loads(stripped), False
-    except json.JSONDecodeError:
-        return None, True
-
-
-def create_dataset_card(
-    source_dataset: str,
-    model: str,
-    num_samples: int,
-    processing_time: str,
-    mode_label: str,
-    template: Optional[Dict[str, Any]],
-    enable_thinking: bool,
-    temperature: float,
-    output_column: str,
-    image_column: str,
-    split: str,
-) -> str:
-    """Create a dataset card documenting the NuExtract3 run."""
-    model_name = model.split("/")[-1]
-    template_block = ""
-    if template is not None:
-        template_block = (
-            "\n### Extraction Template\n\n```json\n"
-            + json.dumps(template, indent=2)
-            + "\n```\n"
-        )
-
-    return f"""---
-tags:
-- ocr
-- structured-extraction
-- document-processing
-- nuextract3
-- markdown
-- uv-script
-- generated
----
-
-# {model_name} on {source_dataset}
-
-This dataset contains outputs from [{source_dataset}](https://huggingface.co/datasets/{source_dataset}) processed with [NuExtract3](https://huggingface.co/{model}), a 4B vision-language model for document understanding.
-
-## Processing Details
-
-- **Source Dataset**: [{source_dataset}](https://huggingface.co/datasets/{source_dataset})
-- **Model**: [{model}](https://huggingface.co/{model})
-- **Mode**: {mode_label}
-- **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**: `{output_column}`
-- **Dataset Split**: `{split}`
-- **Temperature**: {temperature}
-- **Thinking Mode**: {"enabled" if enable_thinking else "disabled"}
-{template_block}
-## Dataset Structure
-
-Original columns plus:
-- `{output_column}`: NuExtract3 output ({"JSON string" if template else "markdown"})
-- `inference_info`: JSON list tracking models applied to this dataset
-{"- `" + output_column + "_reasoning`: model's thinking trace (when enabled)" if enable_thinking 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 = 16,
-    max_model_len: int = 16384,
-    max_tokens: int = 8192,
-    gpu_memory_utilization: float = 0.8,
-    mode: str = "markdown",
-    template_arg: Optional[str] = None,
-    schema_arg: Optional[str] = None,
-    enable_thinking: bool = False,
-    instructions: Optional[str] = None,
-    temperature: Optional[float] = None,
-    model: str = MODEL_DEFAULT,
-    hf_token: str = None,
-    split: str = "train",
-    max_samples: int = None,
-    private: bool = False,
-    shuffle: bool = False,
-    seed: int = 42,
-    output_column: Optional[str] = None,
-    verbose: bool = False,
-    config: str = None,
-    create_pr: bool = False,
-):
-    """Process images from an HF dataset through NuExtract3."""
-
-    check_cuda_availability()
-    start_time = datetime.now()
-
-    HF_TOKEN = hf_token or os.environ.get("HF_TOKEN")
-    if HF_TOKEN:
-        login(token=HF_TOKEN)
-
-    template = resolve_template(template_arg, schema_arg)
-    extraction_mode = template is not None
-    mode_label = "structured-extraction" if extraction_mode else mode
-
-    if output_column is None:
-        output_column = "extraction" if extraction_mode else "markdown"
-
-    if temperature is None:
-        temperature = 0.6 if enable_thinking else 0.2
-
-    logger.info(f"Using model: {model}")
-    logger.info(f"Mode: {mode_label}")
-    logger.info(f"Thinking: {enable_thinking}  Temperature: {temperature}")
-    if extraction_mode:
-        logger.info(f"Template: {json.dumps(template, indent=2)}")
-
-    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")
-
-    logger.info("Initializing vLLM with NuExtract3")
-    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},
-    )
-
-    sampling_params = SamplingParams(
-        temperature=temperature,
-        max_tokens=max_tokens,
-    )
-
-    chat_template_kwargs: Dict[str, Any] = {"enable_thinking": enable_thinking}
-    if extraction_mode:
-        chat_template_kwargs["template"] = json.dumps(template, indent=4)
-    else:
-        chat_template_kwargs["mode"] = mode
-    if instructions:
-        chat_template_kwargs["instructions"] = instructions
-
-    logger.info(f"Processing {len(dataset)} images in batches of {batch_size}")
-    logger.info(f"Output will be written to column: {output_column}")
-
-    all_outputs: List[str] = []
-    all_reasoning: List[Optional[str]] = []
-    all_parse_errors: List[bool] = []
-    total_batches = (len(dataset) + batch_size - 1) // batch_size
-    processed = 0
-
-    for batch_num, batch_indices in enumerate(
-        partition_all(batch_size, range(len(dataset))), 1
-    ):
-        batch_indices = list(batch_indices)
-        batch_images = [dataset[i][image_column] for i in batch_indices]
-
-        logger.info(
-            f"Batch {batch_num}/{total_batches} "
-            f"({processed}/{len(dataset)} images done)"
-        )
-
-        try:
-            batch_messages = [make_message(img) for img in batch_images]
-            outputs = llm.chat(
-                batch_messages,
-                sampling_params,
-                chat_template_kwargs=chat_template_kwargs,
-                chat_template_content_format="openai",
-            )
-
-            for output in outputs:
-                raw_text = output.outputs[0].text
-                reasoning, answer = split_thinking(raw_text)
-
-                if extraction_mode:
-                    parsed, parse_error = parse_json_output(answer)
-                    stored = (
-                        json.dumps(parsed, ensure_ascii=False)
-                        if parsed is not None
-                        else answer
-                    )
-                    all_outputs.append(stored)
-                    all_parse_errors.append(parse_error)
-                else:
-                    all_outputs.append(answer)
-                    all_parse_errors.append(False)
-
-                all_reasoning.append(reasoning)
-
-            processed += len(batch_images)
-
-        except Exception as e:
-            logger.error(f"Error processing batch: {e}")
-            all_outputs.extend(["[NUEXTRACT3 ERROR]"] * len(batch_images))
-            all_reasoning.extend([None] * len(batch_images))
-            all_parse_errors.extend([True] * len(batch_images))
-            processed += len(batch_images)
-
-    processing_duration = datetime.now() - start_time
-    processing_time_str = f"{processing_duration.total_seconds() / 60:.1f} min"
-
-    logger.info(f"Adding '{output_column}' column to dataset")
-    dataset = dataset.add_column(output_column, all_outputs)
-
-    if enable_thinking and any(r is not None for r in all_reasoning):
-        reasoning_col = f"{output_column}_reasoning"
-        logger.info(f"Adding '{reasoning_col}' column to dataset")
-        dataset = dataset.add_column(reasoning_col, all_reasoning)
-
-    if extraction_mode:
-        parse_error_count = sum(all_parse_errors)
-        if parse_error_count:
-            logger.warning(
-                f"{parse_error_count}/{len(all_parse_errors)} extractions failed to parse as JSON"
-            )
-
-    inference_entry = {
-        "model_id": model,
-        "model_name": MODEL_NAME,
-        "column_name": output_column,
-        "timestamp": datetime.now().isoformat(),
-        "mode": mode_label,
-        "has_template": extraction_mode,
-        "enable_thinking": enable_thinking,
-        "temperature": temperature,
-        "max_tokens": max_tokens,
-    }
-    if extraction_mode:
-        inference_entry["parse_error_rate"] = (
-            sum(all_parse_errors) / len(all_parse_errors) if all_parse_errors else 0.0
-        )
-
-    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)
-
-    logger.info(f"Pushing to {output_dataset}")
-    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=f"Add {model} {mode_label} results ({len(dataset)} samples)"
-                + (f" [{config}]" if config else ""),
-            )
-            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. Results are lost.")
-                sys.exit(1)
-
-    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,
-        mode_label=mode_label,
-        template=template,
-        enable_thinking=enable_thinking,
-        temperature=temperature,
-        output_column=output_column,
-        image_column=image_column,
-        split=split,
-    )
-    card = DatasetCard(card_content)
-    card.push_to_hub(output_dataset, token=HF_TOKEN)
-
-    logger.info("Done! NuExtract3 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",
-            "numind",
-        ]:
-            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("=" * 70)
-        print("NuExtract3 - Document-to-Markdown + Structured Extraction (4B)")
-        print("=" * 70)
-        print("\nModes:")
-        print("  markdown          - Image -> markdown (default)")
-        print("  content           - Image -> plain content")
-        print("  --template / --schema  - Image -> JSON shaped like the template")
-        print("\nExamples:")
-        print("\n1. Markdown OCR:")
-        print("   uv run nuextract3.py input-dataset output-dataset")
-        print("\n2. Structured extraction with an inline template:")
-        print("   uv run nuextract3.py input output \\")
-        print('     --template \'{"title": "verbatim-string", "date": "date"}\'')
-        print("\n3. Structured extraction from a JSON Schema (e.g. Pydantic):")
-        print("   uv run nuextract3.py input output --schema schema.json")
-        print("\n   (--template / --schema also accept a URL or a local file path)")
-        print("\n4. Reasoning mode for harder documents:")
-        print("   uv run nuextract3.py input output --enable-thinking")
-        print("\n5. Test with 10 samples:")
-        print("   uv run nuextract3.py large-ds test --max-samples 10 --shuffle")
-        print("\n6. Running on HF Jobs (use vllm/vllm-openai image for built kernels):")
-        print("   hf jobs uv run --flavor a100-large \\")
-        print("     --image vllm/vllm-openai:latest \\")
-        print("     --python /usr/bin/python3 \\")
-        print("     -e PYTHONPATH=/usr/local/lib/python3.12/dist-packages \\")
-        print("     -s HF_TOKEN \\")
-        print(
-            "     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/nuextract3.py \\"
-        )
-        print("       input-dataset output-dataset --batch-size 16")
-        print("\nFor full help: uv run nuextract3.py --help")
-        sys.exit(0)
-
-    parser = argparse.ArgumentParser(
-        description="NuExtract3: document-to-markdown + schema-guided JSON extraction (4B VLM)",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Modes:
-  (default)     Markdown OCR (image -> clean markdown)
-  --mode content
-                Plain-content extraction (less structured than markdown)
-  --template PATH_OR_JSON
-                Structured extraction with a NuExtract template
-  --schema PATH_OR_JSON
-                Structured extraction from a JSON Schema
-                (e.g. Pydantic Model.model_json_schema())
-
-Examples:
-  uv run nuextract3.py my-docs analyzed-docs
-  uv run nuextract3.py receipts extracted \\
-      --template '{"store": "verbatim-string", "total": "number"}'
-  uv run nuextract3.py contracts extracted --schema contract_schema.json
-  uv run nuextract3.py hard-docs out --enable-thinking
-        """,
-    )
-
-    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=16,
-        help="Batch size for processing (default: 16)",
-    )
-    parser.add_argument(
-        "--max-model-len",
-        type=int,
-        default=16384,
-        help="Maximum model context length (default: 16384)",
-    )
-    parser.add_argument(
-        "--max-tokens",
-        type=int,
-        default=8192,
-        help="Maximum tokens to generate (default: 8192)",
-    )
-    parser.add_argument(
-        "--gpu-memory-utilization",
-        type=float,
-        default=0.8,
-        help="GPU memory utilization (default: 0.8)",
-    )
-    parser.add_argument(
-        "--mode",
-        choices=["markdown", "content"],
-        default="markdown",
-        help="OCR mode when no template/schema is given (default: markdown)",
-    )
-    parser.add_argument(
-        "--template",
-        help="NuExtract template: inline JSON, a URL, or a file path",
-    )
-    parser.add_argument(
-        "--schema",
-        help="JSON Schema to auto-convert: inline JSON, a URL, or a file path",
-    )
-    parser.add_argument(
-        "--enable-thinking",
-        action="store_true",
-        help="Enable reasoning mode (slower, better on hard documents)",
-    )
-    parser.add_argument(
-        "--instructions",
-        default=None,
-        help=(
-            "Free-text instructions passed to NuExtract via "
-            "chat_template_kwargs.instructions (e.g. routing guidance across "
-            "optional schema branches, output-format rules). "
-            "See https://huggingface.co/numind/NuExtract3#instructions"
-        ),
-    )
-    parser.add_argument(
-        "--temperature",
-        type=float,
-        default=None,
-        help="Sampling temperature (default: 0.2 non-thinking, 0.6 thinking)",
-    )
-    parser.add_argument(
-        "--model",
-        default=MODEL_DEFAULT,
-        help=f"Model ID (default: {MODEL_DEFAULT})",
-    )
-    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(
-        "--config",
-        help="Config/subset name when pushing to Hub (for benchmarking multiple models in one repo)",
-    )
-    parser.add_argument(
-        "--create-pr",
-        action="store_true",
-        help="Create a pull request instead of pushing directly (for parallel benchmarking)",
-    )
-    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(
-        "--output-column",
-        default=None,
-        help="Column name for output (default: 'markdown' in OCR mode, 'extraction' in template mode)",
-    )
-    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,
-        gpu_memory_utilization=args.gpu_memory_utilization,
-        mode=args.mode,
-        template_arg=args.template,
-        schema_arg=args.schema,
-        enable_thinking=args.enable_thinking,
-        instructions=args.instructions,
-        temperature=args.temperature,
-        model=args.model,
-        hf_token=args.hf_token,
-        split=args.split,
-        max_samples=args.max_samples,
-        private=args.private,
-        shuffle=args.shuffle,
-        seed=args.seed,
-        output_column=args.output_column,
-        verbose=args.verbose,
-        config=args.config,
-        create_pr=args.create_pr,
-    )

numarkdown-ocr.py

@@ -47,10 +47,6 @@ from huggingface_hub import DatasetCard, login
 from PIL import Image
 from toolz import partition_all
 from tqdm.auto import tqdm
-# Disable vLLM's FlashInfer sampler: it JIT-compiles a CUDA kernel needing nvcc, which the
-# default uv-script image lacks (engine init then crashes). Greedy OCR doesn't use it; this
-# lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
 from vllm import LLM, SamplingParams
 
 logging.basicConfig(level=logging.INFO)

olmocr2-vllm.py

@@ -50,11 +50,8 @@ from huggingface_hub import DatasetCard, login
 from PIL import Image
 from toolz import partition_all
 from tqdm.auto import tqdm
-# Disable vLLM's FlashInfer sampler: it JIT-compiles a CUDA kernel needing nvcc, which the
-# default uv-script image lacks (engine init then crashes). Greedy OCR doesn't use it; this
-# lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
 from vllm import LLM, SamplingParams
+from vllm.sampling_params import GuidedDecodingParams
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -368,25 +365,13 @@ def main(
         "stop": ["<|im_end|>", "<|endoftext|>"],
     }
 
-    # Add guided decoding if requested (enforces YAML front matter structure).
-    # vLLM 0.22.x renamed this API: GuidedDecodingParams (guided_decoding=) →
-    # StructuredOutputsParams (structured_outputs=). Import lazily + shim so the
-    # default path (guided_decoding=False) never touches the moved symbol.
+    # Add guided decoding if requested (enforces YAML front matter structure)
     if guided_decoding:
         logger.info("Enabling guided decoding with YAML front matter regex")
-        front_matter_regex = r"---\nprimary_language: (?:[a-z]{2}|null)\nis_rotation_valid: (?:True|False|true|false)\nrotation_correction: (?:0|90|180|270)\nis_table: (?:True|False|true|false)\nis_diagram: (?:True|False|true|false)\n(?:---|---\n[\s\S]+)"
-        try:
-            from vllm.sampling_params import StructuredOutputsParams
-
-            sampling_params_kwargs["structured_outputs"] = StructuredOutputsParams(
-                regex=front_matter_regex
-            )
-        except ImportError:
-            from vllm.sampling_params import GuidedDecodingParams
-
-            sampling_params_kwargs["guided_decoding"] = GuidedDecodingParams(
-                regex=front_matter_regex
-            )
+        guided_params = GuidedDecodingParams(
+            regex=r"---\nprimary_language: (?:[a-z]{2}|null)\nis_rotation_valid: (?:True|False|true|false)\nrotation_correction: (?:0|90|180|270)\nis_table: (?:True|False|true|false)\nis_diagram: (?:True|False|true|false)\n(?:---|---\n[\s\S]+)"
+        )
+        sampling_params_kwargs["guided_decoding"] = guided_params
 
     sampling_params = SamplingParams(**sampling_params_kwargs)
 

paddleocr-vl-1.6.py

@@ -1,798 +0,0 @@
-# /// script
-# requires-python = ">=3.11"
-# dependencies = [
-#     "datasets>=4.0.0",
-#     "huggingface-hub",
-#     "pillow",
-#     "vllm>=0.15.1",
-#     "tqdm",
-#     "toolz",
-#     "torch",
-#     "pyarrow",
-#     "transformers",
-# ]
-# ///
-
-"""
-Convert document images to text/tables/formulas using PaddleOCR-VL-1.6 with vLLM.
-
-PaddleOCR-VL-1.6 is a compact 0.9B OCR model that reaches a new SOTA of 96.33% on
-OmniDocBench v1.6. It combines a NaViT-style dynamic resolution visual encoder with
-the ERNIE-4.5-0.3B language model and is a plug-and-play upgrade of PaddleOCR-VL-1.5.
-
-Features:
-- 🎯 SOTA: 96.33% on OmniDocBench v1.6 (0.9B params, smallest top-tier OCR model)
-- 📝 OCR mode: General text extraction to markdown
-- 📊 Table mode: HTML table recognition and extraction
-- 📐 Formula mode: LaTeX mathematical notation
-- 📈 Chart mode: Structured chart analysis
-- 🔍 Spotting mode: Text spotting with localization
-- 🔖 Seal mode: Seal/stamp recognition
-- 🌍 Multilingual support (en/zh + more)
-- 🔧 Based on ERNIE-4.5 (different from Qwen-based models)
-
-Model: PaddlePaddle/PaddleOCR-VL-1.6
-Backend: vLLM offline (batch inference)
-
-HF Jobs note: PaddleOCR-VL-1.6 is supported by stable vLLM, but on HF Jobs you must run
-with the pre-built vLLM image so flashinfer's CUDA kernels are reused. The default
-uv-script image has the CUDA runtime but no `nvcc`, so vLLM's flashinfer sampler crashes
-at warmup with "Could not find nvcc". Use image-mode (see the example at the bottom):
-    --image vllm/vllm-openai:latest --flavor a100-large
-    --python /usr/bin/python3 -e PYTHONPATH=/usr/local/lib/python3.12/dist-packages
-This is the same image-mode pattern as nuextract3.py. Verified end-to-end on a100-large
-(2026-06-01): 5/5 clean markdown on davanstrien/ufo-ColPali, ~194 tok/s, 0 errors.
-"""
-
-import argparse
-import base64
-import io
-import json
-import logging
-import math
-import os
-import sys
-import time
-from typing import Any, Dict, List, Union
-from datetime import datetime
-
-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
-# Disable vLLM's FlashInfer sampler: it JIT-compiles a CUDA kernel needing nvcc, which the
-# default uv-script image lacks (engine init then crashes). Greedy OCR doesn't use it; this
-# lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
-from vllm import LLM, SamplingParams
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-MODEL_ID = "PaddlePaddle/PaddleOCR-VL-1.6"
-
-# Task mode configurations from official PaddleOCR-VL documentation
-TASK_MODES = {
-    "ocr": "OCR:",
-    "table": "Table Recognition:",
-    "formula": "Formula Recognition:",
-    "chart": "Chart Recognition:",
-    "spotting": "Spotting:",
-    "seal": "Seal Recognition:",
-}
-
-# Task descriptions for dataset card
-TASK_DESCRIPTIONS = {
-    "ocr": "General text extraction to markdown format",
-    "table": "Table extraction to HTML format",
-    "formula": "Mathematical formula recognition to LaTeX",
-    "chart": "Chart and diagram analysis",
-    "spotting": "Text spotting with localization",
-    "seal": "Seal and stamp recognition",
-}
-
-
-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.")
-        logger.error("Please run on a machine with a CUDA-capable GPU.")
-        sys.exit(1)
-    else:
-        logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
-
-
-def smart_resize(
-    height: int,
-    width: int,
-    factor: int = 28,
-    min_pixels: int = 28 * 28 * 130,
-    max_pixels: int = 28 * 28 * 1280,
-) -> tuple[int, int]:
-    """
-    PaddleOCR-VL's intelligent resize logic.
-
-    Rescales the image so that:
-    1. Both dimensions are divisible by 'factor' (28)
-    2. Total pixels are within [min_pixels, max_pixels]
-    3. Aspect ratio is maintained as closely as possible
-
-    Args:
-        height: Original image height
-        width: Original image width
-        factor: Dimension divisibility factor (default: 28)
-        min_pixels: Minimum total pixels (default: 100,880)
-        max_pixels: Maximum total pixels (default: 1,003,520)
-
-    Returns:
-        Tuple of (new_height, new_width)
-    """
-    if height < factor:
-        width = round((width * factor) / height)
-        height = factor
-
-    if width < factor:
-        height = round((height * factor) / width)
-        width = factor
-
-    if max(height, width) / min(height, width) > 200:
-        logger.warning(
-            f"Extreme aspect ratio detected: {max(height, width) / min(height, width):.1f}"
-        )
-        # Continue anyway, but warn about potential issues
-
-    h_bar = round(height / factor) * factor
-    w_bar = 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
-
-
-def make_ocr_message(
-    image: Union[Image.Image, Dict[str, Any], str],
-    task_mode: str = "ocr",
-    apply_smart_resize: bool = True,
-) -> List[Dict]:
-    """
-    Create chat message for PaddleOCR-VL processing.
-
-    PaddleOCR-VL expects a specific format with the task prefix after the image.
-    """
-    # Convert to PIL Image if needed
-    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)}")
-
-    # Convert to RGB
-    pil_img = pil_img.convert("RGB")
-
-    # Apply smart resize if requested. Spotting benefits from higher resolution
-    # (per the model card), so allow more pixels in that mode.
-    if apply_smart_resize:
-        original_size = pil_img.size
-        max_pixels = 28 * 28 * (2048 if task_mode == "spotting" else 1280)
-        new_height, new_width = smart_resize(
-            pil_img.height, pil_img.width, max_pixels=max_pixels
-        )
-        if (new_width, new_height) != (pil_img.width, pil_img.height):
-            pil_img = pil_img.resize((new_width, new_height), Image.Resampling.LANCZOS)
-            logger.debug(f"Resized image from {original_size} to {pil_img.size}")
-
-    # Convert to base64 data URI
-    buf = io.BytesIO()
-    pil_img.save(buf, format="PNG")
-    data_uri = f"data:image/png;base64,{base64.b64encode(buf.getvalue()).decode()}"
-
-    # PaddleOCR-VL message format: image first, then task prefix
-    return [
-        {
-            "role": "user",
-            "content": [
-                {"type": "image_url", "image_url": {"url": data_uri}},
-                {"type": "text", "text": TASK_MODES[task_mode]},
-            ],
-        }
-    ]
-
-
-def create_dataset_card(
-    source_dataset: str,
-    model: str,
-    task_mode: str,
-    num_samples: int,
-    processing_time: str,
-    batch_size: int,
-    max_model_len: int,
-    max_tokens: int,
-    gpu_memory_utilization: float,
-    temperature: float,
-    apply_smart_resize: bool,
-    image_column: str = "image",
-    split: str = "train",
-) -> str:
-    """Create a dataset card documenting the OCR process."""
-    task_description = TASK_DESCRIPTIONS[task_mode]
-
-    return f"""---
-tags:
-- ocr
-- document-processing
-- paddleocr-vl
-- paddleocr-vl-1.6
-- {task_mode}
-- uv-script
-- generated
----
-
-# Document Processing using PaddleOCR-VL-1.6 ({task_mode.upper()} mode)
-
-This dataset contains {task_mode.upper()} results from images in [{source_dataset}](https://huggingface.co/datasets/{source_dataset}) using PaddleOCR-VL-1.6, an ultra-compact 0.9B OCR model (96.33% SOTA on OmniDocBench v1.6).
-
-## Processing Details
-
-- **Source Dataset**: [{source_dataset}](https://huggingface.co/datasets/{source_dataset})
-- **Model**: [{model}](https://huggingface.co/{model})
-- **Task Mode**: `{task_mode}` - {task_description}
-- **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}
-- **Smart Resize**: {"Enabled" if apply_smart_resize else "Disabled"}
-- **Max Model Length**: {max_model_len:,} tokens
-- **Max Output Tokens**: {max_tokens:,}
-- **Temperature**: {temperature}
-- **GPU Memory Utilization**: {gpu_memory_utilization:.1%}
-
-## Model Information
-
-PaddleOCR-VL-1.6 is a state-of-the-art, resource-efficient model tailored for document parsing:
-- 🎯 **SOTA** - 96.33% on OmniDocBench v1.6
-- 🧩 **Ultra-compact** - Only 0.9B parameters
-- 📝 **OCR mode** - General text extraction
-- 📊 **Table mode** - HTML table recognition
-- 📐 **Formula mode** - LaTeX mathematical notation
-- 📈 **Chart mode** - Structured chart analysis
-- 🔍 **Spotting mode** - Text spotting with localization
-- 🔖 **Seal mode** - Seal/stamp recognition
-- 🌍 **Multilingual** - Support for multiple languages
-- 🔧 **ERNIE-4.5 based** - Different architecture from Qwen models
-
-### Task Modes
-
-- **OCR**: Extract text content to markdown format
-- **Table Recognition**: Extract tables to HTML format
-- **Formula Recognition**: Extract mathematical formulas to LaTeX
-- **Chart Recognition**: Analyze and describe charts/diagrams
-- **Spotting**: Text spotting with localization
-- **Seal Recognition**: Seal and stamp recognition
-
-## Dataset Structure
-
-The dataset contains all original columns plus:
-- `markdown`: The extracted content based on task mode
-- `inference_info`: JSON list tracking all OCR models applied to this dataset
-
-## Usage
-
-```python
-from datasets import load_dataset
-import json
-
-# Load the dataset
-dataset = load_dataset("{{output_dataset_id}}", split="{split}")
-
-# Access the extracted content
-for example in dataset:
-    print(example["markdown"])
-    break
-
-# View all OCR models applied to this dataset
-inference_info = json.loads(dataset[0]["inference_info"])
-for info in inference_info:
-    print(f"Task: {{info['task_mode']}} - Model: {{info['model_id']}}")
-```
-
-## Reproduction
-
-This dataset was generated using the [uv-scripts/ocr](https://huggingface.co/datasets/uv-scripts/ocr) PaddleOCR-VL-1.6 script.
-On HF Jobs, run with the pre-built vLLM image (image-mode) so flashinfer kernels are reused:
-
-```bash
-hf jobs uv run \\
-    --image vllm/vllm-openai:latest --flavor a100-large \\
-    --python /usr/bin/python3 -e PYTHONPATH=/usr/local/lib/python3.12/dist-packages \\
-    -s HF_TOKEN \\
-    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/paddleocr-vl-1.6.py \\
-    {source_dataset} \\
-    <output-dataset> \\
-    --task-mode {task_mode} \\
-    --image-column {image_column} \\
-    --batch-size {batch_size} \\
-    --max-model-len {max_model_len} \\
-    --max-tokens {max_tokens} \\
-    --gpu-memory-utilization {gpu_memory_utilization}
-```
-
-## Performance
-
-- **Model Size**: 0.9B parameters (smallest among top-tier OCR models)
-- **Processing Speed**: ~{num_samples / (float(processing_time.split()[0]) * 60):.2f} images/second
-- **Architecture**: NaViT visual encoder + ERNIE-4.5-0.3B language model
-
-Generated with 🤖 [UV Scripts](https://huggingface.co/uv-scripts)
-"""
-
-
-def main(
-    input_dataset: str,
-    output_dataset: str,
-    image_column: str = "image",
-    batch_size: int = 16,
-    task_mode: str = "ocr",
-    max_model_len: int = 8192,
-    max_tokens: int = 4096,
-    temperature: float = 0.0,
-    gpu_memory_utilization: float = 0.8,
-    apply_smart_resize: bool = True,
-    hf_token: str = None,
-    split: str = "train",
-    max_samples: int = None,
-    private: bool = False,
-    shuffle: bool = False,
-    seed: int = 42,
-    output_column: str = None,
-    config: str = None,
-    create_pr: bool = False,
-    verbose: bool = False,
-):
-    """Process images from HF dataset through PaddleOCR-VL-1.6 model."""
-
-    # Check CUDA availability first
-    check_cuda_availability()
-
-    # Track processing start time
-    start_time = datetime.now()
-
-    # Enable high-performance Xet downloads
-    os.environ["HF_XET_HIGH_PERFORMANCE"] = "1"
-
-    # Login to HF if token provided
-    HF_TOKEN = hf_token or os.environ.get("HF_TOKEN")
-    if HF_TOKEN:
-        login(token=HF_TOKEN)
-
-    # Validate task mode
-    if task_mode not in TASK_MODES:
-        raise ValueError(
-            f"Invalid task_mode '{task_mode}'. Choose from: {list(TASK_MODES.keys())}"
-        )
-
-    # Default output column is 'markdown' for consistency across scripts
-    if output_column is None:
-        output_column = "markdown"
-
-    logger.info(f"Using task mode: {task_mode} - {TASK_DESCRIPTIONS[task_mode]}")
-    logger.info(f"Output will be written to column: {output_column}")
-
-    # Load dataset
-    logger.info(f"Loading dataset: {input_dataset}")
-    dataset = load_dataset(input_dataset, split=split)
-
-    # Validate image column
-    if image_column not in dataset.column_names:
-        raise ValueError(
-            f"Column '{image_column}' not found. Available: {dataset.column_names}"
-        )
-
-    # Shuffle if requested
-    if shuffle:
-        logger.info(f"Shuffling dataset with seed {seed}")
-        dataset = dataset.shuffle(seed=seed)
-
-    # Limit samples if requested
-    if max_samples:
-        dataset = dataset.select(range(min(max_samples, len(dataset))))
-        logger.info(f"Limited to {len(dataset)} samples")
-
-    # Initialize vLLM model
-    logger.info(f"Initializing vLLM with {MODEL_ID}")
-    logger.info("This may take a minute on first run (model is only 0.9B)...")
-
-    try:
-        llm = LLM(
-            model=MODEL_ID,
-            trust_remote_code=True,
-            max_model_len=max_model_len,
-            gpu_memory_utilization=gpu_memory_utilization,
-            limit_mm_per_prompt={"image": 1},
-            max_num_batched_tokens=16384,
-            enable_prefix_caching=False,
-            enforce_eager=True,
-        )
-    except Exception as e:
-        logger.error(f"Failed to initialize PaddleOCR-VL-1.6 with vLLM: {e}")
-        logger.error(
-            "On HF Jobs, run with the pre-built vLLM image so flashinfer kernels are "
-            "reused (the default uv-script image has no nvcc):"
-        )
-        logger.error(
-            "  --image vllm/vllm-openai:latest --flavor a100-large "
-            "--python /usr/bin/python3 -e PYTHONPATH=/usr/local/lib/python3.12/dist-packages"
-        )
-        sys.exit(1)
-
-    # Sampling parameters - deterministic for OCR
-    sampling_params = SamplingParams(
-        temperature=temperature,
-        max_tokens=max_tokens,
-    )
-
-    logger.info(f"Processing {len(dataset)} images in batches of {batch_size}")
-    if apply_smart_resize:
-        logger.info("Smart resize enabled (PaddleOCR-VL's adaptive resolution)")
-
-    # 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=f"PaddleOCR-VL-1.6 {task_mode.upper()} processing",
-    ):
-        batch_indices = list(batch_indices)
-        batch_images = [dataset[i][image_column] for i in batch_indices]
-
-        try:
-            # Create messages for batch with task-specific prefix
-            batch_messages = [
-                make_ocr_message(
-                    img, task_mode=task_mode, apply_smart_resize=apply_smart_resize
-                )
-                for img in batch_images
-            ]
-
-            # Process with vLLM
-            outputs = llm.chat(batch_messages, sampling_params)
-
-            # Extract outputs
-            for output in outputs:
-                text = output.outputs[0].text.strip()
-                all_outputs.append(text)
-
-        except Exception as e:
-            logger.error(f"Error processing batch: {e}")
-            # Add error placeholders for failed batch
-            all_outputs.extend([f"[{task_mode.upper()} 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 to dataset
-    logger.info(f"Adding '{output_column}' column to dataset")
-    dataset = dataset.add_column(output_column, all_outputs)
-
-    # Handle inference_info tracking (for multi-model comparisons)
-    inference_entry = {
-        "model_id": MODEL_ID,
-        "model_name": "PaddleOCR-VL-1.6",
-        "model_size": "0.9B",
-        "task_mode": task_mode,
-        "column_name": output_column,
-        "timestamp": datetime.now().isoformat(),
-        "temperature": temperature,
-        "max_tokens": max_tokens,
-        "smart_resize": apply_smart_resize,
-        "backend": "vllm",
-    }
-
-    if "inference_info" in dataset.column_names:
-        # Append to existing inference info
-        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:
-        # Create new inference_info column
-        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}")
-    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=f"Add {MODEL_ID} OCR results ({len(dataset)} samples)"
-                + (f" [{config}]" if config else ""),
-            )
-            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 a PR to avoid touching main)
-    if not create_pr:
-        logger.info("Creating dataset card")
-        card_content = create_dataset_card(
-            source_dataset=input_dataset,
-            model=MODEL_ID,
-            task_mode=task_mode,
-            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,
-            temperature=temperature,
-            apply_smart_resize=apply_smart_resize,
-            image_column=image_column,
-            split=split,
-        )
-
-        card = DatasetCard(card_content)
-        card.push_to_hub(output_dataset, token=HF_TOKEN)
-
-    logger.info("✅ PaddleOCR-VL-1.6 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"Task mode: {task_mode} - {TASK_DESCRIPTIONS[task_mode]}")
-
-    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__":
-    # Show example usage if no arguments
-    if len(sys.argv) == 1:
-        print("=" * 80)
-        print("PaddleOCR-VL-1.6 Document Processing")
-        print("=" * 80)
-        print("\nUltra-compact 0.9B OCR model (96.33% SOTA on OmniDocBench v1.6)")
-        print("\nFeatures:")
-        print("- 🎯 SOTA - 96.33% on OmniDocBench v1.6 (0.9B params)")
-        print("- 📝 OCR mode - General text extraction")
-        print("- 📊 Table mode - HTML table recognition")
-        print("- 📐 Formula mode - LaTeX mathematical notation")
-        print("- 📈 Chart mode - Structured chart analysis")
-        print("- 🔍 Spotting mode - Text spotting with localization")
-        print("- 🔖 Seal mode - Seal/stamp recognition")
-        print("- 🌍 Multilingual support")
-        print("- 🔧 Based on ERNIE-4.5 (unique architecture)")
-        print("\nTask Modes:")
-        for mode, description in TASK_DESCRIPTIONS.items():
-            print(f"  {mode:8} - {description}")
-        print("\nExample usage:")
-        print("\n1. Basic OCR (default mode):")
-        print("   uv run paddleocr-vl-1.6.py input-dataset output-dataset")
-        print("\n2. Table extraction:")
-        print("   uv run paddleocr-vl-1.6.py docs tables-extracted --task-mode table")
-        print("\n3. Formula recognition:")
-        print(
-            "   uv run paddleocr-vl-1.6.py papers formulas --task-mode formula --batch-size 32"
-        )
-        print("\n4. Chart analysis:")
-        print("   uv run paddleocr-vl-1.6.py diagrams charts-analyzed --task-mode chart")
-        print("\n5. Test with small sample:")
-        print("   uv run paddleocr-vl-1.6.py dataset test --max-samples 10 --shuffle")
-        print("\n6. Running on HF Jobs (image-mode required — see note below):")
-        print("   hf jobs uv run \\")
-        print("     --image vllm/vllm-openai:latest --flavor a100-large \\")
-        print(
-            "     --python /usr/bin/python3 -e PYTHONPATH=/usr/local/lib/python3.12/dist-packages \\"
-        )
-        print("     -s HF_TOKEN \\")
-        print(
-            "     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/paddleocr-vl-1.6.py \\"
-        )
-        print("       input-dataset output-dataset --task-mode ocr")
-        print("\n   NOTE: the default uv-script image has no nvcc, so vLLM's flashinfer")
-        print("   sampler crashes at warmup. The vllm/vllm-openai image ships the kernels.")
-        print("\n" + "=" * 80)
-        print("\nFor full help, run: uv run paddleocr-vl-1.6.py --help")
-        sys.exit(0)
-
-    parser = argparse.ArgumentParser(
-        description="Document processing using PaddleOCR-VL-1.6 (0.9B SOTA OCR model)",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Task Modes:
-  ocr       General text extraction to markdown (default)
-  table     Table extraction to HTML format
-  formula   Mathematical formula recognition to LaTeX
-  chart     Chart and diagram analysis
-  spotting  Text spotting with localization
-  seal      Seal and stamp recognition
-
-Examples:
-  # Basic text OCR
-  uv run paddleocr-vl-1.6.py my-docs analyzed-docs
-
-  # Extract tables from documents
-  uv run paddleocr-vl-1.6.py papers tables --task-mode table
-
-  # Recognize mathematical formulas
-  uv run paddleocr-vl-1.6.py textbooks formulas --task-mode formula
-
-  # Analyze charts and diagrams
-  uv run paddleocr-vl-1.6.py reports charts --task-mode chart
-
-  # Test with random sampling
-  uv run paddleocr-vl-1.6.py large-dataset test --max-samples 50 --shuffle --task-mode ocr
-
-  # Disable smart resize for original resolution
-  uv run paddleocr-vl-1.6.py images output --no-smart-resize
-        """,
-    )
-
-    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=16,
-        help="Batch size for processing (default: 16)",
-    )
-    parser.add_argument(
-        "--task-mode",
-        choices=list(TASK_MODES.keys()),
-        default="ocr",
-        help="Task type: ocr (default), table, formula, chart, spotting, or seal",
-    )
-    parser.add_argument(
-        "--max-model-len",
-        type=int,
-        default=8192,
-        help="Maximum model context length (default: 8192)",
-    )
-    parser.add_argument(
-        "--max-tokens",
-        type=int,
-        default=4096,
-        help="Maximum tokens to generate (default: 4096)",
-    )
-    parser.add_argument(
-        "--temperature",
-        type=float,
-        default=0.0,
-        help="Sampling temperature (default: 0.0 for deterministic)",
-    )
-    parser.add_argument(
-        "--gpu-memory-utilization",
-        type=float,
-        default=0.8,
-        help="GPU memory utilization (default: 0.8)",
-    )
-    parser.add_argument(
-        "--no-smart-resize",
-        action="store_true",
-        help="Disable PaddleOCR-VL's smart resize, use original image size",
-    )
-    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(
-        "--output-column",
-        help="Column name for output (default: markdown)",
-    )
-    parser.add_argument(
-        "--config",
-        help="Config/subset name when pushing to Hub (for benchmarking multiple models in one repo)",
-    )
-    parser.add_argument(
-        "--create-pr",
-        action="store_true",
-        help="Create a pull request instead of pushing directly (for parallel benchmarking)",
-    )
-    parser.add_argument(
-        "--verbose",
-        action="store_true",
-        help="Log resolved package versions after processing (useful for pinning deps)",
-    )
-
-    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,
-        task_mode=args.task_mode,
-        max_model_len=args.max_model_len,
-        max_tokens=args.max_tokens,
-        temperature=args.temperature,
-        gpu_memory_utilization=args.gpu_memory_utilization,
-        apply_smart_resize=not args.no_smart_resize,
-        hf_token=args.hf_token,
-        split=args.split,
-        max_samples=args.max_samples,
-        private=args.private,
-        shuffle=args.shuffle,
-        seed=args.seed,
-        output_column=args.output_column,
-        config=args.config,
-        create_pr=args.create_pr,
-        verbose=args.verbose,
-    )

paddleocr-vl.py

@@ -56,10 +56,6 @@ from huggingface_hub import DatasetCard, login
 from PIL import Image
 from toolz import partition_all
 from tqdm.auto import tqdm
-# Disable vLLM's FlashInfer sampler: it JIT-compiles a CUDA kernel needing nvcc, which the
-# default uv-script image lacks (engine init then crashes). Greedy OCR doesn't use it; this
-# lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
 from vllm import LLM, SamplingParams
 
 logging.basicConfig(level=logging.INFO)

pp-doclayout.py

@@ -1,1183 +0,0 @@
-# /// script
-# requires-python = ">=3.10"
-# dependencies = [
-#     "paddlepaddle-gpu>=3.0.0",
-#     "paddleocr>=3.0.0",
-#     "opencv-contrib-python-headless",
-#     "datasets>=4.0.0",
-#     "huggingface-hub>=1.6.0",
-#     "pyarrow>=15.0",
-#     "pillow",
-#     "numpy",
-#     "tqdm",
-# ]
-#
-# [tool.uv]
-# # PaddleOCR/PaddleX pull in opencv-contrib-python (full) which needs system
-# # libGL.so.1 — not present in the slim uv-on-bookworm image used by HF Jobs.
-# # Swap to the headless cv2 variant (same `import cv2`, no GUI deps).
-# override-dependencies = [
-#     "opencv-contrib-python ; python_version < '0'",
-#     "opencv-python ; python_version < '0'",
-# ]
-#
-# [[tool.uv.index]]
-# name = "paddle"
-# url = "https://www.paddlepaddle.org.cn/packages/stable/cu126/"
-# explicit = true
-#
-# [tool.uv.sources]
-# paddlepaddle-gpu = { index = "paddle" }
-# ///
-
-"""
-Detect document layout regions (text/title/table/figure/formula/...) with PP-DocLayout-L.
-
-Runs PaddleOCR's PP-DocLayout-L (or M / S / plus-L variant) over an image source
-and emits per-image bounding-box predictions. Unlike the OCR scripts in this repo
-this does NOT extract text — it only locates and classifies regions.
-
-Source can be:
-  - HF dataset repo (default): "namespace/dataset"
-  - HF bucket of image files: "hf://buckets/namespace/bucket/optional/prefix"
-
-Sink can be:
-  - HF dataset repo (default): "namespace/dataset" (one push at end + dataset card)
-  - HF bucket: "hf://buckets/namespace/bucket/run-name" (incremental parquet
-    shards, resumable, no git overhead)
-
-Output schema (column `layout` is a JSON string):
-  [{"bbox": [x1, y1, x2, y2], "label": "text", "score": 0.97, "cls_id": 2}, ...]
-
-Coordinates are in the original input-image pixel space.
-
-Example commands:
-
-  # Dataset -> dataset (smoke on L4)
-  hf jobs uv run --flavor l4x1 -s HF_TOKEN https://huggingface.co/datasets/uv-scripts/ocr/raw/main/pp-doclayout.py \\
-      davanstrien/ufo-ColPali pp-doclayout-smoke \\
-      --max-samples 3 --shuffle --seed 42 --private
-
-  # Dataset -> bucket (incremental shards, resumable)
-  hf buckets create davanstrien/pp-doclayout-scratch --exist-ok
-  hf jobs uv run --flavor l4x1 -s HF_TOKEN https://huggingface.co/datasets/uv-scripts/ocr/raw/main/pp-doclayout.py \\
-      davanstrien/ufo-ColPali \\
-      hf://buckets/davanstrien/pp-doclayout-scratch/run1 \\
-      --max-samples 20 --shard-size 5
-
-  # Bucket of images -> dataset
-  hf jobs uv run --flavor l4x1 -s HF_TOKEN https://huggingface.co/datasets/uv-scripts/ocr/raw/main/pp-doclayout.py \\
-      hf://buckets/davanstrien/pp-doclayout-images \\
-      pp-doclayout-from-bucket --private
-"""
-
-import argparse
-import io
-import json
-import logging
-import os
-import sys
-import time
-from dataclasses import dataclass
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any, Dict, Iterator, List, Optional, Tuple, Union
-
-import numpy as np
-from PIL import Image, UnidentifiedImageError
-from tqdm.auto import tqdm
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-
-# ---------------------------------------------------------------------------
-# Constants
-# ---------------------------------------------------------------------------
-
-VALID_MODELS = [
-    "PP-DocLayout-L",
-    "PP-DocLayout-M",
-    "PP-DocLayout-S",
-    "PP-DocLayout_plus-L",
-]
-
-MODEL_SIZES = {
-    "PP-DocLayout-L": "~123M params (RT-DETR-L backbone)",
-    "PP-DocLayout-M": "~22M params (PicoDet-M)",
-    "PP-DocLayout-S": "~4M params (PicoDet-S)",
-    "PP-DocLayout_plus-L": "~123M params, 20-class plus variant",
-}
-
-IMAGE_EXTENSIONS = {
-    ".jpg", ".jpeg", ".png", ".tif", ".tiff", ".webp", ".bmp", ".jp2", ".j2k",
-}
-
-BUCKET_PREFIX = "hf://buckets/"
-
-
-# ---------------------------------------------------------------------------
-# URL helpers
-# ---------------------------------------------------------------------------
-
-
-def is_bucket_url(s: str) -> bool:
-    return s.startswith(BUCKET_PREFIX)
-
-
-def parse_bucket_url(url: str) -> Tuple[str, str]:
-    """Split `hf://buckets/ns/bucket/path/in/bucket` into (`ns/bucket`, `path/in/bucket`)."""
-    if not is_bucket_url(url):
-        raise ValueError(f"Not a bucket URL: {url}")
-    rest = url[len(BUCKET_PREFIX) :].strip("/")
-    parts = rest.split("/", 2)
-    if len(parts) < 2:
-        raise ValueError(
-            f"Bucket URL must include namespace and bucket name: {url}"
-        )
-    bucket_id = f"{parts[0]}/{parts[1]}"
-    prefix = parts[2] if len(parts) > 2 else ""
-    return bucket_id, prefix
-
-
-# ---------------------------------------------------------------------------
-# Image helpers
-# ---------------------------------------------------------------------------
-
-
-def to_pil(image: Union[Image.Image, Dict[str, Any], str, bytes]) -> Image.Image:
-    if isinstance(image, Image.Image):
-        return image.convert("RGB")
-    if isinstance(image, dict) and "bytes" in image:
-        return Image.open(io.BytesIO(image["bytes"])).convert("RGB")
-    if isinstance(image, (bytes, bytearray)):
-        return Image.open(io.BytesIO(image)).convert("RGB")
-    if isinstance(image, str):
-        return Image.open(image).convert("RGB")
-    raise ValueError(f"Unsupported image type: {type(image)}")
-
-
-def pil_to_array(pil_img: Image.Image) -> np.ndarray:
-    """RGB PIL -> uint8 ndarray. PaddleOCR's predict() accepts numpy arrays directly."""
-    return np.asarray(pil_img, dtype=np.uint8)
-
-
-# ---------------------------------------------------------------------------
-# Result extraction
-# ---------------------------------------------------------------------------
-
-
-def extract_detections(result: Any) -> List[Dict[str, Any]]:
-    """Pull a clean list of detections out of a paddleocr LayoutDetection result."""
-    payload = result.json
-    res = payload.get("res", payload) if isinstance(payload, dict) else {}
-    boxes = res.get("boxes", []) if isinstance(res, dict) else []
-    detections = []
-    for box in boxes:
-        coord = box.get("coordinate") or box.get("bbox") or []
-        coord = [float(x) for x in coord]
-        detections.append(
-            {
-                "bbox": coord,
-                "label": box.get("label"),
-                "score": float(box.get("score", 0.0)),
-                "cls_id": int(box.get("cls_id", -1)),
-            }
-        )
-    return detections
-
-
-# ---------------------------------------------------------------------------
-# Sources
-# ---------------------------------------------------------------------------
-
-
-@dataclass
-class SourceItem:
-    key: str  # stable identifier per image (used for dedup/resume)
-    image: Image.Image
-    extras: Dict[str, Any]  # original row fields (only populated for dataset source)
-
-
-def iter_dataset_images(
-    dataset_id: str,
-    image_column: str,
-    split: str,
-    shuffle: bool,
-    seed: int,
-    max_samples: Optional[int],
-):
-    """Iterate (key, PIL) pairs from an HF dataset repo.
-
-    Returns: (iterator, total, dataset_reference). The dataset reference is the
-    post-shuffle/post-select Dataset, kept around so the dataset-repo sink can
-    `add_column("layout", ...)` and preserve the original schema (especially
-    Image-type columns).
-    """
-    from datasets import load_dataset
-
-    logger.info(f"Loading dataset: {dataset_id} (split={split})")
-    ds = load_dataset(dataset_id, split=split)
-
-    if image_column not in ds.column_names:
-        raise ValueError(
-            f"Column '{image_column}' not found. Available: {ds.column_names}"
-        )
-
-    if shuffle:
-        logger.info(f"Shuffling with seed {seed}")
-        ds = ds.shuffle(seed=seed)
-    if max_samples:
-        ds = ds.select(range(min(max_samples, len(ds))))
-        logger.info(f"Limited to {len(ds)} samples")
-
-    total = len(ds)
-
-    def gen() -> Iterator[SourceItem]:
-        skipped = 0
-        for i in range(total):
-            try:
-                row = ds[i]
-                image = to_pil(row[image_column])
-            except (UnidentifiedImageError, OSError) as e:
-                skipped += 1
-                logger.warning(
-                    f"Skipping unreadable image at row {i}: "
-                    f"{type(e).__name__}: {e}"
-                )
-                continue
-            yield SourceItem(
-                key=f"row-{i:08d}",
-                image=image,
-                extras={},  # original schema is preserved by the sink via the dataset ref
-            )
-        if skipped:
-            logger.info(f"Skipped {skipped} unreadable image(s) total")
-
-    return gen(), total, ds
-
-
-SOURCE_PATHS_SNAPSHOT = "_source_paths.json"
-
-
-def _bucket_snapshot_path(output_url: str) -> Tuple[str, str]:
-    """Return (bucket_id, key) for the source-paths snapshot inside an output bucket."""
-    out_bucket_id, out_prefix = parse_bucket_url(output_url)
-    snapshot_key = (
-        f"{out_prefix}/{SOURCE_PATHS_SNAPSHOT}".lstrip("/")
-        if out_prefix
-        else SOURCE_PATHS_SNAPSHOT
-    )
-    return out_bucket_id, snapshot_key
-
-
-def iter_bucket_images(
-    bucket_url: str,
-    shuffle: bool,
-    seed: int,
-    max_samples: Optional[int],
-    hf_token: Optional[str],
-    output_url: Optional[str] = None,
-) -> Tuple[Iterator[SourceItem], int]:
-    """Glob image files under a bucket prefix and stream them via HfFileSystem.
-
-    If `output_url` is a bucket, the resolved source-path list is snapshotted to
-    `<output>/_source_paths.json` on first run. Subsequent runs against the same
-    output prefix reuse that snapshot, so resume stays consistent even if the
-    source bucket grows or `--shuffle`/`--max-samples` would otherwise pick a
-    different subset on the second run.
-    """
-    from huggingface_hub import HfApi, HfFileSystem
-
-    bucket_id, prefix = parse_bucket_url(bucket_url)
-    fs = HfFileSystem(token=hf_token)
-    base = f"{BUCKET_PREFIX}{bucket_id}/{prefix}".rstrip("/")
-
-    snapshot_bucket_id: Optional[str] = None
-    snapshot_key: Optional[str] = None
-    cached_paths: Optional[List[str]] = None
-
-    if output_url and is_bucket_url(output_url):
-        snapshot_bucket_id, snapshot_key = _bucket_snapshot_path(output_url)
-        snapshot_url = f"{BUCKET_PREFIX}{snapshot_bucket_id}/{snapshot_key}"
-        try:
-            with fs.open(snapshot_url, "rb") as f:
-                snapshot = json.load(f)
-            if snapshot.get("source_url") != bucket_url:
-                logger.warning(
-                    f"Output prefix already has a snapshot referencing a "
-                    f"different source ({snapshot.get('source_url')!r} vs "
-                    f"{bucket_url!r}). Ignoring and re-listing."
-                )
-            else:
-                cached_paths = snapshot["paths"]
-                logger.info(
-                    f"Reusing existing snapshot of {len(cached_paths)} source paths "
-                    f"(written {snapshot.get('created_at', 'unknown')})"
-                )
-        except FileNotFoundError:
-            pass
-        except Exception as e:
-            logger.warning(f"Could not read existing snapshot ({e}); re-listing.")
-
-    if cached_paths is not None:
-        all_paths = cached_paths
-    else:
-        logger.info(f"Listing images under {base}")
-        all_paths = []
-        try:
-            for entry in fs.find(base, detail=False):
-                ext = Path(entry).suffix.lower()
-                if ext in IMAGE_EXTENSIONS:
-                    all_paths.append(entry)
-        except FileNotFoundError as e:
-            raise ValueError(f"Bucket prefix not found: {base}") from e
-
-        if not all_paths:
-            raise ValueError(
-                f"No image files (any of {sorted(IMAGE_EXTENSIONS)}) under {base}"
-            )
-
-        all_paths.sort()
-        if shuffle:
-            rng = np.random.default_rng(seed)
-            rng.shuffle(all_paths)
-        if max_samples:
-            all_paths = all_paths[:max_samples]
-
-        # Persist the chosen list so resume runs see exactly this set.
-        if snapshot_bucket_id is not None and snapshot_key is not None:
-            api = HfApi(token=hf_token)
-            payload = {
-                "source_url": bucket_url,
-                "shuffle": shuffle,
-                "seed": seed,
-                "max_samples": max_samples,
-                "created_at": datetime.now(timezone.utc).isoformat(),
-                "paths": all_paths,
-            }
-            api.batch_bucket_files(
-                snapshot_bucket_id,
-                add=[(json.dumps(payload).encode(), snapshot_key)],
-                token=hf_token,
-            )
-            logger.info(
-                f"Wrote source-path snapshot ({len(all_paths)} paths) to "
-                f"hf://buckets/{snapshot_bucket_id}/{snapshot_key}"
-            )
-
-    total = len(all_paths)
-    logger.info(f"Found {total} images in bucket")
-
-    def key_for(path: str) -> str:
-        # Use the full bucket path (`buckets/<id>/<rel>`) as returned by
-        # fs.find. This is stable across reruns (so resume works), and the
-        # stored value in `source_path` is fully addressable — open via
-        # HfFileSystem directly with `hf://` re-prepended.
-        return path
-
-    def gen() -> Iterator[SourceItem]:
-        skipped = 0
-        for path in all_paths:
-            try:
-                with fs.open(path, "rb") as f:
-                    data = f.read()
-                image = to_pil(data)
-            except (UnidentifiedImageError, OSError) as e:
-                skipped += 1
-                logger.warning(
-                    f"Skipping unreadable image {path}: "
-                    f"{type(e).__name__}: {e}"
-                )
-                continue
-            yield SourceItem(
-                key=key_for(path),
-                image=image,
-                extras={"__source_path": key_for(path)},
-            )
-        if skipped:
-            logger.info(f"Skipped {skipped} unreadable image(s) total")
-
-    return gen(), total
-
-
-# ---------------------------------------------------------------------------
-# Sinks
-# ---------------------------------------------------------------------------
-
-
-class DatasetRepoSink:
-    """Buffer all results in memory, push once at end with dataset card + inference_info.
-
-    Two modes:
-      - `original_dataset` provided (dataset-repo source): preserve the source
-        schema (including Image-type columns) and just `add_column("layout", ...)`.
-      - `original_dataset` is None (bucket-image source): build a Dataset from
-        collected rows containing __source_path + layout.
-    """
-
-    def __init__(
-        self,
-        repo_id: str,
-        *,
-        hf_token: Optional[str],
-        private: bool,
-        config: Optional[str],
-        create_pr: bool,
-        source_id: str,
-        original_dataset=None,
-    ):
-        self.repo_id = repo_id
-        self.hf_token = hf_token
-        self.private = private
-        self.config = config
-        self.create_pr = create_pr
-        self.source_id = source_id
-        self.original_dataset = original_dataset
-        # Used when original_dataset is None: row-by-row buffer.
-        self._rows: List[Dict[str, Any]] = []
-        # Used when original_dataset is set: ordered layouts aligned with dataset rows.
-        self._layouts: List[str] = []
-
-    @property
-    def kind(self) -> str:
-        return "dataset"
-
-    def already_done(self) -> set:
-        return set()  # dataset sink does a single push, no resume
-
-    def write(self, key: str, layout: List[Dict[str, Any]], extras: Dict[str, Any]) -> None:
-        layout_json = json.dumps(layout, ensure_ascii=False)
-        if self.original_dataset is not None:
-            self._layouts.append(layout_json)
-            return
-        row = {"__source_key": key, "layout": layout_json}
-        for k, v in extras.items():
-            if isinstance(v, (str, int, float, bool)) or v is None:
-                row[k] = v
-        self._rows.append(row)
-
-    def finalize(self, model_id: str, args_dict: Dict[str, Any]) -> None:
-        from datasets import Dataset
-
-        if self.original_dataset is not None:
-            if len(self._layouts) != len(self.original_dataset):
-                logger.warning(
-                    f"Layout count ({len(self._layouts)}) != dataset rows "
-                    f"({len(self.original_dataset)}); padding with empty layouts."
-                )
-                # Pad to keep add_column happy.
-                while len(self._layouts) < len(self.original_dataset):
-                    self._layouts.append("[]")
-            ds = self.original_dataset.add_column("layout", self._layouts)
-        else:
-            if not self._rows:
-                logger.warning("No rows produced; nothing to push.")
-                return
-            ds = Dataset.from_list(self._rows)
-            if "__source_key" in ds.column_names:
-                ds = ds.rename_column("__source_key", "source_path")
-
-        inference_entry = build_inference_entry(model_id, args_dict)
-
-        if "inference_info" in ds.column_names:
-            logger.info("Updating existing inference_info column")
-
-            def _update(example):
-                try:
-                    existing = (
-                        json.loads(example["inference_info"])
-                        if example["inference_info"]
-                        else []
-                    )
-                except (json.JSONDecodeError, TypeError):
-                    existing = []
-                existing.append(inference_entry)
-                return {"inference_info": json.dumps(existing)}
-
-            ds = ds.map(_update)
-        else:
-            ds = ds.add_column(
-                "inference_info", [json.dumps([inference_entry])] * len(ds)
-            )
-
-        logger.info(f"Pushing {len(ds)} rows to {self.repo_id}")
-        push_kwargs = {
-            "private": self.private,
-            "token": self.hf_token,
-            "max_shard_size": "500MB",
-            "create_pr": self.create_pr,
-            "commit_message": f"Add PP-DocLayout layout predictions ({len(ds)} samples)"
-            + (f" [{self.config}]" if self.config else ""),
-        }
-        if self.config:
-            push_kwargs["config_name"] = self.config
-
-        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"
-                ds.push_to_hub(self.repo_id, **push_kwargs)
-                break
-            except Exception as e:
-                logger.error(f"Upload attempt {attempt}/{max_retries} failed: {e}")
-                if attempt == max_retries:
-                    logger.error("All upload attempts failed.")
-                    raise
-                time.sleep(30 * (2 ** (attempt - 1)))
-
-        # Dataset card
-        from huggingface_hub import DatasetCard
-
-        card = DatasetCard(
-            create_dataset_card(
-                source=self.source_id,
-                model_name=args_dict["model_name"],
-                num_samples=len(ds),
-                processing_time=args_dict["processing_time"],
-                output_column="layout",
-                threshold=args_dict["threshold"],
-                layout_nms=args_dict["layout_nms"],
-            )
-        )
-        card.push_to_hub(self.repo_id, token=self.hf_token)
-        logger.info(
-            f"Done: https://huggingface.co/datasets/{self.repo_id}"
-        )
-
-
-class BucketShardSink:
-    """Write incremental parquet shards to a bucket prefix. Resumable."""
-
-    METADATA_FILE = "_metadata.json"
-    SHARD_PATTERN = "shard-{:05d}.parquet"
-
-    def __init__(
-        self,
-        bucket_url: str,
-        *,
-        hf_token: Optional[str],
-        shard_size: int,
-        include_images: bool,
-        resume: bool,
-        source_id: str,
-    ):
-        from huggingface_hub import HfApi, HfFileSystem, create_bucket
-
-        self.bucket_url = bucket_url
-        self.bucket_id, self.prefix = parse_bucket_url(bucket_url)
-        self.hf_token = hf_token
-        self.shard_size = shard_size
-        self.include_images = include_images
-        self.resume = resume
-        self.source_id = source_id
-
-        self._api = HfApi(token=hf_token)
-        self._fs = HfFileSystem(token=hf_token)
-
-        # Make sure the bucket exists. Path inside the bucket is created lazily on first write.
-        try:
-            create_bucket(self.bucket_id, exist_ok=True, token=hf_token)
-        except Exception as e:
-            # If we don't have create rights but the bucket already exists, that's fine.
-            logger.warning(f"create_bucket('{self.bucket_id}') warning: {e}")
-
-        self._buffer: List[Dict[str, Any]] = []
-        self._next_shard_idx = self._discover_next_shard_idx()
-        self._completed_keys = self._discover_completed_keys() if resume else set()
-        if self._completed_keys:
-            logger.info(
-                f"Resume: found {len(self._completed_keys)} already-processed keys, will skip them"
-            )
-
-    @property
-    def kind(self) -> str:
-        return "bucket"
-
-    def already_done(self) -> set:
-        return self._completed_keys
-
-    # --- internal helpers ---
-
-    def _shard_path(self, idx: int) -> str:
-        return self._join(self.SHARD_PATTERN.format(idx))
-
-    def _join(self, name: str) -> str:
-        return f"{self.prefix}/{name}".lstrip("/") if self.prefix else name
-
-    def _list_existing_shards(self) -> List[str]:
-        try:
-            tree = self._api.list_bucket_tree(
-                self.bucket_id, prefix=self.prefix or None, recursive=True
-            )
-        except Exception:
-            return []
-        shards: List[str] = []
-        for item in tree:
-            path = getattr(item, "path", None)
-            ftype = getattr(item, "type", None)
-            if not path or ftype not in (None, "file"):
-                continue
-            base = Path(path).name
-            if base.startswith("shard-") and base.endswith(".parquet"):
-                shards.append(path)
-        return sorted(shards)
-
-    def _discover_next_shard_idx(self) -> int:
-        shards = self._list_existing_shards()
-        max_idx = -1
-        for s in shards:
-            stem = Path(s).stem  # shard-00007
-            try:
-                max_idx = max(max_idx, int(stem.split("-")[-1]))
-            except ValueError:
-                continue
-        return max_idx + 1
-
-    def _discover_completed_keys(self) -> set:
-        import pyarrow.parquet as pq
-
-        keys: set = set()
-        for shard_path in self._list_existing_shards():
-            full = f"{BUCKET_PREFIX}{self.bucket_id}/{shard_path}"
-            try:
-                with self._fs.open(full, "rb") as f:
-                    table = pq.read_table(f, columns=["__source_key"])
-                keys.update(table.column("__source_key").to_pylist())
-            except Exception as e:
-                logger.warning(f"Could not read keys from {shard_path}: {e}")
-        return keys
-
-    def _flush(self) -> None:
-        if not self._buffer:
-            return
-        import pyarrow as pa
-        import pyarrow.parquet as pq
-
-        # Build a stable schema. Skip the image column if not requested.
-        columns = ["__source_key", "layout"]
-        if self.include_images:
-            columns.append("__image_bytes")
-        # Carry through any extra string-coercible fields (e.g. __source_path).
-        extra_keys = sorted(
-            {k for row in self._buffer for k in row.keys() if k not in columns}
-        )
-        columns.extend(extra_keys)
-
-        table_dict = {c: [row.get(c) for row in self._buffer] for c in columns}
-        # pyarrow infers types from python objects; strings/bytes/lists handled fine.
-        table = pa.Table.from_pydict(table_dict)
-
-        buf = io.BytesIO()
-        pq.write_table(table, buf, compression="zstd")
-        data = buf.getvalue()
-
-        shard_remote = self._shard_path(self._next_shard_idx)
-        logger.info(
-            f"Writing shard {self._next_shard_idx} ({len(self._buffer)} rows, "
-            f"{len(data) / 1024 / 1024:.1f} MiB) to {shard_remote}"
-        )
-        self._api.batch_bucket_files(
-            self.bucket_id, add=[(data, shard_remote)], token=self.hf_token
-        )
-        self._next_shard_idx += 1
-        self._buffer.clear()
-
-    def write(self, key: str, layout: List[Dict[str, Any]], extras: Dict[str, Any]) -> None:
-        row: Dict[str, Any] = {
-            "__source_key": key,
-            "layout": json.dumps(layout, ensure_ascii=False),
-        }
-        if self.include_images and "__image_bytes" in extras:
-            row["__image_bytes"] = extras["__image_bytes"]
-        # Pass through string/numeric extras (skip raw PIL Image objects which
-        # the dataset source never injects directly into extras anyway).
-        for k, v in extras.items():
-            if k in row or k == "__image_bytes":
-                continue
-            if isinstance(v, (str, int, float, bool)) or v is None:
-                row[k] = v
-        self._buffer.append(row)
-        if len(self._buffer) >= self.shard_size:
-            self._flush()
-
-    def finalize(self, model_id: str, args_dict: Dict[str, Any]) -> None:
-        # Flush trailing rows.
-        self._flush()
-        # Write/update the metadata file alongside the shards.
-        meta = {
-            "model_id": model_id,
-            "model_name": args_dict["model_name"],
-            "task_mode": "layout-detection",
-            "source": self.source_id,
-            "threshold": args_dict["threshold"],
-            "layout_nms": args_dict["layout_nms"],
-            "shard_size": args_dict["shard_size"],
-            "include_images": self.include_images,
-            "last_run_at": datetime.now(timezone.utc).isoformat(),
-            "processing_time": args_dict.get("processing_time"),
-        }
-        meta_bytes = json.dumps(meta, indent=2).encode("utf-8")
-        meta_path = self._join(self.METADATA_FILE)
-        self._api.batch_bucket_files(
-            self.bucket_id, add=[(meta_bytes, meta_path)], token=self.hf_token
-        )
-        logger.info(
-            f"Done: https://huggingface.co/buckets/{self.bucket_id}"
-            + (f"/{self.prefix}" if self.prefix else "")
-        )
-
-
-# ---------------------------------------------------------------------------
-# inference_info + dataset card
-# ---------------------------------------------------------------------------
-
-
-def build_inference_entry(model_id: str, args_dict: Dict[str, Any]) -> Dict[str, Any]:
-    return {
-        "model_id": "PaddlePaddle/" + args_dict["model_name"],
-        "model_name": args_dict["model_name"],
-        "model_size": MODEL_SIZES.get(args_dict["model_name"], "unknown"),
-        "task_mode": "layout-detection",
-        "column_name": "layout",
-        "timestamp": datetime.now(timezone.utc).isoformat(),
-        "threshold": args_dict["threshold"],
-        "layout_nms": args_dict["layout_nms"],
-        "backend": "paddleocr",
-    }
-
-
-def create_dataset_card(
-    source: str,
-    model_name: str,
-    num_samples: int,
-    processing_time: str,
-    output_column: str,
-    threshold: float,
-    layout_nms: bool,
-) -> str:
-    """Render the dataset card markdown for the dataset-repo sink."""
-    if is_bucket_url(source):
-        source_link = f"[{source}]({source})"
-    else:
-        source_link = f"[{source}](https://huggingface.co/datasets/{source})"
-
-    return f"""---
-tags:
-- layout-detection
-- document-processing
-- paddleocr
-- pp-doclayout
-- uv-script
-- generated
-viewer: false
----
-
-# Layout detection with {model_name}
-
-Bounding-box layout predictions for images from {source_link}, produced by
-PaddleOCR's [{model_name}](https://huggingface.co/PaddlePaddle/{model_name}).
-
-## Processing details
-
-- **Source**: {source_link}
-- **Model**: PaddlePaddle/{model_name} ({MODEL_SIZES.get(model_name, "unknown")})
-- **Samples**: {num_samples:,}
-- **Processing time**: {processing_time}
-- **Processing date**: {datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M UTC")}
-- **Confidence threshold**: {threshold}
-- **Layout NMS**: {"on" if layout_nms else "off"}
-- **Output column**: `{output_column}` (JSON-encoded list of detections)
-
-## Schema
-
-Each row contains the original columns plus:
-
-- `{output_column}`: JSON string. List of detections:
-  ```json
-  [
-    {{"bbox": [x1, y1, x2, y2], "label": "text", "score": 0.97, "cls_id": 2}},
-    {{"bbox": [x1, y1, x2, y2], "label": "table", "score": 0.92, "cls_id": 5}}
-  ]
-  ```
-  Coordinates are in **original input-image pixel space** (top-left origin,
-  `[xmin, ymin, xmax, ymax]`).
-- `inference_info`: JSON list tracking every model that has been applied to
-  this dataset (appended on each run).
-
-## Usage
-
-```python
-import json
-from datasets import load_dataset
-
-ds = load_dataset("{{output_dataset_id}}", split="train")
-detections = json.loads(ds[0]["{output_column}"])
-for det in detections:
-    print(det["label"], det["score"], det["bbox"])
-```
-
-## Reproduction
-
-```bash
-hf jobs uv run --flavor l4x1 -s HF_TOKEN \\
-    https://huggingface.co/datasets/uv-scripts/ocr/raw/main/pp-doclayout.py \\
-    {source} <output> --model-name {model_name}
-```
-
-Generated with [UV Scripts](https://huggingface.co/uv-scripts).
-"""
-
-
-# ---------------------------------------------------------------------------
-# Main
-# ---------------------------------------------------------------------------
-
-
-def resolve_device(device: str) -> str:
-    if device == "gpu":
-        try:
-            import paddle  # noqa: F401
-
-            if paddle.device.is_compiled_with_cuda() and paddle.device.cuda.device_count() > 0:
-                logger.info(
-                    f"GPU available: {paddle.device.cuda.device_count()} device(s)"
-                )
-                return "gpu"
-            logger.warning("No CUDA GPU detected; falling back to CPU.")
-            return "cpu"
-        except Exception as e:
-            logger.warning(f"GPU check failed ({e}); falling back to CPU.")
-            return "cpu"
-    return device
-
-
-def main(args: argparse.Namespace) -> None:
-    from huggingface_hub import login
-
-    start_time = datetime.now()
-    hf_token = args.hf_token or os.environ.get("HF_TOKEN")
-    if hf_token:
-        login(token=hf_token)
-
-    device = resolve_device(args.device)
-
-    # ---------- source ----------
-    original_dataset = None
-    if is_bucket_url(args.input_source):
-        src_iter, total = iter_bucket_images(
-            args.input_source,
-            shuffle=args.shuffle,
-            seed=args.seed,
-            max_samples=args.max_samples,
-            hf_token=hf_token,
-            output_url=args.output_target,
-        )
-    else:
-        src_iter, total, original_dataset = iter_dataset_images(
-            args.input_source,
-            image_column=args.image_column,
-            split=args.split,
-            shuffle=args.shuffle,
-            seed=args.seed,
-            max_samples=args.max_samples,
-        )
-
-    # ---------- sink ----------
-    if is_bucket_url(args.output_target):
-        sink: Union[BucketShardSink, DatasetRepoSink] = BucketShardSink(
-            args.output_target,
-            hf_token=hf_token,
-            shard_size=args.shard_size,
-            include_images=args.include_images,
-            resume=not args.no_resume,
-            source_id=args.input_source,
-        )
-    else:
-        sink = DatasetRepoSink(
-            args.output_target,
-            hf_token=hf_token,
-            private=args.private,
-            config=args.config,
-            create_pr=args.create_pr,
-            source_id=args.input_source,
-            original_dataset=original_dataset,
-        )
-
-    completed = sink.already_done()
-
-    # ---------- model ----------
-    if args.model_name not in VALID_MODELS:
-        raise ValueError(
-            f"Invalid model {args.model_name!r}. Choose from: {VALID_MODELS}"
-        )
-    logger.info(f"Loading PaddleOCR LayoutDetection model: {args.model_name} on {device}")
-    # PaddleX gates `import cv2` at module load time on
-    # `is_dep_available("opencv-contrib-python")`, which checks
-    # `importlib.metadata.version(...)`. We ship `opencv-contrib-python-headless`
-    # (same `cv2`, no system libGL.so.1 needed) — but that's a different
-    # distribution name, so the gate fails and `cv2` is never bound, causing
-    # NameErrors deep inside paddlex modules. Patch the metadata lookup to
-    # alias the GUI cv2 distros to the headless variant before importing
-    # paddleocr; this lets paddlex's own `import cv2` succeed naturally.
-    import importlib.metadata as _metadata
-
-    _orig_metadata_version = _metadata.version
-
-    def _patched_metadata_version(dep_name):
-        if dep_name in ("opencv-contrib-python", "opencv-python"):
-            for headless_alias in (
-                "opencv-contrib-python-headless",
-                "opencv-python-headless",
-            ):
-                try:
-                    return _orig_metadata_version(headless_alias)
-                except _metadata.PackageNotFoundError:
-                    continue
-        return _orig_metadata_version(dep_name)
-
-    _metadata.version = _patched_metadata_version
-
-    from paddleocr import LayoutDetection
-
-    model = LayoutDetection(model_name=args.model_name, device=device)
-
-    # ---------- loop ----------
-    processed = 0
-    skipped = 0
-    errors = 0
-    pbar = tqdm(src_iter, total=total, desc=f"Layout {args.model_name}")
-    for item in pbar:
-        if item.key in completed:
-            skipped += 1
-            continue
-        try:
-            arr = pil_to_array(item.image)
-            results = model.predict(
-                arr,
-                batch_size=args.batch_size,
-                layout_nms=args.layout_nms,
-            )
-            if not results:
-                detections: List[Dict[str, Any]] = []
-            else:
-                detections = extract_detections(results[0])
-                if args.threshold and args.threshold > 0:
-                    detections = [d for d in detections if d["score"] >= args.threshold]
-        except Exception as e:
-            logger.error(f"Error on {item.key}: {e}")
-            detections = []
-            errors += 1
-
-        extras = dict(item.extras)
-        if isinstance(sink, BucketShardSink) and args.include_images:
-            buf = io.BytesIO()
-            item.image.save(buf, format="PNG")
-            extras["__image_bytes"] = buf.getvalue()
-
-        sink.write(item.key, detections, extras)
-        processed += 1
-
-    duration = datetime.now() - start_time
-    processing_time_str = f"{duration.total_seconds() / 60:.2f} min"
-    logger.info(
-        f"Processed {processed} (skipped {skipped}, errors {errors}) in {processing_time_str}"
-    )
-
-    args_dict = {
-        "model_name": args.model_name,
-        "threshold": args.threshold,
-        "layout_nms": args.layout_nms,
-        "shard_size": args.shard_size,
-        "processing_time": processing_time_str,
-    }
-    sink.finalize(model_id=f"PaddlePaddle/{args.model_name}", args_dict=args_dict)
-
-    if args.verbose:
-        import importlib.metadata
-
-        logger.info("--- Resolved package versions ---")
-        for pkg in [
-            "paddlepaddle",
-            "paddlepaddle-gpu",
-            "paddleocr",
-            "huggingface-hub",
-            "datasets",
-            "pyarrow",
-            "pillow",
-            "numpy",
-        ]:
-            try:
-                logger.info(f"  {pkg}=={importlib.metadata.version(pkg)}")
-            except importlib.metadata.PackageNotFoundError:
-                logger.info(f"  {pkg}: not installed")
-        logger.info("--- End versions ---")
-
-
-# ---------------------------------------------------------------------------
-# CLI
-# ---------------------------------------------------------------------------
-
-
-def _print_usage_banner() -> None:
-    print("=" * 80)
-    print("PP-DocLayout layout detection")
-    print("=" * 80)
-    print(
-        "\nDetect document layout regions (text/title/table/figure/formula/...)"
-    )
-    print("with PaddleOCR's PP-DocLayout-L (or M / S / plus-L variant).")
-    print("\nModels:")
-    for m in VALID_MODELS:
-        print(f"  {m:24s} {MODEL_SIZES.get(m, '')}")
-    print("\nSources:")
-    print("  - HF dataset repo:        namespace/dataset")
-    print("  - HF bucket of images:    hf://buckets/namespace/bucket[/prefix]")
-    print("\nSinks:")
-    print("  - HF dataset repo (one push + dataset card):")
-    print("      namespace/dataset")
-    print("  - HF bucket (incremental shards, resumable):")
-    print("      hf://buckets/namespace/bucket/run-name")
-    print("\nExamples:")
-    print("\n  # Smoke test on L4 (dataset -> dataset)")
-    print("  hf jobs uv run --flavor l4x1 -s HF_TOKEN https://huggingface.co/datasets/uv-scripts/ocr/raw/main/pp-doclayout.py \\")
-    print("      davanstrien/ufo-ColPali pp-doclayout-smoke \\")
-    print("      --max-samples 3 --shuffle --seed 42 --private")
-    print("\n  # Dataset -> bucket (incremental shards)")
-    print(
-        "  hf jobs uv run --flavor l4x1 -s HF_TOKEN https://huggingface.co/datasets/uv-scripts/ocr/raw/main/pp-doclayout.py \\"
-    )
-    print("      davanstrien/ufo-ColPali \\")
-    print(
-        "      hf://buckets/davanstrien/pp-doclayout-scratch/run1 \\"
-    )
-    print("      --max-samples 20 --shard-size 5")
-    print("\n  # Bucket of images -> dataset")
-    print(
-        "  hf jobs uv run --flavor l4x1 -s HF_TOKEN https://huggingface.co/datasets/uv-scripts/ocr/raw/main/pp-doclayout.py \\"
-    )
-    print(
-        "      hf://buckets/davanstrien/pp-doclayout-images \\"
-    )
-    print("      pp-doclayout-from-bucket --private")
-    print("\nFor full help, run: uv run pp-doclayout.py --help")
-    print("=" * 80)
-
-
-def build_parser() -> argparse.ArgumentParser:
-    p = argparse.ArgumentParser(
-        description="PP-DocLayout layout detection over an HF dataset or bucket.",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-    p.add_argument(
-        "input_source",
-        help="HF dataset id (namespace/dataset) OR hf://buckets/ns/bucket[/prefix]",
-    )
-    p.add_argument(
-        "output_target",
-        help="HF dataset id (namespace/dataset) OR hf://buckets/ns/bucket/run-name",
-    )
-    p.add_argument(
-        "--model-name",
-        default="PP-DocLayout-L",
-        choices=VALID_MODELS,
-        help="PaddleOCR layout model variant (default: PP-DocLayout-L)",
-    )
-    p.add_argument(
-        "--device",
-        default="gpu",
-        choices=["gpu", "cpu"],
-        help="Device for inference (default: gpu, falls back to cpu if CUDA missing)",
-    )
-    p.add_argument(
-        "--batch-size",
-        type=int,
-        default=1,
-        help="Per-image batch size passed to model.predict (default: 1)",
-    )
-    p.add_argument(
-        "--threshold",
-        type=float,
-        default=0.5,
-        help="Drop detections below this confidence (default: 0.5; 0 disables)",
-    )
-    p.add_argument(
-        "--layout-nms",
-        dest="layout_nms",
-        action="store_true",
-        default=True,
-        help="Enable layout NMS (default: on)",
-    )
-    p.add_argument(
-        "--no-layout-nms",
-        dest="layout_nms",
-        action="store_false",
-        help="Disable layout NMS",
-    )
-    # Dataset-source-specific
-    p.add_argument(
-        "--image-column",
-        default="image",
-        help="Column containing images (dataset-repo source only, default: image)",
-    )
-    p.add_argument(
-        "--split",
-        default="train",
-        help="Dataset split (dataset-repo source only, default: train)",
-    )
-    p.add_argument(
-        "--max-samples", type=int, help="Limit number of samples (for testing)"
-    )
-    p.add_argument(
-        "--shuffle", action="store_true", help="Shuffle source before processing"
-    )
-    p.add_argument(
-        "--seed", type=int, default=42, help="Random seed for shuffle (default: 42)"
-    )
-    # Dataset-sink-specific
-    p.add_argument(
-        "--private", action="store_true", help="Private dataset output (dataset sink only)"
-    )
-    p.add_argument(
-        "--config",
-        help="Config/subset name when pushing to Hub (dataset sink only)",
-    )
-    p.add_argument(
-        "--create-pr",
-        action="store_true",
-        help="Create PR instead of direct push (dataset sink only)",
-    )
-    # Bucket-sink-specific
-    p.add_argument(
-        "--shard-size",
-        type=int,
-        default=256,
-        help="Rows per parquet shard for bucket sink (default: 256)",
-    )
-    p.add_argument(
-        "--include-images",
-        action="store_true",
-        help="Embed source image bytes in bucket output shards (off by default)",
-    )
-    p.add_argument(
-        "--no-resume",
-        action="store_true",
-        help="Disable resume scan when writing to a bucket sink",
-    )
-    # Auth + diagnostics
-    p.add_argument("--hf-token", help="Hugging Face API token (else uses HF_TOKEN env)")
-    p.add_argument(
-        "--verbose",
-        action="store_true",
-        help="Log resolved package versions at the end",
-    )
-    return p
-
-
-if __name__ == "__main__":
-    if len(sys.argv) == 1:
-        _print_usage_banner()
-        sys.exit(0)
-    main(build_parser().parse_args())

qianfan-ocr.py

@@ -1,632 +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
-# Disable vLLM's FlashInfer sampler: it JIT-compiles a CUDA kernel needing nvcc, which the
-# default uv-script image lacks (engine init then crashes). Greedy OCR doesn't use it; this
-# lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
-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,
-    )

rolm-ocr.py

@@ -40,10 +40,6 @@ from huggingface_hub import DatasetCard, login
 from PIL import Image
 from toolz import partition_all
 from tqdm.auto import tqdm
-# Disable vLLM's FlashInfer sampler: it JIT-compiles a CUDA kernel needing nvcc, which the
-# default uv-script image lacks (engine init then crashes). Greedy OCR doesn't use it; this
-# lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
 from vllm import LLM, SamplingParams
 from datetime import datetime
 

smoldocling-ocr.py

@@ -42,13 +42,9 @@ from typing import Any, Dict, Union
 import torch
 from datasets import load_dataset
 from huggingface_hub import DatasetCard, login
-from PIL import Image, UnidentifiedImageError
+from PIL import Image
 from toolz import partition_all
 from tqdm.auto import tqdm
-# Disable vLLM's FlashInfer sampler: it JIT-compiles a CUDA kernel needing nvcc, which the
-# default uv-script image lacks (engine init then crashes). Greedy OCR doesn't use it; this
-# lets the plain default-image command work. On the vllm/vllm-openai image it's a harmless no-op.
-os.environ.setdefault("VLLM_USE_FLASHINFER_SAMPLER", "0")
 from vllm import LLM, SamplingParams
 
 logging.basicConfig(level=logging.INFO)
@@ -303,21 +299,7 @@ def main(
         desc="OCR processing",
     ):
         batch_indices = list(batch_indices)
-
-        # Fetch images first, with per-batch fallback for unreadable files.
-        # One corrupt image used to take down the entire run via the list
-        # comprehension; now we mark the whole batch as skipped and continue.
-        try:
-            batch_images = [dataset[i][image_column] for i in batch_indices]
-        except (UnidentifiedImageError, OSError) as e:
-            logger.warning(
-                f"Skipping batch of {len(batch_indices)} — unreadable image "
-                f"in batch: {type(e).__name__}: {e}"
-            )
-            all_output.extend(
-                ["[OCR SKIPPED — UNREADABLE IMAGE]"] * len(batch_indices)
-            )
-            continue
+        batch_images = [dataset[i][image_column] for i in batch_indices]
 
         try:
             # Prepare inputs for batch