Upload paddleocr-vl-1.5.py with huggingface_hub

paddleocr-vl-1.5.py

@@ -9,7 +9,6 @@
 #     "transformers>=5.0.0",
 #     "accelerate",
 #     "tqdm",
-#     "toolz",
 # ]
 # ///
 
@@ -56,7 +55,6 @@ 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
 
 logging.basicConfig(level=logging.INFO)
@@ -413,36 +411,24 @@ def main(
 
     logger.info(f"Model loaded on {next(model.parameters()).device}")
     max_pixels = MAX_PIXELS.get(task_mode, MAX_PIXELS["default"])
-    logger.info(f"Processing {len(dataset)} images in batches of {batch_size}")
+    logger.info(f"Processing {len(dataset)} images (one at a time for stability)")
     logger.info(f"Image resizing: max_pixels={max_pixels:,} (handled by processor)")
 
-    # Process images in batches
+    # Process images one at a time
+    # Note: Batch processing with transformers VLMs can be unreliable,
+    # so we process individually for stability
     all_outputs = []
 
-    for batch_indices in tqdm(
-        partition_all(batch_size, range(len(dataset))),
-        total=(len(dataset) + batch_size - 1) // batch_size,
-        desc=f"PaddleOCR-VL-1.5 {task_mode.upper()}",
-    ):
-        batch_indices = list(batch_indices)
-        batch_images = [dataset[i][image_column] for i in batch_indices]
-
+    for i in tqdm(range(len(dataset)), desc=f"PaddleOCR-VL-1.5 {task_mode.upper()}"):
         try:
-            # Prepare images and create messages
-            processed_images = [prepare_image(img) for img in batch_images]
-
-            # Create messages for batch
-            batch_messages = [
-                create_message(img, task_mode) for img in processed_images
-            ]
+            # Prepare image and create message
+            image = dataset[i][image_column]
+            pil_image = prepare_image(image)
+            messages = create_message(pil_image, task_mode)
 
-            # Get max_pixels for image processing
-            max_pixels = MAX_PIXELS.get(task_mode, MAX_PIXELS["default"])
-
-            # Process with transformers batch inference
+            # Process with transformers
             inputs = processor.apply_chat_template(
-                batch_messages,
-                padding=True,
+                messages,
                 add_generation_prompt=True,
                 tokenize=True,
                 return_dict=True,
@@ -455,7 +441,7 @@ def main(
                 },
             ).to(model.device)
 
-            # Generate outputs
+            # Generate output
             with torch.no_grad():
                 outputs = model.generate(
                     **inputs,
@@ -463,21 +449,15 @@ def main(
                     do_sample=False,
                 )
 
-            # Decode outputs - skip input tokens
+            # Decode output - skip input tokens
             input_len = inputs["input_ids"].shape[1]
-            generated_ids = outputs[:, input_len:]
-            results = processor.batch_decode(generated_ids, skip_special_tokens=True)
-
-            # Add to outputs
-            for text in results:
-                all_outputs.append(text.strip())
+            generated_ids = outputs[0, input_len:]
+            result = processor.decode(generated_ids, skip_special_tokens=True)
+            all_outputs.append(result.strip())
 
         except Exception as e:
-            logger.error(f"Error processing batch: {e}")
-            # Add error placeholders for failed batch
-            all_outputs.extend(
-                [f"[{task_mode.upper()} ERROR: {str(e)[:100]}]"] * len(batch_images)
-            )
+            logger.error(f"Error processing image {i}: {e}")
+            all_outputs.append(f"[{task_mode.upper()} ERROR: {str(e)[:100]}]")
 
     # Calculate processing time
     processing_duration = datetime.now() - start_time
@@ -656,8 +636,8 @@ Backend: Transformers batch inference (not vLLM)
     parser.add_argument(
         "--batch-size",
         type=int,
-        default=8,
-        help="Batch size for processing (default: 8)",
+        default=1,
+        help="Batch size (currently ignored - images processed one at a time for stability)",
     )
     parser.add_argument(
         "--task-mode",