Update dots-ocr.py with official prompts and simplified design

dots-ocr.py

@@ -4,30 +4,31 @@
 #     "datasets",
 #     "huggingface-hub[hf_transfer]",
 #     "pillow",
-#     "vllm",
-#     "transformers>=4.45.0",
-#     "qwen-vl-utils",
+#     "vllm>=0.9.1",
 #     "tqdm",
 #     "toolz",
 #     "torch",
-#     "flash-attn",
 # ]
 #
 # ///
 
 """
-Document layout analysis and OCR using dots.ocr with vLLM.
+Convert document images to markdown using DoTS.ocr with vLLM.
 
-This script processes document images through the dots.ocr model to extract
-layout information, text content, or both. Supports multiple output formats
-including JSON, structured columns, and markdown.
+DoTS.ocr is a compact 1.7B multilingual document parsing model with SOTA performance
+on 100+ languages. This script uses vLLM for efficient batch processing (2-3x faster
+than native HuggingFace transformers).
 
 Features:
-- Layout detection with bounding boxes and categories
-- Text extraction with reading order preservation
-- Multiple prompt modes for different tasks
-- Flexible output formats
-- Multilingual document support
+- 🌍 Multilingual support (100+ languages)
+- ⚡ Fast processing with vLLM (2-3x speedup)
+- 📊 Table extraction and formatting
+- 📐 Formula recognition
+- 📝 Layout-aware text extraction
+- 🎯 Compact model (1.7B parameters)
+
+Model: rednote-hilab/dots.ocr
+vLLM: Officially tested with 0.9.1+ (native support via PR #24645)
 """
 
 import argparse
@@ -37,37 +38,29 @@ import json
 import logging
 import os
 import sys
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Union
+from datetime import datetime
 
 import torch
 from datasets import load_dataset
-from huggingface_hub import login
+from huggingface_hub import DatasetCard, login
 from PIL import Image
 from toolz import partition_all
 from tqdm.auto import tqdm
-
-# Import both vLLM and transformers - we'll use based on flag
-try:
-    from vllm import LLM, SamplingParams
-    VLLM_AVAILABLE = True
-except ImportError:
-    VLLM_AVAILABLE = False
-    
-from transformers import AutoModelForCausalLM, AutoProcessor
+from vllm import LLM, SamplingParams
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Try to import qwen_vl_utils for transformers backend
-try:
-    from qwen_vl_utils import process_vision_info
-    QWEN_VL_AVAILABLE = True
-except ImportError:
-    QWEN_VL_AVAILABLE = False
-    logger.warning("qwen_vl_utils not available, transformers backend may not work properly")
 
