Upload paddleocr-vl-1.5.py with huggingface_hub

paddleocr-vl-1.5.py

@@ -45,7 +45,6 @@ import argparse
 import io
 import json
 import logging
-import math
 import os
 import sys
 from datetime import datetime
@@ -101,59 +100,6 @@ def check_cuda_availability():
         logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
 
 
-def smart_resize(
-    height: int,
-    width: int,
-    factor: int = 28,
-    min_pixels: int = 28 * 28 * 130,
-    max_pixels: int = 28 * 28 * 1280,
-) -> tuple[int, int]:
-    """
-    PaddleOCR-VL's intelligent resize logic.
-
-    Rescales the image so that:
-    1. Both dimensions are divisible by 'factor' (28)
-    2. Total pixels are within [min_pixels, max_pixels]
-    3. Aspect ratio is maintained as closely as possible
-
-    Args:
-        height: Original image height
-        width: Original image width
-        factor: Dimension divisibility factor (default: 28)
-        min_pixels: Minimum total pixels (default: 100,880)
-        max_pixels: Maximum total pixels (default: 1,003,520)
-
-    Returns:
-        Tuple of (new_height, new_width)
-    """
-    if height < factor:
-        width = round((width * factor) / height)
-        height = factor
-
-    if width < factor:
-        height = round((height * factor) / width)
-        width = factor
-
-    if max(height, width) / min(height, width) > 200:
-        logger.warning(
-            f"Extreme aspect ratio detected: {max(height, width) / min(height, width):.1f}"
-        )
-
-    h_bar = round(height / factor) * factor
-    w_bar = round(width / factor) * factor
-
-    if h_bar * w_bar > max_pixels:
-        beta = math.sqrt((height * width) / max_pixels)
-        h_bar = math.floor(height / beta / factor) * factor
-        w_bar = math.floor(width / beta / factor) * factor
-    elif h_bar * w_bar < min_pixels:
-        beta = math.sqrt(min_pixels / (height * width))
-        h_bar = math.ceil(height * beta / factor) * factor
-        w_bar = math.ceil(width * beta / factor) * factor
-
-    return h_bar, w_bar
-
-
 def prepare_image(
     image: Union[Image.Image, Dict[str, Any], str],
 ) -> Image.Image:
@@ -212,9 +158,7 @@ def create_dataset_card(
     task_mode: str,
     num_samples: int,
     processing_time: str,
-    batch_size: int,
     max_tokens: int,
-    apply_smart_resize: bool,
     image_column: str = "image",
     split: str = "train",
 ) -> str:
@@ -249,10 +193,8 @@ This dataset contains {task_mode.upper()} results from images in [{source_datase
 - **Image Column**: `{image_column}`
 - **Output Column**: `paddleocr_1.5_{task_mode}`
 - **Dataset Split**: `{split}`
-- **Batch Size**: {batch_size}
-- **Smart Resize**: {"Enabled" if apply_smart_resize else "Disabled"}
 - **Max Output Tokens**: {max_tokens:,}
-- **Backend**: Transformers (batch inference)
+- **Backend**: Transformers (single image processing)
 
 ## Model Information
 
@@ -312,8 +254,7 @@ uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/paddleocr-vl-1.5.
     {source_dataset} \\
     <output-dataset> \\
     --task-mode {task_mode} \\
-    --image-column {image_column} \\
-    --batch-size {batch_size}
+    --image-column {image_column}
 ```
 
 ## Performance
@@ -321,7 +262,7 @@ uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/paddleocr-vl-1.5.
 - **Model Size**: 0.9B parameters
 - **Benchmark Score**: 94.5% SOTA on OmniDocBench v1.5
 - **Processing Speed**: ~{num_samples / (float(processing_time.split()[0]) * 60):.2f} images/second
-- **Backend**: Transformers batch inference
+- **Backend**: Transformers (single image processing)
 
 Generated with 🤖 [UV Scripts](https://huggingface.co/uv-scripts)
 """
@@ -331,10 +272,8 @@ def main(
     input_dataset: str,
     output_dataset: str,
     image_column: str = "image",
-    batch_size: int = 8,
     task_mode: str = "ocr",
     max_tokens: int = 512,
-    apply_smart_resize: bool = True,
     hf_token: str = None,
     split: str = "train",
     max_samples: int = None,
@@ -418,10 +357,8 @@ def main(
     # Note: Batch processing with transformers VLMs can be unreliable,
     # so we process individually for stability
     all_outputs = []
-    logger.info("Starting image processing loop...")
 
     for i in tqdm(range(len(dataset)), desc=f"PaddleOCR-VL-1.5 {task_mode.upper()}"):
-        logger.info(f"Processing image {i+1}/{len(dataset)}...")
         try:
             # Prepare image and create message
             image = dataset[i][image_column]
@@ -456,7 +393,6 @@ def main(
             generated_ids = outputs[0, input_len:]
             result = processor.decode(generated_ids, skip_special_tokens=True)
             all_outputs.append(result.strip())
-            logger.info(f"Image {i+1} done. Output length: {len(result)} chars")
 
         except Exception as e:
             logger.error(f"Error processing image {i}: {e}")
@@ -479,7 +415,6 @@ def main(
         "column_name": output_column,
         "timestamp": datetime.now().isoformat(),
         "max_tokens": max_tokens,
-        "smart_resize": apply_smart_resize,
         "backend": "transformers",
     }
 
@@ -519,9 +454,7 @@ def main(
         task_mode=task_mode,
         num_samples=len(dataset),
         processing_time=processing_time_str,
-        batch_size=batch_size,
         max_tokens=max_tokens,
-        apply_smart_resize=apply_smart_resize,
         image_column=image_column,
         split=split,
     )
@@ -567,9 +500,7 @@ if __name__ == "__main__":
         print("\n2. Table extraction:")
         print("   uv run paddleocr-vl-1.5.py docs tables-extracted --task-mode table")
         print("\n3. Formula recognition:")
-        print(
-            "   uv run paddleocr-vl-1.5.py papers formulas --task-mode formula --batch-size 16"
-        )
+        print("   uv run paddleocr-vl-1.5.py papers formulas --task-mode formula")
         print("\n4. Text spotting (higher resolution):")
         print("   uv run paddleocr-vl-1.5.py images spotted --task-mode spotting")
         print("\n5. Seal recognition:")
@@ -636,12 +567,6 @@ Backend: Transformers batch inference (not vLLM)
         default="image",
         help="Column containing images (default: image)",
     )
-    parser.add_argument(
-        "--batch-size",
-        type=int,
-        default=1,
-        help="Batch size (currently ignored - images processed one at a time for stability)",
-    )
     parser.add_argument(
         "--task-mode",
         choices=list(TASK_MODES.keys()),
@@ -654,11 +579,6 @@ Backend: Transformers batch inference (not vLLM)
         default=512,
         help="Maximum tokens to generate (default: 512)",
     )
-    parser.add_argument(
-        "--no-smart-resize",
-        action="store_true",
-        help="Disable smart resize, use original image size",
-    )
     parser.add_argument("--hf-token", help="Hugging Face API token")
     parser.add_argument(
         "--split", default="train", help="Dataset split to use (default: train)"
@@ -691,10 +611,8 @@ Backend: Transformers batch inference (not vLLM)
         input_dataset=args.input_dataset,
         output_dataset=args.output_dataset,
         image_column=args.image_column,
-        batch_size=args.batch_size,
         task_mode=args.task_mode,
         max_tokens=args.max_tokens,
-        apply_smart_resize=not args.no_smart_resize,
         hf_token=args.hf_token,
         split=args.split,
         max_samples=args.max_samples,