Add OCR scripts collection with fixed deepseek-ocr-vllm dependencies

README.md

@@ -0,0 +1,391 @@
+---
+viewer: false
+tags: [uv-script, ocr, vision-language-model, document-processing]
+---
+
+# OCR UV Scripts
+
+> Part of [uv-scripts](https://huggingface.co/uv-scripts) - ready-to-run ML tools powered by UV
+
+Ready-to-run OCR scripts that work with `uv run` - no setup required!
+
+## 🚀 Quick Start with HuggingFace Jobs
+
+Run OCR on any dataset without needing your own GPU:
+
+```bash
+# Quick test with 10 samples
+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 \
+    --max-samples 10
+```
+
+That's it! The script will:
+
+- ✅ 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]`
+
+## 📋 Available Scripts
+
+### LightOnOCR (`lighton-ocr.py`) ⚡ Good one to test first since it's small and fast!
+
+Fast and compact OCR using [lightonai/LightOnOCR-1B-1025](https://huggingface.co/lightonai/LightOnOCR-1B-1025):
+
+- ⚡ **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
+
+**Vocabulary sizes:**
+- `151k`: Full vocabulary, all languages (default)
+- `32k`: European languages, ~12% faster decoding
+- `16k`: European languages, ~12% faster decoding
+
+**Quick start:**
+```bash
+# 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
+```
+
+### DeepSeek-OCR (`deepseek-ocr-vllm.py`) ⭐ NEW
+
+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
+
+### 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']))"
+```
+
+### Random Sampling
+
+Get representative samples with the new `--shuffle` flag:
+
+```bash
+# Random 50 samples instead of first 50
+uv run rolm-ocr.py ordered-dataset output --max-samples 50 --shuffle
+
+# Reproducible random sampling
+uv run nanonets-ocr.py dataset output --max-samples 100 --shuffle --seed 42
+```
+
+### Automatic Dataset Cards
+
+Every OCR run now generates comprehensive dataset documentation including:
+- Model configuration and parameters
+- Processing statistics
+- Column descriptions
+- Reproduction instructions
+
+## 💻 Usage Examples
+
+### Run on HuggingFace Jobs (Recommended)
+
+No GPU? No problem! Run on HF infrastructure:
+
+```bash
+# 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 \
+    davanstrien/handbooks-deep-ocr \
+    --max-samples 100 \
+    --shuffle \
+    --resolution-mode large
+
+# 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
+
+# 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
+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"
+)
+```
+
+### Run Locally (Requires GPU)
+
+```bash
+# 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
+
+# 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
+
+```
+
+## 📁 Works With
+
+Any HuggingFace dataset containing images - documents, forms, receipts, books, handwriting.
+
+## 🎛️ Configuration Options
+
+### Common Options (All Scripts)
+
+| Option                     | Default | Description                   |
+| -------------------------- | ------- | ----------------------------- |
+| `--image-column`           | `image` | Column containing images      |
+| `--batch-size`             | `32`/`16`* | Images processed together     |
+| `--max-model-len`          | `8192`/`16384`** | Max context length     |
+| `--max-tokens`             | `4096`/`8192`** | Max output tokens      |
+| `--gpu-memory-utilization` | `0.8`   | GPU memory usage (0.0-1.0)    |
+| `--split`                  | `train` | Dataset split to process      |
+| `--max-samples`            | None    | Limit samples (for testing)   |
+| `--private`                | False   | Make output dataset private   |
+| `--shuffle`                | False   | Shuffle dataset before processing |
+| `--seed`                   | `42`    | Random seed for shuffling     |
+
+*RolmOCR and DoTS use batch size 16
+**RolmOCR uses 16384/8192
+
+### Script-Specific Options
+
+**DeepSeek-OCR**:
+- `--resolution-mode`: Quality level - `tiny`, `small`, `base`, `large`, or `gundam` (default)
+- `--prompt-mode`: Task type - `document` (default), `image`, `free`, `figure`, or `describe`
+- `--prompt`: Custom OCR prompt (overrides prompt-mode)
+- `--base-size`, `--image-size`, `--crop-mode`: Override resolution mode manually
+- ⚠️ **Important for HF Jobs**: Add `-e UV_TORCH_BACKEND=auto` for proper PyTorch installation
+
+**RolmOCR**:
+- Output column is auto-generated from model name (e.g., `rolmocr_text`)
+- Use `--output-column` to override the default name
+
+**DoTS.ocr**:
+- `--prompt-mode`: Choose `ocr` (default), `layout-all`, or `layout-only`
+- `--custom-prompt`: Override with custom prompt text
+- `--output-column`: Output column name (default: `markdown`)
+
+💡 **Performance tip**: Increase batch size for faster processing (e.g., `--batch-size 256` on A100)

deepseek-ocr-vllm.py

@@ -0,0 +1,692 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#     "datasets",
+#     "huggingface-hub[hf_transfer]",
+#     "pillow",
+#     "vllm>=0.6.0",
+#     "tqdm",
+#     "toolz",
+#     "torch",
+# ]
+# ///
+
+"""
+Convert document images to markdown using DeepSeek-OCR with vLLM.
+
+This script processes images through the DeepSeek-OCR model to extract
+text and structure as markdown, using vLLM for efficient batch processing.
+
+NOTE: Uses vLLM nightly wheels from main (PR #27247 now merged). First run
+may take a few minutes to download and install dependencies.
+
+Features:
+- Multiple resolution modes (Tiny/Small/Base/Large/Gundam)
+- LaTeX equation recognition
+- Table extraction and formatting
+- Document structure preservation
+- Image grounding and descriptions
+- Multilingual support
+- Batch processing with vLLM for better performance
+"""
+
+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
+from vllm import LLM, SamplingParams
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Resolution mode presets
+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": 1024, "crop_mode": False},
+    "large": {"base_size": 1280, "image_size": 1280, "crop_mode": False},
+    "gundam": {
+        "base_size": 1024,
+        "image_size": 640,
+        "crop_mode": True,
+    },  # Dynamic resolution
+}
+
+# Prompt mode presets (from DeepSeek-OCR GitHub)
+PROMPT_MODES = {
+    "document": "<image>\n<|grounding|>Convert the document to markdown.",
+    "image": "<image>\n<|grounding|>OCR this image.",
+    "free": "<image>\nFree OCR.",
+    "figure": "<image>\nParse the figure.",
+    "describe": "<image>\nDescribe this image in detail.",
+}
+
+
+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 make_ocr_message(
+    image: Union[Image.Image, Dict[str, Any], str],
+    prompt: str = "<image>\n<|grounding|>Convert the document to markdown. ",
+) -> List[Dict]:
+    """Create 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)}")
+
+    # Convert to 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 message in vLLM format
+    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,
+    resolution_mode: str,
+    base_size: int,
+    image_size: int,
+    crop_mode: 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
+- deepseek
+- deepseek-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 DeepSeek-OCR.
+
+## 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}
+- **Resolution Mode**: {resolution_mode}
+- **Base Size**: {base_size}
+- **Image Size**: {image_size}
+- **Crop Mode**: {crop_mode}
+- **Max Model Length**: {max_model_len:,} tokens
+- **Max Output Tokens**: {max_tokens:,}
+- **GPU Memory Utilization**: {gpu_memory_utilization:.1%}
+
+## Model Information
+
+DeepSeek-OCR is a state-of-the-art document OCR model that excels at:
+- 📐 **LaTeX equations** - Mathematical formulas preserved in LaTeX format
+- 📊 **Tables** - Extracted and formatted as HTML/markdown
+- 📝 **Document structure** - Headers, lists, and formatting maintained
+- 🖼️ **Image grounding** - Spatial layout and bounding box information
+- 🔍 **Complex layouts** - Multi-column and hierarchical structures
+- 🌍 **Multilingual** - Supports multiple languages
+
+### Resolution Modes
+
+- **Tiny** (512×512): Fast processing, 64 vision tokens
+- **Small** (640×640): Balanced speed/quality, 100 vision tokens
+- **Base** (1024×1024): High quality, 256 vision tokens
+- **Large** (1280×1280): Maximum quality, 400 vision tokens
+- **Gundam** (dynamic): Adaptive multi-tile processing for large documents
+
+## 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
+import json
+
+# Load the dataset
+dataset = load_dataset("{{{{output_dataset_id}}}}", split="{split}")
+
+# Access the markdown text
+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"Column: {{{{info['column_name']}}}} - Model: {{{{info['model_id']}}}}")
+```
+
+## Reproduction
+
+This dataset was generated using the [uv-scripts/ocr](https://huggingface.co/datasets/uv-scripts/ocr) DeepSeek OCR vLLM script:
+
+```bash
+uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/deepseek-ocr-vllm.py \\\\
+    {source_dataset} \\\\
+    <output-dataset> \\\\
+    --resolution-mode {resolution_mode} \\\\
+    --image-column {image_column}
+```
+
+## Performance
+
+- **Processing Speed**: ~{num_samples / (float(processing_time.split()[0]) * 60):.1f} images/second
+- **Processing Method**: Batch processing with vLLM (2-3x speedup over sequential)
+
+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,  # Smaller batch size to avoid potential memory issues with DeepSeek-OCR
+    model: str = "deepseek-ai/DeepSeek-OCR",
+    resolution_mode: str = "gundam",
+    base_size: int = None,
+    image_size: int = None,
+    crop_mode: bool = None,
+    max_model_len: int = 8192,
+    max_tokens: int = 8192,
+    gpu_memory_utilization: float = 0.8,
+    prompt_mode: str = "document",
+    prompt: str = None,
+    hf_token: str = None,
+    split: str = "train",
+    max_samples: int = None,
+    private: bool = False,
+    shuffle: bool = False,
+    seed: int = 42,
+):
+    """Process images from HF dataset through DeepSeek-OCR model with vLLM."""
+
+    # Check CUDA availability first
+    check_cuda_availability()
+
+    # Track processing start time
+    start_time = datetime.now()
+
+    # Enable HF_TRANSFER for faster downloads
+    os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"
+
+    # Login to HF if token provided
+    HF_TOKEN = hf_token or os.environ.get("HF_TOKEN")
+    if HF_TOKEN:
+        login(token=HF_TOKEN)
+
+    # Determine resolution settings
+    if resolution_mode in RESOLUTION_MODES:
+        mode_config = RESOLUTION_MODES[resolution_mode]
+        final_base_size = (
+            base_size if base_size is not None else mode_config["base_size"]
+        )
+        final_image_size = (
+            image_size if image_size is not None else mode_config["image_size"]
+        )
+        final_crop_mode = (
+            crop_mode if crop_mode is not None else mode_config["crop_mode"]
+        )
+        logger.info(f"Using resolution mode: {resolution_mode}")
+    else:
+        # Custom mode - require all parameters
+        if base_size is None or image_size is None or crop_mode is None:
+            raise ValueError(
+                f"Invalid resolution mode '{resolution_mode}'. "
+                f"Use one of {list(RESOLUTION_MODES.keys())} or specify "
+                f"--base-size, --image-size, and --crop-mode manually."
+            )
+        final_base_size = base_size
+        final_image_size = image_size
+        final_crop_mode = crop_mode
+        resolution_mode = "custom"
+
+    logger.info(
+        f"Resolution: base_size={final_base_size}, "
+        f"image_size={final_image_size}, crop_mode={final_crop_mode}"
+    )
+
+    # Determine prompt
+    if prompt is not None:
+        final_prompt = prompt
+        logger.info(f"Using custom prompt")
+    elif prompt_mode in PROMPT_MODES:
+        final_prompt = PROMPT_MODES[prompt_mode]
+        logger.info(f"Using prompt mode: {prompt_mode}")
+    else:
+        raise ValueError(
+            f"Invalid prompt mode '{prompt_mode}'. "
+            f"Use one of {list(PROMPT_MODES.keys())} or specify --prompt"
+        )
+
+    logger.info(f"Prompt: {final_prompt}")
+
+    # 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}")
+    logger.info("This may take a few minutes on first run...")
+
+    # Add specific parameters for DeepSeek-OCR compatibility
+    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,  # Use torch.compile instead of eager execution
+    )
+
+    sampling_params = SamplingParams(
+        temperature=0.0,  # Deterministic for OCR
+        max_tokens=max_tokens,
+    )
+
+    logger.info(f"Processing {len(dataset)} images in batches of {batch_size}")
+    logger.info(
+        "Using vLLM for batch processing - should be faster than sequential processing"
+    )
+
+    # Process images in batches
+    all_markdown = []
+
+    for batch_indices in tqdm(
+        partition_all(batch_size, range(len(dataset))),
+        total=(len(dataset) + batch_size - 1) // batch_size,
+        desc="DeepSeek-OCR vLLM processing",
+    ):
+        batch_indices = list(batch_indices)
+        batch_images = [dataset[i][image_column] for i in batch_indices]
+
+        try:
+            # Create messages for batch
+            batch_messages = [make_ocr_message(img, final_prompt) 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_markdown.append(text)
+
+        except Exception as e:
+            logger.error(f"Error processing batch: {e}")
+            # Add error placeholders for failed batch
+            all_markdown.extend(["[OCR FAILED]"] * len(batch_images))
+
+    # Calculate processing time
+    processing_duration = datetime.now() - start_time
+    processing_time_str = f"{processing_duration.total_seconds() / 60:.1f} min"
+
+    # 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...")
+
+    # Check for existing inference_info
+    if "inference_info" in dataset.column_names:
+        # Parse existing info from first row (all rows have same info)
+        try:
+            existing_info = json.loads(dataset[0]["inference_info"])
+            if not isinstance(existing_info, list):
+                existing_info = [existing_info]  # Convert old format to list
+        except (json.JSONDecodeError, TypeError):
+            existing_info = []
+        # Remove old column to update it
+        dataset = dataset.remove_columns(["inference_info"])
+    else:
+        existing_info = []
+
+    # Add new inference info
+    new_info = {
+        "column_name": "markdown",
+        "model_id": model,
+        "processing_date": datetime.now().isoformat(),
+        "resolution_mode": resolution_mode,
+        "base_size": final_base_size,
+        "image_size": final_image_size,
+        "crop_mode": final_crop_mode,
+        "prompt": final_prompt,
+        "prompt_mode": prompt_mode if prompt is None else "custom",
+        "batch_size": batch_size,
+        "max_tokens": max_tokens,
+        "gpu_memory_utilization": gpu_memory_utilization,
+        "max_model_len": max_model_len,
+        "script": "deepseek-ocr-vllm.py",
+        "script_version": "1.0.0",
+        "script_url": "https://huggingface.co/datasets/uv-scripts/ocr/raw/main/deepseek-ocr-vllm.py",
+        "implementation": "vllm (batch processing)",
+    }
+    existing_info.append(new_info)
+
+    # Add updated inference_info column
+    info_json = json.dumps(existing_info, ensure_ascii=False)
+    dataset = dataset.add_column("inference_info", [info_json] * len(dataset))
+
+    # Push to hub
+    logger.info(f"Pushing to {output_dataset}")
+    dataset.push_to_hub(output_dataset, private=private, token=HF_TOKEN)
+
+    # 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_str,
+        batch_size=batch_size,
+        max_model_len=max_model_len,
+        max_tokens=max_tokens,
+        gpu_memory_utilization=gpu_memory_utilization,
+        resolution_mode=resolution_mode,
+        base_size=final_base_size,
+        image_size=final_image_size,
+        crop_mode=final_crop_mode,
+        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}"
+    )
+    logger.info(f"Processing time: {processing_time_str}")
+
+
+if __name__ == "__main__":
+    # Show example usage if no arguments
+    if len(sys.argv) == 1:
+        print("=" * 80)
+        print("DeepSeek-OCR to Markdown Converter (vLLM)")
+        print("=" * 80)
+        print("\nThis script converts document images to markdown using")
+        print("DeepSeek-OCR with vLLM for efficient batch processing.")
+        print("\nFeatures:")
+        print("- Multiple resolution modes (Tiny/Small/Base/Large/Gundam)")
+        print("- LaTeX equation recognition")
+        print("- Table extraction and formatting")
+        print("- Document structure preservation")
+        print("- Image grounding and spatial layout")
+        print("- Multilingual support")
+        print("- ⚡ Fast batch processing with vLLM (2-3x speedup)")
+        print("\nExample usage:")
+        print("\n1. Basic OCR conversion (Gundam mode - dynamic resolution):")
+        print("   uv run deepseek-ocr-vllm.py document-images markdown-docs")
+        print("\n2. High quality mode (Large - 1280×1280):")
+        print(
+            "   uv run deepseek-ocr-vllm.py scanned-pdfs extracted-text --resolution-mode large"
+        )
+        print("\n3. Fast processing (Tiny - 512×512):")
+        print("   uv run deepseek-ocr-vllm.py quick-test output --resolution-mode tiny")
+        print("\n4. Parse figures from documents:")
+        print("   uv run deepseek-ocr-vllm.py scientific-papers figures --prompt-mode figure")
+        print("\n5. Free OCR without layout:")
+        print("   uv run deepseek-ocr-vllm.py images text --prompt-mode free")
+        print("\n6. Process a subset for testing:")
+        print(
+            "   uv run deepseek-ocr-vllm.py large-dataset test-output --max-samples 10"
+        )
+        print("\n7. Custom resolution:")
+        print("   uv run deepseek-ocr-vllm.py dataset output \\")
+        print("       --base-size 1024 --image-size 640 --crop-mode")
+        print("\n8. Running on HF Jobs:")
+        print("   hf jobs uv run --flavor l4x1 \\")
+        print("     -s HF_TOKEN \\")
+        print("     -e UV_TORCH_BACKEND=auto \\")
+        print(
+            "     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/deepseek-ocr-vllm.py \\"
+        )
+        print("       your-document-dataset \\")
+        print("       your-markdown-output")
+        print("\n" + "=" * 80)
+        print("\nFor full help, run: uv run deepseek-ocr-vllm.py --help")
+        sys.exit(0)
+
+    parser = argparse.ArgumentParser(
+        description="OCR images to markdown using DeepSeek-OCR (vLLM)",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Resolution Modes:
+  tiny      512×512 pixels, fast processing (64 vision tokens)
+  small     640×640 pixels, balanced (100 vision tokens)
+  base      1024×1024 pixels, high quality (256 vision tokens)
+  large     1280×1280 pixels, maximum quality (400 vision tokens)
+  gundam    Dynamic multi-tile processing (adaptive)
+
+Prompt Modes:
+  document  Convert document to markdown with grounding (default)
+  image     OCR any image with grounding
+  free      Free OCR without layout preservation
+  figure    Parse figures from documents
+  describe  Generate detailed image descriptions
+
+Examples:
+  # Basic usage with default Gundam mode
+  uv run deepseek-ocr-vllm.py my-images-dataset ocr-results
+
+  # High quality processing
+  uv run deepseek-ocr-vllm.py documents extracted-text --resolution-mode large
+
+  # Fast processing for testing
+  uv run deepseek-ocr-vllm.py dataset output --resolution-mode tiny --max-samples 100
+
+  # Parse figures from a document dataset
+  uv run deepseek-ocr-vllm.py scientific-papers figures --prompt-mode figure
+
+  # Free OCR without layout (fastest)
+  uv run deepseek-ocr-vllm.py images text --prompt-mode free
+
+  # Custom prompt for specific task
+  uv run deepseek-ocr-vllm.py dataset output --prompt "<image>\nExtract all table data."
+
+  # Custom resolution settings
+  uv run deepseek-ocr-vllm.py dataset output --base-size 1024 --image-size 640 --crop-mode
+
+  # With custom batch size for performance tuning
+  uv run deepseek-ocr-vllm.py dataset output --batch-size 16 --max-model-len 16384
+        """,
+    )
+
+    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, adjust based on GPU memory)",
+    )
+    parser.add_argument(
+        "--model",
+        default="deepseek-ai/DeepSeek-OCR",
+        help="Model to use (default: deepseek-ai/DeepSeek-OCR)",
+    )
+    parser.add_argument(
+        "--resolution-mode",
+        default="gundam",
+        choices=list(RESOLUTION_MODES.keys()) + ["custom"],
+        help="Resolution mode preset (default: gundam)",
+    )
+    parser.add_argument(
+        "--base-size",
+        type=int,
+        help="Base resolution size (overrides resolution-mode)",
+    )
+    parser.add_argument(
+        "--image-size",
+        type=int,
+        help="Image tile size (overrides resolution-mode)",
+    )
+    parser.add_argument(
+        "--crop-mode",
+        action="store_true",
+        help="Enable dynamic multi-tile cropping (overrides resolution-mode)",
+    )
+    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=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(
+        "--prompt-mode",
+        default="document",
+        choices=list(PROMPT_MODES.keys()),
+        help="Prompt mode preset (default: document). Use --prompt for custom prompts.",
+    )
+    parser.add_argument(
+        "--prompt",
+        help="Custom OCR prompt (overrides --prompt-mode)",
+    )
+    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)",
+    )
+
+    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,
+        resolution_mode=args.resolution_mode,
+        base_size=args.base_size,
+        image_size=args.image_size,
+        crop_mode=args.crop_mode if args.crop_mode else None,
+        max_model_len=args.max_model_len,
+        max_tokens=args.max_tokens,
+        gpu_memory_utilization=args.gpu_memory_utilization,
+        prompt_mode=args.prompt_mode,
+        prompt=args.prompt,
+        hf_token=args.hf_token,
+        split=args.split,
+        max_samples=args.max_samples,
+        private=args.private,
+        shuffle=args.shuffle,
+        seed=args.seed,
+    )

