Add RolmOCR script and enhance OCR scripts with new features

- Add rolm-ocr.py: Fast general-purpose OCR using reducto/RolmOCR
- Add inference_info tracking to all OCR scripts for multi-model comparison
- Add --shuffle and --seed flags for random sampling
- Add automatic dataset card generation with processing details
- Update README.md with new script documentation and feature descriptions
- Dynamic column naming for RolmOCR (e.g., rolmocr_text)

These enhancements support iterative model comparison workflows and better sampling strategies for OCR evaluation.

README.md

@@ -30,6 +30,16 @@ That's it! The script will:
 
 ## 📋 Available Scripts
 
+### 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:
@@ -50,6 +60,43 @@ Advanced document layout analysis and OCR using [rednote-hilab/dots.ocr](https:/
 - 🌍 **Multilingual support** - Handles multiple languages seamlessly
 - 🔧 **Flexible output** - JSON, structured columns, or markdown
 
+## 🆕 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)
@@ -115,6 +162,10 @@ uv run nanonets-ocr.py input-dataset output-dataset
 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
+
 # dots.ocr examples
 uv run dots-ocr.py documents analyzed-docs  # Full layout + OCR
 uv run dots-ocr.py scans layouts --mode layout-only  # Layout only
@@ -127,20 +178,29 @@ Any HuggingFace dataset containing images - documents, forms, receipts, books, h
 
 ## 🎛️ Configuration Options
 
-### Common Options (Both Scripts)
+### Common Options (All Scripts)
 
 | Option                     | Default | Description                   |
 | -------------------------- | ------- | ----------------------------- |
 | `--image-column`           | `image` | Column containing images      |
-| `--batch-size`             | `32`    | Images processed together     |
-| `--max-model-len`          | `8192`/`24000`* | Max context length     |
-| `--max-tokens`             | `4096`/`16384`* | Max output tokens      |
+| `--batch-size`             | `32`/`16`* | Images processed together     |
+| `--max-model-len`          | `8192`/`16384`**/`24000`*** | Max context length     |
+| `--max-tokens`             | `4096`/`8192`**/`16384`*** | 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 uses batch size 16
+**RolmOCR uses 16384/8192
+***dots.ocr uses 24000/16384
+
+### RolmOCR Specific
 
-*dots.ocr uses higher defaults (24000/16384)
+- Output column is auto-generated from model name (e.g., `rolmocr_text`)
+- Use `--output-column` to override the default name
 
 ### dots.ocr Specific Options
 

nanonets-ocr.py

@@ -28,6 +28,7 @@ Features:
 import argparse
 import base64
 import io
+import json
 import logging
 import os
 import sys
@@ -35,11 +36,12 @@ from typing import Any, Dict, List, Union
 
 import torch
 from datasets import load_dataset
-from huggingface_hub import login
+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__)
@@ -87,6 +89,115 @@ def make_ocr_message(
     ]
 
 
+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,
@@ -100,11 +211,16 @@ def main(
     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"
@@ -124,6 +240,11 @@ def main(
             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))))
@@ -178,10 +299,70 @@ def main(
     # 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(
@@ -212,7 +393,9 @@ if __name__ == "__main__":
         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. Running on HF Jobs:")
+        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=... \\")
@@ -238,6 +421,9 @@ Examples:
 
   # 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
         """,
     )
 
@@ -289,6 +475,17 @@ Examples:
     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()
 
@@ -305,4 +502,6 @@ Examples:
         split=args.split,
         max_samples=args.max_samples,
         private=args.private,
+        shuffle=args.shuffle,
+        seed=args.seed,
     )

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,
+    )