Add olmOCR2 script and usage instructions

README.md

@@ -124,6 +124,20 @@ Compact multilingual OCR using [rednote-hilab/dots.ocr](https://huggingface.co/r
 - 🎯 **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
 
@@ -243,6 +257,15 @@ hf jobs uv run \
     --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 \

olmocr2-vllm.py

@@ -0,0 +1,568 @@
+# /// 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
+
+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,
+) -> List[Dict]:
+    """Create chat message for olmOCR 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
+- 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",
+    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,
+    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
+        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 for deterministic)
+        gpu_memory_utilization: Fraction of GPU memory to use
+        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")
+
+    # Check if output column already exists with inference info
+    output_column_name = "markdown"
+    metadata_column_name = "olmocr_metadata"
+    inference_info_column = "inference_info"
+
+    # 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 low temperature for deterministic output
+    sampling_params = SamplingParams(
+        temperature=temperature,
+        max_tokens=max_tokens,
+        stop=["<|im_end|>", "<|endoftext|>"],
+    )
+
+    # 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 output in outputs:
+            response_text = output.outputs[0].text
+            metadata, content = parse_yaml_frontmatter(response_text)
+            all_outputs.append(content)
+            all_metadata.append(json.dumps(metadata))
+
+    # Add results to dataset
+    ds = ds.add_column(output_column_name, all_outputs)
+    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(
+        "--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 for deterministic output)",
+    )
+    parser.add_argument(
+        "--gpu-memory-utilization",
+        type=float,
+        default=0.8,
+        help="GPU memory utilization (default: 0.8)",
+    )
+    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,
+        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,
+        hf_token=args.hf_token,
+        split=args.split,
+        max_samples=args.max_samples,
+        private=args.private,
+        shuffle=args.shuffle,
+        seed=args.seed,
+    )