-# Prompt definitions from dots.ocr's dict_promptmode_to_prompt
-PROMPT_MODES = {
+# ────────────────────────────────────────────────────────────────
+# DoTS OCR Prompt Templates (from official dots.ocr repo)
+# Source: https://github.com/rednote-hilab/dots.ocr/blob/master/dots_ocr/utils/prompts.py
+# ────────────────────────────────────────────────────────────────
+
+PROMPT_TEMPLATES = {
+    "ocr": "Extract the text content from this image.",
+
     "layout-all": """Please output the layout information from the PDF image, including each layout element's bbox, its category, and the corresponding text content within the bbox.
 
 1. Bbox format: [x1, y1, x2, y2]
@@ -84,14 +77,9 @@ PROMPT_MODES = {
     - 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.
-""",
-    
+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.""",
-    
-    "ocr": """Extract the text content from this image.""",
-    
-    "grounding-ocr": """Extract text from the given bounding box on the image (format: [x1, y1, x2, y2]).\nBounding Box:\n"""
 }
 
 
@@ -105,12 +93,11 @@ def check_cuda_availability():
         logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
 
 
-def make_dots_message(
+def make_ocr_message(
     image: Union[Image.Image, Dict[str, Any], str],
-    mode: str = "layout-all",
-    bbox: Optional[List[int]] = None,
+    prompt: str = PROMPT_TEMPLATES["ocr"],
 ) -> List[Dict]:
-    """Create chat message for dots.ocr processing."""
+    """Create chat message for OCR processing."""
     # Convert to PIL Image if needed
     if isinstance(image, Image.Image):
         pil_img = image
@@ -121,18 +108,14 @@ def make_dots_message(
     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()}"
 
-    # Get prompt for the specified mode
-    prompt = PROMPT_MODES.get(mode, PROMPT_MODES["layout-all"])
-    
-    # Add bbox for grounding-ocr mode
-    if mode == "grounding-ocr" and bbox:
-        prompt = prompt + str(bbox)
-    
     # Return message in vLLM format
     return [
         {
@@ -145,242 +128,145 @@ def make_dots_message(
     ]
 
 
-def parse_dots_output(
-    output: str,
-    output_format: str = "json",
-    filter_category: Optional[str] = None,
-    mode: str = "layout-all",
-) -> Union[str, Dict[str, List]]:
-    """Parse dots.ocr output and convert to requested format."""
-    
-    # For simple OCR mode, return text directly
-    if mode == "ocr":
-        return output.strip()
-    
-    try:
-        # Parse JSON output
-        data = json.loads(output.strip())
-        
-        # Filter by category if requested
-        if filter_category and "categories" in data:
-            indices = [i for i, cat in enumerate(data["categories"]) if cat == filter_category]
-            filtered_data = {
-                "bboxes": [data["bboxes"][i] for i in indices],
-                "categories": [data["categories"][i] for i in indices],
-            }
-            
-            # Only include texts if present (layout-all mode)
-            if "texts" in data:
-                filtered_data["texts"] = [data["texts"][i] for i in indices]
-            
-            # Include reading_order if present
-            if "reading_order" in data:
-                # Filter reading order to only include indices that are in our filtered set
-                filtered_reading_order = []
-                for group in data.get("reading_order", []):
-                    filtered_group = [idx for idx in group if idx in indices]
-                    if filtered_group:
-                        # Remap indices to new positions
-                        remapped_group = [indices.index(idx) for idx in filtered_group]
-                        filtered_reading_order.append(remapped_group)
-                if filtered_reading_order:
-                    filtered_data["reading_order"] = filtered_reading_order
-            
-            data = filtered_data
-        
-        if output_format == "json":
-            return json.dumps(data, ensure_ascii=False)
-        
-        elif output_format == "structured":
-            # Return structured data for column creation
-            result = {
-                "bboxes": data.get("bboxes", []),
-                "categories": data.get("categories", []),
-            }
-            
-            # Only include texts for layout-all mode
-            if mode == "layout-all":
-                result["texts"] = data.get("texts", [])
-            else:
-                result["texts"] = []
-            
-            return result
-        
-        elif output_format == "markdown":
-            # Convert to markdown format
-            # Only works well with layout-all mode
-            if mode != "layout-all" or "texts" not in data:
-                logger.warning("Markdown format works best with layout-all mode")
-                return json.dumps(data, ensure_ascii=False)
-            
-            md_lines = []
-            texts = data.get("texts", [])
-            categories = data.get("categories", [])
-            reading_order = data.get("reading_order", [])
-            
-            # If reading order is provided, use it
-            if reading_order:
-                for group in reading_order:
-                    for idx in group:
-                        if idx < len(texts) and idx < len(categories):
-                            text = texts[idx]
-                            category = categories[idx]
-                            md_lines.append(format_markdown_text(text, category))
-            else:
-                # Fall back to sequential order
-                for text, category in zip(texts, categories):
-                    md_lines.append(format_markdown_text(text, category))
-            
-            return "\n".join(md_lines)
-            
-    except json.JSONDecodeError as e:
-        logger.warning(f"Failed to parse JSON output: {e}")
-        return output.strip()
-    except Exception as e:
-        logger.error(f"Error parsing output: {e}")
-        return output.strip()
-
-
-def format_markdown_text(text: str, category: str) -> str:
-    """Format text based on its category for markdown output."""
-    if category == "Title":
-        return f"# {text}\n"
-    elif category == "Section-header":
-        return f"## {text}\n"
-    elif category == "List-item":
-        return f"- {text}"
-    elif category == "Page-header" or category == "Page-footer":
-        return f"_{text}_\n"
-    elif category == "Caption":
-        return f"**{text}**\n"
-    elif category == "Footnote":
-        return f"[^{text}]\n"
-    elif category == "Table":
-        # Tables are already in HTML format from dots.ocr
-        return f"\n{text}\n"
-    elif category == "Formula":
-        # Formulas are already in LaTeX format
-        return f"\n${text}$\n"
-    elif category == "Picture":
-        # Pictures don't have text in dots.ocr output
-        return "\n![Image]()\n"
-    else:  # Text and any other categories
-        return f"{text}\n"
-
-
-def process_with_transformers(
-    images: List[Union[Image.Image, Dict[str, Any], str]],
-    model,
-    processor,
-    mode: str = "layout-all",
-    max_new_tokens: int = 16384,
-) -> List[str]:
-    """Process images using transformers instead of vLLM."""
-    outputs = []
-    
-    for image in tqdm(images, desc="Processing with transformers"):
-        # Convert to PIL Image if needed
-        if isinstance(image, dict) and "bytes" in image:
-            pil_image = Image.open(io.BytesIO(image["bytes"]))
-        elif isinstance(image, str):
-            pil_image = Image.open(image)
-        else:
-            pil_image = image
-            
-        # Get prompt for the mode
-        prompt = PROMPT_MODES.get(mode, PROMPT_MODES["layout-all"])
-        
-        # Create messages in the format expected by dots.ocr
-        messages = [
-            {
-                "role": "user",
-                "content": [
-                    {"type": "image", "image": pil_image},
-                    {"type": "text", "text": prompt}
-                ]
-            }
-        ]
-        
-        # Preparation for inference (following demo code)
-        text = processor.apply_chat_template(
-            messages, 
-            tokenize=False, 
-            add_generation_prompt=True
-        )
-        
-        if QWEN_VL_AVAILABLE:
-            # Use process_vision_info as shown in demo
-            image_inputs, video_inputs = process_vision_info(messages)
-            inputs = processor(
-                text=[text],
-                images=image_inputs,
-                videos=video_inputs,
-                padding=True,
-                return_tensors="pt",
-            )
-        else:
-            # Fallback approach without qwen_vl_utils
-            inputs = processor(
-                text=text,
-                images=[pil_image],
-                return_tensors="pt",
-            )
-        
-        inputs = inputs.to(model.device)
-        
-        # Generate
-        with torch.no_grad():
-            generated_ids = model.generate(
-                **inputs,
-                max_new_tokens=max_new_tokens,
-                temperature=0.0,
-                do_sample=False,
-            )
-        
-        # Decode output (following demo code)
-        generated_ids_trimmed = [
-            out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
-        ]
-        output_text = processor.batch_decode(
-            generated_ids_trimmed, 
-            skip_special_tokens=True, 
-            clean_up_tokenization_spaces=False
-        )[0]
-        
-        outputs.append(output_text.strip())
-    
-    return outputs
+def create_dataset_card(
+    source_dataset: str,
+    model: str,
+    num_samples: int,
+    processing_time: str,
+    batch_size: int,
+    max_model_len: int,
+    max_tokens: int,
+    gpu_memory_utilization: float,
+    image_column: str = "image",
+    split: str = "train",
+    prompt_mode: str = "general",
+) -> str:
+    """Create a dataset card documenting the OCR process."""
+    model_name = model.split("/")[-1]
+
+    return f"""---
+viewer: false
+tags:
+- ocr
+- document-processing
+- dots-ocr
+- multilingual
+- markdown
+- uv-script
+- generated
+---
+
+# Document OCR using {model_name}
+
+This dataset contains OCR results from images in [{source_dataset}](https://huggingface.co/datasets/{source_dataset}) using DoTS.ocr, a compact 1.7B multilingual model.
+
+## Processing Details
+
+- **Source Dataset**: [{source_dataset}](https://huggingface.co/datasets/{source_dataset})
+- **Model**: [{model}](https://huggingface.co/{model})
+- **Number of Samples**: {num_samples:,}
+- **Processing Time**: {processing_time}
+- **Processing Date**: {datetime.now().strftime("%Y-%m-%d %H:%M UTC")}
+
+### Configuration
+
+- **Image Column**: `{image_column}`
+- **Output Column**: `markdown`
+- **Dataset Split**: `{split}`
+- **Batch Size**: {batch_size}
+- **Prompt Mode**: {prompt_mode}
+- **Max Model Length**: {max_model_len:,} tokens
+- **Max Output Tokens**: {max_tokens:,}
+- **GPU Memory Utilization**: {gpu_memory_utilization:.1%}
+
+## Model Information
+
+DoTS.ocr is a compact multilingual document parsing model that excels at:
+- 🌍 **100+ Languages** - Multilingual document support
+- 📊 **Table extraction** - Structured data recognition
+- 📐 **Formulas** - Mathematical notation preservation
+- 📝 **Layout-aware** - Reading order and structure preservation
+- ⚡ **Fast inference** - 2-3x faster than native HF with vLLM
+- 🎯 **Compact** - Only 1.7B parameters
+
+## Dataset Structure
+
+The dataset contains all original columns plus:
+- `markdown`: The extracted text in markdown format
+- `inference_info`: JSON list tracking all OCR models applied to this dataset
+
+## Usage
+
+```python
+from datasets import load_dataset
+import json
+
+# Load the dataset
+dataset = load_dataset("{{output_dataset_id}}", split="{split}")
+
+# Access the markdown text
+for example in dataset:
+    print(example["markdown"])
+    break
+
+# View all OCR models applied to this dataset
+inference_info = json.loads(dataset[0]["inference_info"])
+for info in inference_info:
+    print(f"Column: {{info['column_name']}} - Model: {{info['model_id']}}")
+```
+
+## Reproduction
+
+This dataset was generated using the [uv-scripts/ocr](https://huggingface.co/datasets/uv-scripts/ocr) DoTS OCR script:
+
+```bash
+uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/dots-ocr.py \\
+    {source_dataset} \\
+    <output-dataset> \\
+    --image-column {image_column} \\
+    --batch-size {batch_size} \\
+    --prompt-mode {prompt_mode} \\
+    --max-model-len {max_model_len} \\
+    --max-tokens {max_tokens} \\
+    --gpu-memory-utilization {gpu_memory_utilization}
+```
+
+## Performance
+
+- **Processing Speed**: ~{num_samples / (float(processing_time.split()[0]) * 60):.1f} images/second
+- **GPU Configuration**: vLLM with {gpu_memory_utilization:.0%} GPU memory utilization
+
+Generated with 🤖 [UV Scripts](https://huggingface.co/uv-scripts)
+"""
 
 
 def main(
     input_dataset: str,
     output_dataset: str,
     image_column: str = "image",
-    mode: str = "layout-all",
-    output_format: str = "json",
-    filter_category: Optional[str] = None,
-    batch_size: int = 32,
+    batch_size: int = 16,
     model: str = "rednote-hilab/dots.ocr",
-    max_model_len: int = 24000,
-    max_tokens: int = 16384,
+    max_model_len: int = 8192,
+    max_tokens: int = 8192,
     gpu_memory_utilization: float = 0.8,
-    hf_token: Optional[str] = None,
+    hf_token: str = None,
     split: str = "train",
-    max_samples: Optional[int] = None,
+    max_samples: int = None,
     private: bool = False,
-    use_transformers: bool = False,
-    # Column name parameters
-    output_column: str = "dots_ocr_output",
-    bbox_column: str = "layout_bboxes",
-    category_column: str = "layout_categories",
-    text_column: str = "layout_texts",
-    markdown_column: str = "markdown",
+    shuffle: bool = False,
+    seed: int = 42,
+    prompt_mode: str = "ocr",
+    custom_prompt: str = None,
+    output_column: str = "markdown",
 ):
-    """Process images from HF dataset through dots.ocr model."""
+    """Process images from HF dataset through DoTS.ocr model."""
 
     # Check CUDA availability first
     check_cuda_availability()
 
+    # Track processing start time
+    start_time = datetime.now()
+
     # Enable HF_TRANSFER for faster downloads
     os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"
 
@@ -389,6 +275,14 @@ def main(
     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)
@@ -399,207 +293,176 @@ def main(
             f"Column '{image_column}' not found. Available: {dataset.column_names}"
         )
 
+    # Shuffle if requested
+    if shuffle:
+        logger.info(f"Shuffling dataset with seed {seed}")
+        dataset = dataset.shuffle(seed=seed)
+
     # Limit samples if requested
     if max_samples:
         dataset = dataset.select(range(min(max_samples, len(dataset))))
         logger.info(f"Limited to {len(dataset)} samples")
 
-    # Process images in batches
-    all_outputs = []
-    
-    if use_transformers or not VLLM_AVAILABLE:
-        # Use transformers
-        if not use_transformers and not VLLM_AVAILABLE:
-            logger.warning("vLLM not available, falling back to transformers")
-            
-        logger.info(f"Initializing transformers with model: {model}")
-        hf_model = AutoModelForCausalLM.from_pretrained(
-            model,
-            torch_dtype=torch.bfloat16,
-            device_map="auto",
-            trust_remote_code=True,
-        )
-        processor = AutoProcessor.from_pretrained(model, trust_remote_code=True)
-        
-        logger.info(f"Processing {len(dataset)} images with transformers")
-        logger.info(f"Mode: {mode}, Output format: {output_format}")
-        
-        # Process all images
-        all_images = [dataset[i][image_column] for i in range(len(dataset))]
-        raw_outputs = process_with_transformers(
-            all_images, 
-            hf_model, 
-            processor, 
-            mode=mode,
-            max_new_tokens=max_tokens
-        )
-        
-        # Parse outputs
-        for raw_text in raw_outputs:
-            parsed = parse_dots_output(raw_text, output_format, filter_category, mode)
-            all_outputs.append(parsed)
-            
-    else:
-        # Use vLLM
-        logger.info(f"Initializing vLLM with model: {model}")
-        llm = LLM(
-            model=model,
-            trust_remote_code=True,
-            max_model_len=max_model_len,
-            gpu_memory_utilization=gpu_memory_utilization,
-        )
+    # Initialize vLLM model
+    logger.info(f"Initializing vLLM with model: {model}")
+    logger.info("This may take a few minutes on first run...")
+    llm = LLM(
+        model=model,
+        trust_remote_code=True,
+        max_model_len=max_model_len,
+        gpu_memory_utilization=gpu_memory_utilization,
+    )
 
-        sampling_params = SamplingParams(
-            temperature=0.0,  # Deterministic for OCR
-            max_tokens=max_tokens,
-        )
+    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"Mode: {mode}, Output format: {output_format}")
+    logger.info(f"Processing {len(dataset)} images in batches of {batch_size}")
+    logger.info(f"Output will be written to column: {output_column}")
 
-        # Process in batches to avoid memory issues
-        for batch_indices in tqdm(
-            partition_all(batch_size, range(len(dataset))),
-            total=(len(dataset) + batch_size - 1) // batch_size,
-            desc="dots.ocr processing",
-        ):
-            batch_indices = list(batch_indices)
-            batch_images = [dataset[i][image_column] for i in batch_indices]
+    # Process images in batches
+    all_outputs = []
 
+    for batch_indices in tqdm(
+        partition_all(batch_size, range(len(dataset))),
+        total=(len(dataset) + batch_size - 1) // batch_size,
+        desc="DoTS.ocr processing",
+    ):
+        batch_indices = list(batch_indices)
+        batch_images = [dataset[i][image_column] for i in batch_indices]
+
+        try:
+            # Create messages for batch
+            batch_messages = [make_ocr_message(img, prompt) for img in batch_images]
+
+            # Process with vLLM
+            outputs = llm.chat(batch_messages, sampling_params)
+
+            # Extract outputs
+            for output in outputs:
+                text = output.outputs[0].text.strip()
+                all_outputs.append(text)
+
+        except Exception as e:
+            logger.error(f"Error processing batch: {e}")
+            # Add error placeholders for failed batch
+            all_outputs.extend(["[OCR ERROR]"] * len(batch_images))
+
+    # Calculate processing time
+    processing_duration = datetime.now() - start_time
+    processing_time_str = f"{processing_duration.total_seconds() / 60:.1f} min"
+
+    # Add output column to dataset
+    logger.info(f"Adding '{output_column}' column to dataset")
+    dataset = dataset.add_column(output_column, all_outputs)
+
+    # Handle inference_info tracking (for multi-model comparisons)
+    inference_entry = {
+        "model_id": model,
+        "column_name": output_column,
+        "timestamp": datetime.now().isoformat(),
+        "prompt_mode": prompt_mode if not custom_prompt else "custom",
+    }
+
+    if "inference_info" in dataset.column_names:
+        # Append to existing inference info
+        logger.info("Updating existing inference_info column")
+
+        def update_inference_info(example):
             try:
-                # Create messages for batch
-                batch_messages = [make_dots_message(img, mode=mode) for img in batch_images]
-
-                # Process with vLLM
-                outputs = llm.chat(batch_messages, sampling_params)
-
-                # Extract and parse outputs
-                for output in outputs:
-                    raw_text = output.outputs[0].text.strip()
-                    parsed = parse_dots_output(raw_text, output_format, filter_category, mode)
-                    all_outputs.append(parsed)
-
-            except Exception as e:
-                logger.error(f"Error processing batch: {e}")
-                # Add error placeholders for failed batch
-                all_outputs.extend([{"error": str(e)}] * len(batch_images))
-
-    # Add columns to dataset based on output format
-    logger.info("Adding output columns to dataset")
-    
-    if output_format == "json":
-        dataset = dataset.add_column(output_column, all_outputs)
-        
-    elif output_format == "structured":
-        # Extract lists from structured outputs
-        bboxes = []
-        categories = []
-        texts = []
-        
-        for output in all_outputs:
-            if isinstance(output, dict) and "error" not in output:
-                bboxes.append(output.get("bboxes", []))
-                categories.append(output.get("categories", []))
-                texts.append(output.get("texts", []))
-            else:
-                bboxes.append([])
-                categories.append([])
-                texts.append([])
-        
-        dataset = dataset.add_column(bbox_column, bboxes)
-        dataset = dataset.add_column(category_column, categories)
-        dataset = dataset.add_column(text_column, texts)
-        
-    elif output_format == "markdown":
-        dataset = dataset.add_column(markdown_column, all_outputs)
-    
-    else:  # ocr mode
-        dataset = dataset.add_column(output_column, all_outputs)
+                existing_info = json.loads(example["inference_info"]) if example["inference_info"] else []
+            except (json.JSONDecodeError, TypeError):
+                existing_info = []
+
+            existing_info.append(inference_entry)
+            return {"inference_info": json.dumps(existing_info)}
+
+        dataset = dataset.map(update_inference_info)
+    else:
+        # Create new inference_info column
+        logger.info("Creating new inference_info column")
+        inference_list = [json.dumps([inference_entry])] * len(dataset)
+        dataset = dataset.add_column("inference_info", inference_list)
 
     # Push to hub
     logger.info(f"Pushing to {output_dataset}")
     dataset.push_to_hub(output_dataset, private=private, token=HF_TOKEN)
 
-    logger.info("✅ dots.ocr processing complete!")
-    logger.info(
-        f"Dataset available at: https://huggingface.co/datasets/{output_dataset}"
+    # Create and push dataset card
+    logger.info("Creating dataset card")
+    card_content = create_dataset_card(
+        source_dataset=input_dataset,
+        model=model,
+        num_samples=len(dataset),
+        processing_time=processing_time_str,
+        batch_size=batch_size,
+        max_model_len=max_model_len,
+        max_tokens=max_tokens,
+        gpu_memory_utilization=gpu_memory_utilization,
+        image_column=image_column,
+        split=split,
+        prompt_mode=prompt_mode if not custom_prompt else "custom",
     )
 
+    card = DatasetCard(card_content)
+    card.push_to_hub(output_dataset, token=HF_TOKEN)
+
+    logger.info("✅ DoTS.ocr processing complete!")
+    logger.info(f"Dataset available at: https://huggingface.co/datasets/{output_dataset}")
+    logger.info(f"Processing time: {processing_time_str}")
+
 
 if __name__ == "__main__":
     # Show example usage if no arguments
     if len(sys.argv) == 1:
         print("=" * 80)
-        print("dots.ocr Document Layout Analysis and OCR")
+        print("DoTS.ocr Document Processing")
         print("=" * 80)
-        print("\nThis script processes document images using the dots.ocr model to")
-        print("extract layout information, text content, or both.")
+        print("\nCompact 1.7B multilingual OCR model supporting 100+ languages")
         print("\nFeatures:")
-        print("- Layout detection with bounding boxes and categories")
-        print("- Text extraction with reading order preservation")
-        print("- Multiple output formats (JSON, structured, markdown)")
-        print("- Multilingual document support")
+        print("- 🌍 Multilingual support (100+ languages)")
+        print("- ⚡ Fast processing with vLLM (2-3x speedup)")
+        print("- 📊 Table extraction and formatting")
+        print("- 📐 Formula recognition")
+        print("- 📝 Layout-aware text extraction")
         print("\nExample usage:")
-        print("\n1. Full layout analysis + OCR (default):")
-        print("   uv run dots-ocr.py document-images analyzed-docs")
-        print("\n2. Layout detection only:")
-        print("   uv run dots-ocr.py scanned-pdfs layout-analysis --mode layout-only")
-        print("\n3. Simple OCR (text only):")
-        print("   uv run dots-ocr.py documents extracted-text --mode ocr")
-        print("\n4. Convert to markdown:")
-        print("   uv run dots-ocr.py papers papers-markdown --output-format markdown")
-        print("\n5. Extract only tables:")
-        print("   uv run dots-ocr.py reports table-data --filter-category Table")
-        print("\n6. Structured output with custom columns:")
-        print("   uv run dots-ocr.py docs analyzed \\")
-        print("       --output-format structured \\")
-        print("       --bbox-column boxes \\")
-        print("       --category-column types \\")
-        print("       --text-column content")
-        print("\n7. Process a subset for testing:")
-        print("   uv run dots-ocr.py large-dataset test-output --max-samples 10")
-        print("\n8. Use transformers backend (more compatible):")
-        print("   uv run dots-ocr.py documents analyzed --use-transformers")
-        print("\n9. Running on HF Jobs:")
-        print("   hf jobs run --gpu l4x1 \\")
+        print("\n1. Basic OCR:")
+        print("   uv run dots-ocr.py input-dataset output-dataset")
+        print("\n2. With custom settings:")
+        print("   uv run dots-ocr.py docs analyzed-docs --batch-size 20 --max-samples 100")
+        print("\n3. Layout analysis with structure:")
+        print("   uv run dots-ocr.py papers analyzed-structure --prompt-mode layout-all")
+        print("\n4. Layout detection only (no text):")
+        print("   uv run dots-ocr.py docs layout-info --prompt-mode layout-only")
+        print("\n5. Running on HF Jobs:")
+        print("   hf jobs uv run --flavor l4x1 \\")
         print("     -e HF_TOKEN=$(python3 -c \"from huggingface_hub import get_token; print(get_token())\") \\")
-        print(
-            "     uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/dots-ocr.py \\"
-        )
-        print("       your-document-dataset \\")
-        print("       your-analyzed-output \\")
-        print("       --use-transformers")
+        print("     -e HF_HUB_ENABLE_HF_TRANSFER=1 \\")
+        print("     https://huggingface.co/datasets/uv-scripts/ocr/raw/main/dots-ocr.py \\")
+        print("       input-dataset output-dataset")
         print("\n" + "=" * 80)
         print("\nFor full help, run: uv run dots-ocr.py --help")
         sys.exit(0)
 
     parser = argparse.ArgumentParser(
-        description="Document layout analysis and OCR using dots.ocr",
+        description="Document OCR using DoTS.ocr (1.7B multilingual model)",
         formatter_class=argparse.RawDescriptionHelpFormatter,
         epilog="""
-Modes:
-  layout-all   - Extract layout + text content (default)
-  layout-only  - Extract only layout information (bbox + category)
-  ocr          - Extract only text content
-  grounding-ocr - Extract text from specific bbox (requires --bbox)
-
-Output Formats:
-  json        - Raw JSON output from model (default)
-  structured  - Separate columns for bboxes, categories, texts
-  markdown    - Convert to markdown format
+Prompt Modes (official DoTS.ocr prompts):
+  ocr         - Simple text extraction (default)
+  layout-all  - Layout analysis with bboxes, categories, and text (JSON output)
+  layout-only - Layout detection with bboxes and categories only (JSON output)
 
 Examples:
-  # Basic layout + OCR
+  # Basic text OCR (default)
   uv run dots-ocr.py my-docs analyzed-docs
 
-  # Layout detection only
-  uv run dots-ocr.py papers layouts --mode layout-only
+  # Full layout analysis with structure
+  uv run dots-ocr.py papers structured --prompt-mode layout-all
 
-  # Convert to markdown
-  uv run dots-ocr.py scans readable --output-format markdown
-
-  # Extract only formulas
-  uv run dots-ocr.py math-docs formulas --filter-category Formula
+  # Random sampling for testing
+  uv run dots-ocr.py large-dataset test --max-samples 50 --shuffle
         """,
     )
 
@@ -610,29 +473,11 @@ Examples:
         default="image",
         help="Column containing images (default: image)",
     )
-    parser.add_argument(
-        "--mode",
-        choices=["layout-all", "layout-only", "ocr", "grounding-ocr"],
-        default="layout-all",
-        help="Processing mode (default: layout-all)",
-    )
-    parser.add_argument(
-        "--output-format",
-        choices=["json", "structured", "markdown"],
-        default="json",
-        help="Output format (default: json)",
-    )
-    parser.add_argument(
-        "--filter-category",
-        choices=['Caption', 'Footnote', 'Formula', 'List-item', 'Page-footer', 
-                 'Page-header', 'Picture', 'Section-header', 'Table', 'Text', 'Title'],
-        help="Filter results by layout category",
-    )
     parser.add_argument(
         "--batch-size",
         type=int,
-        default=32,
-        help="Batch size for processing (default: 32)",
+        default=16,
+        help="Batch size for processing (default: 16, DoTS handles 16-30 well)",
     )
     parser.add_argument(
         "--model",
@@ -642,14 +487,14 @@ Examples:
     parser.add_argument(
         "--max-model-len",
         type=int,
-        default=24000,
-        help="Maximum model context length (default: 24000)",
+        default=8192,
+        help="Maximum model context length (default: 8192)",
     )
     parser.add_argument(
         "--max-tokens",
         type=int,
-        default=16384,
-        help="Maximum tokens to generate (default: 16384)",
+        default=8192,
+        help="Maximum tokens to generate (default: 8192)",
     )
     parser.add_argument(
         "--gpu-memory-utilization",
@@ -670,36 +515,28 @@ Examples:
         "--private", action="store_true", help="Make output dataset private"
     )
     parser.add_argument(
-        "--use-transformers",
-        action="store_true",
-        help="Use transformers instead of vLLM (more compatible but slower)",
+        "--shuffle", action="store_true", help="Shuffle dataset before processing"
     )
-    
-    # Column name customization
     parser.add_argument(
-        "--output-column",
-        default="dots_ocr_output",
-        help="Column name for JSON output (default: dots_ocr_output)",
-    )
-    parser.add_argument(
-        "--bbox-column",
-        default="layout_bboxes",
-        help="Column name for bboxes in structured mode (default: layout_bboxes)",
+        "--seed",
+        type=int,
+        default=42,
+        help="Random seed for shuffling (default: 42)",
     )
     parser.add_argument(
-        "--category-column",
-        default="layout_categories",
-        help="Column name for categories in structured mode (default: layout_categories)",
+        "--prompt-mode",
+        choices=list(PROMPT_TEMPLATES.keys()),
+        default="ocr",
+        help=f"Prompt template to use: {', '.join(PROMPT_TEMPLATES.keys())} (default: ocr)",
     )
     parser.add_argument(
-        "--text-column",
-        default="layout_texts",
-        help="Column name for texts in structured mode (default: layout_texts)",
+        "--custom-prompt",
+        help="Custom prompt text (overrides --prompt-mode)",
     )
     parser.add_argument(
-        "--markdown-column",
+        "--output-column",
         default="markdown",
-        help="Column name for markdown output (default: markdown)",
+        help="Column name for output text (default: markdown)",
     )
 
     args = parser.parse_args()
@@ -708,9 +545,6 @@ Examples:
         input_dataset=args.input_dataset,
         output_dataset=args.output_dataset,
         image_column=args.image_column,
-        mode=args.mode,
-        output_format=args.output_format,
-        filter_category=args.filter_category,
         batch_size=args.batch_size,
         model=args.model,
         max_model_len=args.max_model_len,
@@ -720,10 +554,9 @@ Examples:
         split=args.split,
         max_samples=args.max_samples,
         private=args.private,
-        use_transformers=args.use_transformers,
+        shuffle=args.shuffle,
+        seed=args.seed,
+        prompt_mode=args.prompt_mode,
+        custom_prompt=args.custom_prompt,
         output_column=args.output_column,
-        bbox_column=args.bbox_column,
-        category_column=args.category_column,
-        text_column=args.text_column,
-        markdown_column=args.markdown_column,
-    )
+    )