Datasets:

uv-scripts
/

ocr

Tags:

ocr / deepseek-ocr.py

Sync from GitHub via hub-sync

5bbe409 verified 4 months ago

21.9 kB

# /// script
# requires-python = ">=3.11"
# dependencies = [
#     "datasets>=4.0.0",
#     "huggingface-hub",
#     "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 ensure_output_columns_free(dataset, columns, overwrite=False):
    """Fail fast if an output column would collide with an existing input column.
    Adding a column that already exists silently overwrites it (e.g. a ground-truth
    `text`/`markdown` column) or crashes on push with a duplicate-column error only
    *after* inference has run. Catch it up front. With overwrite=True, drop the clashing
    column(s) here instead (logged) so the later add_column is clean.
    """
    clash = [c for c in columns if c in dataset.column_names]
    if not clash:
        return dataset
    if overwrite:
        logger.warning(f"--overwrite: replacing existing column(s) {clash}")
        return dataset.remove_columns(clash)
    logger.error(
        f"Output column(s) {clash} already exist in the input dataset "
        f"(columns: {dataset.column_names})."
    )
    logger.error("Choose a different --output-column, or pass --overwrite to replace them.")
    sys.exit(1)


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,
    output_column: str = "markdown",
    overwrite: bool = False,
):
    """Process images from HF dataset through DeepSeek-OCR model."""

    # Check CUDA availability first
    check_cuda_availability()

    # Track processing start time
    start_time = datetime.now()



    # 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}"
        )

    # Fail fast if the output column would collide with an existing input column
    dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)

    # 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 Exception:
            pass

    # Add output column to dataset
    logger.info(f"Adding '{output_column}' column to dataset")
    dataset = dataset.add_column(output_column, 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": output_column,
        "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)",
    )
    parser.add_argument(
        "--output-column",
        default="markdown",
        help="Column name for the OCR output text (default: markdown)",
    )
    parser.add_argument(
        "--overwrite",
        action="store_true",
        help="Replace the output column if it already exists in the input dataset "
        "(default: error out to avoid clobbering an existing column).",
    )

    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,
        output_column=args.output_column,
        overwrite=args.overwrite,
    )

	# /// script
	# requires-python = ">=3.11"
	# dependencies = [
	# "datasets>=4.0.0",
	# "huggingface-hub",
	# "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 ensure_output_columns_free(dataset, columns, overwrite=False):
	"""Fail fast if an output column would collide with an existing input column.

	Adding a column that already exists silently overwrites it (e.g. a ground-truth
	`text`/`markdown` column) or crashes on push with a duplicate-column error only
	after inference has run. Catch it up front. With overwrite=True, drop the clashing
	column(s) here instead (logged) so the later add_column is clean.
	"""
	clash = [c for c in columns if c in dataset.column_names]
	if not clash:
	return dataset
	if overwrite:
	logger.warning(f"--overwrite: replacing existing column(s) {clash}")
	return dataset.remove_columns(clash)
	logger.error(
	f"Output column(s) {clash} already exist in the input dataset "
	f"(columns: {dataset.column_names})."
	)
	logger.error("Choose a different --output-column, or pass --overwrite to replace them.")
	sys.exit(1)


	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,
	output_column: str = "markdown",
	overwrite: bool = False,
	):
	"""Process images from HF dataset through DeepSeek-OCR model."""

	# Check CUDA availability first
	check_cuda_availability()

	# Track processing start time
	start_time = datetime.now()



	# 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}"
	)

	# Fail fast if the output column would collide with an existing input column
	dataset = ensure_output_columns_free(dataset, [output_column], overwrite=overwrite)

	# 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 Exception:
	pass

	# Add output column to dataset
	logger.info(f"Adding '{output_column}' column to dataset")
	dataset = dataset.add_column(output_column, 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": output_column,
	"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)",
	)
	parser.add_argument(
	"--output-column",
	default="markdown",
	help="Column name for the OCR output text (default: markdown)",
	)
	parser.add_argument(
	"--overwrite",
	action="store_true",
	help="Replace the output column if it already exists in the input dataset "
	"(default: error out to avoid clobbering an existing column).",
	)

	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,
	output_column=args.output_column,
	overwrite=args.overwrite,
	)