deepseek-ocr.py

@@ -0,0 +1,604 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#     "datasets",
+#     "huggingface-hub[hf_transfer]",
+#     "pillow",
+#     "torch",
+#     "torchvision",
+#     "transformers==4.46.3",
+#     "tokenizers==0.20.3",
+#     "tqdm",
+#     "addict",
+#     "matplotlib",
+#     "einops",
+#     "easydict",
+# ]
+#
+# ///
+
+"""
+Convert document images to markdown using DeepSeek-OCR with Transformers.
+
+This script processes images through the DeepSeek-OCR model to extract
+text and structure as markdown, using the official Transformers API.
+
+Features:
+- Multiple resolution modes (Tiny/Small/Base/Large/Gundam)
+- LaTeX equation recognition
+- Table extraction and formatting
+- Document structure preservation
+- Image grounding and descriptions
+- Multilingual support
+
+Note: This script processes images sequentially (no batching) using the
+official transformers API. It's slower than vLLM-based scripts but uses
+the well-supported official implementation.
+"""
+
+import argparse
+import json
+import logging
+import os
+import shutil
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+import torch
+from datasets import load_dataset
+from huggingface_hub import DatasetCard, login
+from PIL import Image
+from tqdm.auto import tqdm
+from transformers import AutoModel, AutoTokenizer
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Resolution mode presets
+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": 1024, "crop_mode": False},
+    "large": {"base_size": 1280, "image_size": 1280, "crop_mode": False},
+    "gundam": {"base_size": 1024, "image_size": 640, "crop_mode": True},  # Dynamic resolution
+}
+
+
+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 create_dataset_card(
+    source_dataset: str,
+    model: str,
+    num_samples: int,
+    processing_time: str,
+    resolution_mode: str,
+    base_size: int,
+    image_size: int,
+    crop_mode: 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
+- deepseek
+- deepseek-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 DeepSeek-OCR.
+
+## 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}`
+- **Resolution Mode**: {resolution_mode}
+- **Base Size**: {base_size}
+- **Image Size**: {image_size}
+- **Crop Mode**: {crop_mode}
+
+## Model Information
+
+DeepSeek-OCR is a state-of-the-art document OCR model that excels at:
+- 📐 **LaTeX equations** - Mathematical formulas preserved in LaTeX format
+- 📊 **Tables** - Extracted and formatted as HTML/markdown
+- 📝 **Document structure** - Headers, lists, and formatting maintained
+- 🖼️ **Image grounding** - Spatial layout and bounding box information
+- 🔍 **Complex layouts** - Multi-column and hierarchical structures
+- 🌍 **Multilingual** - Supports multiple languages
+
+### Resolution Modes
+
+- **Tiny** (512×512): Fast processing, 64 vision tokens
+- **Small** (640×640): Balanced speed/quality, 100 vision tokens
+- **Base** (1024×1024): High quality, 256 vision tokens
+- **Large** (1280×1280): Maximum quality, 400 vision tokens
+- **Gundam** (dynamic): Adaptive multi-tile processing for large documents
+
+## 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
+import json
+
+# Load the dataset
+dataset = load_dataset("{{{{output_dataset_id}}}}", split="{split}")
+
+# Access the markdown text
+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"Column: {{{{info['column_name']}}}} - Model: {{{{info['model_id']}}}}")
+```
+
+## Reproduction
+
+This dataset was generated using the [uv-scripts/ocr](https://huggingface.co/datasets/uv-scripts/ocr) DeepSeek OCR script:
+
+```bash
+uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/deepseek-ocr.py \\
+    {source_dataset} \\
+    <output-dataset> \\
+    --resolution-mode {resolution_mode} \\
+    --image-column {image_column}
+```
+
+## Performance
+
+- **Processing Speed**: ~{num_samples / (float(processing_time.split()[0]) * 60):.1f} images/second
+- **Processing Method**: Sequential (Transformers API, no batching)
+
+Note: This uses the official Transformers implementation. For faster batch processing,
+consider using the vLLM version once DeepSeek-OCR is officially supported by vLLM.
+
+Generated with 🤖 [UV Scripts](https://huggingface.co/uv-scripts)
+"""
+
+
+def process_single_image(
+    model,
+    tokenizer,
+    image: Image.Image,
+    prompt: str,
+    base_size: int,
+    image_size: int,
+    crop_mode: bool,
+    temp_image_path: str,
+    temp_output_dir: str,
+) -> str:
+    """Process a single image through DeepSeek-OCR."""
+    # Convert to RGB if needed
+    if image.mode != "RGB":
+        image = image.convert("RGB")
+
+    # Save to temp file (model.infer expects a file path)
+    image.save(temp_image_path, format="PNG")
+
+    # Run inference
+    result = model.infer(
+        tokenizer,
+        prompt=prompt,
+        image_file=temp_image_path,
+        output_path=temp_output_dir,  # Need real directory path
+        base_size=base_size,
+        image_size=image_size,
+        crop_mode=crop_mode,
+        save_results=False,
+        test_compress=False,
+    )
+
+    return result if isinstance(result, str) else str(result)
+
+
+def main(
+    input_dataset: str,
+    output_dataset: str,
+    image_column: str = "image",
+    model: str = "deepseek-ai/DeepSeek-OCR",
+    resolution_mode: str = "gundam",
+    base_size: Optional[int] = None,
+    image_size: Optional[int] = None,
+    crop_mode: Optional[bool] = None,
+    prompt: str = "<image>\n<|grounding|>Convert the document to markdown.",
+    hf_token: str = None,
+    split: str = "train",
+    max_samples: int = None,
+    private: bool = False,
+    shuffle: bool = False,
+    seed: int = 42,
+):
+    """Process images from HF dataset through DeepSeek-OCR model."""
+
+    # Check CUDA availability first
+    check_cuda_availability()
+
+    # Track processing start time
+    start_time = datetime.now()
+
+    # Enable HF_TRANSFER for faster downloads
+    os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"
+
+    # Login to HF if token provided
+    HF_TOKEN = hf_token or os.environ.get("HF_TOKEN")
+    if HF_TOKEN:
+        login(token=HF_TOKEN)
+
+    # Determine resolution settings
+    if resolution_mode in RESOLUTION_MODES:
+        mode_config = RESOLUTION_MODES[resolution_mode]
+        final_base_size = base_size if base_size is not None else mode_config["base_size"]
+        final_image_size = image_size if image_size is not None else mode_config["image_size"]
+        final_crop_mode = crop_mode if crop_mode is not None else mode_config["crop_mode"]
+        logger.info(f"Using resolution mode: {resolution_mode}")
+    else:
+        # Custom mode - require all parameters
+        if base_size is None or image_size is None or crop_mode is None:
+            raise ValueError(
+                f"Invalid resolution mode '{resolution_mode}'. "
+                f"Use one of {list(RESOLUTION_MODES.keys())} or specify "
+                f"--base-size, --image-size, and --crop-mode manually."
+            )
+        final_base_size = base_size
+        final_image_size = image_size
+        final_crop_mode = crop_mode
+        resolution_mode = "custom"
+
+    logger.info(
+        f"Resolution: base_size={final_base_size}, "
+        f"image_size={final_image_size}, crop_mode={final_crop_mode}"
+    )
+
+    # 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 model
+    logger.info(f"Loading model: {model}")
+    tokenizer = AutoTokenizer.from_pretrained(model, trust_remote_code=True)
+
+    try:
+        model_obj = AutoModel.from_pretrained(
+            model,
+            _attn_implementation="flash_attention_2",
+            trust_remote_code=True,
+            use_safetensors=True,
+        )
+    except Exception as e:
+        logger.warning(f"Failed to load with flash_attention_2: {e}")
+        logger.info("Falling back to standard attention...")
+        model_obj = AutoModel.from_pretrained(
+            model,
+            trust_remote_code=True,
+            use_safetensors=True,
+        )
+
+    model_obj = model_obj.eval().cuda().to(torch.bfloat16)
+    logger.info("Model loaded successfully")
+
+    # Process images sequentially
+    all_markdown = []
+
+    logger.info(f"Processing {len(dataset)} images (sequential, no batching)")
+    logger.info("Note: This may be slower than vLLM-based scripts")
+
+    # Create temp directories for image files and output (simple local dirs)
+    temp_dir = Path("temp_images")
+    temp_dir.mkdir(exist_ok=True)
+    temp_image_path = str(temp_dir / "temp_image.png")
+
+    temp_output_dir = Path("temp_output")
+    temp_output_dir.mkdir(exist_ok=True)
+
+    try:
+        for i in tqdm(range(len(dataset)), desc="OCR processing"):
+            try:
+                image = dataset[i][image_column]
+
+                # Handle different image formats
+                if isinstance(image, dict) and "bytes" in image:
+                    from io import BytesIO
+                    image = Image.open(BytesIO(image["bytes"]))
+                elif isinstance(image, str):
+                    image = Image.open(image)
+                elif not isinstance(image, Image.Image):
+                    raise ValueError(f"Unsupported image type: {type(image)}")
+
+                # Process image
+                result = process_single_image(
+                    model_obj,
+                    tokenizer,
+                    image,
+                    prompt,
+                    final_base_size,
+                    final_image_size,
+                    final_crop_mode,
+                    temp_image_path,
+                    str(temp_output_dir),
+                )
+
+                all_markdown.append(result)
+
+            except Exception as e:
+                logger.error(f"Error processing image {i}: {e}")
+                all_markdown.append("[OCR FAILED]")
+
+    finally:
+        # Clean up temp directories
+        try:
+            shutil.rmtree(temp_dir)
+            shutil.rmtree(temp_output_dir)
+        except:
+            pass
+
+    # 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...")
+
+    # Check for existing inference_info
+    if "inference_info" in dataset.column_names:
+        try:
+            existing_info = json.loads(dataset[0]["inference_info"])
+            if not isinstance(existing_info, list):
+                existing_info = [existing_info]
+        except (json.JSONDecodeError, TypeError):
+            existing_info = []
+        dataset = dataset.remove_columns(["inference_info"])
+    else:
+        existing_info = []
+
+    # Add new inference info
+    new_info = {
+        "column_name": "markdown",
+        "model_id": model,
+        "processing_date": datetime.now().isoformat(),
+        "resolution_mode": resolution_mode,
+        "base_size": final_base_size,
+        "image_size": final_image_size,
+        "crop_mode": final_crop_mode,
+        "prompt": prompt,
+        "script": "deepseek-ocr.py",
+        "script_version": "1.0.0",
+        "script_url": "https://huggingface.co/datasets/uv-scripts/ocr/raw/main/deepseek-ocr.py",
+        "implementation": "transformers (sequential)",
+    }
+    existing_info.append(new_info)
+
+    # Add updated inference_info column
+    info_json = json.dumps(existing_info, ensure_ascii=False)
+    dataset = dataset.add_column("inference_info", [info_json] * len(dataset))
+
+    # 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,
+        resolution_mode=resolution_mode,
+        base_size=final_base_size,
+        image_size=final_image_size,
+        crop_mode=final_crop_mode,
+        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 __name__ == "__main__":
+    # Show example usage if no arguments
+    if len(sys.argv) == 1:
+        print("=" * 80)
+        print("DeepSeek-OCR to Markdown Converter (Transformers)")
+        print("=" * 80)
+        print("\nThis script converts document images to markdown using")
+        print("DeepSeek-OCR with the official Transformers API.")
+        print("\nFeatures:")
+        print("- Multiple resolution modes (Tiny/Small/Base/Large/Gundam)")
+        print("- LaTeX equation recognition")
+        print("- Table extraction and formatting")
+        print("- Document structure preservation")
+        print("- Image grounding and spatial layout")
+        print("- Multilingual support")
+        print("\nNote: Sequential processing (no batching). Slower than vLLM scripts.")
+        print("\nExample usage:")
+        print("\n1. Basic OCR conversion (Gundam mode - dynamic resolution):")
+        print("   uv run deepseek-ocr.py document-images markdown-docs")
+        print("\n2. High quality mode (Large - 1280×1280):")
+        print("   uv run deepseek-ocr.py scanned-pdfs extracted-text --resolution-mode large")
+        print("\n3. Fast processing (Tiny - 512×512):")
+        print("   uv run deepseek-ocr.py quick-test output --resolution-mode tiny")
+        print("\n4. Process a subset for testing:")
+        print("   uv run deepseek-ocr.py large-dataset test-output --max-samples 10")
+        print("\n5. Custom resolution:")
+        print("   uv run deepseek-ocr.py dataset output \\")
+        print("       --base-size 1024 --image-size 640 --crop-mode")
+        print("\n6. Running on HF Jobs:")
+        print("   hf jobs uv run --flavor l4x1 \\")
+        print('     --secrets HF_TOKEN \\')
+        print("     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/deepseek-ocr.py \\")
+        print("       your-document-dataset \\")
+        print("       your-markdown-output")
+        print("\n" + "=" * 80)
+        print("\nFor full help, run: uv run deepseek-ocr.py --help")
+        sys.exit(0)
+
+    parser = argparse.ArgumentParser(
+        description="OCR images to markdown using DeepSeek-OCR (Transformers)",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Resolution Modes:
+  tiny      512×512 pixels, fast processing (64 vision tokens)
+  small     640×640 pixels, balanced (100 vision tokens)
+  base      1024×1024 pixels, high quality (256 vision tokens)
+  large     1280×1280 pixels, maximum quality (400 vision tokens)
+  gundam    Dynamic multi-tile processing (adaptive)
+
+Examples:
+  # Basic usage with default Gundam mode
+  uv run deepseek-ocr.py my-images-dataset ocr-results
+
+  # High quality processing
+  uv run deepseek-ocr.py documents extracted-text --resolution-mode large
+
+  # Fast processing for testing
+  uv run deepseek-ocr.py dataset output --resolution-mode tiny --max-samples 100
+
+  # Custom resolution settings
+  uv run deepseek-ocr.py dataset output --base-size 1024 --image-size 640 --crop-mode
+        """,
+    )
+
+    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(
+        "--model",
+        default="deepseek-ai/DeepSeek-OCR",
+        help="Model to use (default: deepseek-ai/DeepSeek-OCR)",
+    )
+    parser.add_argument(
+        "--resolution-mode",
+        default="gundam",
+        choices=list(RESOLUTION_MODES.keys()) + ["custom"],
+        help="Resolution mode preset (default: gundam)",
+    )
+    parser.add_argument(
+        "--base-size",
+        type=int,
+        help="Base resolution size (overrides resolution-mode)",
+    )
+    parser.add_argument(
+        "--image-size",
+        type=int,
+        help="Image tile size (overrides resolution-mode)",
+    )
+    parser.add_argument(
+        "--crop-mode",
+        action="store_true",
+        help="Enable dynamic multi-tile cropping (overrides resolution-mode)",
+    )
+    parser.add_argument(
+        "--prompt",
+        default="<image>\n<|grounding|>Convert the document to markdown.",
+        help="Prompt for OCR (default: grounding markdown conversion)",
+    )
+    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)",
+    )
+
+    args = parser.parse_args()
+
+    main(
+        input_dataset=args.input_dataset,
+        output_dataset=args.output_dataset,
+        image_column=args.image_column,
+        model=args.model,
+        resolution_mode=args.resolution_mode,
+        base_size=args.base_size,
+        image_size=args.image_size,
+        crop_mode=args.crop_mode if args.crop_mode else None,
+        prompt=args.prompt,
+        hf_token=args.hf_token,
+        split=args.split,
+        max_samples=args.max_samples,
+        private=args.private,
+        shuffle=args.shuffle,
+        seed=args.seed,
+    )

dots-ocr.py

@@ -0,0 +1,553 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#     "datasets",
+#     "huggingface-hub[hf_transfer]",
+#     "pillow",
+#     "vllm>=0.9.1",
+#     "tqdm",
+#     "toolz",
+#     "torch",
+# ]
+#
+# ///
+
+"""
+Convert document images to markdown using DoTS.ocr with vLLM.
+
+DoTS.ocr is a compact 1.7B multilingual document parsing model with SOTA performance
+on 100+ languages. This script uses vLLM for efficient batch processing.
+
+Features:
+- 🌍 Multilingual support (100+ languages)
+- 📊 Table extraction and formatting
+- 📐 Formula recognition
+- 📝 Layout-aware text extraction
+- 🎯 Compact model (1.7B parameters)
+
+Model: rednote-hilab/dots.ocr
+vLLM: Officially tested with 0.9.1+ (native support via PR #24645)
+"""
+
+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
+from vllm import LLM, SamplingParams
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+# ────────────────────────────────────────────────────────────────
+# DoTS OCR Prompt Templates (from official dots.ocr repo)
+# Source: https://github.com/rednote-hilab/dots.ocr/blob/master/dots_ocr/utils/prompts.py
+# ────────────────────────────────────────────────────────────────
+
+PROMPT_TEMPLATES = {
+    "ocr": "Extract the text content from this image.",
+
+    "layout-all": """Please output the layout information from the PDF image, including each layout element's bbox, its category, and the corresponding text content within the bbox.
+
+1. Bbox format: [x1, y1, x2, y2]
+
+2. Layout Categories: The possible categories are ['Caption', 'Footnote', 'Formula', 'List-item', 'Page-footer', 'Page-header', 'Picture', 'Section-header', 'Table', 'Text', 'Title'].
+
+3. Text Extraction & Formatting Rules:
+    - Picture: For the 'Picture' category, the text field should be omitted.
+    - Formula: Format its text as LaTeX.
+    - Table: Format its text as HTML.
+    - All Others (Text, Title, etc.): Format their text as Markdown.
+
+4. Constraints:
+    - The output text must be the original text from the image, with no translation.
+    - All layout elements must be sorted according to human reading order.
+
+5. Final Output: The entire output must be a single JSON object.""",
+
+    "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.""",
+}
+
+
+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 make_ocr_message(
+    image: Union[Image.Image, Dict[str, Any], str],
+    prompt: str = PROMPT_TEMPLATES["ocr"],
+) -> List[Dict]:
+    """Create 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)}")
+
+    # Convert to 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 message in vLLM format
+    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",
+    prompt_mode: str = "general",
+) -> str:
+    """Create a dataset card documenting the OCR process."""
+    model_name = model.split("/")[-1]
+
+    return f"""---
+tags:
+- ocr
+- document-processing
+- dots-ocr
+- multilingual
+- markdown
+- uv-script
+- generated
+---
+
+# Document OCR using {model_name}
+
+This dataset contains OCR results from images in [{source_dataset}](https://huggingface.co/datasets/{source_dataset}) using DoTS.ocr, a compact 1.7B multilingual 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}
+- **Max Model Length**: {max_model_len:,} tokens
+- **Max Output Tokens**: {max_tokens:,}
+- **GPU Memory Utilization**: {gpu_memory_utilization:.1%}
+
+## Model Information
+
+DoTS.ocr is a compact 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
+- 🎯 **Compact** - Only 1.7B parameters
+
+## 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 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 markdown text
+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"Column: {{info['column_name']}} - Model: {{info['model_id']}}")
+```
+
+## Reproduction
+
+This dataset was generated using the [uv-scripts/ocr](https://huggingface.co/datasets/uv-scripts/ocr) DoTS OCR script:
+
+```bash
+uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/dots-ocr.py \\
+    {source_dataset} \\
+    <output-dataset> \\
+    --image-column {image_column} \\
+    --batch-size {batch_size} \\
+    --prompt-mode {prompt_mode} \\
+    --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 = "rednote-hilab/dots.ocr",
+    max_model_len: int = 8192,
+    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,
+    prompt_mode: str = "ocr",
+    custom_prompt: str = None,
+    output_column: str = "markdown",
+):
+    """Process images from HF dataset through DoTS.ocr model."""
+
+    # Check CUDA availability first
+    check_cuda_availability()
+
+    # Track processing start time
+    start_time = datetime.now()
+
+    # Enable HF_TRANSFER for faster downloads
+    os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"
+
+    # Login to HF if token provided
+    HF_TOKEN = hf_token or os.environ.get("HF_TOKEN")
+    if HF_TOKEN:
+        login(token=HF_TOKEN)
+
+    # Determine prompt to use
+    if custom_prompt:
+        prompt = custom_prompt
+        logger.info(f"Using custom prompt: {prompt[:50]}...")
+    else:
+        prompt = PROMPT_TEMPLATES.get(prompt_mode, PROMPT_TEMPLATES["ocr"])
+        logger.info(f"Using prompt mode: {prompt_mode}")
+
+    # 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: {model}")
+    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,
+    )
+
+    sampling_params = SamplingParams(
+        temperature=0.0,  # Deterministic for OCR
+        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="DoTS.ocr processing",
+    ):
+        batch_indices = list(batch_indices)
+        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
+            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(["[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 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,
+        "column_name": output_column,
+        "timestamp": datetime.now().isoformat(),
+        "prompt_mode": prompt_mode if not custom_prompt else "custom",
+    }
+
+    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
+    logger.info(f"Pushing to {output_dataset}")
+    dataset.push_to_hub(output_dataset, private=private, token=HF_TOKEN)
+
+    # 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_str,
+        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,
+        prompt_mode=prompt_mode if not custom_prompt else "custom",
+    )
+
+    card = DatasetCard(card_content)
+    card.push_to_hub(output_dataset, token=HF_TOKEN)
+
+    logger.info("✅ DoTS.ocr processing complete!")
+    logger.info(f"Dataset available at: https://huggingface.co/datasets/{output_dataset}")
+    logger.info(f"Processing time: {processing_time_str}")
+
+
+if __name__ == "__main__":
+    # Show example usage if no arguments
+    if len(sys.argv) == 1:
+        print("=" * 80)
+        print("DoTS.ocr Document Processing")
+        print("=" * 80)
+        print("\nCompact 1.7B multilingual OCR model supporting 100+ languages")
+        print("\nFeatures:")
+        print("- 🌍 Multilingual support (100+ languages)")
+        print("- ⚡ Fast processing with vLLM (2-3x speedup)")
+        print("- 📊 Table extraction and formatting")
+        print("- 📐 Formula recognition")
+        print("- 📝 Layout-aware text extraction")
+        print("\nExample usage:")
+        print("\n1. Basic OCR:")
+        print("   uv run dots-ocr.py input-dataset output-dataset")
+        print("\n2. With custom settings:")
+        print("   uv run dots-ocr.py docs analyzed-docs --batch-size 20 --max-samples 100")
+        print("\n3. Layout analysis with structure:")
+        print("   uv run dots-ocr.py papers analyzed-structure --prompt-mode layout-all")
+        print("\n4. Layout detection only (no text):")
+        print("   uv run dots-ocr.py docs layout-info --prompt-mode layout-only")
+        print("\n5. Running on HF Jobs:")
+        print("   hf jobs uv run --flavor l4x1 \\")
+        print("     -e HF_TOKEN=$(python3 -c \"from huggingface_hub import get_token; print(get_token())\") \\")
+        print("     -e HF_HUB_ENABLE_HF_TRANSFER=1 \\")
+        print("     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/dots-ocr.py \\")
+        print("       input-dataset output-dataset")
+        print("\n" + "=" * 80)
+        print("\nFor full help, run: uv run dots-ocr.py --help")
+        sys.exit(0)
+
+    parser = argparse.ArgumentParser(
+        description="Document OCR using DoTS.ocr (1.7B multilingual model)",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Prompt Modes (official DoTS.ocr 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)
+
+Examples:
+  # Basic text OCR (default)
+  uv run dots-ocr.py my-docs analyzed-docs
+
+  # Full layout analysis with structure
+  uv run dots-ocr.py papers structured --prompt-mode layout-all
+
+  # Random sampling for testing
+  uv run dots-ocr.py large-dataset test --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, DoTS handles 16-30 well)",
+    )
+    parser.add_argument(
+        "--model",
+        default="rednote-hilab/dots.ocr",
+        help="Model to use (default: rednote-hilab/dots.ocr)",
+    )
+    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=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 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=f"Prompt template to use: {', '.join(PROMPT_TEMPLATES.keys())} (default: ocr)",
+    )
+    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)",
+    )
+
+    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,
+        prompt_mode=args.prompt_mode,
+        custom_prompt=args.custom_prompt,
+        output_column=args.output_column,
+    )

lighton-ocr.py

@@ -0,0 +1,639 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#     "datasets",
+#     "huggingface-hub[hf_transfer]",
+#     "pillow",
+#     "vllm",
+#     "tqdm",
+#     "toolz",
+#     "torch",
+#     "triton-kernels @ git+https://github.com/triton-lang/[email protected]#subdirectory=python/triton_kernels",
+# ]
+#
+# [[tool.uv.index]]
+# url = "https://wheels.vllm.ai/nightly"
+#
+# [tool.uv]
+# prerelease = "allow"
+# ///
+
+"""
+Convert document images to markdown using LightOnOCR with vLLM.
+
+LightOnOCR is a compact 1B multilingual OCR model optimized for production speed.
+Combines Pixtral ViT encoder with Qwen3 language model for efficient document parsing.
+
+NOTE: Requires vLLM nightly wheels for LightOnOCR support. First run may take
+a few minutes to download and install dependencies.
+
+Features:
+- ⚡ Fastest: 5.71 pages/sec on H100 GPU
+- 🎯 Compact: Only 1B parameters
+- 🌍 Multilingual with European language optimization
+- 📐 LaTeX formula recognition
+- 📊 Table extraction (markdown format)
+- 📝 Document structure preservation
+- 🔤 3 vocabulary sizes (151k/32k/16k tokens)
+
+Model: lightonai/LightOnOCR-1B-1025
+vLLM: Requires nightly build from main branch
+Performance: 76.1% overall benchmark score
+"""
+
+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
+from vllm import LLM, SamplingParams
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+# Model variants with different vocabulary sizes
+MODEL_VARIANTS = {
+    "151k": "lightonai/LightOnOCR-1B-1025",  # Full vocabulary (default)
+    "32k": "lightonai/LightOnOCR-0.9B-32k-1025",  # European languages optimized
+    "16k": "lightonai/LightOnOCR-0.9B-16k-1025",  # European languages optimized
+}
+
+
+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 resize_image_to_target(image: Image.Image, target_size: int = 1540) -> Image.Image:
+    """
+    Resize image so longest dimension is target_size while maintaining aspect ratio.
+
+    LightOnOCR was trained with images at 1540px max resolution and 200 DPI.
+    """
+    width, height = image.size
+
+    # If image is already smaller, don't upscale
+    if max(width, height) <= target_size:
+        return image
+
+    # Calculate new dimensions maintaining aspect ratio
+    if width > height:
+        new_width = target_size
+        new_height = int(height * (target_size / width))
+    else:
+        new_height = target_size
+        new_width = int(width * (target_size / height))
+
+    return image.resize((new_width, new_height), Image.Resampling.LANCZOS)
+
+
+def make_ocr_message(
+    image: Union[Image.Image, Dict[str, Any], str],
+    resize: bool = True,
+    target_size: int = 1540,
+) -> List[Dict]:
+    """
+    Create chat message for OCR processing.
+
+    LightOnOCR was trained with 1540px max resolution at 200 DPI for optimal results.
+    """
+    # 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")
+
+    # Resize to optimal dimensions for LightOnOCR
+    if resize:
+        pil_img = resize_image_to_target(pil_img, target_size)
+        logger.debug(f"Resized image 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()}"
+
+    # LightOnOCR uses message format with empty text prompt before image
+    # (matching official demo: text first, then image)
+    return [
+        {
+            "role": "user",
+            "content": [
+                {"type": "text", "text": ""},
+                {"type": "image_url", "image_url": {"url": data_uri}},
+            ],
+        }
+    ]
+
+
+def create_dataset_card(
+    source_dataset: str,
+    model: str,
+    vocab_size: str,
+    num_samples: int,
+    processing_time: str,
+    batch_size: int,
+    max_model_len: int,
+    max_tokens: int,
+    gpu_memory_utilization: float,
+    temperature: float,
+    top_p: float,
+    target_size: int,
+    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
+- lighton-ocr
+- markdown
+- uv-script
+- generated
+---
+
+# Document OCR using {model_name}
+
+This dataset contains OCR results from images in [{source_dataset}](https://huggingface.co/datasets/{source_dataset}) using LightOnOCR, a fast and compact 1B OCR model.
+
+## Processing Details
+
+- **Source Dataset**: [{source_dataset}](https://huggingface.co/datasets/{source_dataset})
+- **Model**: [{model}](https://huggingface.co/{model})
+- **Vocabulary Size**: {vocab_size} tokens
+- **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}
+- **Target Image Size**: {target_size}px (longest dimension)
+- **Max Model Length**: {max_model_len:,} tokens
+- **Max Output Tokens**: {max_tokens:,}
+- **Temperature**: {temperature}
+- **Top P**: {top_p}
+- **GPU Memory Utilization**: {gpu_memory_utilization:.1%}
+
+## Model Information
+
+LightOnOCR is a fast, compact OCR model that excels at:
+- ⚡ **Production Speed** - 5.71 pages/second on H100 GPU
+- 🎯 **Compact Size** - Only 1B parameters
+- 📐 **LaTeX formulas** - Mathematical notation in LaTeX format
+- 📊 **Tables** - Extracted and formatted as markdown
+- 📝 **Document structure** - Hierarchy and layout preservation
+- 🌍 **Multilingual** - Optimized for European languages
+- 🔤 **Flexible vocabulary** - 151k/32k/16k token variants
+
+### Vocabulary Variants
+
+- **151k tokens**: Full vocabulary, supports all languages
+- **32k tokens**: European languages optimized (~12% faster decoding)
+- **16k tokens**: European languages optimized (~12% faster decoding)
+
+## Dataset Structure
+
+The dataset contains all original columns plus:
+- `markdown`: The extracted text in markdown format with LaTeX formulas
+- `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 markdown text
+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"Column: {{info['column_name']}} - Model: {{info['model_id']}}")
+```
+
+## Reproduction
+
+This dataset was generated using the [uv-scripts/ocr](https://huggingface.co/datasets/uv-scripts/ocr) LightOnOCR script:
+
+```bash
+uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lighton-ocr.py \\
+    {source_dataset} \\
+    <output-dataset> \\
+    --vocab-size {vocab_size} \\
+    --image-column {image_column} \\
+    --batch-size {batch_size}
+```
+
+## Performance
+
+- **Processing Speed**: ~{num_samples / (float(processing_time.split()[0]) * 60):.2f} images/second
+- **Benchmark Score**: 76.1% overall (across diverse document types)
+- **Optimization**: Native resolution ViT + lightweight decoder
+
+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,
+    vocab_size: str = "151k",
+    max_model_len: int = 8192,
+    max_tokens: int = 6500,
+    temperature: float = 0.2,
+    top_p: float = 0.9,
+    gpu_memory_utilization: float = 0.8,
+    target_size: int = 1540,
+    no_resize: bool = False,
+    hf_token: str = None,
+    split: str = "train",
+    max_samples: int = None,
+    private: bool = False,
+    shuffle: bool = False,
+    seed: int = 42,
+    output_column: str = "markdown",
+):
+    """Process images from HF dataset through LightOnOCR model."""
+
+    # Check CUDA availability first
+    check_cuda_availability()
+
+    # Track processing start time
+    start_time = datetime.now()
+
+    # Enable HF_TRANSFER for faster downloads
+    os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"
+
+    # Login to HF if token provided
+    HF_TOKEN = hf_token or os.environ.get("HF_TOKEN")
+    if HF_TOKEN:
+        login(token=HF_TOKEN)
+
+    # Get model ID from vocabulary size
+    if vocab_size not in MODEL_VARIANTS:
+        raise ValueError(
+            f"Invalid vocab_size '{vocab_size}'. Choose from: {list(MODEL_VARIANTS.keys())}"
+        )
+    model = MODEL_VARIANTS[vocab_size]
+    logger.info(f"Using model: {model} ({vocab_size} vocabulary)")
+
+    # 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 LightOnOCR")
+    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},  # One image per prompt
+        enforce_eager=False,  # Use torch.compile for better performance
+    )
+
+    # LightOnOCR recommended sampling parameters
+    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}")
+    if not no_resize:
+        logger.info(f"Images will be resized to {target_size}px (longest dimension)")
+
+    # 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="LightOnOCR processing",
+    ):
+        batch_indices = list(batch_indices)
+        batch_images = [dataset[i][image_column] for i in batch_indices]
+
+        try:
+            # Create messages for batch
+            batch_messages = [
+                make_ocr_message(img, resize=not no_resize, target_size=target_size)
+                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(["[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 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,
+        "model_name": "LightOnOCR",
+        "vocab_size": vocab_size,
+        "column_name": output_column,
+        "timestamp": datetime.now().isoformat(),
+        "temperature": temperature,
+        "top_p": top_p,
+        "max_tokens": max_tokens,
+        "target_size": target_size if not no_resize else "original",
+    }
+
+    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
+    logger.info(f"Pushing to {output_dataset}")
+    dataset.push_to_hub(output_dataset, private=private, token=HF_TOKEN)
+
+    # Create and push dataset card
+    logger.info("Creating dataset card")
+    card_content = create_dataset_card(
+        source_dataset=input_dataset,
+        model=model,
+        vocab_size=vocab_size,
+        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,
+        top_p=top_p,
+        target_size=target_size,
+        image_column=image_column,
+        split=split,
+    )
+
+    card = DatasetCard(card_content)
+    card.push_to_hub(output_dataset, token=HF_TOKEN)
+
+    logger.info("✅ LightOnOCR 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 __name__ == "__main__":
+    # Show example usage if no arguments
+    if len(sys.argv) == 1:
+        print("=" * 80)
+        print("LightOnOCR Document Processing")
+        print("=" * 80)
+        print("\nFast, compact 1B OCR model for production workloads")
+        print("\nFeatures:")
+        print("- ⚡ Fastest processing: 5.71 pages/sec on H100")
+        print("- 🎯 Compact: Only 1B parameters")
+        print("- 🌍 Multilingual with European language optimization")
+        print("- 📐 LaTeX formula recognition")
+        print("- 📊 Table extraction (markdown format)")
+        print("- 🔤 3 vocabulary sizes for speed/quality tradeoffs")
+        print("\nExample usage:")
+        print("\n1. Basic OCR (full vocabulary):")
+        print("   uv run lighton-ocr.py input-dataset output-dataset")
+        print("\n2. European languages optimized (faster):")
+        print("   uv run lighton-ocr.py docs results --vocab-size 32k")
+        print("\n3. Custom batch size for performance:")
+        print("   uv run lighton-ocr.py docs results --batch-size 32")
+        print("\n4. Test with small sample:")
+        print("   uv run lighton-ocr.py large-dataset test --max-samples 50 --shuffle")
+        print("\n5. Original image size (no resize):")
+        print("   uv run lighton-ocr.py docs output --no-resize")
+        print("\n6. Running on HF Jobs:")
+        print("   hf jobs uv run --flavor l4x1 \\")
+        print("     -e HF_TOKEN=$(python3 -c \"from huggingface_hub import get_token; print(get_token())\") \\")
+        print("     -e HF_HUB_ENABLE_HF_TRANSFER=1 \\")
+        print("     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lighton-ocr.py \\")
+        print("       input-dataset output-dataset --vocab-size 32k")
+        print("\n" + "=" * 80)
+        print("\nVocabulary Size Options:")
+        print("  151k - Full vocabulary (all languages)")
+        print("  32k  - European languages (~12% faster)")
+        print("  16k  - European languages (~12% faster)")
+        print("\nFor full help, run: uv run lighton-ocr.py --help")
+        sys.exit(0)
+
+    parser = argparse.ArgumentParser(
+        description="Document OCR using LightOnOCR (fast 1B model)",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Vocabulary Size Options:
+  151k    Full vocabulary supporting all languages (default)
+  32k     European languages optimized (~12% faster decoding)
+  16k     European languages optimized (~12% faster decoding)
+
+Examples:
+  # Basic text OCR with full vocabulary
+  uv run lighton-ocr.py my-docs analyzed-docs
+
+  # Fast processing for European languages
+  uv run lighton-ocr.py papers results --vocab-size 32k
+
+  # Test with random sampling
+  uv run lighton-ocr.py large-dataset test --max-samples 50 --shuffle
+
+  # Custom batch size for GPU optimization
+  uv run lighton-ocr.py dataset output --batch-size 32 --gpu-memory-utilization 0.9
+        """,
+    )
+
+    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(
+        "--vocab-size",
+        default="151k",
+        choices=list(MODEL_VARIANTS.keys()),
+        help="Vocabulary size variant (default: 151k)",
+    )
+    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=6500,
+        help="Maximum tokens to generate (default: 6500)",
+    )
+    parser.add_argument(
+        "--temperature",
+        type=float,
+        default=0.2,
+        help="Sampling temperature (default: 0.2)",
+    )
+    parser.add_argument(
+        "--top-p",
+        type=float,
+        default=0.9,
+        help="Top-p sampling parameter (default: 0.9)",
+    )
+    parser.add_argument(
+        "--gpu-memory-utilization",
+        type=float,
+        default=0.8,
+        help="GPU memory utilization (default: 0.8)",
+    )
+    parser.add_argument(
+        "--target-size",
+        type=int,
+        default=1540,
+        help="Target size for longest image dimension in pixels (default: 1540, matching training)",
+    )
+    parser.add_argument(
+        "--no-resize",
+        action="store_true",
+        help="Don't resize images (use original 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",
+        default="markdown",
+        help="Column name for output text (default: markdown)",
+    )
+
+    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,
+        vocab_size=args.vocab_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,
+        target_size=args.target_size,
+        no_resize=args.no_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,
+    )

nanonets-ocr.py

@@ -0,0 +1,507 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#     "datasets",
+#     "huggingface-hub[hf_transfer]",
+#     "pillow",
+#     "vllm",
+#     "tqdm",
+#     "toolz",
+#     "torch",  # Added for CUDA check
+# ]
+#
+# ///
+
+"""
+Convert document images to markdown using Nanonets-OCR-s with vLLM.
+
+This script processes images through the Nanonets-OCR-s model to extract
+text and structure as markdown, ideal for document understanding tasks.
+
+Features:
+- LaTeX equation recognition
+- Table extraction and formatting
+- Document structure preservation
+- Signature and watermark detection
+"""
+
+import argparse
+import base64
+import io
+import json
+import logging
+import os
+import sys
+from typing import Any, Dict, List, Union
+
+import torch
+from datasets import load_dataset
+from huggingface_hub import DatasetCard, login
+from PIL import Image
+from toolz import partition_all
+from tqdm.auto import tqdm
+from vllm import LLM, SamplingParams
+from datetime import datetime
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+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 make_ocr_message(
+    image: Union[Image.Image, Dict[str, Any], str],
+    prompt: str = "Extract the text from the above document as if you were reading it naturally. Return the tables in html format. Return the equations in LaTeX representation. If there is an image in the document and image caption is not present, add a small description of the image inside the <img></img> tag; otherwise, add the image caption inside <img></img>. Watermarks should be wrapped in brackets. Ex: <watermark>OFFICIAL COPY</watermark>. Page numbers should be wrapped in brackets. Ex: <page_number>14</page_number> or <page_number>9/22</page_number>. Prefer using ☐ and ☑ for check boxes.",
+) -> List[Dict]:
+    """Create 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)}")
+
+    # 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 message in vLLM format
+    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"""---
+viewer: false
+tags:
+- ocr
+- document-processing
+- nanonets
+- 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 Nanonets-OCR-s.
+
+## 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}
+- **Max Model Length**: {max_model_len:,} tokens
+- **Max Output Tokens**: {max_tokens:,}
+- **GPU Memory Utilization**: {gpu_memory_utilization:.1%}
+
+## Model Information
+
+Nanonets-OCR-s is a state-of-the-art document OCR model that excels at:
+- 📐 **LaTeX equations** - Mathematical formulas preserved in LaTeX format
+- 📊 **Tables** - Extracted and formatted as HTML
+- 📝 **Document structure** - Headers, lists, and formatting maintained
+- 🖼️ **Images** - Captions and descriptions included in `<img>` tags
+- ☑️ **Forms** - Checkboxes rendered as ☐/☑
+- 🔖 **Watermarks** - Wrapped in `<watermark>` tags
+- 📄 **Page numbers** - Wrapped in `<page_number>` tags
+
+## 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
+import json
+
+# Load the dataset
+dataset = load_dataset("{{output_dataset_id}}", split="{split}")
+
+# Access the markdown text
+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"Column: {{info['column_name']}} - Model: {{info['model_id']}}")
+```
+
+## Reproduction
+
+This dataset was generated using the [uv-scripts/ocr](https://huggingface.co/datasets/uv-scripts/ocr) Nanonets OCR script:
+
+```bash
+uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/nanonets-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}
+```
+
+## Performance
+
+- **Processing Speed**: ~{num_samples / (float(processing_time.split()[0]) * 60):.1f} images/second
+- **GPU Configuration**: vLLM with {gpu_memory_utilization:.0%} 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 = 32,
+    model: str = "nanonets/Nanonets-OCR-s",
+    max_model_len: int = 8192,
+    max_tokens: int = 4096,
+    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,
+):
+    """Process images from HF dataset through OCR model."""
+
+    # Check CUDA availability first
+    check_cuda_availability()
+    
+    # Track processing start time
+    start_time = datetime.now()
+
+    # Enable HF_TRANSFER for faster downloads
+    os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "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},
+    )
+
+    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}")
+
+    # Process in batches to avoid memory issues
+    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:
+            # Create messages for batch
+            batch_messages = [make_ocr_message(img) for img in batch_images]
+
+            # Process with vLLM
+            outputs = llm.chat(batch_messages, sampling_params)
+
+            # Extract markdown from outputs
+            for output in outputs:
+                markdown_text = output.outputs[0].text.strip()
+                all_markdown.append(markdown_text)
+
+        except Exception as e:
+            logger.error(f"Error processing batch: {e}")
+            # Add error placeholders for failed batch
+            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...")
+    
+    # Check for existing inference_info
+    if "inference_info" in dataset.column_names:
+        # Parse existing info from first row (all rows have same info)
+        try:
+            existing_info = json.loads(dataset[0]["inference_info"])
+            if not isinstance(existing_info, list):
+                existing_info = [existing_info]  # Convert old format to list
+        except (json.JSONDecodeError, TypeError):
+            existing_info = []
+        # Remove old column to update it
+        dataset = dataset.remove_columns(["inference_info"])
+    else:
+        existing_info = []
+    
+    # Add new inference info
+    new_info = {
+        "column_name": "markdown",
+        "model_id": model,
+        "processing_date": datetime.now().isoformat(),
+        "batch_size": batch_size,
+        "max_tokens": max_tokens,
+        "gpu_memory_utilization": gpu_memory_utilization,
+        "max_model_len": max_model_len,
+        "script": "nanonets-ocr.py",
+        "script_version": "1.0.0",
+        "script_url": "https://huggingface.co/datasets/uv-scripts/ocr/raw/main/nanonets-ocr.py"
+    }
+    existing_info.append(new_info)
+    
+    # Add updated inference_info column
+    info_json = json.dumps(existing_info, ensure_ascii=False)
+    dataset = dataset.add_column("inference_info", [info_json] * len(dataset))
+
+    # 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 __name__ == "__main__":
+    # Show example usage if no arguments
+    if len(sys.argv) == 1:
+        print("=" * 80)
+        print("Nanonets OCR to Markdown Converter")
+        print("=" * 80)
+        print("\nThis script converts document images to structured markdown using")
+        print("the Nanonets-OCR-s model with vLLM acceleration.")
+        print("\nFeatures:")
+        print("- LaTeX equation recognition")
+        print("- Table extraction and formatting")
+        print("- Document structure preservation")
+        print("- Signature and watermark detection")
+        print("\nExample usage:")
+        print("\n1. Basic OCR conversion:")
+        print("   uv run nanonets-ocr.py document-images markdown-docs")
+        print("\n2. With custom settings:")
+        print("   uv run nanonets-ocr.py scanned-pdfs extracted-text \\")
+        print("       --image-column page \\")
+        print("       --batch-size 16 \\")
+        print("       --gpu-memory-utilization 0.8")
+        print("\n3. Process a subset for testing:")
+        print("   uv run nanonets-ocr.py large-dataset test-output --max-samples 10")
+        print("\n4. Random sample from ordered dataset:")
+        print("   uv run nanonets-ocr.py ordered-dataset random-test --max-samples 50 --shuffle")
+        print("\n5. Running on HF Jobs:")
+        print("   hfjobs run \\")
+        print("     --flavor l4x1 \\")
+        print("     --secret HF_TOKEN=... \\")
+        print(
+            "     uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/nanonets-ocr.py \\"
+        )
+        print("       your-document-dataset \\")
+        print("       your-markdown-output")
+        print("\n" + "=" * 80)
+        print("\nFor full help, run: uv run nanonets-ocr.py --help")
+        sys.exit(0)
+
+    parser = argparse.ArgumentParser(
+        description="OCR images to markdown using Nanonets-OCR-s",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Basic usage
+  uv run nanonets-ocr.py my-images-dataset ocr-results
+
+  # With specific image column
+  uv run nanonets-ocr.py documents extracted-text --image-column scan
+
+  # Process subset for testing
+  uv run nanonets-ocr.py large-dataset test-output --max-samples 100
+
+  # Random sample from ordered dataset
+  uv run nanonets-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=32,
+        help="Batch size for processing (default: 32)",
+    )
+    parser.add_argument(
+        "--model",
+        default="nanonets/Nanonets-OCR-s",
+        help="Model to use (default: nanonets/Nanonets-OCR-s)",
+    )
+    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(
+        "--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)",
+    )
+
+    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,
+    )

