add UI

app.py

@@ -1,17 +1,38 @@
 import torch 
 import torchvision 
-from torchvision.models.detection import FasterRCNN_ResNet50_FPN_Weights 
+from torchvision.models.detection import FasterRCNN_ResNet50_FPN_Weights, MaskRCNN_ResNet50_FPN_Weights
+from torchvision.transforms import functional as F
 from PIL import Image 
 import numpy as np 
 import matplotlib.pyplot as plt 
+import matplotlib.patches as patches
 import gradio as gr 
 import os 
 import sys
- 
-# Load the pre-trained model once 
-model = torchvision.models.detection.fasterrcnn_resnet50_fpn(weights=FasterRCNN_ResNet50_FPN_Weights.DEFAULT) 
-model.eval() 
- 
+import random
+from typing import Tuple, List, Dict, Any, Optional
+
+
+# Load models only once
+def load_models():
+    print("Loading detection models...", file=sys.stderr)
+    # Model 1: Faster R-CNN
+    model1 = torchvision.models.detection.fasterrcnn_resnet50_fpn(weights=FasterRCNN_ResNet50_FPN_Weights.DEFAULT)
+    model1.eval()
+    
+    # Model 2: RetinaNet 
+    model2 = torchvision.models.detection.retinanet_resnet50_fpn_v2(weights=torchvision.models.detection.RetinaNet_ResNet50_FPN_V2_Weights.DEFAULT)
+    model2.eval()
+    
+    # Segmentation model
+    seg_model = torchvision.models.detection.maskrcnn_resnet50_fpn(weights=MaskRCNN_ResNet50_FPN_Weights.DEFAULT)
+    seg_model.eval()
+    
+    return model1, model2, seg_model
+
+# Global models
+MODEL1, MODEL2, SEG_MODEL = load_models()
+
 # COCO class names 
 COCO_INSTANCE_CATEGORY_NAMES = [ 
     '__background__', 'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus', 
@@ -26,118 +47,326 @@ COCO_INSTANCE_CATEGORY_NAMES = [
     'N/A', 'N/A', 'toilet', 'N/A', 'tv', 'laptop', 'mouse', 'remote', 'keyboard', 'cell phone', 
     'microwave', 'oven', 'toaster', 'sink', 'refrigerator', 'N/A', 'book', 
     'clock', 'vase', 'scissors', 'teddy bear', 'hair drier', 'toothbrush' 
-] 
+]
 
-# Gradio-compatible detection function 
-def detect_objects(image, threshold=0.5): 
-    if image is None:
-        print("Image is None, returning empty output", file=sys.stderr)
-        # Create a blank image as output
-        blank_img = Image.new('RGB', (400, 400), color='white')
-        plt.figure(figsize=(10, 10))
-        plt.imshow(blank_img)
-        plt.text(0.5, 0.5, "No image provided", 
-                 horizontalalignment='center', verticalalignment='center',
-                 transform=plt.gca().transAxes, fontsize=20)
-        plt.axis('off')
-        output_path = "blank_output.png"
-        plt.savefig(output_path)
-        plt.close()
-        return output_path
+def get_prediction(model, image, threshold=0.5):
+    """Get prediction from model"""
+    transform = FasterRCNN_ResNet50_FPN_Weights.DEFAULT.transforms()
+    image_tensor = transform(image).unsqueeze(0)
+    
+    with torch.no_grad():
+        prediction = model(image_tensor)[0]
+    
+    boxes = prediction['boxes'].cpu().numpy()
+    labels = prediction['labels'].cpu().numpy()
+    scores = prediction['scores'].cpu().numpy()
+    
+    # Filter by threshold
+    keep = scores >= threshold
+    boxes = boxes[keep]
+    labels = labels[keep]
+    scores = scores[keep]
+    
+    return boxes, labels, scores
+
+def get_segmentation_prediction(model, image, threshold=0.5):
+    """Get segmentation prediction"""
+    transform = MaskRCNN_ResNet50_FPN_Weights.DEFAULT.transforms()
+    image_tensor = transform(image).unsqueeze(0)
+    
+    with torch.no_grad():
+        prediction = model(image_tensor)[0]
+    
+    boxes = prediction['boxes'].cpu().numpy()
+    labels = prediction['labels'].cpu().numpy()
+    scores = prediction['scores'].cpu().numpy()
+    masks = prediction['masks'].cpu().numpy()
+    
+    # Filter by threshold
+    keep = scores >= threshold
+    boxes = boxes[keep]
+    labels = labels[keep]
+    scores = scores[keep]
+    masks = masks[keep]
+    
+    return boxes, labels, scores, masks
+
+def visualize_detection(image, boxes, labels, scores, title="Detection Results"):
+    """Visualize detection results"""
+    image_np = np.array(image)
+    plt.figure(figsize=(10, 10))
+    plt.imshow(image_np)
+    ax = plt.gca()
+    
+    for box, label, score in zip(boxes, labels, scores):
+        x1, y1, x2, y2 = box
+        ax.add_patch(plt.Rectangle((x1, y1), x2 - x1, y2 - y1, 
+                    fill=False, color='red', linewidth=2))
+        class_name = COCO_INSTANCE_CATEGORY_NAMES[label]
+        ax.text(x1, y1, f'{class_name}: {score:.2f}', 
+                bbox=dict(facecolor='yellow', alpha=0.5),
+                fontsize=12, color='black')
+    
+    plt.title(title)
+    plt.axis('off')
+    plt.tight_layout()
+    
+    # Save the figure
+    output_path = f"{title.replace(' ', '_').lower()}.png"
+    plt.savefig(output_path)
+    plt.close()
+    return output_path
+
+def visualize_segmentation(image, boxes, labels, scores, masks, title="Segmentation Results"):
+    """Visualize segmentation results"""
+    image_np = np.array(image)
+    plt.figure(figsize=(10, 10))
+    plt.imshow(image_np)
+    ax = plt.gca()
+    
+    # Random colors for masks
+    colors = plt.cm.rainbow(np.linspace(0, 1, len(masks)))
+    
+    for box, label, score, mask, color in zip(boxes, labels, scores, masks, colors):
+        # Draw bounding box
+        x1, y1, x2, y2 = box
+        rect = patches.Rectangle((x1, y1), x2 - x1, y2 - y1,
+                                 linewidth=2, edgecolor='r', facecolor='none')
+        ax.add_patch(rect)
         
+        # Add text
+        class_name = COCO_INSTANCE_CATEGORY_NAMES[label]
+        ax.text(x1, y1-10, f'{class_name}: {score:.2f}', 
+                bbox=dict(facecolor='yellow', alpha=0.5),
+                fontsize=12, color='black')
+        
+        # Draw mask
+        mask_image = mask[0, :, :]  # First channel
+        mask_overlay = np.zeros_like(image_np, dtype=np.uint8)
+        for c in range(3):
+            mask_overlay[:, :, c] = np.where(mask_image > 0.5,
+                                             int(color[c] * 255), 0)
+        
+        # Add mask with transparency
+        alpha = 0.5
+        mask_bool = mask_image > 0.5
+        for c in range(3):
+            image_np[:, :, c] = np.where(
+                mask_bool,
+                image_np[:, :, c] * (1-alpha) + mask_overlay[:, :, c] * alpha,
+                image_np[:, :, c]
+            )
+    
+    plt.imshow(image_np)
+    plt.title(title)
+    plt.axis('off')
+    plt.tight_layout()
+    
+    # Save the figure
+    output_path = f"{title.replace(' ', '_').lower()}.png"
+    plt.savefig(output_path)
+    plt.close()
+    return output_path
+
+def calculate_metrics(boxes, labels, scores):
+    """Calculate simple metrics for model comparison"""
+    # In a real app, you'd use proper metrics like mAP
+    # For simplicity, we'll use:
+    # 1. Number of detections
+    # 2. Average confidence score
+    # 3. Number of unique classes detected
+    
+    num_detections = len(boxes)
+    avg_confidence = np.mean(scores) if len(scores) > 0 else 0
+    unique_classes = len(set(labels))
+    
+    return {
+        "num_detections": num_detections,
+        "avg_confidence": avg_confidence,
+        "unique_classes": unique_classes,
+        "total_score": num_detections * avg_confidence + unique_classes  # Simple combined metric
+    }
+
+def process_game(image, task_type, user_prediction, confidence_threshold=0.5):
+    """Main game function that processes the image based on selected task type"""
+    if image is None:
+        return {
+            "status": "error",
+            "message": "Please upload an image to continue."
+        }, None, None, None, None
+    
     try:
-        print(f"Processing image of type {type(image)} and threshold {threshold}", file=sys.stderr)
-        # Make sure threshold is a valid number
-        if threshold is None:
-            threshold = 0.5
-            print("Threshold was None, using default 0.5", file=sys.stderr)
-        
-        # Convert threshold to float if it's not already
-        threshold = float(threshold)
-        
-        transform = FasterRCNN_ResNet50_FPN_Weights.DEFAULT.transforms() 
-        image_tensor = transform(image).unsqueeze(0) 
-     
-        with torch.no_grad(): 
-            prediction = model(image_tensor)[0] 
-     
-        boxes = prediction['boxes'].cpu().numpy() 
-        labels = prediction['labels'].cpu().numpy() 
-        scores = prediction['scores'].cpu().numpy() 
-     
-        image_np = np.array(image) 
-        plt.figure(figsize=(10, 10)) 
-        plt.imshow(image_np) 
-        ax = plt.gca() 
-     
-        for box, label, score in zip(boxes, labels, scores): 
-            # Explicit debug prints to trace the comparison issue
-            print(f"Score: {score}, Threshold: {threshold}, Type: {type(score)}/{type(threshold)}", file=sys.stderr)
+        if task_type == "Object Detection":
+            # Model 1: Faster R-CNN
+            boxes1, labels1, scores1 = get_prediction(MODEL1, image, confidence_threshold)
+            result1 = visualize_detection(image, boxes1, labels1, scores1, "Faster R-CNN Results")
+            metrics1 = calculate_metrics(boxes1, labels1, scores1)
+            
+            # Model 2: RetinaNet
+            boxes2, labels2, scores2 = get_prediction(MODEL2, image, confidence_threshold)
+            result2 = visualize_detection(image, boxes2, labels2, scores2, "RetinaNet Results")
+            metrics2 = calculate_metrics(boxes2, labels2, scores2)
+            
+            # Determine winner
+            score1 = metrics1["total_score"]
+            score2 = metrics2["total_score"]
+            
+            if score1 > score2:
+                winner = "Model 1 (Faster R-CNN)"
+                winning_score = score1
+                losing_score = score2
+            elif score2 > score1:
+                winner = "Model 2 (RetinaNet)"
+                winning_score = score2
+                losing_score = score1
+            else:
+                winner = "Tie"
+                winning_score = score1
+                losing_score = score2
+            
+            user_correct = (user_prediction == "Model 1" and winner == "Model 1 (Faster R-CNN)") or \
+                          (user_prediction == "Model 2" and winner == "Model 2 (RetinaNet)") or \
+                          (user_prediction == "Tie" and winner == "Tie")
+            
+            result_message = f"Winner: {winner} (Score: {winning_score:.2f} vs {losing_score:.2f})\n"
+            result_message += f"Your prediction: {user_prediction} - {'Correct!' if user_correct else 'Incorrect!'}\n\n"
+            result_message += f"Model 1 detected {metrics1['num_detections']} objects with {metrics1['unique_classes']} unique classes.\n"
+            result_message += f"Model 2 detected {metrics2['num_detections']} objects with {metrics2['unique_classes']} unique classes."
+            
+            return {"status": "success", "message": result_message}, result1, result2, None, None
+        
+        elif task_type == "Instance Segmentation":
+            # Only using one model for segmentation for now
+            boxes, labels, scores, masks = get_segmentation_prediction(SEG_MODEL, image, confidence_threshold)
+            seg_result = visualize_segmentation(image, boxes, labels, scores, masks, "Mask R-CNN Results")
+            
+            # Also get detection results for comparison
+            boxes1, labels1, scores1 = get_prediction(MODEL1, image, confidence_threshold)
+            det_result = visualize_detection(image, boxes1, labels1, scores1, "Detection Results")
+            
+            metrics_seg = calculate_metrics(boxes, labels, scores)
+            metrics_det = calculate_metrics(boxes1, labels1, scores1)
+            
+            result_message = f"Segmentation detected {metrics_seg['num_detections']} objects with {metrics_seg['unique_classes']} unique classes.\n"
+            result_message += f"The segmentation model provides pixel-level masks for each detected object."
+            
+            return {"status": "success", "message": result_message}, None, None, det_result, seg_result
+        
+        else:
+            return {"status": "error", "message": "Invalid task type selected."}, None, None, None, None
             
