Add batch processing support for up to 50 images

app.py

@@ -46,9 +46,9 @@ def preprocess_image(image):
     img_final = np.transpose(img_norm, (2, 0, 1))
     return np.expand_dims(img_final, axis=0).astype(np.float32)
 
-def predict(image):
+def predict_single_image(image):
     """
-    Run inference on input image and return predictions with metrics
+    Run inference on a single image
     
     Args:
         image: PIL Image or numpy array
@@ -90,60 +90,199 @@ def predict(image):
         "inference_time_ms": f"{inference_time:.2f}"
     }
 
-# Create Gradio interface
-demo = gr.Interface(
-    fn=predict,
-    inputs=gr.Image(type="pil", label="Upload Bus Inspection Image"),
-    outputs=gr.JSON(label="Prediction Results"),
-    title="🚌 Bus Inspection Classifier - SigLIP v2",
-    description="""
-    Upload an image of a bus component for automated classification.
-    
-    **18 Categories:**
-    AC Mat | Alco brake camera | Alco-brake device | Back windshield | Bus back side | Bus front side | Bus side | Cabin | Driver grooming | First aid kit | Floormats & POS | Front windshield | Hat rack | ITMS Device | Jack & Spare tyre | Luggage compartment | RFID Card | Seats
-    
-    **Returns:**
-    - `class_name`: Predicted bus component category
-    - `confidence`: Model confidence score (%)
-    - `inference_time_ms`: Processing time in milliseconds
+def predict_batch(images):
+    """
+    Run inference on multiple images (up to 50)
+    
+    Args:
+        images: List of PIL Images or file paths
+        
+    Returns:
+        dict: Summary and list of individual results
+    """
+    if images is None or len(images) == 0:
+        return {
+            "error": "No images 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 = []
+    total_start_time = time.time()
+    
+    for idx, img in enumerate(images):
+        try:
+            # Handle file path or PIL Image
+            if isinstance(img, str):
+                image = Image.open(img).convert('RGB')
+            elif isinstance(img, np.ndarray):
+                image = Image.fromarray(img).convert('RGB')
+            else:
+                image = img.convert('RGB')
+            
+            # Get prediction
+            result = predict_single_image(image)
+            result["image_index"] = idx + 1
+            results.append(result)
+            
+        except Exception as e:
+            results.append({
+                "image_index": idx + 1,
+                "error": str(e),
+                "class_name": None,
+                "confidence": None,
+                "inference_time_ms": None
+            })
+    
+    total_time = (time.time() - total_start_time) * 1000
+    
+    return {
+        "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]),
+        "total_processing_time_ms": f"{total_time:.2f}",
+        "average_time_per_image_ms": f"{total_time / len(images):.2f}",
+        "results": results
+    }
+
+# Create tabbed interface
+with gr.Blocks(title="🚌 Bus Inspection Classifier") as demo:
+    gr.Markdown("# 🚌 Bus Inspection Classifier - SigLIP v2")
+    gr.Markdown("""
+    Automated bus component classification using the **SigLIP v2** vision model.
+    
+    **18 Categories:** AC Mat | Alco brake camera | Alco-brake device | Back windshield | Bus back side | Bus front side | Bus side | Cabin | Driver grooming | First aid kit | Floormats & POS | Front windshield | Hat rack | ITMS Device | Jack & Spare tyre | Luggage compartment | RFID Card | Seats
+    """)
+    
+    with gr.Tabs():
+        # Single Image Tab
+        with gr.Tab("Single Image"):
+            gr.Markdown("### Upload a single bus inspection image")
+            with gr.Row():
+                with gr.Column():
+                    single_input = gr.Image(type="pil", label="Upload Image")
+                    single_button = gr.Button("Classify", variant="primary")
+                with gr.Column():
+                    single_output = gr.JSON(label="Prediction Result")
+            
+            single_button.click(
+                fn=predict_single_image,
+                inputs=single_input,
+                outputs=single_output
+            )
+            
+            gr.Markdown("""
+            **Returns:**
+            - `class_name`: Predicted bus component category
+            - `confidence`: Model confidence score (%)
+            - `inference_time_ms`: Processing time in milliseconds
+            """)
+        
+        # Batch Processing Tab
+        with gr.Tab("Batch Processing (Up to 50 Images)"):
+            gr.Markdown("### Upload multiple images for batch classification")
+            with gr.Row():
+                with gr.Column():
+                    batch_input = gr.File(
+                        file_count="multiple",
+                        label="Upload Images (Max 50)",
+                        file_types=["image"]
+                    )
+                    batch_button = gr.Button("Classify Batch", variant="primary")
+                with gr.Column():
+                    batch_output = gr.JSON(label="Batch Results")
+            
+            batch_button.click(
+                fn=predict_batch,
+                inputs=batch_input,
+                outputs=batch_output
+            )
+            
+            gr.Markdown("""
+            **Returns:**
+            ```json
+            {
+              "total_images": 10,
+              "successful_predictions": 10,
+              "failed_predictions": 0,
+              "total_processing_time_ms": "456.78",
+              "average_time_per_image_ms": "45.68",
+              "results": [
+                {
+                  "image_index": 1,
+                  "class_name": "Bus front side",
+                  "confidence": "98.45%",
+                  "inference_time_ms": "43.21"
+                },
+                ...
+              ]
+            }
+            ```
+            """)
     
+    # API Documentation
+    gr.Markdown("""
     ---
     
-    ### 🔌 API Usage
+    ## 🔌 API Usage
+    
+    ### Single Image API
     
-    **Python Example:**
+    **Using Gradio Client (Python):**
     ```python
-    import requests
-    from PIL import Image
+    from gradio_client import Client
+    
+    client = Client("Wicky/bus-inspection-classifier")
+    result = client.predict("bus_image.jpg", api_name="/predict")
+    print(result)
+    ```
+    
+    ### Batch Processing API
     
-    # Your Hugging Face Space URL
-    API_URL = "https://YOUR-USERNAME-bus-inspection.hf.space/api/predict"
+    **Using Gradio Client (Python):**
+    ```python
+    from gradio_client import Client
     
-    # Load your image
-    image = Image.open("bus_image.jpg")
+    client = Client("Wicky/bus-inspection-classifier")
     
-    # Make prediction
-    response = requests.post(API_URL, files={"data": open("bus_image.jpg", "rb")})
-    result = response.json()
+    # Upload multiple images
+    image_files = ["img1.jpg", "img2.jpg", "img3.jpg"]
+    result = client.predict(image_files, api_name="/predict_batch")
     
-    print(f"Class: {result['class_name']}")
-    print(f"Confidence: {result['confidence']}")
-    print(f"Time: {result['inference_time_ms']} ms")
+    print(f"Total: {result['total_images']}")
+    print(f"Successful: {result['successful_predictions']}")
+    
+    for res in result['results']:
+        print(f"Image {res['image_index']}: {res['class_name']} ({res['confidence']})")
     ```
     
-    Using the **Gradio Client:**
+    **Using Python Requests:**
     ```python
-    from gradio_client import Client
+    import requests
     
-    client = Client("YOUR-USERNAME/bus-inspection")
-    result = client.predict("bus_image.jpg")
-    print(result)
+    files = [
+        ('files', open('img1.jpg', 'rb')),
+        ('files', open('img2.jpg', 'rb')),
+        ('files', open('img3.jpg', 'rb'))
+    ]
+    
+    response = requests.post(
+        "https://Wicky-bus-inspection-classifier.hf.space/api/predict_batch",
+        files=files
+    )
+    
+    results = response.json()
+    print(results)
     ```
-    """,
-    examples=[],
-    allow_flagging="never",
-    analytics_enabled=False
-)
+    """)
 
 if __name__ == "__main__":
     demo.launch()