Update app.py

added Progress bar, ETA and multiple images in Inference tool

app.py

@@ -17,73 +17,86 @@ def yolo_inference_tool():
     Single-model, single-image inference subpage (example).
     """
     st.header("YOLO Model Inference Tool")
-    st.write("Upload an image and a YOLO model (.pt) file to run inference and view detailed results.")
-
-    image_file = st.file_uploader("Upload Image", type=["jpg", "jpeg", "png"], key="inference_image")
+    st.write("Upload one or more images and a YOLO model (.pt) file to run inference and view detailed results.")
+    
+    # Allow multiple images upload
+    images = st.file_uploader("Upload Images", type=["jpg", "jpeg", "png"], key="inference_images", accept_multiple_files=True)
     model_file = st.file_uploader("Upload YOLO model (.pt)", type=["pt"], key="inference_model")
-
+    
     if st.button("Submit (Single-Model Inference)"):
-        if not image_file or not model_file:
-            st.error("Please upload both an image and a model.")
+        if not images or not model_file:
+            st.error("Please upload at least one image and a model.")
             return
 
-        # Save files
-        image_path = save_uploaded_file(image_file)
+        # Save and load the model file
         model_path = save_uploaded_file(model_file)
-
-        # Load image
-        try:
-            image = Image.open(image_file).convert("RGB")
-        except Exception as e:
-            st.error(f"Error reading image: {e}")
-            return
-
-        st.subheader("Image Details")
-        st.write(f"**Image Size:** {image.size[0]} x {image.size[1]}")
-        st.write(f"**File Type:** {image_file.type}")
-
-        # Load model
         try:
             model = YOLO(model_path)
         except Exception as e:
             st.error(f"Error loading model: {e}")
             return
 
-        # Inference
-        st.subheader("Inference Results")
-        try:
-            results = model(np.array(image))
-        except Exception as e:
-            st.error(f"Inference error: {e}")
-            return
+        total_images = len(images)
+        progress_bar = st.progress(0)
+        eta_placeholder = st.empty()
+        start_time = time.time()
+        steps_done = 0
 
-        r = results[0]
-        boxes_data = []
-        if r.boxes is not None and len(r.boxes) > 0:
-            for i in range(len(r.boxes)):
-                coords = r.boxes.xyxy[i].cpu().numpy() if hasattr(r.boxes.xyxy[i], "cpu") else r.boxes.xyxy[i]
-                conf = r.boxes.conf[i].cpu().numpy() if hasattr(r.boxes.conf[i], "cpu") else r.boxes.conf[i]
-                cls_idx = int(r.boxes.cls[i].cpu().numpy()) if hasattr(r.boxes.cls[i], "cpu") else int(r.boxes.cls[i])
-                class_name = r.names.get(cls_idx, "Unknown")
-                boxes_data.append({
-                    "Box": i + 1,
-                    "Coordinates": f"[{coords[0]:.1f}, {coords[1]:.1f}, {coords[2]:.1f}, {coords[3]:.1f}]",
-                    "Confidence": f"{conf:.2f}",
-                    "Class": class_name
-                })
-            df_boxes = pd.DataFrame(boxes_data)
-            st.subheader("Detected Objects")
-            st.dataframe(df_boxes, use_container_width=True)
-        else:
-            st.write("No objects detected.")
-
-        # Annotated image
-        try:
-            annotated_img_pil = r.plot(conf=True, boxes=True, labels=True, pil=True)
-            st.subheader("Annotated Image")
-            st.image(annotated_img_pil, caption="Inference Output", use_container_width=True)
-        except Exception as e:
-            st.error(f"Error generating annotated image: {e}")
+        # Dictionaries to store inference results and metrics
+        image_results = {}
+        metrics = []
+        
+        for img_file in images:
+            steps_done += 1
+            fraction_done = steps_done / total_images
+            progress_bar.progress(fraction_done)
+            
+            elapsed_time = time.time() - start_time
+            time_per_step = elapsed_time / steps_done
+            remaining_steps = total_images - steps_done
+            eta_seconds = remaining_steps * time_per_step
+            eta_placeholder.info(f"Progress: {fraction_done:.1%}. ETA: ~{eta_seconds:.1f} s")
+
+            try:
+                pil_img = Image.open(img_file).convert("RGB")
+            except Exception as e:
+                st.error(f"Error reading image {img_file.name}: {e}")
+                continue
+
+            try:
+                result = model(np.array(pil_img))
+            except Exception as e:
+                st.error(f"Inference error on image {img_file.name}: {e}")
+                continue
+
+            r = result[0]
+            image_results[img_file.name] = r
+
+            # Collect basic metrics if available (e.g., inference time and detections)
+            inference_time = r.speed.get('inference', None) if isinstance(r.speed, dict) else None
+            detection_count = len(r.boxes) if r.boxes is not None else 0
+            metrics.append({
+                "Image": img_file.name,
+                "Inference Time (ms)": inference_time if inference_time is not None else "N/A",
+                "Detections": detection_count
+            })
+        
+        eta_placeholder.empty()
+        
+        # Display per-image metrics if collected
+        st.subheader("Inference Metrics")
+        if metrics:
+            df_metrics = pd.DataFrame(metrics)
+            st.dataframe(df_metrics, use_container_width=True)
+        
+        # Display annotated images (using pil=True to ensure RGB output)
+        st.subheader("Annotated Images")
+        for img_name, r in image_results.items():
+            try:
+                annotated_img = r.plot(conf=True, boxes=True, labels=True, pil=True)
+                st.image(annotated_img, caption=img_name, use_container_width=True)
+            except Exception as e:
+                st.error(f"Error generating annotated image for {img_name}: {e}")
 
 def yolo_model_comparison_tool():
     """