Add real-time progressive display for batch processing

app.py

@@ -96,16 +96,14 @@ def predict_single_image(image):
 
 def predict_batch(images, csv_file):
     """
-    Run inference on multiple images or CSV with image URLs (unlimited)
+    Run inference on multiple images or CSV with image URLs (unlimited) with PROGRESSIVE DISPLAY
     
     Args:
         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
+    Yields:
+        tuple: (gallery_data, json_results) after each image is processed
     """
     # Check if CSV file is provided
     if csv_file is not None:
@@ -115,17 +113,18 @@ def predict_batch(images, csv_file):
             
             # Validate columns
             if 'Answer' not in df.columns or 'Questions - QuestionId → Name' not in df.columns:
-                return [], {
+                yield [], {
                     "error": "CSV must have 'Answer' and 'Questions - QuestionId → Name' columns",
                     "total_images": 0,
                     "results": []
                 }
+                return
             
             results = []
             gallery_images = []
             total_start_time = time.time()
             
-            # Process each row
+            # Process each row PROGRESSIVELY
             for idx, row in df.iterrows():
                 try:
                     # Get image URL and expected class
@@ -165,41 +164,65 @@ def predict_batch(images, csv_file):
                         "inference_time_ms": None,
                         "match": "✗"
                     })
+                
+                # YIELD after each image - REAL-TIME UPDATE!
+                elapsed_time = (time.time() - total_start_time) * 1000
+                successful = [r for r in results if "error" not in r]
+                matched = [r for r in successful if r["match"] == "✓"]
+                
+                json_results = {
+                    "source": "CSV",
+                    "status": f"Processing... {idx + 1}/{len(df)}",
+                    "total_images": len(df),
+                    "processed": idx + 1,
+                    "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%",
+                    "elapsed_time_ms": f"{elapsed_time:.2f}",
+                    "average_time_per_image_ms": f"{elapsed_time / (idx + 1):.2f}",
+                    "results": results[-10:]  # Show last 10 for performance
+                }
+                
+                yield gallery_images.copy(), json_results
             
+            # Final yield with complete results
             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 = {
+            final_results = {
                 "source": "CSV",
+                "status": "✅ Complete!",
                 "total_images": len(df),
+                "processed": 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
+                "results": results  # Full results at the end
             }
             
-            return gallery_images, json_results
+            yield gallery_images, final_results
             
         except Exception as e:
-            return [], {
+            yield [], {
                 "error": f"CSV processing error: {str(e)}",
                 "total_images": 0,
                 "results": []
             }
+            return
     
-    # Process regular image uploads (no limit)
+    # Process regular image uploads (no limit) PROGRESSIVELY
     if images is None or len(images) == 0:
-        return [], {
+        yield [], {
             "error": "No images or CSV provided",
             "total_images": 0,
             "results": []
         }
+        return
     
     results = []
     gallery_images = []
@@ -249,20 +272,40 @@ def predict_batch(images, csv_file):
                 gallery_images.append((error_img, f"#{idx + 1}: ERROR - {str(e)}"))
             except:
                 pass
+        
+        # YIELD after each image - REAL-TIME UPDATE!
+        elapsed_time = (time.time() - total_start_time) * 1000
+        
+        json_results = {
+            "source": "Direct Upload",
+            "status": f"Processing... {idx + 1}/{len(images)}",
+            "total_images": len(images),
+            "processed": idx + 1,
+            "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]),
+            "elapsed_time_ms": f"{elapsed_time:.2f}",
+            "average_time_per_image_ms": f"{elapsed_time / (idx + 1):.2f}",
+            "results": results[-10:]  # Show last 10 for performance
+        }
+        
+        yield gallery_images.copy(), json_results
     
+    # Final yield with complete results
     total_time = (time.time() - total_start_time) * 1000
     
-    json_results = {
+    final_results = {
         "source": "Direct Upload",
+        "status": "✅ Complete!",
         "total_images": len(images),
+        "processed": 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
+        "results": results  # Full results at the end
     }
     
-    return gallery_images, json_results
+    yield gallery_images, final_results
 
 # Create tabbed interface
 with gr.Blocks(title="🚌 Bus Inspection Classifier") as demo: