Fix config_name=None breaking push_to_hub + use cu129 nightly index

- Replace config_name=config with conditional spread to avoid passing
None, which generates invalid YAML (config_name: null) that fails
Hub validation. Applied to all 10 scripts with --config flag.
- Switch vLLM nightly URL from /nightly to /nightly/cu129 in 6 scripts
to get x86_64 wheels (bare /nightly only has ARM wheels currently).
- Includes accumulated improvements: --verbose flag, --config/--create-pr
support, upload retry with XET fallback, inference_info fixes.
- Adds dots-ocr-1.5.py and hunyuan-ocr.py (new scripts).

Verified via HF Jobs smoke tests (7/9 config-flag scripts completed).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

deepseek-ocr-vllm.py

@@ -11,7 +11,7 @@
 # ]
 #
 # [[tool.uv.index]]
-# url = "https://wheels.vllm.ai/nightly"
+# url = "https://wheels.vllm.ai/nightly/cu129"
 #
 # [tool.uv]
 # prerelease = "allow"
@@ -215,6 +215,7 @@ def main(
     seed: int = 42,
     config: str = None,
     create_pr: bool = False,
+    verbose: bool = False,
 ):
     """Process images from HF dataset through DeepSeek-OCR model with vLLM."""
 
@@ -334,41 +335,40 @@ def main(
     # 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",
+    inference_entry = {
         "model_id": model,
-        "processing_date": datetime.now().isoformat(),
-        "prompt": final_prompt,
+        "model_name": "DeepSeek-OCR",
+        "column_name": "markdown",
+        "timestamp": datetime.now().isoformat(),
         "prompt_mode": prompt_mode if prompt is None else "custom",
         "batch_size": batch_size,
         "max_tokens": max_tokens,
         "gpu_memory_utilization": gpu_memory_utilization,
         "max_model_len": max_model_len,
         "script": "deepseek-ocr-vllm.py",
-        "script_version": "2.0.0",
         "script_url": "https://huggingface.co/datasets/uv-scripts/ocr/raw/main/deepseek-ocr-vllm.py",
-        "implementation": "vllm (batch processing, llm.generate + NGramPerReqLogitsProcessor)",
     }
-    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))
+    if "inference_info" in dataset.column_names:
+        logger.info("Updating existing inference_info column")
+
+        def update_inference_info(example):
+            try:
+                existing_info = (
+                    json.loads(example["inference_info"])
+                    if example["inference_info"]
+                    else []
+                )
+            except (json.JSONDecodeError, TypeError):
+                existing_info = []
+            existing_info.append(inference_entry)
+            return {"inference_info": json.dumps(existing_info)}
+
+        dataset = dataset.map(update_inference_info)
+    else:
+        logger.info("Creating new inference_info column")
+        inference_list = [json.dumps([inference_entry])] * len(dataset)
+        dataset = dataset.add_column("inference_info", inference_list)
 
     # Push to hub
     logger.info(f"Pushing to {output_dataset}")
@@ -376,7 +376,7 @@ def main(
         output_dataset,
         private=private,
         token=HF_TOKEN,
-        config_name=config,
+        **({"config_name": config} if config else {}),
         create_pr=create_pr,
         commit_message=f"Add {model} OCR results ({len(dataset)} samples)"
         + (f" [{config}]" if config else ""),
@@ -407,6 +407,17 @@ def main(
     )
     logger.info(f"Processing time: {processing_time_str}")
 
+    if verbose:
+        import importlib.metadata
+
+        logger.info("--- Resolved package versions ---")
+        for pkg in ["vllm", "transformers", "torch", "datasets", "pyarrow", "pillow"]:
+            try:
+                logger.info(f"  {pkg}=={importlib.metadata.version(pkg)}")
+            except importlib.metadata.PackageNotFoundError:
+                logger.info(f"  {pkg}: not installed")
+        logger.info("--- End versions ---")
+
 
 if __name__ == "__main__":
     # Show example usage if no arguments
@@ -560,6 +571,11 @@ Examples:
         default=42,
         help="Random seed for shuffling (default: 42)",
     )
+    parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Log resolved package versions after processing (useful for pinning deps)",
+    )
 
     args = parser.parse_args()
 
@@ -582,4 +598,5 @@ Examples:
         seed=args.seed,
         config=args.config,
         create_pr=args.create_pr,
+        verbose=args.verbose,
     )

deepseek-ocr2-vllm.py

@@ -13,7 +13,7 @@
 # ]
 #
 # [[tool.uv.index]]
-# url = "https://wheels.vllm.ai/nightly"
+# url = "https://wheels.vllm.ai/nightly/cu129"
 #
 # [tool.uv]
 # prerelease = "allow"
@@ -49,6 +49,7 @@ import json
 import logging
 import os
 import sys
+import time
 from datetime import datetime
 from typing import Any, Dict, Union
 
@@ -219,6 +220,10 @@ def main(
     private: bool = False,
     shuffle: bool = False,
     seed: int = 42,
+    output_column: str = "markdown",
+    config: str = None,
+    create_pr: bool = False,
+    verbose: bool = False,
 ):
     """Process images from HF dataset through DeepSeek-OCR-2 model with vLLM."""
 
@@ -332,52 +337,72 @@ def main(
     processing_duration = datetime.now() - start_time
     processing_time_str = f"{processing_duration.total_seconds() / 60:.1f} min"
 
-    # Add markdown column to dataset
-    logger.info("Adding markdown column to dataset")
-    dataset = dataset.add_column("markdown", all_markdown)
+    # Add output column to dataset
+    logger.info(f"Adding '{output_column}' column to dataset")
+    if output_column in dataset.column_names:
+        logger.warning(f"Column '{output_column}' already exists, replacing it")
+        dataset = dataset.remove_columns([output_column])
+    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:
-        # 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",
+    inference_entry = {
         "model_id": model,
-        "processing_date": datetime.now().isoformat(),
-        "prompt": final_prompt,
+        "model_name": "DeepSeek-OCR-2",
+        "column_name": output_column,
+        "timestamp": datetime.now().isoformat(),
         "prompt_mode": prompt_mode if prompt is None else "custom",
-        "batch_size": batch_size,
         "max_tokens": max_tokens,
-        "gpu_memory_utilization": gpu_memory_utilization,
-        "max_model_len": max_model_len,
-        "script": "deepseek-ocr2-vllm.py",
-        "script_version": "1.0.0",
-        "script_url": "https://huggingface.co/datasets/uv-scripts/ocr/raw/main/deepseek-ocr2-vllm.py",
-        "implementation": "vllm (batch processing, llm.generate + NGramPerReqLogitsProcessor)",
     }
-    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))
+    if "inference_info" in dataset.column_names:
+        logger.info("Updating existing inference_info column")
+
+        def update_inference_info(example):
+            try:
+                existing_info = (
+                    json.loads(example["inference_info"])
+                    if example["inference_info"]
+                    else []
+                )
+            except (json.JSONDecodeError, TypeError):
+                existing_info = []
+            existing_info.append(inference_entry)
+            return {"inference_info": json.dumps(existing_info)}
+
+        dataset = dataset.map(update_inference_info)
+    else:
+        logger.info("Creating new inference_info column")
+        inference_list = [json.dumps([inference_entry])] * len(dataset)
+        dataset = dataset.add_column("inference_info", inference_list)
 
-    # Push to hub
+    # Push to hub with retry and XET fallback
     logger.info(f"Pushing to {output_dataset}")
-    dataset.push_to_hub(output_dataset, private=private, token=HF_TOKEN)
+    max_retries = 3
+    for attempt in range(1, max_retries + 1):
+        try:
+            if attempt > 1:
+                logger.warning("Disabling XET (fallback to HTTP upload)")
+                os.environ["HF_HUB_DISABLE_XET"] = "1"
+            dataset.push_to_hub(
+                output_dataset,
+                private=private,
+                token=HF_TOKEN,
+                max_shard_size="500MB",
+                **({"config_name": config} if config else {}),
+                create_pr=create_pr,
+                commit_message=f"Add {model} OCR results ({len(dataset)} samples)"
+                + (f" [{config}]" if config else ""),
+            )
+            break
+        except Exception as e:
+            logger.error(f"Upload attempt {attempt}/{max_retries} failed: {e}")
+            if attempt < max_retries:
+                delay = 30 * (2 ** (attempt - 1))
+                logger.info(f"Retrying in {delay}s...")
+                time.sleep(delay)
+            else:
+                logger.error("All upload attempts failed. OCR results are lost.")
+                sys.exit(1)
 
     # Create and push dataset card
     logger.info("Creating dataset card...")
@@ -404,6 +429,17 @@ def main(
     )
     logger.info(f"Processing time: {processing_time_str}")
 
+    if verbose:
+        import importlib.metadata
+
+        logger.info("--- Resolved package versions ---")
+        for pkg in ["vllm", "transformers", "torch", "datasets", "pyarrow", "pillow"]:
+            try:
+                logger.info(f"  {pkg}=={importlib.metadata.version(pkg)}")
+            except importlib.metadata.PackageNotFoundError:
+                logger.info(f"  {pkg}: not installed")
+        logger.info("--- End versions ---")
+
 
 if __name__ == "__main__":
     # Show example usage if no arguments
@@ -529,6 +565,11 @@ Examples:
     parser.add_argument(
         "--private", action="store_true", help="Make output dataset private"
     )
+    parser.add_argument(
+        "--output-column",
+        default="markdown",
+        help="Column name for OCR output (default: markdown). Use a different name to add alongside existing OCR.",
+    )
     parser.add_argument(
         "--shuffle",
         action="store_true",
@@ -540,6 +581,20 @@ Examples:
         default=42,
         help="Random seed for shuffling (default: 42)",
     )
+    parser.add_argument(
+        "--config",
+        help="Config/subset name when pushing to Hub (for benchmarking multiple models in one repo)",
+    )
+    parser.add_argument(
+        "--create-pr",
+        action="store_true",
+        help="Create a pull request instead of pushing directly (for parallel benchmarking)",
+    )
+    parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Log resolved package versions after processing (useful for pinning deps)",
+    )
 
     args = parser.parse_args()
 
@@ -560,4 +615,8 @@ Examples:
         private=args.private,
         shuffle=args.shuffle,
         seed=args.seed,
+        output_column=args.output_column,
+        config=args.config,
+        create_pr=args.create_pr,
+        verbose=args.verbose,
     )

dots-ocr-1.5.py