-            if score >= threshold: 
-                x1, y1, x2, y2 = box 
-                ax.add_patch(plt.Rectangle((x1, y1), x2 - x1, y2 - y1, 
-                             fill=False, color='red', linewidth=2)) 
-                class_name = COCO_INSTANCE_CATEGORY_NAMES[label] 
-                ax.text(x1, y1, f'{class_name}: {score:.2f}', bbox=dict(facecolor='yellow', alpha=0.5), 
-                        fontsize=12, color='black') 
-     
-        plt.axis('off') 
-        plt.tight_layout() 
-         
-        # Save the figure to return 
-        output_path = "output.png"
-        plt.savefig(output_path) 
-        plt.close() 
-        return output_path
     except Exception as e:
-        print(f"Error in detect_objects: {e}", file=sys.stderr)
+        print(f"Error in process_game: {e}", file=sys.stderr)
         import traceback
         traceback.print_exc(file=sys.stderr)
-        
-        # Create an error image
-        error_img = Image.new('RGB', (400, 400), color='white')
-        plt.figure(figsize=(10, 10))
-        plt.imshow(error_img)
-        plt.text(0.5, 0.5, f"Error: {str(e)}", 
-                 horizontalalignment='center', verticalalignment='center',
-                 transform=plt.gca().transAxes, fontsize=12, wrap=True)
-        plt.axis('off')
-        error_path = "error_output.png"
-        plt.savefig(error_path)
-        plt.close()
-        return error_path
-
-# Create direct file paths for examples
-# These exact filenames match what's visible in your repository
-examples = [
-    os.path.join("/home/user/app", "TEST_IMG_1.jpg"),
-    os.path.join("/home/user/app", "TEST_IMG_2.JPG"),
-    os.path.join("/home/user/app", "TEST_IMG_3.jpg"),
-    os.path.join("/home/user/app", "TEST_IMG_4.jpg")
-]
+        return {"status": "error", "message": f"Error processing image: {str(e)}"}, None, None, None, None
 