nanonets-ocr2.py

@@ -0,0 +1,514 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#     "datasets",
+#     "huggingface-hub[hf_transfer]",
+#     "pillow",
+#     "vllm",
+#     "tqdm",
+#     "toolz",
+#     "torch",
+# ]
+#
+# ///
+
+"""
+Convert document images to markdown using Nanonets-OCR2-3B with vLLM.
+
+This script processes images through the Nanonets-OCR2-3B model (3.75B params)
+to extract text and structure as markdown, ideal for document understanding tasks.
+
+Features:
+- LaTeX equation recognition
+- Table extraction and formatting (HTML)
+- Document structure preservation
+- Image descriptions and captions
+- Signature and watermark detection
+- Checkbox recognition
+- Multilingual support
+"""
+
+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
+from vllm import LLM, SamplingParams
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+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 make_ocr_message(
+    image: Union[Image.Image, Dict[str, Any], str],
+    prompt: str = "Extract the text from the above document as if you were reading it naturally. Return the tables in html format. Return the equations in LaTeX representation. If there is an image in the document and image caption is not present, add a small description of the image inside the <img></img> tag; otherwise, add the image caption inside <img></img>. Watermarks should be wrapped in brackets. Ex: <watermark>OFFICIAL COPY</watermark>. Page numbers should be wrapped in brackets. Ex: <page_number>14</page_number> or <page_number>9/22</page_number>. Prefer using ☐ and ☑ for check boxes.",
+) -> List[Dict]:
+    """Create 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)}")
+
+    # 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 message in vLLM format
+    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
+- nanonets
+- nanonets-ocr2
+- 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 Nanonets-OCR2-3B.
+
+## Processing Details
+
+- **Source Dataset**: [{source_dataset}](https://huggingface.co/datasets/{source_dataset})
+- **Model**: [{model}](https://huggingface.co/{model})
+- **Model Size**: 3.75B parameters
+- **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
+
+Nanonets-OCR2-3B is a state-of-the-art document OCR model that excels at:
+- 📐 **LaTeX equations** - Mathematical formulas preserved in LaTeX format
+- 📊 **Tables** - Extracted and formatted as HTML
+- 📝 **Document structure** - Headers, lists, and formatting maintained
+- 🖼️ **Images** - Captions and descriptions included in `<img>` tags
+- ☑️ **Forms** - Checkboxes rendered as ☐/☑
+- 🔖 **Watermarks** - Wrapped in `<watermark>` tags
+- 📄 **Page numbers** - Wrapped in `<page_number>` tags
+- 🌍 **Multilingual** - Supports multiple languages
+
+## 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
+import json
+
+# Load the dataset
+dataset = load_dataset("{{{{output_dataset_id}}}}", split="{split}")
+
+# Access the markdown text
+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"Column: {{{{info['column_name']}}}} - Model: {{{{info['model_id']}}}}")
+```
+
+## Reproduction
+
+This dataset was generated using the [uv-scripts/ocr](https://huggingface.co/datasets/uv-scripts/ocr) Nanonets OCR2 script:
+
+```bash
+uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/nanonets-ocr2.py \\
+    {source_dataset} \\
+    <output-dataset> \\
+    --model {model} \\
+    --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
+
+- **Processing Speed**: ~{num_samples / (float(processing_time.split()[0]) * 60):.1f} images/second
+- **GPU Configuration**: vLLM with {gpu_memory_utilization:.0%} 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 = "nanonets/Nanonets-OCR2-3B",
+    max_model_len: int = 8192,
+    max_tokens: int = 4096,
+    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,
+):
+    """Process images from HF dataset through Nanonets-OCR2-3B model."""
+
+    # Check CUDA availability first
+    check_cuda_availability()
+
+    # Track processing start time
+    start_time = datetime.now()
+
+    # Enable HF_TRANSFER for faster downloads
+    os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "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},
+    )
+
+    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}")
+
+    # Process in batches to avoid memory issues
+    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:
+            # Create messages for batch
+            batch_messages = [make_ocr_message(img) for img in batch_images]
+
+            # Process with vLLM
+            outputs = llm.chat(batch_messages, sampling_params)
+
+            # Extract markdown from outputs
+            for output in outputs:
+                markdown_text = output.outputs[0].text.strip()
+                all_markdown.append(markdown_text)
+
+        except Exception as e:
+            logger.error(f"Error processing batch: {e}")
+            # Add error placeholders for failed batch
+            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...")
+
+    # Check for existing inference_info
+    if "inference_info" in dataset.column_names:
+        # Parse existing info from first row (all rows have same info)
+        try:
+            existing_info = json.loads(dataset[0]["inference_info"])
+            if not isinstance(existing_info, list):
+                existing_info = [existing_info]  # Convert old format to list
+        except (json.JSONDecodeError, TypeError):
+            existing_info = []
+        # Remove old column to update it
+        dataset = dataset.remove_columns(["inference_info"])
+    else:
+        existing_info = []
+
+    # Add new inference info
+    new_info = {
+        "column_name": "markdown",
+        "model_id": model,
+        "processing_date": datetime.now().isoformat(),
+        "batch_size": batch_size,
+        "max_tokens": max_tokens,
+        "gpu_memory_utilization": gpu_memory_utilization,
+        "max_model_len": max_model_len,
+        "script": "nanonets-ocr2.py",
+        "script_version": "1.0.0",
+        "script_url": "https://huggingface.co/datasets/uv-scripts/ocr/raw/main/nanonets-ocr2.py"
+    }
+    existing_info.append(new_info)
+
+    # Add updated inference_info column
+    info_json = json.dumps(existing_info, ensure_ascii=False)
+    dataset = dataset.add_column("inference_info", [info_json] * len(dataset))
+
+    # 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 __name__ == "__main__":
+    # Show example usage if no arguments
+    if len(sys.argv) == 1:
+        print("=" * 80)
+        print("Nanonets OCR2-3B to Markdown Converter")
+        print("=" * 80)
+        print("\nThis script converts document images to structured markdown using")
+        print("the Nanonets-OCR2-3B model (3.75B params) with vLLM acceleration.")
+        print("\nFeatures:")
+        print("- LaTeX equation recognition")
+        print("- Table extraction and formatting (HTML)")
+        print("- Document structure preservation")
+        print("- Image descriptions and captions")
+        print("- Signature and watermark detection")
+        print("- Checkbox recognition (☐/☑)")
+        print("- Multilingual support")
+        print("\nExample usage:")
+        print("\n1. Basic OCR conversion:")
+        print("   uv run nanonets-ocr2.py document-images markdown-docs")
+        print("\n2. With custom settings:")
+        print("   uv run nanonets-ocr2.py scanned-pdfs extracted-text \\")
+        print("       --image-column page \\")
+        print("       --batch-size 32 \\")
+        print("       --gpu-memory-utilization 0.8")
+        print("\n3. Process a subset for testing:")
+        print("   uv run nanonets-ocr2.py large-dataset test-output --max-samples 10")
+        print("\n4. Random sample from ordered dataset:")
+        print("   uv run nanonets-ocr2.py ordered-dataset random-test \\")
+        print("       --max-samples 50 --shuffle")
+        print("\n5. Running on HF Jobs:")
+        print("   hf jobs uv run --flavor l4x1 \\")
+        print("     -e HF_TOKEN=$(python3 -c \"from huggingface_hub import get_token; print(get_token())\") \\")
+        print("     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/nanonets-ocr2.py \\")
+        print("       your-document-dataset \\")
+        print("       your-markdown-output")
+        print("\n" + "=" * 80)
+        print("\nFor full help, run: uv run nanonets-ocr2.py --help")
+        sys.exit(0)
+
+    parser = argparse.ArgumentParser(
+        description="OCR images to markdown using Nanonets-OCR2-3B",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Basic usage
+  uv run nanonets-ocr2.py my-images-dataset ocr-results
+
+  # With specific image column
+  uv run nanonets-ocr2.py documents extracted-text --image-column scan
+
+  # Process subset for testing
+  uv run nanonets-ocr2.py large-dataset test-output --max-samples 100
+
+  # Random sample from ordered dataset
+  uv run nanonets-ocr2.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="nanonets/Nanonets-OCR2-3B",
+        help="Model to use (default: nanonets/Nanonets-OCR2-3B)",
+    )
+    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(
+        "--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)",
+    )
+
+    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,
+    )

numarkdown-ocr.py

@@ -0,0 +1,683 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#     "datasets",
+#     "huggingface-hub[hf_transfer]",
+#     "pillow",
+#     "vllm",
+#     "tqdm",
+#     "toolz",
+#     "torch",  # Added for CUDA check
+# ]
+#
+# ///
+
+"""
+Convert document images to markdown using NuMarkdown-8B-Thinking with vLLM.
+
+This script processes images through the NuMarkdown model to extract
+text with advanced reasoning capabilities, ideal for complex document understanding.
+
+Features:
+- Reasoning-based document analysis with thinking tokens
+- Superior table extraction and formatting
+- Complex layout understanding
+- Mathematical formula recognition
+- Clean markdown output generation
+- Optional thinking trace inclusion
+- Multi-GPU support with automatic detection
+- Optimized token budget for reasoning models
+"""
+
+import argparse
+import base64
+import io
+import json
+import logging
+import os
+import re
+import sys
+from typing import Any, Dict, List, Union, Optional, Tuple
+from datetime import datetime
+
+import torch
+from torch import cuda
+from datasets import load_dataset
+from huggingface_hub import DatasetCard, HfApi, login
+from PIL import Image
+from toolz import partition_all
+from tqdm.auto import tqdm
+from vllm import LLM, SamplingParams
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+def check_gpu_availability() -> int:
+    """Check if CUDA is available and return the number of GPUs."""
+    if not cuda.is_available():
+        logger.error("CUDA is not available. This script requires a GPU.")
+        logger.error("Please run on a machine with NVIDIA GPU or use HF Jobs with GPU flavor.")
+        sys.exit(1)
+    
+    num_gpus = cuda.device_count()
+    for i in range(num_gpus):
+        gpu_name = cuda.get_device_name(i)
+        gpu_memory = cuda.get_device_properties(i).total_memory / 1024**3
+        logger.info(f"GPU {i}: {gpu_name} with {gpu_memory:.1f} GB memory")
+    
+    return num_gpus
+
+
+def validate_and_resize_image(
+    image: Image.Image,
+    min_pixels: int = 100 * 28 * 28,
+    max_pixels: int = 5000 * 28 * 28,
+) -> Image.Image:
+    """Validate and resize image to meet pixel constraints if necessary."""
+    width, height = image.size
+    total_pixels = width * height
+    
+    if total_pixels < min_pixels or total_pixels > max_pixels:
+        # Calculate scaling factor
+        if total_pixels < min_pixels:
+            scale = (min_pixels / total_pixels) ** 0.5
+        else:
+            scale = (max_pixels / total_pixels) ** 0.5
+        
+        new_width = int(width * scale)
+        new_height = int(height * scale)
+        
+        logger.debug(f"Resizing image from {width}x{height} to {new_width}x{new_height}")
+        image = image.resize((new_width, new_height), Image.Resampling.LANCZOS)
+    
+    return image
+
+
+def extract_answer_from_thinking(text: str, include_thinking: bool = False) -> str:
+    """
+    Extract the final answer from NuMarkdown's thinking output.
+    
+    The model generates output in format:
+    <think>reasoning process...</think>
+    <answer>final markdown output</answer>
+    """
+    if include_thinking:
+        # Return the full output including thinking traces
+        return text.strip()
+    
+    # Extract content between <answer> tags
+    answer_pattern = r'<answer>(.*?)</answer>'
+    answer_match = re.search(answer_pattern, text, re.DOTALL)
+    
+    if answer_match:
+        return answer_match.group(1).strip()
+    
+    # If no answer tags found, check if the entire text is markdown
+    # (sometimes the model might not use tags)
+    if not '<think>' in text and not '<answer>' in text:
+        return text.strip()
+    
+    # Fallback: return everything after </think> if present
+    think_end = text.find('</think>')
+    if think_end != -1:
+        remaining = text[think_end + 8:].strip()
+        # Remove <answer> tags if present
+        remaining = remaining.replace('<answer>', '').replace('</answer>', '').strip()
+        return remaining
+    
+    # Last resort: return the full text
+    logger.warning("Could not extract answer from thinking tokens, returning full text")
+    return text.strip()
+
+
+def make_numarkdown_message(
+    image: Union[Image.Image, Dict[str, Any], str],
+    prompt: str = "Convert this document to markdown. Focus on preserving structure, tables, formulas, and all textual content.",
+) -> List[Dict]:
+    """Create chat message for NuMarkdown processing."""
+    # Convert to PIL Image if needed
+    if isinstance(image, Image.Image):
+        pil_img = image.convert("RGB")
+    elif isinstance(image, dict) and "bytes" in image:
+        pil_img = Image.open(io.BytesIO(image["bytes"])).convert("RGB")
+    elif isinstance(image, str):
+        pil_img = Image.open(image).convert("RGB")
+    else:
+        raise ValueError(f"Unsupported image type: {type(image)}")
+    
+    # Validate and resize if necessary
+    pil_img = validate_and_resize_image(pil_img)
+    
+    # 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 message in vLLM chat format
+    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,
+    include_thinking: bool,
+    tensor_parallel_size: int,
+    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
+- numarkdown
+- markdown
+- reasoning
+- thinking-tokens
+- 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 NuMarkdown-8B-Thinking.
+
+## 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}
+- **Max Model Length**: {max_model_len:,} tokens
+- **Max Output Tokens**: {max_tokens:,}
+- **GPU Memory Utilization**: {gpu_memory_utilization:.1%}
+- **Tensor Parallel Size**: {tensor_parallel_size} GPU(s)
+- **Thinking Traces**: {"Included" if include_thinking else "Excluded (only final answers)"}
+
+## Model Information
+
+NuMarkdown-8B-Thinking is a state-of-the-art reasoning-based document OCR model that excels at:
+- 🧠 **Reasoning Process** - Analyzes document layout before generation
+- 📊 **Complex Tables** - Superior table extraction and formatting
+- 📐 **Mathematical Formulas** - Accurate LaTeX/math notation preservation
+- 📝 **Document Structure** - Maintains hierarchical document organization
+- 🔍 **Layout Analysis** - Understands complex multi-column layouts
+- ✨ **Clean Output** - Generates well-formatted markdown
+
+### Thinking Tokens
+
+This model uses a unique "thinking" process where it:
+1. Analyzes the document structure internally (`<think>` phase)
+2. Generates the final markdown output (`<answer>` phase)
+
+{"The dataset includes both thinking traces and final answers." if include_thinking else "Only the final answers are included (thinking traces removed)."}
+
+## 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 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 markdown text
+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"Column: {{info['column_name']}} - Model: {{info['model_id']}}")
+```
+
+## Reproduction
+
+This dataset was generated using the [uv-scripts/ocr](https://huggingface.co/datasets/uv-scripts/ocr) NuMarkdown OCR script:
+
+```bash
+uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/numarkdown-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} \\
+    {"--include-thinking" if include_thinking else ""}
+```
+
+## Performance
+
+- **Processing Speed**: ~{num_samples / (float(processing_time.split()[0]) * 60):.1f} images/second
+- **GPU Configuration**: {tensor_parallel_size} GPU(s) with {gpu_memory_utilization:.0%} memory utilization
+- **Model Size**: 8.29B parameters
+
+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 = "numind/NuMarkdown-8B-Thinking",
+    max_model_len: int = 16384,
+    max_tokens: int = 16384,
+    gpu_memory_utilization: float = 0.9,
+    tensor_parallel_size: Optional[int] = None,
+    hf_token: str = None,
+    split: str = "train",
+    max_samples: int = None,
+    private: bool = False,
+    shuffle: bool = False,
+    seed: int = 42,
+    include_thinking: bool = False,
+    temperature: float = 0.0,
+    custom_prompt: Optional[str] = None,
+):
+    """Process images from HF dataset through NuMarkdown model.
+    
+    The max_tokens parameter controls the total token budget for both
+    thinking and answer phases. For complex documents with extensive
+    reasoning, the default of 16384 tokens provides ample room for both
+    the thinking process and the final markdown output.
+    """
+    
+    # GPU check and configuration
+    num_gpus = check_gpu_availability()
+    if tensor_parallel_size is None:
+        tensor_parallel_size = num_gpus
+        logger.info(
+            f"Auto-detected {num_gpus} GPU(s), using tensor_parallel_size={tensor_parallel_size}"
+        )
+    else:
+        logger.info(f"Using specified tensor_parallel_size={tensor_parallel_size}")
+        if tensor_parallel_size > num_gpus:
+            logger.warning(
+                f"Requested {tensor_parallel_size} GPUs but only {num_gpus} available"
+            )
+    
+    # Track processing start time
+    start_time = datetime.now()
+    
+    # Enable HF_TRANSFER for faster downloads
+    os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "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 with trust_remote_code for NuMarkdown
+    logger.info(f"Initializing vLLM with model: {model}")
+    logger.info(f"Using {tensor_parallel_size} GPU(s) for inference")
+    llm = LLM(
+        model=model,
+        trust_remote_code=True,  # Required for NuMarkdown
+        max_model_len=max_model_len,
+        gpu_memory_utilization=gpu_memory_utilization,
+        tensor_parallel_size=tensor_parallel_size,
+        limit_mm_per_prompt={"image": 1},
+    )
+    
+    # Set up sampling parameters
+    sampling_params = SamplingParams(
+        temperature=temperature,
+        max_tokens=max_tokens,
+    )
+    
+    # Use custom prompt if provided, otherwise use default
+    prompt = custom_prompt or "Convert this document to markdown. Focus on preserving structure, tables, formulas, and all textual content."
+    
+    # Process images in batches
+    all_markdown = []
+    
+    logger.info(f"Processing {len(dataset)} images in batches of {batch_size}")
+    logger.info(f"Including thinking traces: {include_thinking}")
+    
+    # Process in batches to avoid memory issues
+    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:
+            # Create messages for batch
+            batch_messages = [
+                make_numarkdown_message(img, prompt) for img in batch_images
+            ]
+            
+            # Process with vLLM
+            outputs = llm.chat(batch_messages, sampling_params)
+            
+            # Extract markdown from outputs
+            for output in outputs:
+                raw_text = output.outputs[0].text.strip()
+                # Extract answer from thinking tokens
+                markdown_text = extract_answer_from_thinking(raw_text, include_thinking)
+                all_markdown.append(markdown_text)
+        
+        except Exception as e:
+            logger.error(f"Error processing batch: {e}")
+            # Add error placeholders for failed batch
+            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...")
+    
+    # Check for existing inference_info
+    if "inference_info" in dataset.column_names:
+        # Parse existing info from first row (all rows have same info)
+        try:
+            existing_info = json.loads(dataset[0]["inference_info"])
+            if not isinstance(existing_info, list):
+                existing_info = [existing_info]  # Convert old format to list
+        except (json.JSONDecodeError, TypeError):
+            existing_info = []
+        # Remove old column to update it
+        dataset = dataset.remove_columns(["inference_info"])
+    else:
+        existing_info = []
+    
+    # Add new inference info
+    new_info = {
+        "column_name": "markdown",
+        "model_id": model,
+        "processing_date": datetime.now().isoformat(),
+        "batch_size": batch_size,
+        "max_tokens": max_tokens,
+        "gpu_memory_utilization": gpu_memory_utilization,
+        "max_model_len": max_model_len,
+        "include_thinking": include_thinking,
+        "temperature": temperature,
+        "prompt": prompt,
+        "script": "numarkdown-ocr.py",
+        "script_version": "1.0.0",
+        "script_url": "https://huggingface.co/datasets/uv-scripts/ocr/raw/main/numarkdown-ocr.py"
+    }
+    existing_info.append(new_info)
+    
+    # Add updated inference_info column
+    info_json = json.dumps(existing_info, ensure_ascii=False)
+    dataset = dataset.add_column("inference_info", [info_json] * len(dataset))
+    
+    # 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,
+        include_thinking=include_thinking,
+        tensor_parallel_size=tensor_parallel_size,
+        image_column=image_column,
+        split=split,
+    )
+    
+    # Handle dataset card push with proper repo_id
+    full_repo_id = output_dataset
+    try:
+        card = DatasetCard(card_content)
+        # If output_dataset doesn't contain a username, get the current user's name
+        if "/" not in output_dataset:
+            api = HfApi(token=HF_TOKEN)
+            user_info = api.whoami()
+            full_repo_id = f"{user_info['name']}/{output_dataset}"
+            logger.info(f"Using full repo ID: {full_repo_id}")
+        
+        card.push_to_hub(full_repo_id, token=HF_TOKEN)
+        logger.info("✅ Dataset card created and pushed!")
+    except Exception as e:
+        logger.warning(f"Could not push dataset card: {e}")
+        logger.info("Dataset was successfully created but card upload failed. You can add it manually.")
+    
+    logger.info("✅ OCR conversion complete!")
+    logger.info(
+        f"Dataset available at: https://huggingface.co/datasets/{full_repo_id}"
+    )
+
+
+if __name__ == "__main__":
+    # Show example usage if no arguments
+    if len(sys.argv) == 1:
+        print("=" * 80)
+        print("NuMarkdown-8B-Thinking OCR with Reasoning")
+        print("=" * 80)
+        print("\nThis script converts document images to markdown using")
+        print("the NuMarkdown-8B-Thinking model with advanced reasoning capabilities.")
+        print("\nFeatures:")
+        print("- 🧠 Reasoning-based document analysis")
+        print("- 📊 Superior table extraction and formatting")
+        print("- 📐 Mathematical formula recognition")
+        print("- 📝 Complex layout understanding")
+        print("- ✨ Clean markdown generation")
+        print("- 🔍 Optional thinking trace inclusion")
+        print("\nExample usage:")
+        print("\n1. Basic OCR conversion:")
+        print("   uv run numarkdown-ocr.py document-images markdown-docs")
+        print("\n2. Include thinking traces:")
+        print("   uv run numarkdown-ocr.py complex-docs analyzed-docs --include-thinking")
+        print("\n3. With custom settings:")
+        print("   uv run numarkdown-ocr.py scientific-papers extracted-text \\")
+        print("       --batch-size 8 \\")
+        print("       --max-tokens 16384 \\")
+        print("       --gpu-memory-utilization 0.9")
+        print("\n4. Process a subset for testing:")
+        print("   uv run numarkdown-ocr.py large-dataset test-output --max-samples 10")
+        print("\n5. Custom prompt for specific needs:")
+        print("   uv run numarkdown-ocr.py invoices invoice-data \\")
+        print('       --custom-prompt "Extract all invoice details including line items"')
+        print("\n6. Multi-GPU processing:")
+        print("   uv run numarkdown-ocr.py large-docs processed-docs --tensor-parallel-size 2")
+        print("\n7. Running on HF Jobs:")
+        print("   hf jobs uv run --flavor a100x2 \\")
+        print('     -e HF_TOKEN=$(python3 -c "from huggingface_hub import get_token; print(get_token())") \\')
+        print("     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/numarkdown-ocr.py \\")
+        print("       your-document-dataset \\")
+        print("       your-markdown-output")
+        print("\n" + "=" * 80)
+        print("\nFor full help, run: uv run numarkdown-ocr.py --help")
+        sys.exit(0)
+    
+    parser = argparse.ArgumentParser(
+        description="OCR images to markdown using NuMarkdown-8B-Thinking with reasoning",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Basic usage
+  uv run numarkdown-ocr.py my-images-dataset ocr-results
+  
+  # Include thinking traces in output
+  uv run numarkdown-ocr.py documents analyzed-docs --include-thinking
+  
+  # Process subset for testing
+  uv run numarkdown-ocr.py large-dataset test-output --max-samples 100
+  
+  # Custom prompt for specific extraction
+  uv run numarkdown-ocr.py forms form-data --custom-prompt "Extract all form fields and values"
+  
+  # Multi-GPU for large datasets
+  uv run numarkdown-ocr.py large-dataset processed --tensor-parallel-size 4
+  
+  # Random sample from dataset
+  uv run numarkdown-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, lower than others due to model size)",
+    )
+    parser.add_argument(
+        "--model",
+        default="numind/NuMarkdown-8B-Thinking",
+        help="Model to use (default: numind/NuMarkdown-8B-Thinking)",
+    )
+    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=16384,
+        help="Maximum tokens to generate including thinking tokens (default: 16384)",
+    )
+    parser.add_argument(
+        "--gpu-memory-utilization",
+        type=float,
+        default=0.9,
+        help="GPU memory utilization per GPU (default: 0.9)",
+    )
+    parser.add_argument(
+        "--tensor-parallel-size",
+        type=int,
+        help="Number of GPUs to use (default: auto-detect all available)",
+    )
+    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(
+        "--include-thinking",
+        action="store_true",
+        help="Include thinking traces in output (default: only final answers)",
+    )
+    parser.add_argument(
+        "--temperature",
+        type=float,
+        default=0.0,
+        help="Temperature for generation (default: 0.0 for deterministic)",
+    )
+    parser.add_argument(
+        "--custom-prompt",
+        type=str,
+        help="Custom prompt for the model (overrides default)",
+    )
+    
+    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,
+        tensor_parallel_size=args.tensor_parallel_size,
+        hf_token=args.hf_token,
+        split=args.split,
+        max_samples=args.max_samples,
+        private=args.private,
+        shuffle=args.shuffle,
+        seed=args.seed,
+        include_thinking=args.include_thinking,
+        temperature=args.temperature,
+        custom_prompt=args.custom_prompt,
+    )

olmocr2-vllm.py

@@ -0,0 +1,636 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#     "datasets",
+#     "huggingface-hub[hf_transfer]",
+#     "pillow",
+#     "vllm",
+#     "tqdm",
+#     "toolz",
+#     "torch",
+#     "pyyaml",  # For parsing YAML front matter
+# ]
+#
+# ///
+
+"""
+Convert document images to markdown using olmOCR-2 with vLLM.
+
+This script processes images through the olmOCR-2-7B model to extract
+text and structure as markdown, optimized for document understanding.
+
+Features:
+- LaTeX equation recognition
+- HTML table extraction
+- Document structure preservation (headers, lists, formatting)
+- Rotation detection and correction metadata
+- Figure and chart descriptions
+- Natural reading order inference
+- High-quality OCR for various document types
+
+Model: allenai/olmOCR-2-7B-1025-FP8
+Based on: Qwen2.5-VL-7B-Instruct fine-tuned on olmOCR-mix
+"""
+
+import argparse
+import base64
+import io
+import json
+import logging
+import os
+import re
+import sys
+from datetime import datetime
+from typing import Any, Dict, List, Union
+
+import torch
+import yaml
+from datasets import load_dataset
+from huggingface_hub import DatasetCard, login
+from PIL import Image
+from toolz import partition_all
+from tqdm.auto import tqdm
+from vllm import LLM, SamplingParams
+from vllm.sampling_params import GuidedDecodingParams
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# olmOCR no-anchoring prompt (from olmocr/prompts/prompts.py:build_no_anchoring_v4_yaml_prompt)
+OLMOCR_PROMPT = (
+    "Attached is one page of a document that you must process. "
+    "Just return the plain text representation of this document as if you were reading it naturally. "
+    "Convert equations to LateX and tables to HTML.\n"
+    "If there are any figures or charts, label them with the following markdown syntax "
+    "![Alt text describing the contents of the figure](page_startx_starty_width_height.png)\n"
+    "Return your output as markdown, with a front matter section on top specifying values for the "
+    "primary_language, is_rotation_valid, rotation_correction, is_table, and is_diagram parameters."
+)
+
+
+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 parse_yaml_frontmatter(text: str) -> tuple[dict, str]:
+    """
+    Parse YAML front matter from olmOCR output.
+
+    Expected format:
+    ---
+    primary_language: en
+    is_rotation_valid: true
+    rotation_correction: 0
+    is_table: false
+    is_diagram: false
+    ---
+    # Document content here...
+
+    Returns:
+        (metadata_dict, content_without_frontmatter)
+    """
+    # Match YAML front matter between --- markers
+    pattern = r"^---\s*\n(.*?)\n---\s*\n(.*)$"
+    match = re.match(pattern, text.strip(), re.DOTALL)
+
+    if match:
+        yaml_str = match.group(1)
+        content = match.group(2)
+        try:
+            metadata = yaml.safe_load(yaml_str)
+            return metadata or {}, content
+        except yaml.YAMLError as e:
+            logger.warning(f"Failed to parse YAML front matter: {e}")
+            return {}, text
+    else:
+        # No front matter found, return empty metadata
+        logger.warning("No YAML front matter found in output")
+        return {}, text
+
+
+def make_ocr_message(
+    image: Union[Image.Image, Dict[str, Any], str],
+    prompt: str = OLMOCR_PROMPT,
+    target_longest_dim: int = 1288,
+) -> List[Dict]:
+    """Create chat message for olmOCR processing.
+
+    Args:
+        image: Input image (PIL Image, dict with bytes, or path)
+        prompt: OCR prompt text
+        target_longest_dim: Target size for longest image dimension (default 1288, matching olmOCR)
+    """
+    # 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)}")
+
+    # Resize image to target dimension (matching olmOCR pipeline default of 1288px)
+    width, height = pil_img.size
+    longest_side = max(width, height)
+    if longest_side != target_longest_dim:
+        scale = target_longest_dim / longest_side
+        new_width = int(width * scale)
+        new_height = int(height * scale)
+        pil_img = pil_img.resize((new_width, new_height), Image.Resampling.LANCZOS)
+        logger.debug(f"Resized image from {width}x{height} to {new_width}x{new_height}")
+
+    # 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 message in vLLM format (text before image, matching olmOCR pipeline)
+    return [
+        {
+            "role": "user",
+            "content": [
+                {"type": "text", "text": prompt},
+                {"type": "image_url", "image_url": {"url": data_uri}},
+            ],
+        }
+    ]
+
+
+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
+- olmocr
+- 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 olmOCR-2-7B.
+
+## 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}
+- **Max Model Length**: {max_model_len:,} tokens
+- **Max Output Tokens**: {max_tokens:,}
+- **GPU Memory Utilization**: {gpu_memory_utilization:.1%}
+
+## Model Information
+
+olmOCR-2-7B is a high-quality document OCR model based on Qwen2.5-VL-7B-Instruct, fine-tuned on olmOCR-mix-1025 dataset and optimized with GRPO reinforcement learning.
+
+Key features:
+- 📐 **LaTeX equations** - Mathematical formulas in LaTeX format
+- 📊 **HTML tables** - Structured table extraction
+- 📝 **Document structure** - Headers, lists, formatting preserved
+- 🖼️ **Figure descriptions** - Charts and figures labeled with descriptions
+- 🔄 **Rotation detection** - Metadata about document orientation
+- 📑 **Natural reading order** - Handles multi-column and complex layouts
+- 🎯 **High accuracy** - Scores 82.4 ± 1.1 on olmOCR-Bench
+
+## Output Format
+
+Each row contains:
+- Original image from source dataset
+- `markdown`: Extracted document content in markdown format
+- `olmocr_metadata`: JSON with document metadata (language, rotation, table/diagram flags)
+
+## Columns
+
+- `{image_column}`: Original document image
+- `markdown`: Extracted text and structure in markdown
+- `olmocr_metadata`: Document metadata (primary_language, is_rotation_valid, rotation_correction, is_table, is_diagram)
+- `inference_info`: Processing metadata (model, script version, timestamp)
+
+## Reproduction
+
+```bash
+# Using HF Jobs (recommended)
+hf jobs uv run --flavor l4x1 \\
+  -s HF_TOKEN \\
+  https://huggingface.co/datasets/uv-scripts/ocr/raw/main/olmocr2-vllm.py \\
+  {source_dataset} \\
+  your-username/output-dataset
+
+# Local with GPU
+uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/olmocr2-vllm.py \\
+  {source_dataset} \\
+  your-username/output-dataset
+```
+
+## Citation
+
+```bibtex
+@misc{{olmocr,
+      title={{{{olmOCR: Unlocking Trillions of Tokens in PDFs with Vision Language Models}}}},
+      author={{Jake Poznanski and Jon Borchardt and Jason Dunkelberger and Regan Huff and Daniel Lin and Aman Rangapur and Christopher Wilhelm and Kyle Lo and Luca Soldaini}},
+      year={{2025}},
+      eprint={{2502.18443}},
+      archivePrefix={{arXiv}},
+      primaryClass={{cs.CL}},
+      url={{https://arxiv.org/abs/2502.18443}},
+}}
+```
+
+---
+*Generated with [uv-scripts/ocr](https://huggingface.co/datasets/uv-scripts/ocr)*
+"""
+
+
+def main(
+    input_dataset: str,
+    output_dataset: str,
+    image_column: str = "image",
+    output_column: str = "markdown",
+    batch_size: int = 16,
+    model: str = "allenai/olmOCR-2-7B-1025-FP8",
+    max_model_len: int = 16384,
+    max_tokens: int = 8192,
+    temperature: float = 0.1,
+    gpu_memory_utilization: float = 0.8,
+    guided_decoding: bool = False,
+    hf_token: str = None,
+    split: str = "train",
+    max_samples: int = None,
+    private: bool = False,
+    shuffle: bool = False,
+    seed: int = 42,
+):
+    """
+    Process a dataset of document images through olmOCR-2 to extract markdown.
+
+    Args:
+        input_dataset: HuggingFace dataset ID containing images
+        output_dataset: HuggingFace dataset ID for output
+        image_column: Column name containing images
+        output_column: Column name for markdown output
+        batch_size: Number of images to process at once
+        model: HuggingFace model ID for olmOCR
+        max_model_len: Maximum context length
+        max_tokens: Maximum tokens to generate per image
+        temperature: Sampling temperature (0.1 default, matches olmOCR)
+        gpu_memory_utilization: Fraction of GPU memory to use
+        guided_decoding: Enable guided decoding with regex for YAML front matter
+        hf_token: HuggingFace token for authentication
+        split: Dataset split to process
+        max_samples: Limit number of samples (for testing)
+        private: Make output dataset private
+        shuffle: Shuffle dataset before processing
+        seed: Random seed for shuffling
+    """
+    import time
+
+    start_time = time.time()
+
+    # Check CUDA availability
+    check_cuda_availability()
+
+    # Login to HuggingFace if token provided
+    if hf_token:
+        login(token=hf_token)
+    elif "HF_TOKEN" in os.environ:
+        login(token=os.environ["HF_TOKEN"])
+
+    # Load dataset
+    logger.info(f"Loading dataset: {input_dataset}")
+    ds = load_dataset(input_dataset, split=split)
+
+    # Shuffle if requested
+    if shuffle:
+        logger.info(f"Shuffling dataset with seed {seed}")
+        ds = ds.shuffle(seed=seed)
+
+    # Limit samples if requested
+    if max_samples:
+        logger.info(f"Limiting to {max_samples} samples")
+        ds = ds.select(range(min(max_samples, len(ds))))
+
+    logger.info(f"Processing {len(ds)} samples")
+    logger.info(f"Output will be written to column: {output_column}")
+
+    # Set column names - namespace metadata by output column to avoid conflicts
+    metadata_column_name = f"{output_column}_metadata"
+    inference_info_column = "inference_info"
+    logger.info(f"Metadata will be written to column: {metadata_column_name}")
+
+    # Initialize LLM
+    logger.info(f"Initializing vLLM with model: {model}")
+    llm = LLM(
+        model=model,
+        max_model_len=max_model_len,
+        gpu_memory_utilization=gpu_memory_utilization,
+        limit_mm_per_prompt={"image": 1},
+    )
+
+    # Sampling parameters - olmOCR uses temperature 0.1 (transformers example)
+    sampling_params_kwargs = {
+        "temperature": temperature,
+        "max_tokens": max_tokens,
+        "repetition_penalty": 1.05,  # Discourage repetitive output
+        "stop": ["<|im_end|>", "<|endoftext|>"],
+    }
+
+    # Add guided decoding if requested (enforces YAML front matter structure)
+    if guided_decoding:
+        logger.info("Enabling guided decoding with YAML 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)
+
+    # Process in batches
+    all_outputs = []
+    all_metadata = []
+
+    for batch in tqdm(
+        list(partition_all(batch_size, ds)),
+        desc="Processing batches",
+    ):
+        # Create messages for batch
+        messages = [make_ocr_message(item[image_column]) for item in batch]
+
+        # Run inference
+        outputs = llm.chat(messages, sampling_params=sampling_params)
+
+        # Extract text and parse YAML front matter
+        for idx, output in enumerate(outputs):
+            response_text = output.outputs[0].text
+            finish_reason = output.outputs[0].finish_reason
+
+            # Log warning if generation didn't finish naturally
+            if finish_reason != "stop":
+                logger.warning(
+                    f"Generation did not finish naturally (reason: {finish_reason}), output may be incomplete"
+                )
+
+            metadata, content = parse_yaml_frontmatter(response_text)
+            all_outputs.append(content)
+            all_metadata.append(json.dumps(metadata))
+
+    # Add results to dataset
+    # Check if columns already exist and handle appropriately
+    if output_column in ds.column_names:
+        logger.warning(
+            f"Column '{output_column}' already exists, it will be overwritten"
+        )
+        ds = ds.remove_columns([output_column])
+    ds = ds.add_column(output_column, all_outputs)
+
+    if metadata_column_name in ds.column_names:
+        logger.warning(
+            f"Column '{metadata_column_name}' already exists, it will be overwritten"
+        )
+        ds = ds.remove_columns([metadata_column_name])
+    ds = ds.add_column(metadata_column_name, all_metadata)
+
+    # Add inference information
+    inference_info = json.dumps(
+        {
+            "model": model,
+            "script": "olmocr2-vllm.py",
+            "version": "1.0.0",
+            "timestamp": datetime.now().isoformat(),
+            "batch_size": batch_size,
+            "max_tokens": max_tokens,
+            "temperature": temperature,
+        }
+    )
+
+    # Handle existing inference_info column
+    if inference_info_column in ds.column_names:
+        # Parse existing, append new model info
+        def update_inference_info(example):
+            try:
+                existing = json.loads(example[inference_info_column])
+                if not isinstance(existing, list):
+                    existing = [existing]
+            except (json.JSONDecodeError, KeyError):
+                existing = []
+
+            existing.append(json.loads(inference_info))
+            return {inference_info_column: json.dumps(existing)}
+
+        ds = ds.map(update_inference_info)
+    else:
+        ds = ds.add_column(inference_info_column, [inference_info] * len(ds))
+
+    # Calculate processing time
+    elapsed_time = time.time() - start_time
+    hours = int(elapsed_time // 3600)
+    minutes = int((elapsed_time % 3600) // 60)
+    seconds = int(elapsed_time % 60)
+    processing_time = f"{hours}h {minutes}m {seconds}s"
+
+    # Create and save dataset card
+    card_content = create_dataset_card(
+        source_dataset=input_dataset,
+        model=model,
+        num_samples=len(ds),
+        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,
+    )
+
+    # Push to hub
+    logger.info(f"Pushing to HuggingFace Hub: {output_dataset}")
+    ds.push_to_hub(
+        output_dataset,
+        private=private,
+    )
+
+    # Update dataset card
+    card = DatasetCard(card_content)
+    card.push_to_hub(output_dataset)
+
+    logger.info(f"✓ Processing complete!")
+    logger.info(f"✓ Dataset: https://huggingface.co/datasets/{output_dataset}")
+    logger.info(f"✓ Processing time: {processing_time}")
+    logger.info(f"✓ Samples processed: {len(ds):,}")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Convert document images to markdown using olmOCR-2",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+
+1. Basic OCR on a dataset:
+   uv run olmocr2-vllm.py input-dataset output-dataset
+
+2. Test with first 10 samples:
+   uv run olmocr2-vllm.py input-dataset output-dataset --max-samples 10
+
+3. Process with custom batch size:
+   uv run olmocr2-vllm.py input-dataset output-dataset --batch-size 8
+
+4. Custom image column:
+   uv run olmocr2-vllm.py input-dataset output-dataset --image-column page_image
+
+5. Private output dataset:
+   uv run olmocr2-vllm.py input-dataset output-dataset --private
+
+6. Random sampling:
+   uv run olmocr2-vllm.py input-dataset output-dataset --max-samples 100 --shuffle
+
+7. Running on HuggingFace Jobs:
+   hf jobs uv run --flavor l4x1 \\
+     -s HF_TOKEN \\
+     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/olmocr2-vllm.py \\
+     input-dataset output-dataset
+
+8. Real example with historical documents:
+   hf jobs uv run --flavor l4x1 \\
+     -s HF_TOKEN \\
+     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/olmocr2-vllm.py \\
+     NationalLibraryOfScotland/Britain-and-UK-Handbooks-Dataset \\
+     your-username/handbooks-olmocr \\
+     --max-samples 100 \\
+     --shuffle
+        """,
+    )
+
+    parser.add_argument("input_dataset", help="Input HuggingFace dataset ID")
+    parser.add_argument("output_dataset", help="Output HuggingFace dataset ID")
+    parser.add_argument(
+        "--image-column",
+        default="image",
+        help="Column name containing images (default: image)",
+    )
+    parser.add_argument(
+        "--output-column",
+        default="markdown",
+        help="Column name for markdown output (default: markdown)",
+    )
+    parser.add_argument(
+        "--batch-size",
+        type=int,
+        default=16,
+        help="Batch size for processing (default: 16)",
+    )
+    parser.add_argument(
+        "--model",
+        default="allenai/olmOCR-2-7B-1025-FP8",
+        help="Model to use (default: allenai/olmOCR-2-7B-1025-FP8)",
+    )
+    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(
+        "--temperature",
+        type=float,
+        default=0.1,
+        help="Sampling temperature (default: 0.1, matches olmOCR transformers example)",
+    )
+    parser.add_argument(
+        "--gpu-memory-utilization",
+        type=float,
+        default=0.8,
+        help="GPU memory utilization (default: 0.8)",
+    )
+    parser.add_argument(
+        "--guided-decoding",
+        action="store_true",
+        help="Enable guided decoding with regex for YAML front matter structure",
+    )
+    parser.add_argument(
+        "--hf-token",
+        help="HuggingFace token (or set HF_TOKEN env var)",
+    )
+    parser.add_argument(
+        "--split",
+        default="train",
+        help="Dataset split to process (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)",
+    )
+
+    args = parser.parse_args()
+    main(
+        input_dataset=args.input_dataset,
+        output_dataset=args.output_dataset,
+        image_column=args.image_column,
+        output_column=args.output_column,
+        batch_size=args.batch_size,
+        model=args.model,
+        max_model_len=args.max_model_len,
+        max_tokens=args.max_tokens,
+        temperature=args.temperature,
+        gpu_memory_utilization=args.gpu_memory_utilization,
+        guided_decoding=args.guided_decoding,
+        hf_token=args.hf_token,
+        split=args.split,
+        max_samples=args.max_samples,
+        private=args.private,
+        shuffle=args.shuffle,
+        seed=args.seed,
+    )

paddleocr-vl.py

@@ -0,0 +1,699 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#     "datasets",
+#     "huggingface-hub",
+#     "pillow",
+#     "vllm",
+#     "tqdm",
+#     "toolz",
+#     "torch",
+#     "pyarrow",
+#     "transformers",
+# ]
+#
+# [[tool.uv.index]]
+# url = "https://wheels.vllm.ai/nightly"
+#
+# [tool.uv]
+# prerelease = "allow"
+# ///
+
+"""
+Convert document images to text/tables/formulas using PaddleOCR-VL with vLLM.
+
+PaddleOCR-VL is a compact 0.9B OCR model with task-specific capabilities for
+document parsing. It combines a NaViT-style dynamic resolution visual encoder
+with the ERNIE-4.5-0.3B language model for accurate element recognition.
+
+Features:
+- 🎯 Ultra-compact: Only 0.9B parameters (smallest 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
+- 🌍 Multilingual support
+- ⚡ Fast initialization due to small size
+- 🔧 Based on ERNIE-4.5 (different from Qwen-based models)
+
+Model: PaddlePaddle/PaddleOCR-VL
+vLLM: Requires nightly build for full support
+"""
+
+import argparse
+import base64
+import io
+import json
+import logging
+import math
+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
+from vllm import LLM, SamplingParams
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+# Task mode configurations from official PaddleOCR-VL documentation
+TASK_MODES = {
+    "ocr": "OCR:",
+    "table": "Table Recognition:",
+    "formula": "Formula Recognition:",
+    "chart": "Chart 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",
+}
+
+
+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
+    if apply_smart_resize:
+        original_size = pil_img.size
+        new_width, new_height = smart_resize(pil_img.height, pil_img.width)
+        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
+- {task_mode}
+- uv-script
+- generated
+---
+
+# Document Processing using PaddleOCR-VL ({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, an ultra-compact 0.9B OCR model.
+
+## 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**: `paddleocr_{task_mode}`
+- **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 is a state-of-the-art, resource-efficient model tailored for document parsing:
+- 🎯 **Ultra-compact** - Only 0.9B parameters (smallest OCR model)
+- 📝 **OCR mode** - General text extraction
+- 📊 **Table mode** - HTML table recognition
+- 📐 **Formula mode** - LaTeX mathematical notation
+- 📈 **Chart mode** - Structured chart analysis
+- 🌍 **Multilingual** - Support for multiple languages
+- ⚡ **Fast** - Quick initialization and inference
+- 🔧 **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
+
+## Dataset Structure
+
+The dataset contains all original columns plus:
+- `paddleocr_{task_mode}`: 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["paddleocr_{task_mode}"])
+    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 script:
+
+```bash
+uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/paddleocr-vl.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 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,
+):
+    """Process images from HF dataset through PaddleOCR-VL model."""
+
+    # Check CUDA availability first
+    check_cuda_availability()
+
+    # Track processing start time
+    start_time = datetime.now()
+
+    # Enable HF_TRANSFER for faster downloads
+    os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "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())}"
+        )
+
+    # Auto-generate output column name based on task mode
+    if output_column is None:
+        output_column = f"paddleocr_{task_mode}"
+
+    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
+    model_name = "PaddlePaddle/PaddleOCR-VL"
+    logger.info(f"Initializing vLLM with {model_name}")
+    logger.info("This may take a minute on first run (model is only 0.9B)...")
+
+    # Note: PaddleOCR-VL requires specific vLLM configuration
+    # The model needs custom implementation files to be loaded
+    os.environ["VLLM_USE_V1"] = "0"  # Disable V1 engine for compatibility
+    
+    llm = LLM(
+        model=model_name,
+        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,  # Match server config
+        enable_prefix_caching=False,  # Disable prefix caching like server
+        enforce_eager=True,  # Use eager mode instead of CUDA graphs
+    )
+
+    # 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 {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_name,
+        "model_name": "PaddleOCR-VL",
+        "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,
+    }
+
+    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
+    logger.info(f"Pushing to {output_dataset}")
+    dataset.push_to_hub(output_dataset, private=private, token=HF_TOKEN)
+
+    # Create and push dataset card
+    logger.info("Creating dataset card")
+    card_content = create_dataset_card(
+        source_dataset=input_dataset,
+        model=model_name,
+        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 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 __name__ == "__main__":
+    # Show example usage if no arguments
+    if len(sys.argv) == 1:
+        print("=" * 80)
+        print("PaddleOCR-VL Document Processing")
+        print("=" * 80)
+        print("\nUltra-compact 0.9B OCR model with task-specific capabilities")
+        print("\nFeatures:")
+        print("- 🎯 Smallest OCR model - Only 0.9B parameters")
+        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("- 🌍 Multilingual support")
+        print("- ⚡ Fast initialization and inference")
+        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.py input-dataset output-dataset")
+        print("\n2. Table extraction:")
+        print("   uv run paddleocr-vl.py docs tables-extracted --task-mode table")
+        print("\n3. Formula recognition:")
+        print(
+            "   uv run paddleocr-vl.py papers formulas --task-mode formula --batch-size 32"
+        )
+        print("\n4. Chart analysis:")
+        print("   uv run paddleocr-vl.py diagrams charts-analyzed --task-mode chart")
+        print("\n5. Test with small sample:")
+        print("   uv run paddleocr-vl.py dataset test --max-samples 10 --shuffle")
+        print("\n6. Running on HF Jobs:")
+        print("   hf jobs uv run --flavor l4x1 \\")
+        print(
+            '     -e HF_TOKEN=$(python3 -c "from huggingface_hub import get_token; print(get_token())") \\'
+        )
+        print("     -e HF_HUB_ENABLE_HF_TRANSFER=1 \\")
+        print(
+            "     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/paddleocr-vl.py \\"
+        )
+        print("       input-dataset output-dataset --task-mode ocr")
+        print("\n" + "=" * 80)
+        print("\nFor full help, run: uv run paddleocr-vl.py --help")
+        sys.exit(0)
+
+    parser = argparse.ArgumentParser(
+        description="Document processing using PaddleOCR-VL (0.9B task-specific 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
+
+Examples:
+  # Basic text OCR
+  uv run paddleocr-vl.py my-docs analyzed-docs
+
+  # Extract tables from documents
+  uv run paddleocr-vl.py papers tables --task-mode table
+
+  # Recognize mathematical formulas
+  uv run paddleocr-vl.py textbooks formulas --task-mode formula
+
+  # Analyze charts and diagrams
+  uv run paddleocr-vl.py reports charts --task-mode chart
+
+  # Test with random sampling
+  uv run paddleocr-vl.py large-dataset test --max-samples 50 --shuffle --task-mode ocr
+
+  # Disable smart resize for original resolution
+  uv run paddleocr-vl.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, or chart",
+    )
+    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: paddleocr_[task_mode])",
+    )
+
+    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,
+    )

rolm-ocr.py

@@ -0,0 +1,517 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#     "datasets",
+#     "huggingface-hub[hf_transfer]",
+#     "pillow",
+#     "vllm",
+#     "tqdm",
+#     "toolz",
+#     "torch",  # Added for CUDA check
+# ]
+#
+# ///
+
+"""
+Extract text from document images using RolmOCR with vLLM.
+
+This script processes images through the RolmOCR model to extract
+plain text content, ideal for general-purpose OCR tasks.
+
+Features:
+- Fast and efficient text extraction
+- General-purpose document OCR
+- Based on Qwen2.5-VL-7B architecture
+- Optimized for batch processing with vLLM
+"""
+
+import argparse
+import base64
+import io
+import json
+import logging
+import os
+import sys
+from typing import Any, Dict, List, Union
+
+import torch
+from datasets import load_dataset
+from huggingface_hub import DatasetCard, login
+from PIL import Image
+from toolz import partition_all
+from tqdm.auto import tqdm
+from vllm import LLM, SamplingParams
+from datetime import datetime
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+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 make_ocr_message(
+    image: Union[Image.Image, Dict[str, Any], str],
+    prompt: str = "Return the plain text representation of this document as if you were reading it naturally.\n",
+) -> List[Dict]:
+    """Create 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)}")
+
+    # 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 message in vLLM format
+    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,
+    output_column: 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"""---
+viewer: false
+tags:
+- ocr
+- text-extraction
+- rolmocr
+- uv-script
+- generated
+---
+
+# OCR Text Extraction using {model_name}
+
+This dataset contains extracted text from images in [{source_dataset}](https://huggingface.co/datasets/{source_dataset}) using RolmOCR.
+
+## 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**: `{output_column}`
+- **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
+
+RolmOCR is a fast, general-purpose OCR model based on Qwen2.5-VL-7B architecture. It extracts plain text from document images with high accuracy and efficiency.
+
+## Dataset Structure
+
+The dataset contains all original columns plus:
+- `{output_column}`: The extracted text from each image
+- `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 text
+for example in dataset:
+    print(example["{output_column}"])
+    break
+
+# View all OCR models applied to this dataset
+inference_info = json.loads(dataset[0]["inference_info"])
+for info in inference_info:
+    print(f"Column: {{info['column_name']}} - Model: {{info['model_id']}}")
+```
+
+## Reproduction
+
+This dataset was generated using the [uv-scripts/ocr](https://huggingface.co/datasets/uv-scripts/ocr) RolmOCR script:
+
+```bash
+uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/rolm-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}
+```
+
+## Performance
+
+- **Processing Speed**: ~{num_samples / (float(processing_time.split()[0]) * 60):.1f} images/second
+- **GPU Configuration**: vLLM with {gpu_memory_utilization:.0%} 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 = "reducto/RolmOCR",
+    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,
+    output_column: str = None,
+    shuffle: bool = False,
+    seed: int = 42,
+):
+    """Process images from HF dataset through OCR model."""
+
+    # Check CUDA availability first
+    check_cuda_availability()
+    
+    # Track processing start time
+    start_time = datetime.now()
+
+    # Enable HF_TRANSFER for faster downloads
+    os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "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)
+    
+    # Set output column name dynamically if not provided
+    if output_column is None:
+        # Extract model name from path (e.g., "reducto/RolmOCR" -> "rolmocr")
+        model_name = model.split("/")[-1].lower().replace("-", "_")
+        output_column = f"{model_name}_text"
+        logger.info(f"Using dynamic output column name: {output_column}")
+
+    # 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},
+    )
+
+    sampling_params = SamplingParams(
+        temperature=0.0,  # Deterministic for OCR
+        max_tokens=max_tokens,
+    )
+
+    # Process images in batches
+    all_text = []
+
+    logger.info(f"Processing {len(dataset)} images in batches of {batch_size}")
+
+    # Process in batches to avoid memory issues
+    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:
+            # Create messages for batch
+            batch_messages = [make_ocr_message(img) for img in batch_images]
+
+            # Process with vLLM
+            outputs = llm.chat(batch_messages, sampling_params)
+
+            # Extract text from outputs
+            for output in outputs:
+                text = output.outputs[0].text.strip()
+                all_text.append(text)
+
+        except Exception as e:
+            logger.error(f"Error processing batch: {e}")
+            # Add error placeholders for failed batch
+            all_text.extend(["[OCR FAILED]"] * len(batch_images))
+
+    # Add text column to dataset
+    logger.info(f"Adding {output_column} column to dataset")
+    dataset = dataset.add_column(output_column, all_text)
+    
+    # Handle inference_info tracking
+    logger.info("Updating inference_info...")
+    
+    # Check for existing inference_info
+    if "inference_info" in dataset.column_names:
+        # Parse existing info from first row (all rows have same info)
+        try:
+            existing_info = json.loads(dataset[0]["inference_info"])
+            if not isinstance(existing_info, list):
+                existing_info = [existing_info]  # Convert old format to list
+        except (json.JSONDecodeError, TypeError):
+            existing_info = []
+        # Remove old column to update it
+        dataset = dataset.remove_columns(["inference_info"])
+    else:
+        existing_info = []
+    
+    # Add new inference info
+    new_info = {
+        "column_name": output_column,
+        "model_id": model,
+        "processing_date": datetime.now().isoformat(),
+        "batch_size": batch_size,
+        "max_tokens": max_tokens,
+        "gpu_memory_utilization": gpu_memory_utilization,
+        "max_model_len": max_model_len,
+        "script": "rolm-ocr.py",
+        "script_version": "1.0.0",
+        "script_url": "https://huggingface.co/datasets/uv-scripts/ocr/raw/main/rolm-ocr.py"
+    }
+    existing_info.append(new_info)
+    
+    # Add updated inference_info column
+    info_json = json.dumps(existing_info, ensure_ascii=False)
+    dataset = dataset.add_column("inference_info", [info_json] * len(dataset))
+
+    # 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,
+        output_column=output_column,
+        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 __name__ == "__main__":
+    # Show example usage if no arguments
+    if len(sys.argv) == 1:
+        print("=" * 80)
+        print("RolmOCR Document Text Extraction")
+        print("=" * 80)
+        print("\nThis script extracts plain text from document images using")
+        print("the RolmOCR model with vLLM acceleration.")
+        print("\nFeatures:")
+        print("- Fast and efficient text extraction")
+        print("- General-purpose document OCR")
+        print("- Based on Qwen2.5-VL-7B architecture")
+        print("- Optimized for batch processing")
+        print("\nExample usage:")
+        print("\n1. Basic OCR conversion:")
+        print("   uv run rolm-ocr.py document-images extracted-text")
+        print("\n2. With custom settings:")
+        print("   uv run rolm-ocr.py scanned-docs ocr-output \\")
+        print("       --image-column page \\")
+        print("       --batch-size 8 \\")
+        print("       --gpu-memory-utilization 0.9")
+        print("\n3. Process a subset for testing:")
+        print("   uv run rolm-ocr.py large-dataset test-output --max-samples 10")
+        print("\n4. Random sample from ordered dataset:")
+        print("   uv run rolm-ocr.py ordered-dataset random-test --max-samples 50 --shuffle")
+        print("\n5. Running on HF Jobs:")
+        print("   hf jobs uv run --flavor l4x1 \\")
+        print("     -e HF_TOKEN=$(python3 -c \"from huggingface_hub import get_token; print(get_token())\") \\")
+        print(
+            "     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/rolm-ocr.py \\"
+        )
+        print("       your-document-dataset \\")
+        print("       your-text-output")
+        print("\n" + "=" * 80)
+        print("\nFor full help, run: uv run rolm-ocr.py --help")
+        sys.exit(0)
+
+    parser = argparse.ArgumentParser(
+        description="OCR images to text using RolmOCR",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Basic usage
+  uv run rolm-ocr.py my-images-dataset ocr-results
+
+  # With specific image column
+  uv run rolm-ocr.py documents extracted-text --image-column scan
+
+  # Process subset for testing
+  uv run rolm-ocr.py large-dataset test-output --max-samples 100
+
+  # Random sample of 100 images
+  uv run rolm-ocr.py ordered-dataset random-sample --max-samples 100 --shuffle
+
+  # Custom output column name (default: rolmocr_text)
+  uv run rolm-ocr.py images texts --output-column ocr_text
+        """,
+    )
+
+    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="reducto/RolmOCR",
+        help="Model to use (default: reducto/RolmOCR)",
+    )
+    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(
+        "--output-column",
+        default=None,
+        help="Name of the output column for extracted text (default: auto-generated from model name)",
+    )
+    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)",
+    )
+
+    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,
+        output_column=args.output_column,
+        shuffle=args.shuffle,
+        seed=args.seed,
+    )