@@ -0,0 +1,667 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#     "datasets",
+#     "huggingface-hub",
+#     "pillow",
+#     "vllm>=0.9.1",
+#     "tqdm",
+#     "toolz",
+#     "torch",
+# ]
+#
+# ///
+
+"""
+Convert document images to markdown using DoTS.ocr-1.5 with vLLM.
+
+DoTS.ocr-1.5 is a 3B multilingual document parsing model with SOTA performance
+on 100+ languages. Compared to v1 (1.7B), it adds web screen parsing, scene text
+spotting, SVG code generation, and stronger multilingual document parsing.
+
+Features:
+- Multilingual support (100+ languages)
+- Table extraction and formatting
+- Formula recognition
+- Layout-aware text extraction
+- Web screen parsing (NEW in v1.5)
+- Scene text spotting (NEW in v1.5)
+- SVG code generation (requires dots.ocr-1.5-svg variant)
+
+Model: rednote-hilab/dots.ocr-1.5
+vLLM: Officially supported (same DotsOCRForCausalLM architecture as v1)
+"""
+
+import argparse
+import base64
+import io
+import json
+import logging
+import os
+import sys
+import time
+from datetime import datetime
+from typing import Any, Dict, List, Union
+
+import torch
+from datasets import load_dataset
+from huggingface_hub import DatasetCard, login
+from PIL import Image
+from toolz import partition_all
+from tqdm.auto import tqdm
+from vllm import LLM, SamplingParams
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+# ────────────────────────────────────────────────────────────────
+# DoTS OCR 1.5 Prompt Templates (from official dots.ocr repo)
+# Source: https://github.com/rednote-hilab/dots.ocr/blob/master/dots_ocr/utils/prompts.py
+# ────────────────────────────────────────────────────────────────
+
+PROMPT_TEMPLATES = {
+    "ocr": """Extract the text content from this image.""",
+    "layout-all": """Please output the layout information from the PDF image, including each layout element's bbox, its category, and the corresponding text content within the bbox.
+
+1. Bbox format: [x1, y1, x2, y2]
+
+2. Layout Categories: The possible categories are ['Caption', 'Footnote', 'Formula', 'List-item', 'Page-footer', 'Page-header', 'Picture', 'Section-header', 'Table', 'Text', 'Title'].
+
+3. Text Extraction & Formatting Rules:
+    - Picture: For the 'Picture' category, the text field should be omitted.
+    - Formula: Format its text as LaTeX.
+    - Table: Format its text as HTML.
+    - All Others (Text, Title, etc.): Format their text as Markdown.
+
+4. Constraints:
+    - The output text must be the original text from the image, with no translation.
+    - All layout elements must be sorted according to human reading order.
+
+5. Final Output: The entire output must be a single JSON object.
+""",
+    "layout-only": """Please output the layout information from this PDF image, including each layout's bbox and its category. The bbox should be in the format [x1, y1, x2, y2]. The layout categories for the PDF document include ['Caption', 'Footnote', 'Formula', 'List-item', 'Page-footer', 'Page-header', 'Picture', 'Section-header', 'Table', 'Text', 'Title']. Do not output the corresponding text. The layout result should be in JSON format.""",
+    # NEW in v1.5:
+    "web-parsing": """Parsing the layout info of this webpage image with format json:\n""",
+    "scene-spotting": """Detect and recognize the text in the image.""",
+    "grounding-ocr": """Extract text from the given bounding box on the image (format: [x1, y1, x2, y2]).\nBounding Box:\n""",
+    "general": """ """,
+}
+
+
+def check_cuda_availability():
+    """Check if CUDA is available and exit if not."""
+    if not torch.cuda.is_available():
+        logger.error("CUDA is not available. This script requires a GPU.")
+        logger.error("Please run on a machine with a CUDA-capable GPU.")
+        sys.exit(1)
+    else:
+        logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
+
+
+def make_ocr_message(
+    image: Union[Image.Image, Dict[str, Any], str],
+    prompt: str = PROMPT_TEMPLATES["ocr"],
+) -> List[Dict]:
+    """Create chat message for OCR processing."""
+    # Convert to PIL Image if needed
+    if isinstance(image, Image.Image):
+        pil_img = image
+    elif isinstance(image, dict) and "bytes" in image:
+        pil_img = Image.open(io.BytesIO(image["bytes"]))
+    elif isinstance(image, str):
+        pil_img = Image.open(image)
+    else:
+        raise ValueError(f"Unsupported image type: {type(image)}")
+
+    # Convert to RGB
+    pil_img = pil_img.convert("RGB")
+
+    # Convert to base64 data URI
+    buf = io.BytesIO()
+    pil_img.save(buf, format="PNG")
+    data_uri = f"data:image/png;base64,{base64.b64encode(buf.getvalue()).decode()}"
+
+    # Return message in vLLM format
+    return [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image_url", "image_url": {"url": data_uri}},
+                {"type": "text", "text": prompt},
+            ],
+        }
+    ]
+
+
+def create_dataset_card(
+    source_dataset: str,
+    model: str,
+    num_samples: int,
+    processing_time: str,
+    batch_size: int,
+    max_model_len: int,
+    max_tokens: int,
+    gpu_memory_utilization: float,
+    image_column: str = "image",
+    split: str = "train",
+    prompt_mode: str = "ocr",
+) -> str:
+    """Create a dataset card documenting the OCR process."""
+    model_name = model.split("/")[-1]
+
+    return f"""---
+tags:
+- ocr
+- document-processing
+- dots-ocr-1.5
+- multilingual
+- markdown
+- uv-script
+- generated
+---
+
+# Document OCR using {model_name}
+
+This dataset contains OCR results from images in [{source_dataset}](https://huggingface.co/datasets/{source_dataset}) using DoTS.ocr-1.5, a 3B multilingual model with SOTA document parsing.
+
+## Processing Details
+
+- **Source Dataset**: [{source_dataset}](https://huggingface.co/datasets/{source_dataset})
+- **Model**: [{model}](https://huggingface.co/{model})
+- **Number of Samples**: {num_samples:,}
+- **Processing Time**: {processing_time}
+- **Processing Date**: {datetime.now().strftime("%Y-%m-%d %H:%M UTC")}
+
+### Configuration
+
+- **Image Column**: `{image_column}`
+- **Output Column**: `markdown`
+- **Dataset Split**: `{split}`
+- **Batch Size**: {batch_size}
+- **Prompt Mode**: {prompt_mode}
+- **Max Model Length**: {max_model_len:,} tokens
+- **Max Output Tokens**: {max_tokens:,}
+- **GPU Memory Utilization**: {gpu_memory_utilization:.1%}
+
+## Model Information
+
+DoTS.ocr-1.5 is a 3B multilingual document parsing model that excels at:
+- 100+ Languages — Multilingual document support
+- Table extraction — Structured data recognition
+- Formulas — Mathematical notation preservation
+- Layout-aware — Reading order and structure preservation
+- Web screen parsing — Webpage layout analysis
+- Scene text spotting — Text detection in natural scenes
+
+## Dataset Structure
+
+The dataset contains all original columns plus:
+- `markdown`: The extracted text in markdown format
+- `inference_info`: JSON list tracking all OCR models applied to this dataset
+
+## Usage
+
+```python
+from datasets import load_dataset
+import json
+
+# Load the dataset
+dataset = load_dataset("{{output_dataset_id}}", split="{split}")
+
+# Access the markdown text
+for example in dataset:
+    print(example["markdown"])
+    break
+
+# View all OCR models applied to this dataset
+inference_info = json.loads(dataset[0]["inference_info"])
+for info in inference_info:
+    print(f"Column: {{info['column_name']}} - Model: {{info['model_id']}}")
+```
+
+## Reproduction
+
+This dataset was generated using the [uv-scripts/ocr](https://huggingface.co/datasets/uv-scripts/ocr) DoTS OCR 1.5 script:
+
+```bash
+uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/dots-ocr-1.5.py \\
+    {source_dataset} \\
+    <output-dataset> \\
+    --image-column {image_column} \\
+    --batch-size {batch_size} \\
+    --prompt-mode {prompt_mode} \\
+    --max-model-len {max_model_len} \\
+    --max-tokens {max_tokens} \\
+    --gpu-memory-utilization {gpu_memory_utilization}
+```
+
+Generated with [UV Scripts](https://huggingface.co/uv-scripts)
+"""
+
+
+def main(
+    input_dataset: str,
+    output_dataset: str,
+    image_column: str = "image",
+    batch_size: int = 16,
+    model: str = "rednote-hilab/dots.ocr-1.5",
+    max_model_len: int = 24000,
+    max_tokens: int = 24000,
+    gpu_memory_utilization: float = 0.9,
+    hf_token: str = None,
+    split: str = "train",
+    max_samples: int = None,
+    private: bool = False,
+    shuffle: bool = False,
+    seed: int = 42,
+    prompt_mode: str = "ocr",
+    custom_prompt: str = None,
+    output_column: str = "markdown",
+    config: str = None,
+    create_pr: bool = False,
+    temperature: float = 0.1,
+    top_p: float = 0.9,
+    verbose: bool = False,
+):
+    """Process images from HF dataset through DoTS.ocr-1.5 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 prompt to use
+    if custom_prompt:
+        prompt = custom_prompt
+        logger.info(f"Using custom prompt: {prompt[:50]}...")
+    else:
+        prompt = PROMPT_TEMPLATES.get(prompt_mode, PROMPT_TEMPLATES["ocr"])
+        logger.info(f"Using prompt mode: {prompt_mode}")
+
+    # Load dataset
+    logger.info(f"Loading dataset: {input_dataset}")
+    dataset = load_dataset(input_dataset, split=split)
+
+    # Validate image column
+    if image_column not in dataset.column_names:
+        raise ValueError(
+            f"Column '{image_column}' not found. Available: {dataset.column_names}"
+        )
+
+    # Shuffle if requested
+    if shuffle:
+        logger.info(f"Shuffling dataset with seed {seed}")
+        dataset = dataset.shuffle(seed=seed)
+
+    # Limit samples if requested
+    if max_samples:
+        dataset = dataset.select(range(min(max_samples, len(dataset))))
+        logger.info(f"Limited to {len(dataset)} samples")
+
+    # Initialize vLLM model
+    logger.info(f"Initializing vLLM with model: {model}")
+    logger.info("This may take a few minutes on first run...")
+    llm = LLM(
+        model=model,
+        trust_remote_code=True,
+        max_model_len=max_model_len,
+        gpu_memory_utilization=gpu_memory_utilization,
+    )
+
+    sampling_params = SamplingParams(
+        temperature=temperature,
+        top_p=top_p,
+        max_tokens=max_tokens,
+    )
+
+    logger.info(f"Processing {len(dataset)} images in batches of {batch_size}")
+    logger.info(f"Output will be written to column: {output_column}")
+
+    # Process images in batches
+    all_outputs = []
+
+    for batch_indices in tqdm(
+        partition_all(batch_size, range(len(dataset))),
+        total=(len(dataset) + batch_size - 1) // batch_size,
+        desc="DoTS.ocr-1.5 processing",
+    ):
+        batch_indices = list(batch_indices)
+        batch_images = [dataset[i][image_column] for i in batch_indices]
+
+        try:
+            # Create messages for batch
+            batch_messages = [make_ocr_message(img, prompt) for img in batch_images]
+
+            # Process with vLLM
+            outputs = llm.chat(batch_messages, sampling_params)
+
+            # Extract outputs
+            for output in outputs:
+                text = output.outputs[0].text.strip()
+                all_outputs.append(text)
+
+        except Exception as e:
+            logger.error(f"Error processing batch: {e}")
+            # Add error placeholders for failed batch
+            all_outputs.extend(["[OCR ERROR]"] * len(batch_images))
+
+    # Calculate processing time
+    processing_duration = datetime.now() - start_time
+    processing_time_str = f"{processing_duration.total_seconds() / 60:.1f} min"
+
+    # Add output column to dataset
+    logger.info(f"Adding '{output_column}' column to dataset")
+    dataset = dataset.add_column(output_column, all_outputs)
+
+    # Handle inference_info tracking (for multi-model comparisons)
+    inference_entry = {
+        "model_id": model,
+        "model_name": "DoTS.ocr-1.5",
+        "column_name": output_column,
+        "timestamp": datetime.now().isoformat(),
+        "prompt_mode": prompt_mode if not custom_prompt else "custom",
+        "temperature": temperature,
+        "top_p": top_p,
+        "max_tokens": max_tokens,
+    }
+
+    if "inference_info" in dataset.column_names:
+        # Append to existing inference info
+        logger.info("Updating existing inference_info column")
+
+        def update_inference_info(example):
+            try:
+                existing_info = (
+                    json.loads(example["inference_info"])
+                    if example["inference_info"]
+                    else []
+                )
+            except (json.JSONDecodeError, TypeError):
+                existing_info = []
+
+            existing_info.append(inference_entry)
+            return {"inference_info": json.dumps(existing_info)}
+
+        dataset = dataset.map(update_inference_info)
+    else:
+        # Create new inference_info column
+        logger.info("Creating new inference_info column")
+        inference_list = [json.dumps([inference_entry])] * len(dataset)
+        dataset = dataset.add_column("inference_info", inference_list)
+
+    # Push to hub with retry and XET fallback
+    logger.info(f"Pushing to {output_dataset}")
+    max_retries = 3
+    for attempt in range(1, max_retries + 1):
+        try:
+            if attempt > 1:
+                logger.warning("Disabling XET (fallback to HTTP upload)")
+                os.environ["HF_HUB_DISABLE_XET"] = "1"
+            dataset.push_to_hub(
+                output_dataset,
+                private=private,
+                token=HF_TOKEN,
+                max_shard_size="500MB",
+                **({"config_name": config} if config else {}),
+                create_pr=create_pr,
+                commit_message=f"Add {model} OCR results ({len(dataset)} samples)"
+                + (f" [{config}]" if config else ""),
+            )
+            break
+        except Exception as e:
+            logger.error(f"Upload attempt {attempt}/{max_retries} failed: {e}")
+            if attempt < max_retries:
+                delay = 30 * (2 ** (attempt - 1))
+                logger.info(f"Retrying in {delay}s...")
+                time.sleep(delay)
+            else:
+                logger.error("All upload attempts failed. OCR results are lost.")
+                sys.exit(1)
+
+    # Create and push dataset card
+    logger.info("Creating dataset card")
+    card_content = create_dataset_card(
+        source_dataset=input_dataset,
+        model=model,
+        num_samples=len(dataset),
+        processing_time=processing_time_str,
+        batch_size=batch_size,
+        max_model_len=max_model_len,
+        max_tokens=max_tokens,
+        gpu_memory_utilization=gpu_memory_utilization,
+        image_column=image_column,
+        split=split,
+        prompt_mode=prompt_mode if not custom_prompt else "custom",
+    )
+
+    card = DatasetCard(card_content)
+    card.push_to_hub(output_dataset, token=HF_TOKEN)
+
+    logger.info("DoTS.ocr-1.5 processing complete!")
+    logger.info(
+        f"Dataset available at: https://huggingface.co/datasets/{output_dataset}"
+    )
+    logger.info(f"Processing time: {processing_time_str}")
+
+    if verbose:
+        import importlib.metadata
+
+        logger.info("--- Resolved package versions ---")
+        for pkg in ["vllm", "transformers", "torch", "datasets", "pyarrow", "pillow"]:
+            try:
+                logger.info(f"  {pkg}=={importlib.metadata.version(pkg)}")
+            except importlib.metadata.PackageNotFoundError:
+                logger.info(f"  {pkg}: not installed")
+        logger.info("--- End versions ---")
+
+
+if __name__ == "__main__":
+    # Show example usage if no arguments
+    if len(sys.argv) == 1:
+        print("=" * 80)
+        print("DoTS.ocr-1.5 Document Processing")
+        print("=" * 80)
+        print("\n3B multilingual OCR model supporting 100+ languages")
+        print("\nFeatures:")
+        print("- Multilingual support (100+ languages)")
+        print("- Fast processing with vLLM")
+        print("- Table extraction and formatting")
+        print("- Formula recognition")
+        print("- Layout-aware text extraction")
+        print("- Web screen parsing (NEW in v1.5)")
+        print("- Scene text spotting (NEW in v1.5)")
+        print("\nPrompt modes:")
+        print("  ocr           - Text extraction (default)")
+        print("  layout-all    - Layout + bboxes + text (JSON)")
+        print("  layout-only   - Layout + bboxes only (JSON)")
+        print("  web-parsing   - Webpage layout analysis (JSON)")
+        print("  scene-spotting - Scene text detection")
+        print("  grounding-ocr - Text from bounding box region")
+        print("  general       - Free-form (use with --custom-prompt)")
+        print("\nExample usage:")
+        print("\n1. Basic OCR:")
+        print("   uv run dots-ocr-1.5.py input-dataset output-dataset")
+        print("\n2. Web screen parsing:")
+        print("   uv run dots-ocr-1.5.py screenshots parsed --prompt-mode web-parsing")
+        print("\n3. Scene text spotting:")
+        print("   uv run dots-ocr-1.5.py photos detected --prompt-mode scene-spotting")
+        print("\n4. Layout analysis with structure:")
+        print("   uv run dots-ocr-1.5.py papers analyzed --prompt-mode layout-all")
+        print("\n5. Running on HF Jobs:")
+        print("   hf jobs uv run --flavor l4x1 \\")
+        print("     -s HF_TOKEN \\")
+        print(
+            "     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/dots-ocr-1.5.py \\"
+        )
+        print("       input-dataset output-dataset")
+        print("\n" + "=" * 80)
+        print("\nFor full help, run: uv run dots-ocr-1.5.py --help")
+        sys.exit(0)
+
+    parser = argparse.ArgumentParser(
+        description="Document OCR using DoTS.ocr-1.5 (3B multilingual model)",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Prompt Modes (official DoTS.ocr-1.5 prompts):
+  ocr            - Simple text extraction (default)
+  layout-all     - Layout analysis with bboxes, categories, and text (JSON output)
+  layout-only    - Layout detection with bboxes and categories only (JSON output)
+  web-parsing    - Webpage layout analysis (JSON output) [NEW in v1.5]
+  scene-spotting - Scene text detection and recognition [NEW in v1.5]
+  grounding-ocr  - Extract text from bounding box region [NEW in v1.5]
+  general        - Free-form QA (use with --custom-prompt) [NEW in v1.5]
+
+SVG Code Generation:
+  For SVG output, use --model rednote-hilab/dots.ocr-1.5-svg with:
+  --custom-prompt 'Please generate the SVG code based on the image.'
+
+Examples:
+  # Basic text OCR (default)
+  uv run dots-ocr-1.5.py my-docs analyzed-docs
+
+  # Web screen parsing
+  uv run dots-ocr-1.5.py screenshots parsed --prompt-mode web-parsing
+
+  # Scene text spotting
+  uv run dots-ocr-1.5.py photos spotted --prompt-mode scene-spotting
+
+  # Full layout analysis with structure
+  uv run dots-ocr-1.5.py papers structured --prompt-mode layout-all
+
+  # Random sampling for testing
+  uv run dots-ocr-1.5.py large-dataset test --max-samples 50 --shuffle
+        """,
+    )
+
+    parser.add_argument("input_dataset", help="Input dataset ID from Hugging Face Hub")
+    parser.add_argument("output_dataset", help="Output dataset ID for Hugging Face Hub")
+    parser.add_argument(
+        "--image-column",
+        default="image",
+        help="Column containing images (default: image)",
+    )
+    parser.add_argument(
+        "--batch-size",
+        type=int,
+        default=16,
+        help="Batch size for processing (default: 16)",
+    )
+    parser.add_argument(
+        "--model",
+        default="rednote-hilab/dots.ocr-1.5",
+        help="Model to use (default: rednote-hilab/dots.ocr-1.5)",
+    )
+    parser.add_argument(
+        "--max-model-len",
+        type=int,
+        default=24000,
+        help="Maximum model context length (default: 24000)",
+    )
+    parser.add_argument(
+        "--max-tokens",
+        type=int,
+        default=24000,
+        help="Maximum tokens to generate (default: 24000)",
+    )
+    parser.add_argument(
+        "--gpu-memory-utilization",
+        type=float,
+        default=0.9,
+        help="GPU memory utilization (default: 0.9)",
+    )
+    parser.add_argument("--hf-token", help="Hugging Face API token")
+    parser.add_argument(
+        "--split", default="train", help="Dataset split to use (default: train)"
+    )
+    parser.add_argument(
+        "--max-samples",
+        type=int,
+        help="Maximum number of samples to process (for testing)",
+    )
+    parser.add_argument(
+        "--private", action="store_true", help="Make output dataset private"
+    )
+    parser.add_argument(
+        "--shuffle", action="store_true", help="Shuffle dataset before processing"
+    )
+    parser.add_argument(
+        "--seed",
+        type=int,
+        default=42,
+        help="Random seed for shuffling (default: 42)",
+    )
+    parser.add_argument(
+        "--prompt-mode",
+        choices=list(PROMPT_TEMPLATES.keys()),
+        default="ocr",
+        help=f"Prompt template to use: {', '.join(PROMPT_TEMPLATES.keys())} (default: ocr)",
+    )
+    parser.add_argument(
+        "--custom-prompt",
+        help="Custom prompt text (overrides --prompt-mode)",
+    )
+    parser.add_argument(
+        "--output-column",
+        default="markdown",
+        help="Column name for output text (default: markdown)",
+    )
+    parser.add_argument(
+        "--config",
+        help="Config/subset name when pushing to Hub (for benchmarking multiple models in one repo)",
+    )
+    parser.add_argument(
+        "--create-pr",
+        action="store_true",
+        help="Create a pull request instead of pushing directly (for parallel benchmarking)",
+    )
+    parser.add_argument(
+        "--temperature",
+        type=float,
+        default=0.1,
+        help="Sampling temperature (default: 0.1, per official recommendation)",
+    )
+    parser.add_argument(
+        "--top-p",
+        type=float,
+        default=0.9,
+        help="Top-p sampling (default: 0.9, per official recommendation)",
+    )
+    parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Log resolved package versions after processing (useful for pinning deps)",
+    )
+
+    args = parser.parse_args()
+
+    main(
+        input_dataset=args.input_dataset,
+        output_dataset=args.output_dataset,
+        image_column=args.image_column,
+        batch_size=args.batch_size,
+        model=args.model,
+        max_model_len=args.max_model_len,
+        max_tokens=args.max_tokens,
+        gpu_memory_utilization=args.gpu_memory_utilization,
+        hf_token=args.hf_token,
+        split=args.split,
+        max_samples=args.max_samples,
+        private=args.private,
+        shuffle=args.shuffle,
+        seed=args.seed,
+        prompt_mode=args.prompt_mode,
+        custom_prompt=args.custom_prompt,
+        output_column=args.output_column,
+        config=args.config,
+        create_pr=args.create_pr,
+        temperature=args.temperature,
+        top_p=args.top_p,
+        verbose=args.verbose,
+    )

