Add unlimited CSV batch processing with given class matching

app.py

@@ -3,6 +3,9 @@ import onnxruntime as ort
 import numpy as np
 from PIL import Image
 import time
+import pandas as pd
+import requests
+from io import BytesIO
 
 # Load class names
 CLASS_NAMES = [
@@ -90,33 +93,114 @@ def predict_single_image(image):
         "inference_time_ms": f"{inference_time:.2f}"
     }
 
-def predict_batch(images):
+
+def predict_batch(images, csv_file):
     """
-    Run inference on multiple images (up to 50)
+    Run inference on multiple images or CSV with image URLs (unlimited)
     
     Args:
-        images: List of PIL Images or file paths
+        images: List of PIL Images or file paths (or None)
+        csv_file: CSV file with image URLs (or None)
         
     Returns:
         tuple: (gallery_data, json_results)
             - gallery_data: List of (image, caption) tuples for Gradio Gallery
             - json_results: Dictionary with summary and individual results
     """
+    # Check if CSV file is provided
+    if csv_file is not None:
+        try:
+            # Read CSV
+            df = pd.read_csv(csv_file)
+            
+            # Validate columns
+            if 'Answer' not in df.columns or 'Questions - QuestionId → Name' not in df.columns:
+                return [], {
+                    "error": "CSV must have 'Answer' and 'Questions - QuestionId → Name' columns",
+                    "total_images": 0,
+                    "results": []
+                }
+            
+            results = []
+            gallery_images = []
+            total_start_time = time.time()
+            
+            # Process each row
+            for idx, row in df.iterrows():
+                try:
+                    # Get image URL and expected class
+                    img_url = row['Answer']
+                    given_class = row['Questions - QuestionId → Name']
+                    
+                    # Download image from URL
+                    response = requests.get(img_url, timeout=10)
+                    response.raise_for_status()
+                    image = Image.open(BytesIO(response.content)).convert('RGB')
+                    
+                    # Get prediction
+                    result = predict_single_image(image)
+                    result["image_index"] = idx + 1
+                    result["given_class"] = given_class
+                    result["image_url"] = img_url
+                    
+                    # Check if matches
+                    result["match"] = "✓" if given_class.lower() in result["class_name"].lower() or result["class_name"].lower() in given_class.lower() else "✗"
+                    
+                    results.append(result)
+                    
+                    # Create caption for gallery
+                    caption = f"#{idx + 1}: {result['class_name']} {result['match']}\nGiven: {given_class}\nConf: {result['confidence']} | {result['inference_time_ms']}ms"
+                    
+                    # Add to gallery
+                    gallery_images.append((image, caption))
+                    
+                except Exception as e:
+                    results.append({
+                        "image_index": idx + 1,
+                        "given_class": row.get('Questions - QuestionId → Name', 'Unknown'),
+                        "image_url": row.get('Answer', 'Unknown'),
+                        "error": str(e),
+                        "class_name": None,
+                        "confidence": None,
+                        "inference_time_ms": None,
+                        "match": "✗"
+                    })
+            
+            total_time = (time.time() - total_start_time) * 1000
+            
+            # Calculate accuracy
+            successful = [r for r in results if "error" not in r]
+            matched = [r for r in successful if r["match"] == "✓"]
+            
+            json_results = {
+                "source": "CSV",
+                "total_images": len(df),
+                "successful_predictions": len(successful),
+                "failed_predictions": len(results) - len(successful),
+                "matched_predictions": len(matched),
+                "accuracy": f"{(len(matched) / len(successful) * 100):.2f}%" if successful else "0%",
+                "total_processing_time_ms": f"{total_time:.2f}",
+                "average_time_per_image_ms": f"{total_time / len(df):.2f}",
+                "results": results
+            }
+            
+            return gallery_images, json_results
+            
+        except Exception as e:
+            return [], {
+                "error": f"CSV processing error: {str(e)}",
+                "total_images": 0,
+                "results": []
+            }
+    
+    # Process regular image uploads (no limit)
     if images is None or len(images) == 0:
         return [], {
-            "error": "No images provided",
+            "error": "No images or CSV provided",
             "total_images": 0,
             "results": []
         }
     
-    # Limit to 50 images
-    if len(images) > 50:
-        return [], {
-            "error": "Maximum 50 images allowed",
-            "total_images": len(images),
-            "results": []
-        }
-    
     results = []
     gallery_images = []
     total_start_time = time.time()
@@ -169,6 +253,7 @@ def predict_batch(images):
     total_time = (time.time() - total_start_time) * 1000
     
     json_results = {
+        "source": "Direct Upload",
         "total_images": len(images),
         "successful_predictions": len([r for r in results if "error" not in r]),
         "failed_predictions": len([r for r in results if "error" in r]),
@@ -213,14 +298,23 @@ with gr.Blocks(title="🚌 Bus Inspection Classifier") as demo:
             """)
         
         # Batch Processing Tab
-        with gr.Tab("Batch Processing (Up to 50 Images)"):
-            gr.Markdown("### Upload multiple images for batch classification")
+        with gr.Tab("Batch Processing (Unlimited)"):
+            gr.Markdown("### Upload images OR CSV file with image URLs")
+            gr.Markdown("**Option 1:** Upload multiple images directly")
+            gr.Markdown("**Option 2:** Upload CSV with columns: `Questions - QuestionId → Name` (given class) and `Answer` (image URL)")
             
             batch_input = gr.File(
                 file_count="multiple",
-                label="Upload Images (Max 50)",
+                label="Upload Images",
                 file_types=["image"]
             )
+            
+            csv_input = gr.File(
+                file_count="single",
+                label="OR Upload CSV with Image URLs",
+                file_types=[".csv"]
+            )
+            
             batch_button = gr.Button("Classify Batch", variant="primary", size="lg")
             
             # Gallery to show images with predictions
@@ -238,7 +332,7 @@ with gr.Blocks(title="🚌 Bus Inspection Classifier") as demo:
             
             batch_button.click(
                 fn=predict_batch,
-                inputs=batch_input,
+                inputs=[batch_input, csv_input],
                 outputs=[batch_gallery, batch_output]
             )
             

requirements.txt

@@ -2,3 +2,5 @@ gradio
 onnxruntime
 numpy
 Pillow
+pandas
+requests