smoldocling-ocr.py

@@ -0,0 +1,580 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#     "datasets",
+#     "huggingface-hub[hf_transfer]",
+#     "pillow",
+#     "vllm",
+#     "tqdm",
+#     "toolz",
+#     "torch",  # Added for CUDA check
+#     "docling-core",  # For DocTags conversion
+# ]
+#
+# ///
+
+"""
+Extract structured documents using SmolDocling-256M with vLLM.
+
+This script processes images through the SmolDocling model to extract
+structured document content with DocTags format, ideal for documents
+with code, formulas, tables, and complex layouts.
+
+Features:
+- Ultra-compact 256M parameter model
+- DocTags format for efficient representation
+- Code block recognition with indentation
+- Mathematical formula detection
+- Table and chart extraction
+- Layout preservation with bounding boxes
+"""
+
+import argparse
+import base64
+import io
+import json
+import logging
+import os
+import re
+import sys
+from typing import Any, Dict, List, Union
+from datetime import datetime
+
+import torch
+from datasets import load_dataset
+from docling_core.types.doc import DoclingDocument
+from docling_core.types.doc.document import DocTagsDocument
+from huggingface_hub import DatasetCard, login
+from PIL import Image
+from toolz import partition_all
+from tqdm.auto import tqdm
+from vllm import LLM, SamplingParams
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+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 prepare_llm_input(
+    image: Union[Image.Image, Dict[str, Any], str],
+    prompt_text: str = "Convert page to Docling.",
+) -> Dict:
+    """Prepare input for vLLM processing."""
+    # Convert to PIL Image if needed
+    if isinstance(image, Image.Image):
+        pil_img = image.convert("RGB")
+    elif isinstance(image, dict) and "bytes" in image:
+        pil_img = Image.open(io.BytesIO(image["bytes"])).convert("RGB")
+    elif isinstance(image, str):
+        pil_img = Image.open(image).convert("RGB")
+    else:
+        raise ValueError(f"Unsupported image type: {type(image)}")
+
+    # Create chat template - exact format from the example
+    chat_template = (
+        f"<|im_start|>User:<image>{prompt_text}<end_of_utterance>\nAssistant:"
+    )
+
+    # Return in the format expected by vLLM generate
+    return {"prompt": chat_template, "multi_modal_data": {"image": pil_img}}
+
+
+def convert_doctags_to_markdown(doctags_output: str) -> str:
+    """Convert DocTags output to markdown format."""
+    # For now, just return the raw output as-is
+    # We'll focus on getting the basic vLLM inference working first
+    return doctags_output.strip()
+
+
+def create_dataset_card(
+    source_dataset: str,
+    model: str,
+    num_samples: int,
+    processing_time: str,
+    output_column: str,
+    output_format: 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
+- smoldocling
+- doctags
+- structured-extraction
+- uv-script
+- generated
+---
+
+# Document Processing using {model_name}
+
+This dataset contains structured document extraction from images in [{source_dataset}](https://huggingface.co/datasets/{source_dataset}) using SmolDocling.
+
+## 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**: `{output_column}`
+- **Output Format**: {output_format}
+- **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
+
+SmolDocling-256M is an ultra-compact multimodal model that excels at:
+- 💻 **Code Recognition** - Detects and formats code blocks with proper indentation
+- 🔢 **Formula Recognition** - Identifies and processes mathematical expressions
+- 📊 **Tables & Charts** - Extracts structured data from tables and charts
+- 📐 **Layout Preservation** - Maintains document structure with bounding boxes
+- 🏷️ **DocTags Format** - Efficient minimal representation for documents
+- ⚡ **Fast Inference** - Only 256M parameters for quick processing
+
+## Dataset Structure
+
+The dataset contains all original columns plus:
+- `{output_column}`: The extracted {"DocTags JSON" if output_format == "doctags" else "markdown"} from each image
+- `inference_info`: JSON list tracking all OCR models applied to this dataset
+
+## Usage
+
+```python
+from datasets import load_dataset
+import json
+{"from docling_core.types.doc import DoclingDocument" if output_format == "doctags" else ""}
+{"from docling_core.types.doc.document import DocTagsDocument" if output_format == "doctags" else ""}
+
+# Load the dataset
+dataset = load_dataset("{{output_dataset_id}}", split="{split}")
+
+# Access the extracted content
+for example in dataset:
+    {"# Parse DocTags and convert to desired format" if output_format == "doctags" else ""}
+    {f"doc_tags = DocTagsDocument.model_validate_json(example['{output_column}'])" if output_format == "doctags" else f"print(example['{output_column}'])"}
+    {"doc = DoclingDocument.from_doctags(doc_tags)" if output_format == "doctags" else ""}
+    {"print(doc.export(format='md').text)  # Or 'html', 'json'" if output_format == "doctags" else ""}
+    break
+
+# View all OCR models applied to this dataset
+inference_info = json.loads(dataset[0]["inference_info"])
+for info in inference_info:
+    print(f"Column: {{info['column_name']}} - Model: {{info['model_id']}}")
+```
+
+## Reproduction
+
+This dataset was generated using the [uv-scripts/ocr](https://huggingface.co/datasets/uv-scripts/ocr) SmolDocling script:
+
+```bash
+uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/smoldocling-ocr.py \\
+    {source_dataset} \\
+    <output-dataset> \\
+    --image-column {image_column} \\
+    --output-format {output_format} \\
+    --batch-size {batch_size} \\
+    --max-model-len {max_model_len} \\
+    --max-tokens {max_tokens} \\
+    --gpu-memory-utilization {gpu_memory_utilization}
+```
+
+## Performance
+
+- **Processing Speed**: ~{num_samples / (float(processing_time.split()[0]) * 60):.1f} images/second
+- **Model Size**: 256M parameters (ultra-compact)
+- **GPU Configuration**: vLLM with {gpu_memory_utilization:.0%} 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 = 32,
+    model: str = "ds4sd/SmolDocling-256M-preview",
+    max_model_len: int = 8192,
+    max_tokens: int = 8192,
+    gpu_memory_utilization: float = 0.8,
+    hf_token: str = None,
+    split: str = "train",
+    max_samples: int = None,
+    private: bool = False,
+    output_column: str = None,
+    output_format: str = "markdown",
+    shuffle: bool = False,
+    seed: int = 42,
+    prompt: str = "Convert page to Docling.",
+):
+    """Process images from HF dataset through SmolDocling model."""
+
+    # Check CUDA availability first
+    check_cuda_availability()
+
+    # Track processing start time
+    start_time = datetime.now()
+
+    # Enable HF_TRANSFER for faster downloads
+    os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "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)
+
+    # Set output column name dynamically if not provided
+    if output_column is None:
+        # Extract model name from path (e.g., "ds4sd/SmolDocling-256M-preview" -> "smoldocling")
+        model_name = model.split("/")[-1].split("-")[0].lower()
+        output_column = f"{model_name}_text"
+        logger.info(f"Using dynamic output column name: {output_column}")
+
+    # Validate image column
+    if image_column not in dataset.column_names:
+        raise ValueError(
+            f"Column '{image_column}' not found. Available: {dataset.column_names}"
+        )
+
+    # Validate output format
+    if output_format not in ["markdown", "doctags"]:
+        raise ValueError(
+            f"Invalid output format '{output_format}'. Must be 'markdown' or 'doctags'"
+        )
+
+    # 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},
+    )
+
+    sampling_params = SamplingParams(
+        temperature=0.0,  # Deterministic for OCR
+        max_tokens=max_tokens,
+    )
+
+    # Process images in batches
+    all_output = []
+
+    logger.info(f"Processing {len(dataset)} images in batches of {batch_size}")
+    logger.info(f"Output format: {output_format}")
+
+    # Process in batches to avoid memory issues
+    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:
+            # Prepare inputs for batch
+            batch_inputs = [prepare_llm_input(img, prompt) for img in batch_images]
+
+            # Process with vLLM using generate
+            outputs = llm.generate(batch_inputs, sampling_params=sampling_params)
+
+            # Extract text from outputs
+            for i, output in enumerate(outputs):
+                raw_output = output.outputs[0].text.strip()
+
+                # Convert to markdown if requested
+                if output_format == "markdown":
+                    processed_output = convert_doctags_to_markdown(raw_output)
+                else:
+                    processed_output = raw_output
+
+                all_output.append(processed_output)
+
+        except Exception as e:
+            logger.error(f"Error processing batch: {e}")
+            # Add error placeholders for failed batch
+            all_output.extend(["[OCR FAILED]"] * len(batch_images))
+
+    # Add output column to dataset
+    logger.info(f"Adding {output_column} column to dataset")
+    dataset = dataset.add_column(output_column, all_output)
+
+    # Handle inference_info tracking
+    logger.info("Updating inference_info...")
+
+    # Check for existing inference_info
+    if "inference_info" in dataset.column_names:
+        # Parse existing info from first row (all rows have same info)
+        try:
+            existing_info = json.loads(dataset[0]["inference_info"])
+            if not isinstance(existing_info, list):
+                existing_info = [existing_info]  # Convert old format to list
+        except (json.JSONDecodeError, TypeError):
+            existing_info = []
+        # Remove old column to update it
+        dataset = dataset.remove_columns(["inference_info"])
+    else:
+        existing_info = []
+
+    # Add new inference info
+    new_info = {
+        "column_name": output_column,
+        "model_id": model,
+        "processing_date": datetime.now().isoformat(),
+        "batch_size": batch_size,
+        "max_tokens": max_tokens,
+        "gpu_memory_utilization": gpu_memory_utilization,
+        "max_model_len": max_model_len,
+        "output_format": output_format,
+        "prompt": prompt,
+        "script": "smoldocling-ocr.py",
+        "script_version": "1.0.0",
+        "script_url": "https://huggingface.co/datasets/uv-scripts/ocr/raw/main/smoldocling-ocr.py",
+    }
+    existing_info.append(new_info)
+
+    # Add updated inference_info column
+    info_json = json.dumps(existing_info, ensure_ascii=False)
+    dataset = dataset.add_column("inference_info", [info_json] * len(dataset))
+
+    # 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,
+        output_column=output_column,
+        output_format=output_format,
+        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 __name__ == "__main__":
+    # Show example usage if no arguments
+    if len(sys.argv) == 1:
+        print("=" * 80)
+        print("SmolDocling Ultra-Compact Document Processing")
+        print("=" * 80)
+        print("\nThis script extracts structured document content using")
+        print("the SmolDocling-256M model with vLLM acceleration.")
+        print("\nFeatures:")
+        print("- Ultra-compact 256M parameter model")
+        print("- DocTags format for efficient representation")
+        print("- Code block recognition with indentation")
+        print("- Mathematical formula detection")
+        print("- Table and chart extraction")
+        print("- Layout preservation with bounding boxes")
+        print("\nExample usage:")
+        print("\n1. Basic document conversion to markdown:")
+        print("   uv run smoldocling-ocr.py document-images extracted-docs")
+        print("\n2. Extract with DocTags format:")
+        print("   uv run smoldocling-ocr.py scientific-papers doc-analysis \\")
+        print("       --output-format doctags")
+        print("\n3. Custom settings:")
+        print("   uv run smoldocling-ocr.py code-docs structured-output \\")
+        print("       --image-column page \\")
+        print("       --batch-size 64 \\")
+        print("       --gpu-memory-utilization 0.9")
+        print("\n4. Process a subset for testing:")
+        print("   uv run smoldocling-ocr.py large-dataset test-output --max-samples 10")
+        print("\n5. Random sample from ordered dataset:")
+        print(
+            "   uv run smoldocling-ocr.py ordered-dataset random-test --max-samples 50 --shuffle"
+        )
+        print("\n6. Running on HF Jobs:")
+        print("   hf jobs uv run --flavor l4x1 \\")
+        print(
+            '     -e HF_TOKEN=$(python3 -c "from huggingface_hub import get_token; print(get_token())") \\'
+        )
+        print(
+            "     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/smoldocling-ocr.py \\"
+        )
+        print("       your-document-dataset \\")
+        print("       your-structured-output")
+        print("\n" + "=" * 80)
+        print("\nFor full help, run: uv run smoldocling-ocr.py --help")
+        sys.exit(0)
+
+    parser = argparse.ArgumentParser(
+        description="Extract structured documents using SmolDocling",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Basic usage
+  uv run smoldocling-ocr.py my-images-dataset structured-output
+
+  # With DocTags format output
+  uv run smoldocling-ocr.py documents doc-analysis --output-format doctags
+
+  # Process subset for testing
+  uv run smoldocling-ocr.py large-dataset test-output --max-samples 100
+
+  # Random sample of 100 images
+  uv run smoldocling-ocr.py ordered-dataset random-sample --max-samples 100 --shuffle
+
+  # Custom output column name (default: smoldocling_text)
+  uv run smoldocling-ocr.py images texts --output-column extracted_content
+        """,
+    )
+
+    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=32,
+        help="Batch size for processing (default: 32)",
+    )
+    parser.add_argument(
+        "--model",
+        default="ds4sd/SmolDocling-256M-preview",
+        help="Model to use (default: ds4sd/SmolDocling-256M-preview)",
+    )
+    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=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(
+        "--output-column",
+        default=None,
+        help="Name of the output column for extracted text (default: auto-generated from model name)",
+    )
+    parser.add_argument(
+        "--output-format",
+        default="markdown",
+        choices=["markdown", "doctags"],
+        help="Output format: 'markdown' or 'doctags' (default: markdown)",
+    )
+    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(
+        "--prompt",
+        default="Convert page to Docling.",
+        help="Custom prompt for the model (default: 'Convert page to Docling.')",
+    )
+
+    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,
+        output_column=args.output_column,
+        output_format=args.output_format,
+        shuffle=args.shuffle,
+        seed=args.seed,
+        prompt=args.prompt,
+    )