dots-ocr.py

@@ -383,7 +383,7 @@ def main(
         output_dataset,
         private=private,
         token=HF_TOKEN,
-        config_name=config,
+        **({"config_name": config} if config else {}),
         create_pr=create_pr,
         commit_message=f"Add {model} OCR results ({len(dataset)} samples)"
         + (f" [{config}]" if config else ""),

glm-ocr.py

@@ -383,7 +383,7 @@ def main(
                 private=private,
                 token=HF_TOKEN,
                 max_shard_size="500MB",
-                config_name=config,
+                **({"config_name": config} if config else {}),
                 create_pr=create_pr,
                 commit_message=f"Add {MODEL} OCR results ({len(dataset)} samples)"
                 + (f" [{config}]" if config else ""),

hunyuan-ocr.py

@@ -0,0 +1,845 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#     "datasets",
+#     "huggingface-hub",
+#     "pillow",
+#     "vllm",
+#     "tqdm",
+#     "toolz",
+#     "torch",
+# ]
+#
+# [[tool.uv.index]]
+# url = "https://wheels.vllm.ai/nightly/cu129"
+#
+# [tool.uv]
+# prerelease = "allow"
+# ///
+
+"""
+Convert document images to markdown using HunyuanOCR with vLLM.
+
+HunyuanOCR is a lightweight 1B parameter VLM from Tencent designed for complex
+multilingual document parsing. This script uses vLLM for processing.
+
+Features:
+- 📝 Full document parsing to markdown
+- 📊 Table extraction (HTML format)
+- 📐 Formula recognition (LaTeX format)
+- 📍 Text spotting with coordinates
+- 🔍 Information extraction (key-value, fields, subtitles)
+- 🌐 Photo translation
+- 🎯 Compact model (1B parameters)
+
+Model: tencent/HunyuanOCR
+vLLM: Requires nightly build (trust_remote_code=True)
+
+Note: Due to vLLM V1 engine batching issues with HunyuanOCR, batch_size defaults to 1.
+"""
+
+import argparse
+import base64
+import io
+import json
+import logging
+import os
+import sys
+import time
+from datetime import datetime
+from typing import Any, Dict, List, Union
+
+import torch
+from datasets import load_dataset
+from huggingface_hub import DatasetCard, login
+from PIL import Image
+from toolz import partition_all
+from tqdm.auto import tqdm
+from vllm import LLM, SamplingParams
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+# ────────────────────────────────────────────────────────────────
+# HunyuanOCR Prompt Templates (from official README)
+# Source: https://huggingface.co/tencent/HunyuanOCR
+# ────────────────────────────────────────────────────────────────
+
+PROMPT_TEMPLATES = {
+    # Parsing prompts
+    "parse-document": {
+        "en": "Extract all information from the main body of the document image and represent it in markdown format, ignoring headers and footers. Tables should be expressed in HTML format, formulas in the document should be represented using LaTeX format, and the parsing should be organized according to the reading order.",
+        "cn": "提取文档图片中正文的所有信息用 markdown 格式表示，其中页眉、页脚部分忽略，表格用 html 格式表达，文档中公式用 latex 格式表示，按照阅读顺序组织进行解析。",
+    },
+    "parse-formula": {
+        "en": "Identify the formula in the image and represent it using LaTeX format.",
+        "cn": "识别图片中的公式，用 LaTeX 格式表示。",
+    },
+    "parse-table": {
+        "en": "Parse the table in the image into HTML.",
+        "cn": "把图中的表格解析为 HTML。",
+    },
+    "parse-chart": {
+        "en": "Parse the chart in the image; use Mermaid format for flowcharts and Markdown for other charts.",
+        "cn": "解析图中的图表，对于流程图使用 Mermaid 格式表示，其他图表使用 Markdown 格式表示。",
+    },
+    # Spotting prompt
+    "spot": {
+        "en": "Detect and recognize text in the image, and output the text coordinates in a formatted manner.",
+        "cn": "检测并识别图片中的文字，将文本坐标格式化输出。",
+    },
+    # Extraction prompts
+    "extract-subtitles": {
+        "en": "Extract the subtitles from the image.",
+        "cn": "提取图片中的字幕。",
+    },
+    # Translation prompt (requires target_language substitution)
+    "translate": {
+        "en": "First extract the text, then translate the text content into {target_language}. If it is a document, ignore the header and footer. Formulas should be represented in LaTeX format, and tables should be represented in HTML format.",
+        "cn": "先提取文字，再将文字内容翻译为{target_language}。若是文档，则其中页眉、页脚忽略。公式用latex格式表示，表格用html格式表示。",
+    },
+}
+
+# Templates that require dynamic substitution
+EXTRACT_KEY_TEMPLATE = {
+    "en": "Output the value of {key}.",
+    "cn": "输出 {key} 的值。",
+}
+
+EXTRACT_FIELDS_TEMPLATE = {
+    "en": "Extract the content of the fields: {fields} from the image and return it in JSON format.",
+    "cn": "提取图片中的: {fields} 的字段内容，并按照 JSON 格式返回。",
+}
+
+
+def clean_repeated_substrings(text: str, threshold: int = 10) -> str:
+    """
+    Remove repeated substrings from long outputs.
+
+    HunyuanOCR can sometimes produce repeated patterns in very long outputs.
+    This utility detects and removes substrings that repeat more than threshold times.
+
+    From: https://huggingface.co/tencent/HunyuanOCR
+    """
+    if len(text) <= 8000:
+        return text
+
+    # Check the last portion of the text for repetition
+    check_portion = text[-4000:]
+
+    # Find repeated patterns of various lengths
+    for pattern_len in range(10, 200):
+        pattern = check_portion[-pattern_len:]
+        count = check_portion.count(pattern)
+
+        if count >= threshold:
+            # Find where the repetition starts and truncate
+            first_occurrence = text.find(pattern)
+            if first_occurrence != -1:
+                return text[: first_occurrence + len(pattern)]
+
+    return text
+
+
+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 get_prompt(
+    prompt_mode: str,
+    use_chinese: bool = False,
+    target_language: str = None,
+    key: str = None,
+    fields: List[str] = None,
+) -> str:
+    """Get the appropriate prompt for the given mode."""
+    lang = "cn" if use_chinese else "en"
+
+    if prompt_mode == "extract-key":
+        if not key:
+            raise ValueError("--key is required for extract-key mode")
+        template = EXTRACT_KEY_TEMPLATE[lang]
+        return template.format(key=key)
+
+    if prompt_mode == "extract-fields":
+        if not fields:
+            raise ValueError("--fields is required for extract-fields mode")
+        template = EXTRACT_FIELDS_TEMPLATE[lang]
+        fields_str = str(fields)
+        return template.format(fields=fields_str)
+
+    if prompt_mode == "translate":
+        if not target_language:
+            raise ValueError("--target-language is required for translate mode")
+        template = PROMPT_TEMPLATES["translate"][lang]
+        return template.format(target_language=target_language)
+
+    if prompt_mode not in PROMPT_TEMPLATES:
+        raise ValueError(
+            f"Unknown prompt mode: {prompt_mode}. "
+            f"Available: {list(PROMPT_TEMPLATES.keys()) + ['extract-key', 'extract-fields']}"
+        )
+
+    return PROMPT_TEMPLATES[prompt_mode][lang]
+
+
+def make_ocr_message(
+    image: Union[Image.Image, Dict[str, Any], str],
+    prompt: str,
+) -> List[Dict]:
+    """Create chat message for OCR processing."""
+    # Convert to PIL Image if needed
+    if isinstance(image, Image.Image):
+        pil_img = image
+    elif isinstance(image, dict) and "bytes" in image:
+        pil_img = Image.open(io.BytesIO(image["bytes"]))
+    elif isinstance(image, str):
+        pil_img = Image.open(image)
+    else:
+        raise ValueError(f"Unsupported image type: {type(image)}")
+
+    # Convert to RGB
+    pil_img = pil_img.convert("RGB")
+
+    # Convert to base64 data URI
+    buf = io.BytesIO()
+    pil_img.save(buf, format="PNG")
+    data_uri = f"data:image/png;base64,{base64.b64encode(buf.getvalue()).decode()}"
+
+    # HunyuanOCR format: image before text
+    return [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image_url", "image_url": {"url": data_uri}},
+                {"type": "text", "text": prompt},
+            ],
+        }
+    ]
+
+
+def create_dataset_card(
+    source_dataset: str,
+    model: str,
+    num_samples: int,
+    processing_time: str,
+    batch_size: int,
+    max_model_len: int,
+    max_tokens: int,
+    gpu_memory_utilization: float,
+    image_column: str = "image",
+    split: str = "train",
+    prompt_mode: str = "parse-document",
+    use_chinese: bool = False,
+) -> str:
+    """Create a dataset card documenting the OCR process."""
+    model_name = model.split("/")[-1]
+
+    return f"""---
+tags:
+- ocr
+- document-processing
+- hunyuan-ocr
+- multilingual
+- markdown
+- uv-script
+- generated
+---
+
+# Document OCR using {model_name}
+
+This dataset contains OCR results from images in [{source_dataset}](https://huggingface.co/datasets/{source_dataset}) using HunyuanOCR, a lightweight 1B VLM from Tencent.
+
+## Processing Details
+
+- **Source Dataset**: [{source_dataset}](https://huggingface.co/datasets/{source_dataset})
+- **Model**: [{model}](https://huggingface.co/{model})
+- **Number of Samples**: {num_samples:,}
+- **Processing Time**: {processing_time}
+- **Processing Date**: {datetime.now().strftime("%Y-%m-%d %H:%M UTC")}
+
+### Configuration
+
+- **Image Column**: `{image_column}`
+- **Output Column**: `markdown`
+- **Dataset Split**: `{split}`
+- **Batch Size**: {batch_size}
+- **Prompt Mode**: {prompt_mode}
+- **Prompt Language**: {"Chinese" if use_chinese else "English"}
+- **Max Model Length**: {max_model_len:,} tokens
+- **Max Output Tokens**: {max_tokens:,}
+- **GPU Memory Utilization**: {gpu_memory_utilization:.1%}
+
+## Model Information
+
+HunyuanOCR is a lightweight 1B VLM that excels at:
+- 📝 **Document Parsing** - Full markdown extraction with reading order
+- 📊 **Table Extraction** - HTML format tables
+- 📐 **Formula Recognition** - LaTeX format formulas
+- 📈 **Chart Parsing** - Mermaid/Markdown format
+- 📍 **Text Spotting** - Detection with coordinates
+- 🔍 **Information Extraction** - Key-value, fields, subtitles
+- 🌐 **Translation** - Multilingual photo translation
+
+## Prompt Modes Available
+
+- `parse-document` - Full document parsing (default)
+- `parse-formula` - LaTeX formula extraction
+- `parse-table` - HTML table extraction
+- `parse-chart` - Chart/flowchart parsing
+- `spot` - Text detection with coordinates
+- `extract-key` - Extract specific key value
+- `extract-fields` - Extract multiple fields as JSON
+- `extract-subtitles` - Subtitle extraction
+- `translate` - Document translation
+
+## Dataset Structure
+
+The dataset contains all original columns plus:
+- `markdown`: The extracted text in markdown format
+- `inference_info`: JSON list tracking all OCR models applied to this dataset
+
+## Usage
+
+```python
+from datasets import load_dataset
+import json
+
+# Load the dataset
+dataset = load_dataset("{{output_dataset_id}}", split="{split}")
+
+# Access the markdown text
+for example in dataset:
+    print(example["markdown"])
+    break
+
+# View all OCR models applied to this dataset
+inference_info = json.loads(dataset[0]["inference_info"])
+for info in inference_info:
+    print(f"Column: {{info['column_name']}} - Model: {{info['model_id']}}")
+```
+
+## Reproduction
+
+This dataset was generated using the [uv-scripts/ocr](https://huggingface.co/datasets/uv-scripts/ocr) HunyuanOCR script:
+
+```bash
+uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/hunyuan-ocr.py \\
+    {source_dataset} \\
+    <output-dataset> \\
+    --image-column {image_column} \\
+    --batch-size {batch_size} \\
+    --prompt-mode {prompt_mode} \\
+    --max-model-len {max_model_len} \\
+    --max-tokens {max_tokens} \\
+    --gpu-memory-utilization {gpu_memory_utilization}
+```
+
+Generated with [UV Scripts](https://huggingface.co/uv-scripts)
+"""
+
+
+def main(
+    input_dataset: str,
+    output_dataset: str,
+    image_column: str = "image",
+    batch_size: int = 1,  # Default to 1 due to vLLM V1 batching issues with HunyuanOCR
+    model: str = "tencent/HunyuanOCR",
+    max_model_len: int = 16384,
+    max_tokens: int = 16384,
+    gpu_memory_utilization: float = 0.8,
+    hf_token: str = None,
+    split: str = "train",
+    max_samples: int = None,
+    private: bool = False,
+    shuffle: bool = False,
+    seed: int = 42,
+    prompt_mode: str = "parse-document",
+    target_language: str = None,
+    key: str = None,
+    fields: List[str] = None,
+    use_chinese: bool = False,
+    custom_prompt: str = None,
+    output_column: str = "markdown",
+    clean_output: bool = True,
+    config: str = None,
+    create_pr: bool = False,
+    verbose: bool = False,
+):
+    """Process images from HF dataset through HunyuanOCR 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 prompt to use
+    if custom_prompt:
+        prompt = custom_prompt
+        logger.info(f"Using custom prompt: {prompt[:50]}...")
+    else:
+        prompt = get_prompt(
+            prompt_mode=prompt_mode,
+            use_chinese=use_chinese,
+            target_language=target_language,
+            key=key,
+            fields=fields,
+        )
+        lang_str = "Chinese" if use_chinese else "English"
+        logger.info(f"Using prompt mode: {prompt_mode} ({lang_str})")
+
+    # Load dataset
+    logger.info(f"Loading dataset: {input_dataset}")
+    dataset = load_dataset(input_dataset, split=split)
+
+    # Validate image column
+    if image_column not in dataset.column_names:
+        raise ValueError(
+            f"Column '{image_column}' not found. Available: {dataset.column_names}"
+        )
+
+    # Shuffle if requested
+    if shuffle:
+        logger.info(f"Shuffling dataset with seed {seed}")
+        dataset = dataset.shuffle(seed=seed)
+
+    # Limit samples if requested
+    if max_samples:
+        dataset = dataset.select(range(min(max_samples, len(dataset))))
+        logger.info(f"Limited to {len(dataset)} samples")
+
+    # Initialize vLLM model
+    logger.info(f"Initializing vLLM with model: {model}")
+    logger.info("This may take a few minutes on first run...")
+
+    # Note: HunyuanOCR has batching issues with vLLM V1 engine when batch_size > 1
+    # Using disable_mm_preprocessor_cache and limit_mm_per_prompt for stability
+    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},
+        disable_mm_preprocessor_cache=True,
+        enable_prefix_caching=False,
+    )
+
+    sampling_params = SamplingParams(
+        temperature=0.0,  # Deterministic for OCR
+        max_tokens=max_tokens,
+    )
+
+    logger.info(f"Processing {len(dataset)} images in batches of {batch_size}")
+    logger.info(f"Output will be written to column: {output_column}")
+
+    # Process images in batches
+    all_outputs = []
+
+    for batch_indices in tqdm(
+        partition_all(batch_size, range(len(dataset))),
+        total=(len(dataset) + batch_size - 1) // batch_size,
+        desc="HunyuanOCR processing",
+    ):
+        batch_indices = list(batch_indices)
+        batch_images = [dataset[i][image_column] for i in batch_indices]
+
+        try:
+            # Create messages for batch
+            batch_messages = [make_ocr_message(img, prompt) for img in batch_images]
+
+            # Process with vLLM
+            outputs = llm.chat(batch_messages, sampling_params)
+
+            # Extract outputs
+            for output in outputs:
+                text = output.outputs[0].text.strip()
+                # Clean repeated substrings if enabled
+                if clean_output:
+                    text = clean_repeated_substrings(text)
+                all_outputs.append(text)
+
+        except Exception as e:
+            logger.error(f"Error processing batch: {e}")
+            # Add error placeholders for failed batch
+            all_outputs.extend(["[OCR ERROR]"] * len(batch_images))
+
+    # Calculate processing time
+    processing_duration = datetime.now() - start_time
+    processing_time_str = f"{processing_duration.total_seconds() / 60:.1f} min"
+
+    # Add output column to dataset
+    logger.info(f"Adding '{output_column}' column to dataset")
+    dataset = dataset.add_column(output_column, all_outputs)
+
+    # Handle inference_info tracking (for multi-model comparisons)
+    inference_entry = {
+        "model_id": model,
+        "model_name": "HunyuanOCR",
+        "column_name": output_column,
+        "timestamp": datetime.now().isoformat(),
+        "prompt_mode": prompt_mode if not custom_prompt else "custom",
+        "prompt_language": "cn" if use_chinese else "en",
+    }
+
+    if "inference_info" in dataset.column_names:
+        # Append to existing inference info
+        logger.info("Updating existing inference_info column")
+
+        def update_inference_info(example):
+            try:
+                existing_info = (
+                    json.loads(example["inference_info"])
+                    if example["inference_info"]
+                    else []
+                )
+            except (json.JSONDecodeError, TypeError):
+                existing_info = []
+
+            existing_info.append(inference_entry)
+            return {"inference_info": json.dumps(existing_info)}
+
+        dataset = dataset.map(update_inference_info)
+    else:
+        # Create new inference_info column
+        logger.info("Creating new inference_info column")
+        inference_list = [json.dumps([inference_entry])] * len(dataset)
+        dataset = dataset.add_column("inference_info", inference_list)
+
+    # Push to hub with retry and XET fallback
+    logger.info(f"Pushing to {output_dataset}")
+    commit_msg = f"Add HunyuanOCR OCR results ({len(dataset)} samples)" + (
+        f" [{config}]" if config else ""
+    )
+    max_retries = 3
+    for attempt in range(1, max_retries + 1):
+        try:
+            if attempt > 1:
+                logger.warning("Disabling XET (fallback to HTTP upload)")
+                os.environ["HF_HUB_DISABLE_XET"] = "1"
+            dataset.push_to_hub(
+                output_dataset,
+                private=private,
+                token=HF_TOKEN,
+                max_shard_size="500MB",
+                **({"config_name": config} if config else {}),
+                create_pr=create_pr,
+                commit_message=commit_msg,
+            )
+            break
+        except Exception as e:
+            logger.error(f"Upload attempt {attempt}/{max_retries} failed: {e}")
+            if attempt < max_retries:
+                delay = 30 * (2 ** (attempt - 1))
+                logger.info(f"Retrying in {delay}s...")
+                time.sleep(delay)
+            else:
+                logger.error("All upload attempts failed. OCR results are lost.")
+                sys.exit(1)
+
+    # Create and push dataset card (skip when creating PR to avoid conflicts)
+    if not create_pr:
+        logger.info("Creating dataset card")
+        card_content = create_dataset_card(
+            source_dataset=input_dataset,
+            model=model,
+            num_samples=len(dataset),
+            processing_time=processing_time_str,
+            batch_size=batch_size,
+            max_model_len=max_model_len,
+            max_tokens=max_tokens,
+            gpu_memory_utilization=gpu_memory_utilization,
+            image_column=image_column,
+            split=split,
+            prompt_mode=prompt_mode if not custom_prompt else "custom",
+            use_chinese=use_chinese,
+        )
+
+        card = DatasetCard(card_content)
+        card.push_to_hub(output_dataset, token=HF_TOKEN)
+
+    logger.info("HunyuanOCR processing complete!")
+    logger.info(
+        f"Dataset available at: https://huggingface.co/datasets/{output_dataset}"
+    )
+    logger.info(f"Processing time: {processing_time_str}")
+
+    if verbose:
+        import importlib.metadata
+
+        logger.info("--- Resolved package versions ---")
+        for pkg in [
+            "vllm",
+            "transformers",
+            "torch",
+            "datasets",
+            "pyarrow",
+            "pillow",
+        ]:
+            try:
+                logger.info(f"  {pkg}=={importlib.metadata.version(pkg)}")
+            except importlib.metadata.PackageNotFoundError:
+                logger.info(f"  {pkg}: not installed")
+        logger.info("--- End versions ---")
+
+
+if __name__ == "__main__":
+    # Show example usage if no arguments
+    if len(sys.argv) == 1:
+        print("=" * 80)
+        print("HunyuanOCR Document Processing")
+        print("=" * 80)
+        print("\nLightweight 1B VLM from Tencent for multilingual document parsing")
+        print("\nFeatures:")
+        print("- 📝 Full document parsing to markdown")
+        print("- 📊 Table extraction (HTML format)")
+        print("- 📐 Formula recognition (LaTeX format)")
+        print("- 📍 Text spotting with coordinates")
+        print("- 🔍 Information extraction (key-value, fields)")
+        print("- 🌐 Photo translation")
+        print("\nExample usage:")
+        print("\n1. Basic document parsing:")
+        print("   uv run hunyuan-ocr.py input-dataset output-dataset")
+        print("\n2. Formula extraction:")
+        print("   uv run hunyuan-ocr.py math-docs formulas --prompt-mode parse-formula")
+        print("\n3. Table extraction:")
+        print("   uv run hunyuan-ocr.py docs tables --prompt-mode parse-table")
+        print("\n4. Text spotting with coordinates:")
+        print("   uv run hunyuan-ocr.py images spotted --prompt-mode spot")
+        print("\n5. Extract specific field:")
+        print(
+            '   uv run hunyuan-ocr.py invoices data --prompt-mode extract-key --key "Total Amount"'
+        )
+        print("\n6. Extract multiple fields as JSON:")
+        print(
+            '   uv run hunyuan-ocr.py forms data --prompt-mode extract-fields --fields "name,date,amount"'
+        )
+        print("\n7. Translate document to English:")
+        print(
+            "   uv run hunyuan-ocr.py cn-docs en-docs --prompt-mode translate --target-language English"
+        )
+        print("\n8. Use Chinese prompts:")
+        print("   uv run hunyuan-ocr.py docs output --use-chinese-prompts")
+        print("\n9. 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/hunyuan-ocr.py \\"
+        )
+        print("       input-dataset output-dataset")
+        print("\n" + "=" * 80)
+        print("\nFor full help, run: uv run hunyuan-ocr.py --help")
+        sys.exit(0)
+
+    parser = argparse.ArgumentParser(
+        description="Document OCR using HunyuanOCR (1B lightweight VLM)",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Prompt Modes (official HunyuanOCR prompts):
+  parse-document   - Full document parsing to markdown (default)
+  parse-formula    - LaTeX formula extraction
+  parse-table      - HTML table extraction
+  parse-chart      - Chart/flowchart parsing (Mermaid/Markdown)
+  spot             - Text detection with coordinates
+  extract-key      - Extract specific key value (requires --key)
+  extract-fields   - Extract multiple fields as JSON (requires --fields)
+  extract-subtitles - Subtitle extraction
+  translate        - Document translation (requires --target-language)
+
+Examples:
+  # Basic document OCR (default)
+  uv run hunyuan-ocr.py my-docs analyzed-docs
+
+  # Extract formulas as LaTeX
+  uv run hunyuan-ocr.py math-papers formulas --prompt-mode parse-formula
+
+  # Extract tables as HTML
+  uv run hunyuan-ocr.py reports tables --prompt-mode parse-table
+
+  # Text spotting with coordinates
+  uv run hunyuan-ocr.py images spotted --prompt-mode spot
+
+  # Extract specific key from forms
+  uv run hunyuan-ocr.py invoices amounts --prompt-mode extract-key --key "Total"
+
+  # Extract multiple fields as JSON
+  uv run hunyuan-ocr.py forms data --prompt-mode extract-fields --fields "name,date,amount"
+
+  # Translate Chinese documents to English
+  uv run hunyuan-ocr.py cn-docs translated --prompt-mode translate --target-language English
+
+  # Use Chinese prompts
+  uv run hunyuan-ocr.py docs output --use-chinese-prompts
+
+  # Random sampling for testing
+  uv run hunyuan-ocr.py large-dataset test --max-samples 50 --shuffle
+        """,
+    )
+
+    parser.add_argument("input_dataset", help="Input dataset ID from Hugging Face Hub")
+    parser.add_argument("output_dataset", help="Output dataset ID for Hugging Face Hub")
+    parser.add_argument(
+        "--image-column",
+        default="image",
+        help="Column containing images (default: image)",
+    )
+    parser.add_argument(
+        "--batch-size",
+        type=int,
+        default=1,
+        help="Batch size for processing (default: 1, higher values may cause vLLM errors)",
+    )
+    parser.add_argument(
+        "--model",
+        default="tencent/HunyuanOCR",
+        help="Model to use (default: tencent/HunyuanOCR)",
+    )
+    parser.add_argument(
+        "--max-model-len",
+        type=int,
+        default=16384,
+        help="Maximum model context length (default: 16384)",
+    )
+    parser.add_argument(
+        "--max-tokens",
+        type=int,
+        default=16384,
+        help="Maximum tokens to generate (default: 16384)",
+    )
+    parser.add_argument(
+        "--gpu-memory-utilization",
+        type=float,
+        default=0.8,
+        help="GPU memory utilization (default: 0.8)",
+    )
+    parser.add_argument("--hf-token", help="Hugging Face API token")
+    parser.add_argument(
+        "--split", default="train", help="Dataset split to use (default: train)"
+    )
+    parser.add_argument(
+        "--max-samples",
+        type=int,
+        help="Maximum number of samples to process (for testing)",
+    )
+    parser.add_argument(
+        "--private", action="store_true", help="Make output dataset private"
+    )
+    parser.add_argument(
+        "--shuffle", action="store_true", help="Shuffle dataset before processing"
+    )
+    parser.add_argument(
+        "--seed",
+        type=int,
+        default=42,
+        help="Random seed for shuffling (default: 42)",
+    )
+    parser.add_argument(
+        "--prompt-mode",
+        choices=[
+            "parse-document",
+            "parse-formula",
+            "parse-table",
+            "parse-chart",
+            "spot",
+            "extract-key",
+            "extract-fields",
+            "extract-subtitles",
+            "translate",
+        ],
+        default="parse-document",
+        help="Prompt template to use (default: parse-document)",
+    )
+    parser.add_argument(
+        "--target-language",
+        help="Target language for translation mode (e.g., 'English', 'Chinese')",
+    )
+    parser.add_argument(
+        "--key",
+        help="Key to extract for extract-key mode",
+    )
+    parser.add_argument(
+        "--fields",
+        help="Comma-separated list of fields for extract-fields mode",
+    )
+    parser.add_argument(
+        "--use-chinese-prompts",
+        action="store_true",
+        help="Use Chinese versions of prompts",
+    )
+    parser.add_argument(
+        "--custom-prompt",
+        help="Custom prompt text (overrides --prompt-mode)",
+    )
+    parser.add_argument(
+        "--output-column",
+        default="markdown",
+        help="Column name for output text (default: markdown)",
+    )
+    parser.add_argument(
+        "--no-clean-output",
+        action="store_true",
+        help="Disable cleaning of repeated substrings in output",
+    )
+    parser.add_argument(
+        "--config",
+        help="Dataset config name for multi-model benchmarks",
+    )
+    parser.add_argument(
+        "--create-pr",
+        action="store_true",
+        help="Push results as a pull request instead of direct commit",
+    )
+    parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Log resolved package versions at the end of the run",
+    )
+
+    args = parser.parse_args()
+
+    # Parse fields if provided
+    fields_list = None
+    if args.fields:
+        fields_list = [f.strip() for f in args.fields.split(",")]
+
+    main(
+        input_dataset=args.input_dataset,
+        output_dataset=args.output_dataset,
+        image_column=args.image_column,
+        batch_size=args.batch_size,
+        model=args.model,
+        max_model_len=args.max_model_len,
+        max_tokens=args.max_tokens,
+        gpu_memory_utilization=args.gpu_memory_utilization,
+        hf_token=args.hf_token,
+        split=args.split,
+        max_samples=args.max_samples,
+        private=args.private,
+        shuffle=args.shuffle,
+        seed=args.seed,
+        prompt_mode=args.prompt_mode,
+        target_language=args.target_language,
+        key=args.key,
+        fields=fields_list,
+        use_chinese=args.use_chinese_prompts,
+        custom_prompt=args.custom_prompt,
+        output_column=args.output_column,
+        clean_output=not args.no_clean_output,
+        config=args.config,
+        create_pr=args.create_pr,
+        verbose=args.verbose,
+    )

lighton-ocr.py

@@ -2,7 +2,7 @@
 # requires-python = ">=3.11"
 # dependencies = [
 #     "datasets",
-#     "huggingface-hub[hf_transfer]",
+#     "huggingface-hub",
 #     "pillow",
 #     "vllm",
 #     "tqdm",
@@ -12,7 +12,7 @@
 # ]
 #
 # [[tool.uv.index]]
-# url = "https://wheels.vllm.ai/nightly"
+# url = "https://wheels.vllm.ai/nightly/cu129"
 #
 # [tool.uv]
 # prerelease = "allow"
@@ -300,9 +300,6 @@ def main(
     # 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:
@@ -337,7 +334,7 @@ def main(
         logger.info(f"Limited to {len(dataset)} samples")
 
     # Initialize vLLM model
-    logger.info(f"Initializing vLLM with LightOnOCR")
+    logger.info("Initializing vLLM with LightOnOCR")
     logger.info("This may take a few minutes on first run...")
     llm = LLM(
         model=model,
@@ -418,7 +415,11 @@ def main(
 
         def update_inference_info(example):
             try:
-                existing_info = json.loads(example["inference_info"]) if example["inference_info"] else []
+                existing_info = (
+                    json.loads(example["inference_info"])
+                    if example["inference_info"]
+                    else []
+                )
             except (json.JSONDecodeError, TypeError):
                 existing_info = []
 
@@ -459,9 +460,13 @@ def main(
     card.push_to_hub(output_dataset, token=HF_TOKEN)
 
     logger.info("✅ LightOnOCR processing complete!")
-    logger.info(f"Dataset available at: https://huggingface.co/datasets/{output_dataset}")
+    logger.info(
+        f"Dataset available at: https://huggingface.co/datasets/{output_dataset}"
+    )
     logger.info(f"Processing time: {processing_time_str}")
-    logger.info(f"Processing speed: {len(dataset) / processing_duration.total_seconds():.2f} images/sec")
+    logger.info(
+        f"Processing speed: {len(dataset) / processing_duration.total_seconds():.2f} images/sec"
+    )
 
 
 if __name__ == "__main__":
@@ -491,9 +496,12 @@ if __name__ == "__main__":
         print("   uv run lighton-ocr.py docs output --no-resize")
         print("\n6. Running on HF Jobs:")
         print("   hf jobs uv run --flavor l4x1 \\")
-        print("     -e HF_TOKEN=$(python3 -c \"from huggingface_hub import get_token; print(get_token())\") \\")
-        print("     -e HF_HUB_ENABLE_HF_TRANSFER=1 \\")
-        print("     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lighton-ocr.py \\")
+        print(
+            '     -e HF_TOKEN=$(python3 -c "from huggingface_hub import get_token; print(get_token())") \\'
+        )
+        print(
+            "     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lighton-ocr.py \\"
+        )
         print("       input-dataset output-dataset --vocab-size 32k")
         print("\n" + "=" * 80)
         print("\nVocabulary Size Options:")

lighton-ocr2.py

@@ -12,7 +12,7 @@
 # ]
 #
 # [[tool.uv.index]]
-# url = "https://wheels.vllm.ai/nightly"
+# url = "https://wheels.vllm.ai/nightly/cu129"
 #
 # [tool.uv]
 # prerelease = "allow"
@@ -291,6 +291,7 @@ def main(
     output_column: str = "markdown",
     config: str = None,
     create_pr: bool = False,
+    verbose: bool = False,
 ):
     """Process images from HF dataset through LightOnOCR-2 model."""
 
@@ -408,7 +409,11 @@ def main(
 
         def update_inference_info(example):
             try:
-                existing_info = json.loads(example["inference_info"]) if example["inference_info"] else []
+                existing_info = (
+                    json.loads(example["inference_info"])
+                    if example["inference_info"]
+                    else []
+                )
             except (json.JSONDecodeError, TypeError):
                 existing_info = []
 
@@ -428,7 +433,7 @@ def main(
         output_dataset,
         private=private,
         token=HF_TOKEN,
-        config_name=config,
+        **({"config_name": config} if config else {}),
         create_pr=create_pr,
         commit_message=f"Add {MODEL} OCR results ({len(dataset)} samples)"
         + (f" [{config}]" if config else ""),
@@ -456,9 +461,24 @@ def main(
     card.push_to_hub(output_dataset, token=HF_TOKEN)
 
     logger.info("✅ LightOnOCR-2 processing complete!")
-    logger.info(f"Dataset available at: https://huggingface.co/datasets/{output_dataset}")
+    logger.info(
+        f"Dataset available at: https://huggingface.co/datasets/{output_dataset}"
+    )
     logger.info(f"Processing time: {processing_time_str}")
-    logger.info(f"Processing speed: {len(dataset) / processing_duration.total_seconds():.2f} images/sec")
+    logger.info(
+        f"Processing speed: {len(dataset) / processing_duration.total_seconds():.2f} images/sec"
+    )
+
+    if verbose:
+        import importlib.metadata
+
+        logger.info("--- Resolved package versions ---")
+        for pkg in ["vllm", "transformers", "torch", "datasets", "pyarrow", "pillow"]:
+            try:
+                logger.info(f"  {pkg}=={importlib.metadata.version(pkg)}")
+            except importlib.metadata.PackageNotFoundError:
+                logger.info(f"  {pkg}: not installed")
+        logger.info("--- End versions ---")
 
 
 if __name__ == "__main__":
@@ -489,7 +509,9 @@ if __name__ == "__main__":
         print("\n5. Running on HF Jobs:")
         print("   hf jobs uv run --flavor l4x1 \\")
         print("     -s HF_TOKEN \\")
-        print("     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lighton-ocr2.py \\")
+        print(
+            "     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/lighton-ocr2.py \\"
+        )
         print("       input-dataset output-dataset --batch-size 32")
         print("\n" + "=" * 80)
         print("\nKey Improvements over v1:")
@@ -612,6 +634,11 @@ Examples:
         default="markdown",
         help="Column name for output text (default: markdown)",
     )
+    parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Log resolved package versions after processing (useful for pinning deps)",
+    )
 
     args = parser.parse_args()
 
@@ -636,4 +663,5 @@ Examples:
         output_column=args.output_column,
         config=args.config,
         create_pr=args.create_pr,
+        verbose=args.verbose,
     )

numarkdown-ocr.py

@@ -2,7 +2,7 @@
 # requires-python = ">=3.11"
 # dependencies = [
 #     "datasets",
-#     "huggingface-hub[hf_transfer]",
+#     "huggingface-hub",
 #     "pillow",
 #     "vllm",
 #     "tqdm",
@@ -37,13 +37,13 @@ import logging
 import os
 import re
 import sys
-from typing import Any, Dict, List, Union, Optional, Tuple
+import time
 from datetime import datetime
+from typing import Any, Dict, List, Optional, Union
 
-import torch
 from torch import cuda
 from datasets import load_dataset
-from huggingface_hub import DatasetCard, HfApi, login
+from huggingface_hub import DatasetCard, login
 from PIL import Image
 from toolz import partition_all
 from tqdm.auto import tqdm
@@ -57,15 +57,17 @@ def check_gpu_availability() -> int:
     """Check if CUDA is available and return the number of GPUs."""
     if not cuda.is_available():
         logger.error("CUDA is not available. This script requires a GPU.")
-        logger.error("Please run on a machine with NVIDIA GPU or use HF Jobs with GPU flavor.")
+        logger.error(
+            "Please run on a machine with NVIDIA GPU or use HF Jobs with GPU flavor."
+        )
         sys.exit(1)
-    
+
     num_gpus = cuda.device_count()
     for i in range(num_gpus):
         gpu_name = cuda.get_device_name(i)
         gpu_memory = cuda.get_device_properties(i).total_memory / 1024**3
         logger.info(f"GPU {i}: {gpu_name} with {gpu_memory:.1f} GB memory")
-    
+
     return num_gpus
 
 
@@ -77,27 +79,29 @@ def validate_and_resize_image(
     """Validate and resize image to meet pixel constraints if necessary."""
     width, height = image.size
     total_pixels = width * height
-    
+
     if total_pixels < min_pixels or total_pixels > max_pixels:
         # Calculate scaling factor
         if total_pixels < min_pixels:
             scale = (min_pixels / total_pixels) ** 0.5
         else:
             scale = (max_pixels / total_pixels) ** 0.5
-        
+
         new_width = int(width * scale)
         new_height = int(height * scale)
-        
-        logger.debug(f"Resizing image from {width}x{height} to {new_width}x{new_height}")
+
+        logger.debug(
+            f"Resizing image from {width}x{height} to {new_width}x{new_height}"
+        )
         image = image.resize((new_width, new_height), Image.Resampling.LANCZOS)
-    
+
     return image
 
 
 def extract_answer_from_thinking(text: str, include_thinking: bool = False) -> str:
     """
     Extract the final answer from NuMarkdown's thinking output.
-    
+
     The model generates output in format:
     <think>reasoning process...</think>
     <answer>final markdown output</answer>
@@ -105,27 +109,27 @@ def extract_answer_from_thinking(text: str, include_thinking: bool = False) -> s
     if include_thinking:
         # Return the full output including thinking traces
         return text.strip()
-    
+
     # Extract content between <answer> tags
-    answer_pattern = r'<answer>(.*?)</answer>'
+    answer_pattern = r"<answer>(.*?)</answer>"
     answer_match = re.search(answer_pattern, text, re.DOTALL)
-    
+
     if answer_match:
         return answer_match.group(1).strip()
-    
+
     # If no answer tags found, check if the entire text is markdown
     # (sometimes the model might not use tags)
-    if not '<think>' in text and not '<answer>' in text:
+    if "<think>" not in text and "<answer>" not in text:
         return text.strip()
-    
+
     # Fallback: return everything after </think> if present
-    think_end = text.find('</think>')
+    think_end = text.find("</think>")
     if think_end != -1:
-        remaining = text[think_end + 8:].strip()
+        remaining = text[think_end + 8 :].strip()
         # Remove <answer> tags if present
-        remaining = remaining.replace('<answer>', '').replace('</answer>', '').strip()
+        remaining = remaining.replace("<answer>", "").replace("</answer>", "").strip()
         return remaining
-    
+
     # Last resort: return the full text
     logger.warning("Could not extract answer from thinking tokens, returning full text")
     return text.strip()
@@ -145,15 +149,15 @@ def make_numarkdown_message(
         pil_img = Image.open(image).convert("RGB")
     else:
         raise ValueError(f"Unsupported image type: {type(image)}")
-    
+
     # Validate and resize if necessary
     pil_img = validate_and_resize_image(pil_img)
-    
+
     # Convert to base64 data URI
     buf = io.BytesIO()
     pil_img.save(buf, format="PNG")
     data_uri = f"data:image/png;base64,{base64.b64encode(buf.getvalue()).decode()}"
-    
+
     # Return message in vLLM chat format
     return [
         {
@@ -182,7 +186,7 @@ def create_dataset_card(
 ) -> str:
     """Create a dataset card documenting the OCR process."""
     model_name = model.split("/")[-1]
-    
+
     return f"""---
 tags:
 - ocr
@@ -308,15 +312,19 @@ def main(
     include_thinking: bool = False,
     temperature: float = 0.0,
     custom_prompt: Optional[str] = None,
+    output_column: str = "markdown",
+    config: str = None,
+    create_pr: bool = False,
+    verbose: bool = False,
 ):
     """Process images from HF dataset through NuMarkdown model.
-    
+
     The max_tokens parameter controls the total token budget for both
     thinking and answer phases. For complex documents with extensive
     reasoning, the default of 16384 tokens provides ample room for both
     the thinking process and the final markdown output.
     """
-    
+
     # GPU check and configuration
     num_gpus = check_gpu_availability()
     if tensor_parallel_size is None:
@@ -330,38 +338,35 @@ def main(
             logger.warning(
                 f"Requested {tensor_parallel_size} GPUs but only {num_gpus} available"
             )
-    
+
     # Track processing start time
     start_time = datetime.now()
-    
-    # Enable HF_TRANSFER for faster downloads
-    os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"
-    
+
     # Login to HF if token provided
     HF_TOKEN = hf_token or os.environ.get("HF_TOKEN")
     if HF_TOKEN:
         login(token=HF_TOKEN)
-    
+
     # Load dataset
     logger.info(f"Loading dataset: {input_dataset}")
     dataset = load_dataset(input_dataset, split=split)
-    
+
     # Validate image column
     if image_column not in dataset.column_names:
         raise ValueError(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
-    
+
     # Shuffle if requested
     if shuffle:
         logger.info(f"Shuffling dataset with seed {seed}")
         dataset = dataset.shuffle(seed=seed)
-    
+
     # Limit samples if requested
     if max_samples:
         dataset = dataset.select(range(min(max_samples, len(dataset))))
         logger.info(f"Limited to {len(dataset)} samples")
-    
+
     # Initialize vLLM with trust_remote_code for NuMarkdown
     logger.info(f"Initializing vLLM with model: {model}")
     logger.info(f"Using {tensor_parallel_size} GPU(s) for inference")
@@ -373,22 +378,25 @@ def main(
         tensor_parallel_size=tensor_parallel_size,
         limit_mm_per_prompt={"image": 1},
     )
-    
+
     # Set up sampling parameters
     sampling_params = SamplingParams(
         temperature=temperature,
         max_tokens=max_tokens,
     )
-    
+
     # Use custom prompt if provided, otherwise use default
-    prompt = custom_prompt or "Convert this document to markdown. Focus on preserving structure, tables, formulas, and all textual content."
-    
+    prompt = (
+        custom_prompt
+        or "Convert this document to markdown. Focus on preserving structure, tables, formulas, and all textual content."
+    )
+
     # Process images in batches
     all_markdown = []
-    
+
     logger.info(f"Processing {len(dataset)} images in batches of {batch_size}")
     logger.info(f"Including thinking traces: {include_thinking}")
-    
+
     # Process in batches to avoid memory issues
     for batch_indices in tqdm(
         partition_all(batch_size, range(len(dataset))),
@@ -397,80 +405,97 @@ def main(
     ):
         batch_indices = list(batch_indices)
         batch_images = [dataset[i][image_column] for i in batch_indices]
-        
+
         try:
             # Create messages for batch
             batch_messages = [
                 make_numarkdown_message(img, prompt) for img in batch_images
             ]
-            
+
             # Process with vLLM
             outputs = llm.chat(batch_messages, sampling_params)
-            
+
             # Extract markdown from outputs
             for output in outputs:
                 raw_text = output.outputs[0].text.strip()
                 # Extract answer from thinking tokens
                 markdown_text = extract_answer_from_thinking(raw_text, include_thinking)
                 all_markdown.append(markdown_text)
-        
+
         except Exception as e:
             logger.error(f"Error processing batch: {e}")
             # Add error placeholders for failed batch
             all_markdown.extend(["[OCR FAILED]"] * len(batch_images))
-    
-    # Add markdown column to dataset
-    logger.info("Adding markdown column to dataset")
-    dataset = dataset.add_column("markdown", all_markdown)
-    
+
+    # 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:
-        # 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",
+    inference_entry = {
         "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,
+        "model_name": "NuMarkdown-8B-Thinking",
+        "column_name": output_column,
+        "timestamp": datetime.now().isoformat(),
         "include_thinking": include_thinking,
         "temperature": temperature,
-        "prompt": prompt,
-        "script": "numarkdown-ocr.py",
-        "script_version": "1.0.0",
-        "script_url": "https://huggingface.co/datasets/uv-scripts/ocr/raw/main/numarkdown-ocr.py"
+        "max_tokens": max_tokens,
     }
-    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)
-    
+
+    if "inference_info" in dataset.column_names:
+        logger.info("Updating existing inference_info column")
+
+        def update_inference_info(example):
+            try:
+                existing_info = (
+                    json.loads(example["inference_info"])
+                    if example["inference_info"]
+                    else []
+                )
+            except (json.JSONDecodeError, TypeError):
+                existing_info = []
+            existing_info.append(inference_entry)
+            return {"inference_info": json.dumps(existing_info)}
+
+        dataset = dataset.map(update_inference_info)
+    else:
+        logger.info("Creating new inference_info column")
+        inference_list = [json.dumps([inference_entry])] * len(dataset)
+        dataset = dataset.add_column("inference_info", inference_list)
+
     # Calculate processing time
-    end_time = datetime.now()
-    processing_duration = end_time - start_time
+    processing_duration = datetime.now() - start_time
     processing_time = f"{processing_duration.total_seconds() / 60:.1f} minutes"
-    
+
+    # Push to hub with retry and XET fallback
+    logger.info(f"Pushing to {output_dataset}")
+    max_retries = 3
+    for attempt in range(1, max_retries + 1):
+        try:
+            if attempt > 1:
+                logger.warning("Disabling XET (fallback to HTTP upload)")
+                os.environ["HF_HUB_DISABLE_XET"] = "1"
+            dataset.push_to_hub(
+                output_dataset,
+                private=private,
+                token=HF_TOKEN,
+                max_shard_size="500MB",
+                **({"config_name": config} if config else {}),
+                create_pr=create_pr,
+                commit_message=f"Add {model} OCR results ({len(dataset)} samples)"
+                + (f" [{config}]" if config else ""),
+            )
+            break
+        except Exception as e:
+            logger.error(f"Upload attempt {attempt}/{max_retries} failed: {e}")
+            if attempt < max_retries:
+                delay = 30 * (2 ** (attempt - 1))
+                logger.info(f"Retrying in {delay}s...")
+                time.sleep(delay)
+            else:
+                logger.error("All upload attempts failed. OCR results are lost.")
+                sys.exit(1)
+
     # Create and push dataset card
     logger.info("Creating dataset card...")
     card_content = create_dataset_card(
@@ -487,28 +512,26 @@ def main(
         image_column=image_column,
         split=split,
     )
-    
-    # Handle dataset card push with proper repo_id
-    full_repo_id = output_dataset
-    try:
-        card = DatasetCard(card_content)
-        # If output_dataset doesn't contain a username, get the current user's name
-        if "/" not in output_dataset:
-            api = HfApi(token=HF_TOKEN)
-            user_info = api.whoami()
-            full_repo_id = f"{user_info['name']}/{output_dataset}"
-            logger.info(f"Using full repo ID: {full_repo_id}")
-        
-        card.push_to_hub(full_repo_id, token=HF_TOKEN)
-        logger.info("✅ Dataset card created and pushed!")
-    except Exception as e:
-        logger.warning(f"Could not push dataset card: {e}")
-        logger.info("Dataset was successfully created but card upload failed. You can add it manually.")
-    
-    logger.info("✅ OCR conversion complete!")
+
+    card = DatasetCard(card_content)
+    card.push_to_hub(output_dataset, token=HF_TOKEN)
+
+    logger.info("NuMarkdown processing complete!")
     logger.info(
-        f"Dataset available at: https://huggingface.co/datasets/{full_repo_id}"
+        f"Dataset available at: https://huggingface.co/datasets/{output_dataset}"
     )
+    logger.info(f"Processing time: {processing_time}")
+
+    if verbose:
+        import importlib.metadata
+
+        logger.info("--- Resolved package versions ---")
+        for pkg in ["vllm", "transformers", "torch", "datasets", "pyarrow", "pillow"]:
+            try:
+                logger.info(f"  {pkg}=={importlib.metadata.version(pkg)}")
+            except importlib.metadata.PackageNotFoundError:
+                logger.info(f"  {pkg}: not installed")
+        logger.info("--- End versions ---")
 
 
 if __name__ == "__main__":
@@ -530,7 +553,9 @@ if __name__ == "__main__":
         print("\n1. Basic OCR conversion:")
         print("   uv run numarkdown-ocr.py document-images markdown-docs")
         print("\n2. Include thinking traces:")
-        print("   uv run numarkdown-ocr.py complex-docs analyzed-docs --include-thinking")
+        print(
+            "   uv run numarkdown-ocr.py complex-docs analyzed-docs --include-thinking"
+        )
         print("\n3. With custom settings:")
         print("   uv run numarkdown-ocr.py scientific-papers extracted-text \\")
         print("       --batch-size 8 \\")
@@ -540,19 +565,27 @@ if __name__ == "__main__":
         print("   uv run numarkdown-ocr.py large-dataset test-output --max-samples 10")
         print("\n5. Custom prompt for specific needs:")
         print("   uv run numarkdown-ocr.py invoices invoice-data \\")
-        print('       --custom-prompt "Extract all invoice details including line items"')
+        print(
+            '       --custom-prompt "Extract all invoice details including line items"'
+        )
         print("\n6. Multi-GPU processing:")
-        print("   uv run numarkdown-ocr.py large-docs processed-docs --tensor-parallel-size 2")
+        print(
+            "   uv run numarkdown-ocr.py large-docs processed-docs --tensor-parallel-size 2"
+        )
         print("\n7. Running on HF Jobs:")
         print("   hf jobs uv run --flavor a100x2 \\")
-        print('     -e HF_TOKEN=$(python3 -c "from huggingface_hub import get_token; print(get_token())") \\')
-        print("     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/numarkdown-ocr.py \\")
+        print(
+            '     -e HF_TOKEN=$(python3 -c "from huggingface_hub import get_token; print(get_token())") \\'
+        )
+        print(
+            "     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/numarkdown-ocr.py \\"
+        )
         print("       your-document-dataset \\")
         print("       your-markdown-output")
         print("\n" + "=" * 80)
         print("\nFor full help, run: uv run numarkdown-ocr.py --help")
         sys.exit(0)
-    
+
     parser = argparse.ArgumentParser(
         description="OCR images to markdown using NuMarkdown-8B-Thinking with reasoning",
         formatter_class=argparse.RawDescriptionHelpFormatter,
@@ -577,7 +610,7 @@ Examples:
   uv run numarkdown-ocr.py ordered-dataset random-sample --max-samples 50 --shuffle
         """,
     )
-    
+
     parser.add_argument("input_dataset", help="Input dataset ID from Hugging Face Hub")
     parser.add_argument("output_dataset", help="Output dataset ID for Hugging Face Hub")
     parser.add_argument(
@@ -658,9 +691,28 @@ Examples:
         type=str,
         help="Custom prompt for the model (overrides default)",
     )
-    
+    parser.add_argument(
+        "--output-column",
+        default="markdown",
+        help="Column name for output text (default: markdown)",
+    )
+    parser.add_argument(
+        "--config",
+        help="Config/subset name when pushing to Hub (for benchmarking multiple models in one repo)",
+    )
+    parser.add_argument(
+        "--create-pr",
+        action="store_true",
+        help="Create a pull request instead of pushing directly (for parallel benchmarking)",
+    )
+    parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Log resolved package versions after processing (useful for pinning deps)",
+    )
+
     args = parser.parse_args()
-    
+
     main(
         input_dataset=args.input_dataset,
         output_dataset=args.output_dataset,
@@ -680,4 +732,8 @@ Examples:
         include_thinking=args.include_thinking,
         temperature=args.temperature,
         custom_prompt=args.custom_prompt,
-    )
+        output_column=args.output_column,
+        config=args.config,
+        create_pr=args.create_pr,
+        verbose=args.verbose,
+    )

paddleocr-vl-1.5.py

@@ -47,6 +47,7 @@ import json
 import logging
 import os
 import sys
+import time
 from datetime import datetime
 from typing import Any, Dict, List, Union
 
@@ -273,14 +274,17 @@ def main(
     output_dataset: str,
     image_column: str = "image",
     task_mode: str = "ocr",
-    max_tokens: int = 512,
+    max_tokens: int = 512,  # model card example uses 512 (element-level); increase for full pages
     hf_token: str = None,
     split: str = "train",
     max_samples: int = None,
     private: bool = False,
     shuffle: bool = False,
     seed: int = 42,
-    output_column: str = None,
+    output_column: str = "markdown",
+    config: str = None,
+    create_pr: bool = False,
+    verbose: bool = False,
 ):
     """Process images from HF dataset through PaddleOCR-VL-1.5 model."""
 
@@ -301,10 +305,6 @@ def main(
             f"Invalid task_mode '{task_mode}'. Choose from: {list(TASK_MODES.keys())}"
         )
 
-    # Auto-generate output column name based on task mode
-    if output_column is None:
-        output_column = f"paddleocr_1.5_{task_mode}"
-
     logger.info(f"Using task mode: {task_mode} - {TASK_DESCRIPTIONS[task_mode]}")
     logger.info(f"Output will be written to column: {output_column}")
 
@@ -442,9 +442,34 @@ def main(
         inference_list = [json.dumps([inference_entry])] * len(dataset)
         dataset = dataset.add_column("inference_info", inference_list)
 
-    # Push to hub
+    # Push to hub with retry and XET fallback
     logger.info(f"Pushing to {output_dataset}")
-    dataset.push_to_hub(output_dataset, private=private, token=HF_TOKEN)
+    max_retries = 3
+    for attempt in range(1, max_retries + 1):
+        try:
+            if attempt > 1:
+                logger.warning("Disabling XET (fallback to HTTP upload)")
+                os.environ["HF_HUB_DISABLE_XET"] = "1"
+            dataset.push_to_hub(
+                output_dataset,
+                private=private,
+                token=HF_TOKEN,
+                max_shard_size="500MB",
+                **({"config_name": config} if config else {}),
+                create_pr=create_pr,
+                commit_message=f"Add {MODEL_ID} OCR results ({len(dataset)} samples)"
+                + (f" [{config}]" if config else ""),
+            )
+            break
+        except Exception as e:
+            logger.error(f"Upload attempt {attempt}/{max_retries} failed: {e}")
+            if attempt < max_retries:
+                delay = 30 * (2 ** (attempt - 1))
+                logger.info(f"Retrying in {delay}s...")
+                time.sleep(delay)
+            else:
+                logger.error("All upload attempts failed. OCR results are lost.")
+                sys.exit(1)
 
     # Create and push dataset card
     logger.info("Creating dataset card")
@@ -472,6 +497,17 @@ def main(
     )
     logger.info(f"Task mode: {task_mode} - {TASK_DESCRIPTIONS[task_mode]}")
 
+    if verbose:
+        import importlib.metadata
+
+        logger.info("--- Resolved package versions ---")
+        for pkg in ["vllm", "transformers", "torch", "datasets", "pyarrow", "pillow"]:
+            try:
+                logger.info(f"  {pkg}=={importlib.metadata.version(pkg)}")
+            except importlib.metadata.PackageNotFoundError:
+                logger.info(f"  {pkg}: not installed")
+        logger.info("--- End versions ---")
+
 
 if __name__ == "__main__":
     # Show example usage if no arguments
@@ -577,7 +613,7 @@ Backend: Transformers batch inference (not vLLM)
         "--max-tokens",
         type=int,
         default=512,
-        help="Maximum tokens to generate (default: 512)",
+        help="Maximum tokens to generate (default: 512, per model card element-level example; increase for full pages)",
     )
     parser.add_argument("--hf-token", help="Hugging Face API token")
     parser.add_argument(
@@ -602,7 +638,22 @@ Backend: Transformers batch inference (not vLLM)
     )
     parser.add_argument(
         "--output-column",
-        help="Column name for output (default: paddleocr_1.5_[task_mode])",
+        default="markdown",
+        help="Column name for output text (default: markdown)",
+    )
+    parser.add_argument(
+        "--config",
+        help="Config/subset name when pushing to Hub (for benchmarking multiple models in one repo)",
+    )
+    parser.add_argument(
+        "--create-pr",
+        action="store_true",
+        help="Create a pull request instead of pushing directly (for parallel benchmarking)",
+    )
+    parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Log resolved package versions after processing (useful for pinning deps)",
     )
 
     args = parser.parse_args()
@@ -620,4 +671,7 @@ Backend: Transformers batch inference (not vLLM)
         shuffle=args.shuffle,
         seed=args.seed,
         output_column=args.output_column,
+        config=args.config,
+        create_pr=args.create_pr,
+        verbose=args.verbose,
     )

paddleocr-vl.py

@@ -13,7 +13,7 @@
 # ]
 #
 # [[tool.uv.index]]
-# url = "https://wheels.vllm.ai/nightly"
+# url = "https://wheels.vllm.ai/nightly/cu129"
 #
 # [tool.uv]
 # prerelease = "allow"
@@ -38,6 +38,11 @@ Features:
 
 Model: PaddlePaddle/PaddleOCR-VL
 vLLM: Requires nightly build for full support
+
+IMPORTANT: As of Nov 2024, PaddleOCR-VL batch processing support in vLLM is still
+being finalized. The model works with `vllm serve` but may have issues with the
+LLM batch class. Use alternative models like LightOnOCR or DoTS for now, or run
+PaddleOCR-VL in server mode as shown in the vLLM documentation.
 """
 
 import argparse
@@ -236,7 +241,7 @@ This dataset contains {task_mode.upper()} results from images in [{source_datase
 ### Configuration
 
 - **Image Column**: `{image_column}`
-- **Output Column**: `paddleocr_{task_mode}`
+- **Output Column**: `markdown`
 - **Dataset Split**: `{split}`
 - **Batch Size**: {batch_size}
 - **Smart Resize**: {"Enabled" if apply_smart_resize else "Disabled"}
@@ -267,7 +272,7 @@ PaddleOCR-VL is a state-of-the-art, resource-efficient model tailored for docume
 ## Dataset Structure
 
 The dataset contains all original columns plus:
-- `paddleocr_{task_mode}`: The extracted content based on task mode
+- `markdown`: The extracted content based on task mode
 - `inference_info`: JSON list tracking all OCR models applied to this dataset
 
 ## Usage
@@ -281,7 +286,7 @@ dataset = load_dataset("{{output_dataset_id}}", split="{split}")
 
 # Access the extracted content
 for example in dataset:
-    print(example["paddleocr_{task_mode}"])
+    print(example["markdown"])
     break
 
 # View all OCR models applied to this dataset
@@ -334,17 +339,25 @@ def main(
     shuffle: bool = False,
     seed: int = 42,
     output_column: str = None,
+    verbose: bool = False,
 ):
     """Process images from HF dataset through PaddleOCR-VL model."""
 
     # Check CUDA availability first
     check_cuda_availability()
 
+    # Compatibility warning
+    logger.warning("⚠️  PaddleOCR-VL batch processing in vLLM is experimental.")
+    logger.warning("If initialization fails, consider using:")
+    logger.warning("  1. LightOnOCR (1B) - smallest stable model")
+    logger.warning("  2. DoTS OCR (1.7B) - multilingual support")
+    logger.warning("  3. vllm serve mode for PaddleOCR-VL")
+
     # Track processing start time
     start_time = datetime.now()
 
-    # Enable HF_TRANSFER for faster downloads
-    os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"
+    # Enable high-performance Xet downloads
+    os.environ["HF_XET_HIGH_PERFORMANCE"] = "1"
 
     # Login to HF if token provided
     HF_TOKEN = hf_token or os.environ.get("HF_TOKEN")
@@ -357,9 +370,9 @@ def main(
             f"Invalid task_mode '{task_mode}'. Choose from: {list(TASK_MODES.keys())}"
         )
 
-    # Auto-generate output column name based on task mode
+    # Default output column is 'markdown' for consistency across scripts
     if output_column is None:
-        output_column = f"paddleocr_{task_mode}"
+        output_column = "markdown"
 
     logger.info(f"Using task mode: {task_mode} - {TASK_DESCRIPTIONS[task_mode]}")
     logger.info(f"Output will be written to column: {output_column}")
@@ -390,19 +403,28 @@ def main(
     logger.info("This may take a minute on first run (model is only 0.9B)...")
 
     # Note: PaddleOCR-VL requires specific vLLM configuration
-    # The model needs custom implementation files to be loaded
-    os.environ["VLLM_USE_V1"] = "0"  # Disable V1 engine for compatibility
-    
-    llm = LLM(
-        model=model_name,
-        trust_remote_code=True,
-        max_model_len=max_model_len,
-        gpu_memory_utilization=gpu_memory_utilization,
-        limit_mm_per_prompt={"image": 1},
-        max_num_batched_tokens=16384,  # Match server config
-        enable_prefix_caching=False,  # Disable prefix caching like server
-        enforce_eager=True,  # Use eager mode instead of CUDA graphs
-    )
+    # The model needs to be loaded with specific settings
+    try:
+        # Try with standard configuration first
+        llm = LLM(
+            model=model_name,
+            trust_remote_code=True,
+            max_model_len=max_model_len,
+            gpu_memory_utilization=gpu_memory_utilization,
+            limit_mm_per_prompt={"image": 1},
+            max_num_batched_tokens=16384,
+            enable_prefix_caching=False,
+            enforce_eager=True,
+        )
+    except Exception as e:
+        logger.error(f"Failed to initialize PaddleOCR-VL with vLLM: {e}")
+        logger.error("PaddleOCR-VL may require a newer vLLM version or server mode.")
+        logger.error("Try running with vllm serve instead:")
+        logger.error(f"  vllm serve {model_name} --trust-remote-code \\")
+        logger.error("    --max-num-batched-tokens 16384 \\")
+        logger.error("    --no-enable-prefix-caching \\")
+        logger.error("    --mm-processor-cache-gb 0")
+        sys.exit(1)
 
     # Sampling parameters - deterministic for OCR
     sampling_params = SamplingParams(
@@ -524,6 +546,17 @@ def main(
     logger.info(f"Processing time: {processing_time_str}")
     logger.info(f"Task mode: {task_mode} - {TASK_DESCRIPTIONS[task_mode]}")
 
+    if verbose:
+        import importlib.metadata
+
+        logger.info("--- Resolved package versions ---")
+        for pkg in ["vllm", "transformers", "torch", "datasets", "pyarrow", "pillow"]:
+            try:
+                logger.info(f"  {pkg}=={importlib.metadata.version(pkg)}")
+            except importlib.metadata.PackageNotFoundError:
+                logger.info(f"  {pkg}: not installed")
+        logger.info("--- End versions ---")
+
 
 if __name__ == "__main__":
     # Show example usage if no arguments
@@ -562,7 +595,7 @@ if __name__ == "__main__":
         print(
             '     -e HF_TOKEN=$(python3 -c "from huggingface_hub import get_token; print(get_token())") \\'
         )
-        print("     -e HF_HUB_ENABLE_HF_TRANSFER=1 \\")
+        print("     -e HF_XET_HIGH_PERFORMANCE=1 \\")
         print(
             "     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/paddleocr-vl.py \\"
         )
@@ -673,7 +706,12 @@ Examples:
     )
     parser.add_argument(
         "--output-column",
-        help="Column name for output (default: paddleocr_[task_mode])",
+        help="Column name for output (default: markdown)",
+    )
+    parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Log resolved package versions after processing (useful for pinning deps)",
     )
 
     args = parser.parse_args()
@@ -696,4 +734,5 @@ Examples:
         shuffle=args.shuffle,
         seed=args.seed,
         output_column=args.output_column,
+        verbose=args.verbose,
     )

smoldocling-ocr.py

@@ -2,7 +2,7 @@
 # requires-python = ">=3.11"
 # dependencies = [
 #     "datasets",
-#     "huggingface-hub[hf_transfer]",
+#     "huggingface-hub",
 #     "pillow",
 #     "vllm",
 #     "tqdm",
@@ -30,20 +30,17 @@ Features:
 """
 
 import argparse
-import base64
 import io
 import json
 import logging
 import os
-import re
 import sys
-from typing import Any, Dict, List, Union
+import time
 from datetime import datetime
+from typing import Any, Dict, Union
 
 import torch
 from datasets import load_dataset
-from docling_core.types.doc import DoclingDocument
-from docling_core.types.doc.document import DocTagsDocument
 from huggingface_hub import DatasetCard, login
 from PIL import Image
 from toolz import partition_all
@@ -226,11 +223,14 @@ def main(
     split: str = "train",
     max_samples: int = None,
     private: bool = False,
-    output_column: str = None,
+    output_column: str = "markdown",
     output_format: str = "markdown",
     shuffle: bool = False,
     seed: int = 42,
     prompt: str = "Convert page to Docling.",
+    config: str = None,
+    create_pr: bool = False,
+    verbose: bool = False,
 ):
     """Process images from HF dataset through SmolDocling model."""
 
@@ -240,9 +240,6 @@ def main(
     # 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:
@@ -252,13 +249,6 @@ def main(
     logger.info(f"Loading dataset: {input_dataset}")
     dataset = load_dataset(input_dataset, split=split)
 
-    # Set output column name dynamically if not provided
-    if output_column is None:
-        # Extract model name from path (e.g., "ds4sd/SmolDocling-256M-preview" -> "smoldocling")
-        model_name = model.split("/")[-1].split("-")[0].lower()
-        output_column = f"{model_name}_text"
-        logger.info(f"Using dynamic output column name: {output_column}")
-
     # Validate image column
     if image_column not in dataset.column_names:
         raise ValueError(
@@ -340,52 +330,69 @@ def main(
     dataset = dataset.add_column(output_column, all_output)
 
     # Handle inference_info tracking
-    logger.info("Updating inference_info...")
-
-    # Check for existing inference_info
-    if "inference_info" in dataset.column_names:
-        # Parse existing info from first row (all rows have same info)
-        try:
-            existing_info = json.loads(dataset[0]["inference_info"])
-            if not isinstance(existing_info, list):
-                existing_info = [existing_info]  # Convert old format to list
-        except (json.JSONDecodeError, TypeError):
-            existing_info = []
-        # Remove old column to update it
-        dataset = dataset.remove_columns(["inference_info"])
-    else:
-        existing_info = []
-
-    # Add new inference info
-    new_info = {
-        "column_name": output_column,
+    inference_entry = {
         "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,
+        "model_name": "SmolDocling-256M",
+        "column_name": output_column,
+        "timestamp": datetime.now().isoformat(),
         "output_format": output_format,
-        "prompt": prompt,
-        "script": "smoldocling-ocr.py",
-        "script_version": "1.0.0",
-        "script_url": "https://huggingface.co/datasets/uv-scripts/ocr/raw/main/smoldocling-ocr.py",
+        "max_tokens": max_tokens,
     }
-    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)
+    if "inference_info" in dataset.column_names:
+        logger.info("Updating existing inference_info column")
+
+        def update_inference_info(example):
+            try:
+                existing_info = (
+                    json.loads(example["inference_info"])
+                    if example["inference_info"]
+                    else []
+                )
+            except (json.JSONDecodeError, TypeError):
+                existing_info = []
+            existing_info.append(inference_entry)
+            return {"inference_info": json.dumps(existing_info)}
+
+        dataset = dataset.map(update_inference_info)
+    else:
+        logger.info("Creating new inference_info column")
+        inference_list = [json.dumps([inference_entry])] * len(dataset)
+        dataset = dataset.add_column("inference_info", inference_list)
 
     # Calculate processing time
-    end_time = datetime.now()
-    processing_duration = end_time - start_time
+    processing_duration = datetime.now() - start_time
     processing_time = f"{processing_duration.total_seconds() / 60:.1f} minutes"
 
+    # Push to hub with retry and XET fallback
+    logger.info(f"Pushing to {output_dataset}")
+    max_retries = 3
+    for attempt in range(1, max_retries + 1):
+        try:
+            if attempt > 1:
+                logger.warning("Disabling XET (fallback to HTTP upload)")
+                os.environ["HF_HUB_DISABLE_XET"] = "1"
+            dataset.push_to_hub(
+                output_dataset,
+                private=private,
+                token=HF_TOKEN,
+                max_shard_size="500MB",
+                **({"config_name": config} if config else {}),
+                create_pr=create_pr,
+                commit_message=f"Add {model} OCR results ({len(dataset)} samples)"
+                + (f" [{config}]" if config else ""),
+            )
+            break
+        except Exception as e:
+            logger.error(f"Upload attempt {attempt}/{max_retries} failed: {e}")
+            if attempt < max_retries:
+                delay = 30 * (2 ** (attempt - 1))
+                logger.info(f"Retrying in {delay}s...")
+                time.sleep(delay)
+            else:
+                logger.error("All upload attempts failed. OCR results are lost.")
+                sys.exit(1)
+
     # Create and push dataset card
     logger.info("Creating dataset card...")
     card_content = create_dataset_card(
@@ -405,12 +412,24 @@ def main(
 
     card = DatasetCard(card_content)
     card.push_to_hub(output_dataset, token=HF_TOKEN)
-    logger.info("✅ Dataset card created and pushed!")
+    logger.info("Dataset card created and pushed!")
 
-    logger.info("✅ OCR conversion complete!")
+    logger.info("SmolDocling processing complete!")
     logger.info(
         f"Dataset available at: https://huggingface.co/datasets/{output_dataset}"
     )
+    logger.info(f"Processing time: {processing_time}")
+
+    if verbose:
+        import importlib.metadata
+
+        logger.info("--- Resolved package versions ---")
+        for pkg in ["vllm", "transformers", "torch", "datasets", "pyarrow", "pillow"]:
+            try:
+                logger.info(f"  {pkg}=={importlib.metadata.version(pkg)}")
+            except importlib.metadata.PackageNotFoundError:
+                logger.info(f"  {pkg}: not installed")
+        logger.info("--- End versions ---")
 
 
 if __name__ == "__main__":
@@ -531,8 +550,8 @@ Examples:
     )
     parser.add_argument(
         "--output-column",
-        default=None,
-        help="Name of the output column for extracted text (default: auto-generated from model name)",
+        default="markdown",
+        help="Column name for output text (default: markdown)",
     )
     parser.add_argument(
         "--output-format",
@@ -556,6 +575,20 @@ Examples:
         default="Convert page to Docling.",
         help="Custom prompt for the model (default: 'Convert page to Docling.')",
     )
+    parser.add_argument(
+        "--config",
+        help="Config/subset name when pushing to Hub (for benchmarking multiple models in one repo)",
+    )
+    parser.add_argument(
+        "--create-pr",
+        action="store_true",
+        help="Create a pull request instead of pushing directly (for parallel benchmarking)",
+    )
+    parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Log resolved package versions after processing (useful for pinning deps)",
+    )
 
     args = parser.parse_args()
 
@@ -577,4 +610,7 @@ Examples:
         shuffle=args.shuffle,
         seed=args.seed,
         prompt=args.prompt,
+        config=args.config,
+        create_pr=args.create_pr,
+        verbose=args.verbose,
     )