-# Create Gradio interface
-# Important: For Gradio examples, we need to create a list of lists
-example_list = [[path] for path in examples if os.path.exists(path)]
-
-print(f"Found {len(example_list)} valid examples: {example_list}", file=sys.stderr)
-
-# Create Gradio interface with a simplified approach
-interface = gr.Interface( 
-    fn=detect_objects, 
-    inputs=[
-        gr.Image(type="pil", label="Input Image"),
-        gr.Slider(minimum=0.0, maximum=1.0, value=0.5, step=0.05, label="Confidence Threshold")
-    ],
-    outputs=gr.Image(type="filepath", label="Detected Objects"),
-    title="Faster R-CNN Object Detection",
-    description="Upload an image to detect objects using a pretrained Faster R-CNN model.",
-    examples=example_list,
-    cache_examples=False  # Disable caching to avoid potential issues
-)
+def create_ui():
+    """Create the Gradio UI for the game"""
+    with gr.Blocks(title="Object Detection Game") as app:
+        gr.Markdown("# 🎮 Computer Vision Model Comparison Game")
+        gr.Markdown("Upload an image, choose a task, and predict which model will perform better!")
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                # Input components
+                input_image = gr.Image(type="pil", label="Upload Image")
+                task_type = gr.Radio(
+                    ["Object Detection", "Instance Segmentation"], 
+                    label="Select Task", 
+                    value="Object Detection"
+                )
+                
+                with gr.Row():
+                    with gr.Column(scale=1, visible=True) as detection_options:
+                        user_prediction = gr.Radio(
+                            ["Model 1", "Model 2", "Tie"], 
+                            label="Which model will perform better?",
+                            value="Model 1"
+                        )
+                    
+                confidence = gr.Slider(
+                    minimum=0.0, maximum=1.0, value=0.5, step=0.05,
+                    label="Confidence Threshold"
+                )
+                
+                submit_btn = gr.Button("Run Comparison", variant="primary")
+            
+            with gr.Column(scale=1):
+                # Output components
+                result_msg = gr.JSON(label="Results")
+                
+                # Detection results
+                with gr.Row(visible=True) as detection_results:
+                    model1_output = gr.Image(type="filepath", label="Model 1 (Faster R-CNN)")
+                    model2_output = gr.Image(type="filepath", label="Model 2 (RetinaNet)")
+                
+                # Segmentation results
+                with gr.Row(visible=False) as segmentation_results:
+                    detection_output = gr.Image(type="filepath", label="Detection")
+                    segmentation_output = gr.Image(type="filepath", label="Segmentation")
+        
+        # Example images
+        examples = [
+            os.path.join("/home/user/app", "TEST_IMG_1.jpg"),
+            os.path.join("/home/user/app", "TEST_IMG_2.JPG"),
+            os.path.join("/home/user/app", "TEST_IMG_3.jpg"),
+            os.path.join("/home/user/app", "TEST_IMG_4.jpg")
+        ]
+        
+        # Filter to valid examples
+        example_list = [ex for ex in examples if os.path.exists(ex)]
+        
+        if example_list:
+            gr.Examples(
+                examples=example_list,
+                inputs=input_image,
+                label="Example Images"
+            )
+        
+        # Event handlers
+        def update_task_visibility(task):
+            if task == "Object Detection":
+                return gr.update(visible=True), gr.update(visible=False), gr.update(visible=True), gr.update(visible=False)
+            else:
+                return gr.update(visible=False), gr.update(visible=True), gr.update(visible=False), gr.update(visible=True)
+        
+        task_type.change(
+            fn=update_task_visibility,
+            inputs=task_type,
+            outputs=[detection_options, segmentation_results, detection_results, segmentation_results]
+        )
+        
+        # Submit button click event
+        submit_btn.click(
+            fn=process_game,
+            inputs=[input_image, task_type, user_prediction, confidence],
+            outputs=[result_msg, model1_output, model2_output, detection_output, segmentation_output]
+        )
+        
+        # Add markdown information about the models
+        gr.Markdown("""
+        ## About the Models
+        
+        ### Detection Models:
+        - **Model 1** is Faster R-CNN with ResNet50 backbone, a two-stage detector that's accurate but relatively slower.
+        - **Model 2** is RetinaNet with ResNet50 backbone, a one-stage detector that's designed for better speed-accuracy trade-off.
+        
+        ### Instance Segmentation:
+        - The segmentation model is Mask R-CNN with ResNet50 backbone, which provides pixel-level masks in addition to bounding boxes.
+        
+        ### How is the winner determined?
+        The winner is determined based on a combined score of:
+        1. Number of objects detected
+        2. Average confidence score
+        3. Number of unique classes detected
+        
+        Can you predict which model will perform better on your image?
+        """)
+        
+    return app
 
-# Launch with specific configuration for Hugging Face
+# Launch the app
 if __name__ == "__main__":
-    # Launch with debug mode enabled
-    interface.launch(debug=True)
+    app = create_ui()
+    app.launch(debug=True)