V1

app.py

@@ -3,32 +3,20 @@ import importlib.util
 import os
 import sys
 import cv2
-
-# Check if detectron2 is installed
-if importlib.util.find_spec("detectron2") is None:
-    print("Installing PyTorch and Detectron2...")
-    os.system("pip install torch torchvision --extra-index-url https://download.pytorch.org/whl/cpu")
-    os.system("pip install git+https://github.com/facebookresearch/detectron2.git")
-
-    print("Installation complete!")
-
-# -*- coding: utf-8 -*-
-
-
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-import os
-import sys
 import time
 import torch
 import numpy as np
 import gradio as gr
 from PIL import Image
 from torchvision import transforms
+import traceback
 
-DEFAULT_DAMAGE_MODEL_PATH = "./model_final.pth"  # Replace with your actual path
-DEFAULT_DEEPFAKE_MODEL_PATH = "./PoseEfficientNet_custom_laanet_model_final.pth"  # Replace with your actual path  
-DEFAULT_DEEPFAKE_CFG_PATH = "./configs/detector2.yaml"  # Replace with your actual path
+# Check if detectron2 is installed
+if importlib.util.find_spec("detectron2") is None:
+    print("Installing PyTorch and Detectron2...")
+    os.system("pip install torch torchvision --extra-index-url https://download.pytorch.org/whl/cpu")
+    os.system("pip install git+https://github.com/facebookresearch/detectron2.git")
+    print("Installation complete!")
 
 # Add current directory to path
 if not os.getcwd() in sys.path:
@@ -54,6 +42,103 @@ except ImportError:
     print("Warning: Custom models couldn't be imported. Only damage detection will work.")
     MODELS_IMPORTED = False
 
+# Define the model paths at the beginning of your script
+DEFAULT_DAMAGE_MODEL_PATH = "./model_final.pth"  # Replace with your actual path
+DEFAULT_DEEPFAKE_MODEL_PATH = "./PoseEfficientNet_custom_laanet_model_final.pth"  # Replace with your actual path  
+DEFAULT_DEEPFAKE_CFG_PATH = "./configs/detector2.yaml"  # Replace with your actual path
+
+def verify_detectron2_installation():
+    """Verify that Detectron2 is properly installed and can access model zoo"""
+    import sys
+    import importlib.util
+    
+    results = {
+        "detectron2_installed": False,
+        "model_zoo_accessible": False,
+        "can_create_cfg": False,
+        "error_messages": []
+    }
+    
+    # Check if detectron2 is installed
+    try:
+        if importlib.util.find_spec("detectron2") is not None:
+            results["detectron2_installed"] = True
+            print("✅ Detectron2 is installed")
+            
+            # Try importing detectron2
+            try:
+                import detectron2
+                print(f"✅ Detectron2 version: {detectron2.__version__}")
+                
+                # Try accessing model zoo
+                try:
+                    from detectron2 import model_zoo
+                    # Try accessing a config file
+                    config_file = "COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml"
+                    config_path = model_zoo.get_config_file(config_file)
+                    if os.path.exists(config_path):
+                        results["model_zoo_accessible"] = True
+                        print(f"✅ Model zoo is accessible, found config: {config_path}")
+                    else:
+                        results["error_messages"].append(f"Config file exists but cannot be accessed: {config_path}")
+                        print(f"❌ Config file exists but cannot be accessed: {config_path}")
+                except Exception as e:
+                    results["error_messages"].append(f"Error accessing model zoo: {str(e)}")
+                    print(f"❌ Error accessing model zoo: {str(e)}")
+                    traceback.print_exc()
+                
+                # Try creating a config
+                try:
+                    from detectron2.config import get_cfg
+                    cfg = get_cfg()
+                    results["can_create_cfg"] = True
+                    print("✅ Can create Detectron2 config")
+                    
+                    # Try setting up a model configuration
+                    try:
+                        cfg.merge_from_file(model_zoo.get_config_file(config_file))
+                        print("✅ Can load model configuration from model zoo")
+                        
+                        # Check if we can set up a default predictor (without actually creating it)
+                        try:
+                            from detectron2.engine import DefaultPredictor
+                            print("✅ DefaultPredictor class is available")
+                        except Exception as e:
+                            results["error_messages"].append(f"Error importing DefaultPredictor: {str(e)}")
+                            print(f"❌ Error importing DefaultPredictor: {str(e)}")
+                    except Exception as e:
+                        results["error_messages"].append(f"Error setting up model configuration: {str(e)}")
+                        print(f"❌ Error setting up model configuration: {str(e)}")
+                except Exception as e:
+                    results["error_messages"].append(f"Error creating Detectron2 config: {str(e)}")
+                    print(f"❌ Error creating Detectron2 config: {str(e)}")
+            except Exception as e:
+                results["error_messages"].append(f"Error importing detectron2: {str(e)}")
+                print(f"❌ Error importing detectron2: {str(e)}")
+        else:
+            results["error_messages"].append("Detectron2 is not installed")
+            print("❌ Detectron2 is not installed")
+    except Exception as e:
+        results["error_messages"].append(f"Error checking Detectron2 installation: {str(e)}")
+        print(f"❌ Error checking Detectron2 installation: {str(e)}")
+    
+    # Print Python version and platform info
+    print(f"Python version: {sys.version}")
+    print(f"Platform: {sys.platform}")
+    
+    # Print PyTorch version if available
+    try:
+        import torch
+        print(f"PyTorch version: {torch.__version__}")
+        print(f"CUDA available: {torch.cuda.is_available()}")
+        if torch.cuda.is_available():
+            print(f"CUDA version: {torch.version.cuda}")
+            print(f"GPU: {torch.cuda.get_device_name(0)}")
+    except ImportError:
+        print("PyTorch is not installed")
+    
+    return results
+
 def setup_device(device_str):
     """Set up the computation device based on user input and availability"""
     if device_str == 'auto':
@@ -72,32 +157,62 @@ def setup_device(device_str):
         return torch.device('cpu')
 
 def setup_damage_detector(model_path, threshold=0.7):
-    """Set up the damage detection model using Detectron2"""
+    """Set up the damage detection model using Detectron2 with enhanced error logging"""
     if not DETECTRON2_AVAILABLE:
         print("Detectron2 is not installed. Cannot set up damage detector.")
         return None, None
+    
+    try:    
+        print(f"Checking if damage model exists at path: {model_path}")
+        if model_path is None:
+            print("Error: No damage model path specified")
+            return None, None
+            
+        if not os.path.exists(model_path):
+            print(f"Error: Damage model file not found at {model_path}")
+            return None, None
         
-    if model_path is None or not os.path.exists(model_path):
-        print("No damage model specified or file not found. Skipping damage detection.")
-        return None, None
+        print("Model file exists, setting up configuration...")
+        cfg = get_cfg()
+        print("Loading base config from model zoo...")
+        try:
+            cfg.merge_from_file(model_zoo.get_config_file("COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml"))
+            print("Base config loaded successfully")
+        except Exception as e:
+            print(f"Error loading base config: {e}")
+            traceback.print_exc()
+            return None, None
         
-    cfg = get_cfg()
-    cfg.merge_from_file(model_zoo.get_config_file("COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml"))
-    cfg.MODEL.WEIGHTS = model_path
-    cfg.MODEL.ROI_HEADS.NUM_CLASSES = 1  # Only one class (damage)
-    cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = threshold
-    
-    # Explicitly set to use CPU if on Mac (MPS)
-    if torch.backends.mps.is_available():
-        cfg.MODEL.DEVICE = "cpu"
-        print("Mac MPS detected - forcing Detectron2 to use CPU")
-    
-    try:
-        predictor = DefaultPredictor(cfg)
-        return predictor, cfg
+        print(f"Setting model weights to: {model_path}")
+        cfg.MODEL.WEIGHTS = model_path
+        cfg.MODEL.ROI_HEADS.NUM_CLASSES = 1  # Only one class (damage)
+        cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = threshold
+        
+        # Explicitly set to use CPU if on Mac (MPS)
+        if hasattr(torch, 'backends') and hasattr(torch.backends, 'mps') and torch.backends.mps.is_available():
+            cfg.MODEL.DEVICE = "cpu"
+            print("Mac MPS detected - forcing Detectron2 to use CPU")
+        
+        # Print configuration for debugging
+        print("Detectron2 configuration:")
+        print(f"- Model weights: {cfg.MODEL.WEIGHTS}")
+        print(f"- Number of classes: {cfg.MODEL.ROI_HEADS.NUM_CLASSES}")
+        print(f"- Score threshold: {cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST}")
+        print(f"- Device: {cfg.MODEL.DEVICE}")
+        
+        print("Creating predictor...")
+        try:
+            predictor = DefaultPredictor(cfg)
+            print("Predictor created successfully!")
+            return predictor, cfg
+        except Exception as e:
+            print(f"Error creating predictor: {e}")
+            traceback.print_exc()
+            return None, cfg
     except Exception as e:
-        print(f"Error setting up damage detector: {e}")
-        return None, cfg
+        print(f"Unexpected error in damage detector setup: {e}")
+        traceback.print_exc()
+        return None, None
 
 def load_deepfake_model(model_path, cfg_path, device):
     """Load the deepfake detection model"""
@@ -138,7 +253,6 @@ def load_deepfake_model(model_path, cfg_path, device):
         return model, cfg
     except Exception as e:
         print(f"Error loading deepfake model: {e}")
-        import traceback
         traceback.print_exc()
         return None, None
 
@@ -175,7 +289,6 @@ def preprocess_for_deepfake(image, cfg, device):
         return img_tensor
     except Exception as e:
         print(f"Error preprocessing image for deepfake detection: {e}")
-        import traceback
         traceback.print_exc()
         return None
 
@@ -226,6 +339,7 @@ def detect_damage(img, damage_detector):
         return img, outputs, damage_regions
     except Exception as e:
         print(f"Error detecting damage: {e}")
+        traceback.print_exc()
         # If error occurs, return the whole image as region
         if 'img' in locals() and img is not None:
             h, w = img.shape[:2]
@@ -325,7 +439,6 @@ def check_deepfake(image, damage_regions, deepfake_model, deepfake_cfg, device,
         return results
     except Exception as e:
         print(f"Error in deepfake detection: {e}")
-        import traceback
         traceback.print_exc()
         return []
 
@@ -394,74 +507,141 @@ def visualize_results(image, damage_outputs, deepfake_results, damage_threshold)
         return result_img
     except Exception as e:
         print(f"Error visualizing results: {e}")
-        import traceback
         traceback.print_exc()
         return np.array(image, dtype=np.uint8)  # Return the original image as a numpy array
 
 def process_image(input_image, damage_model_path, deepfake_model_path, deepfake_cfg_path, 
                  damage_threshold, deepfake_threshold, skip_damage, device_str):
-    """Process an image through the car damage and deepfake detection pipeline"""
+    """Process an image through the car damage and deepfake detection pipeline with enhanced error handling"""
     progress_info = []
     
-    # Convert Gradio image to numpy array
-    if isinstance(input_image, dict) and "path" in input_image:
-        img = cv2.imread(input_image["path"])
-    elif isinstance(input_image, str):
-        img = cv2.imread(input_image)
-    elif isinstance(input_image, np.ndarray):
-        # Make a copy to avoid modifying the original
-        img = input_image.copy()
-        # Convert from RGB to BGR (OpenCV format)
-        if len(img.shape) == 3 and img.shape[2] == 3:
-            img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
-    else:
-        return None, "Error: Unsupported image format"
+    # Print all input paths for debugging
+    progress_info.append(f"Input parameters:")
+    progress_info.append(f"- Damage model path: {damage_model_path}")
+    progress_info.append(f"- Deepfake model path: {deepfake_model_path}")
+    progress_info.append(f"- Deepfake config path: {deepfake_cfg_path}")
+    progress_info.append(f"- Damage threshold: {damage_threshold}")
+    progress_info.append(f"- Deepfake threshold: {deepfake_threshold}")
+    progress_info.append(f"- Skip damage detection: {skip_damage}")
+    progress_info.append(f"- Device: {device_str}")
     
-    if img is None:
-        return None, "Error: Could not read the image"
+    # Check if model files exist
+    if not skip_damage and damage_model_path:
+        if os.path.exists(damage_model_path):
+            progress_info.append(f"Damage model file exists at: {damage_model_path}")
+        else:
+            progress_info.append(f"ERROR: Damage model file NOT FOUND at: {damage_model_path}")
+    
+    if deepfake_model_path:
+        if os.path.exists(deepfake_model_path):
+            progress_info.append(f"Deepfake model file exists at: {deepfake_model_path}")
+        else:
+            progress_info.append(f"ERROR: Deepfake model file NOT FOUND at: {deepfake_model_path}")
+    
+    if deepfake_cfg_path:
+        if os.path.exists(deepfake_cfg_path):
+            progress_info.append(f"Deepfake config file exists at: {deepfake_cfg_path}")
+        else:
+            progress_info.append(f"ERROR: Deepfake config file NOT FOUND at: {deepfake_cfg_path}")
+    
+    # Convert Gradio image to numpy array
+    try:
+        if isinstance(input_image, dict) and "path" in input_image:
+            img = cv2.imread(input_image["path"])
+        elif isinstance(input_image, str):
+            img = cv2.imread(input_image)
+        elif isinstance(input_image, np.ndarray):
+            # Make a copy to avoid modifying the original
+            img = input_image.copy()
+            # Convert from RGB to BGR (OpenCV format)
+            if len(img.shape) == 3 and img.shape[2] == 3:
+                img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
+        else:
+            return None, "Error: Unsupported image format"
+        
+        if img is None:
+            return None, "Error: Could not read the image"
+    except Exception as e:
+        error_trace = traceback.format_exc()
+        return None, f"Error loading image: {str(e)}\n{error_trace}"
     
     # Progress update
     progress_info.append("Image loaded successfully")
     
     # Setup device
-    device = setup_device(device_str)
-    progress_info.append(f"Using device: {device}")
+    try:
+        device = setup_device(device_str)
+        progress_info.append(f"Using device: {device}")
+    except Exception as e:
+        error_trace = traceback.format_exc()
+        progress_info.append(f"Error setting up device: {str(e)}\n{error_trace}")
+        device = torch.device('cpu')
+        progress_info.append(f"Falling back to CPU")
     
     # Initialize models
     damage_detector = None
     deepfake_model = None
     deepfake_cfg = None
     
+    # Check Detectron2 availability
+    if not skip_damage:
+        progress_info.append(f"Detectron2 available: {DETECTRON2_AVAILABLE}")
+        
+        if not DETECTRON2_AVAILABLE:
+            progress_info.append("Warning: Detectron2 is not available. Install with:")
+            progress_info.append("pip install torch torchvision --extra-index-url https://download.pytorch.org/whl/cpu")
+            progress_info.append("pip install git+https://github.com/facebookresearch/detectron2.git")
+    
     # Setup damage detector if not skipped
     if not skip_damage and damage_model_path:
         progress_info.append("Setting up damage detector...")
-        damage_detector, detector_cfg = setup_damage_detector(damage_model_path, float(damage_threshold))
-        if damage_detector is None and DETECTRON2_AVAILABLE:
-            progress_info.append("Failed to initialize damage detector")
-        else:
-            progress_info.append("Damage detector initialized successfully")
+        try:
+            damage_detector, detector_cfg = setup_damage_detector(damage_model_path, float(damage_threshold))
+            if damage_detector is None and DETECTRON2_AVAILABLE:
+                progress_info.append("Failed to initialize damage detector")
+            else:
+                progress_info.append("Damage detector initialized successfully")
+        except Exception as e:
+            error_trace = traceback.format_exc()
+            progress_info.append(f"Error in damage detector setup: {str(e)}\n{error_trace}")
     
     # Setup deepfake detector
     if deepfake_model_path and deepfake_cfg_path:
         progress_info.append("Setting up deepfake detector...")
-        deepfake_model, deepfake_cfg = load_deepfake_model(deepfake_model_path, deepfake_cfg_path, device)
-        if deepfake_model is None:
-            progress_info.append("Failed to initialize deepfake detector")
-        else:
-            progress_info.append("Deepfake detector initialized successfully")
+        try:
+            deepfake_model, deepfake_cfg = load_deepfake_model(deepfake_model_path, deepfake_cfg_path, device)
+            if deepfake_model is None:
+                progress_info.append("Failed to initialize deepfake detector")
+            else:
+                progress_info.append("Deepfake detector initialized successfully")
+        except Exception as e:
+            error_trace = traceback.format_exc()
+            progress_info.append(f"Error in deepfake detector setup: {str(e)}\n{error_trace}")
     
     # Ensure at least one detector is working
     if damage_detector is None and deepfake_model is None:
-        return None, "Error: Neither damage nor deepfake detector is available"
+        return None, "\n".join(progress_info) + "\nError: Neither damage nor deepfake detector is available"
     
     # Step 1: Detect damage or use whole image
     progress_info.append("Detecting damage regions...")
     start_time = time.time()
-    img, damage_outputs, damage_regions = detect_damage(img, damage_detector)
-    damage_time = time.time() - start_time
+    try:
+        img, damage_outputs, damage_regions = detect_damage(img, damage_detector)
+        damage_time = time.time() - start_time
+    except Exception as e:
+        error_trace = traceback.format_exc()
+        progress_info.append(f"Error in damage detection: {str(e)}\n{error_trace}")
+        h, w = img.shape[:2]
+        damage_regions = [{
+            "box": (0, 0, w, h),
+            "score": 1.0,
+            "mask": None
+        }]
+        damage_outputs = None
+        damage_time = time.time() - start_time
     
     if img is None:
-        return None, "Error: Failed to process image"
+        return None, "\n".join(progress_info) + "\nError: Failed to process image"
     
     # Print damage detection results
     if damage_detector is not None and damage_regions:
@@ -474,48 +654,154 @@ def process_image(input_image, damage_model_path, deepfake_model_path, deepfake_
     if deepfake_model is not None:
         progress_info.append("Performing deepfake detection...")
         start_time = time.time()
-        deepfake_results = check_deepfake(
-            img, damage_regions, deepfake_model, deepfake_cfg, device, float(deepfake_threshold)
-        )
-        deepfake_time = time.time() - start_time
-        
-        if deepfake_results:
-            progress_info.append(f"Deepfake detection completed in {deepfake_time:.3f} seconds")
+        try:
+            deepfake_results = check_deepfake(
+                img, damage_regions, deepfake_model, deepfake_cfg, device, float(deepfake_threshold)
+            )
+            deepfake_time = time.time() - start_time
             
-            # Generate report
-            for result in deepfake_results:
-                if "region_id" in result:
-                    region_id = result["region_id"]
-                    fake_prob = result["deepfake_prob"]
-                    is_fake = result["is_fake"]
-                    progress_info.append(f"Region {region_id}: {'FAKE' if is_fake else 'REAL'} (Probability: {fake_prob*100:.2f}%)")
-                elif "region" in result and result["region"] == "full_image":
-                    fake_prob = result["deepfake_prob"]
-                    is_fake = result["is_fake"]
-                    progress_info.append(f"Whole image: {'FAKE' if is_fake else 'REAL'} (Probability: {fake_prob*100:.2f}%)")
-        else:
-            progress_info.append("No deepfake detection results")
+            if deepfake_results:
+                progress_info.append(f"Deepfake detection completed in {deepfake_time:.3f} seconds")
+                
+                # Generate report
+                for result in deepfake_results:
+                    if "region_id" in result:
+                        region_id = result["region_id"]
+                        fake_prob = result["deepfake_prob"]
+                        is_fake = result["is_fake"]
+                        progress_info.append(f"Region {region_id}: {'FAKE' if is_fake else 'REAL'} (Probability: {fake_prob*100:.2f}%)")
+                    elif "region" in result and result["region"] == "full_image":
+                        fake_prob = result["deepfake_prob"]
+                        is_fake = result["is_fake"]
+                        progress_info.append(f"Whole image: {'FAKE' if is_fake else 'REAL'} (Probability: {fake_prob*100:.2f}%)")
+            else:
+                progress_info.append("No deepfake detection results")
+        except Exception as e:
+            error_trace = traceback.format_exc()
+            progress_info.append(f"Error in deepfake detection: {str(e)}\n{error_trace}")
     
     # Step 3: Visualize final results
     progress_info.append("Generating visualization...")
-    result_img = visualize_results(img, damage_outputs, deepfake_results, float(damage_threshold))
-    
-    # Convert back to RGB for Gradio
-    if len(result_img.shape) == 3 and result_img.shape[2] == 3:
-        result_img = cv2.cvtColor(result_img, cv2.COLOR_BGR2RGB)
+    try:
+        result_img = visualize_results(img, damage_outputs, deepfake_results, float(damage_threshold))
+        
+        # Convert back to RGB for Gradio
+        if len(result_img.shape) == 3 and result_img.shape[2] == 3:
+            result_img = cv2.cvtColor(result_img, cv2.COLOR_BGR2RGB)
+    except Exception as e:
+        error_trace = traceback.format_exc()
+        progress_info.append(f"Error in visualization: {str(e)}\n{error_trace}")
+        # Return original image if visualization fails
+        result_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) if len(img.shape) == 3 and img.shape[2] == 3 else img
     
     progress_info.append("Processing complete!")
     
     return result_img, "\n".join(progress_info)
 
-
-
-
 def create_gradio_interface():
     with gr.Blocks(title="Car Damage & Deepfake Detection") as app:
         gr.Markdown("# Car Damage Detection & Deepfake Verification")
         gr.Markdown("Upload an image to detect car damage and check if it's a deepfake")
         
+        # Add a diagnostic tab
+        with gr.Tab("Diagnostics"):
+            with gr.Row():
+                run_diagnostic_btn = gr.Button("Run Detectron2 Diagnostics", variant="primary")
+                diagnostic_output = gr.Textbox(label="Diagnostic Results", lines=20)
+            
+            # Function to run diagnostics
+            def run_diagnostics():
+                results = verify_detectron2_installation()
+                
+                # Check model paths
+                output_lines = ["# System Diagnostics", ""]
+                
+                # Check damage model
+                if os.path.exists(DEFAULT_DAMAGE_MODEL_PATH):
+                    file_size = os.path.getsize(DEFAULT_DAMAGE_MODEL_PATH) / (1024 * 1024)  # Size in MB
+                    output_lines.append(f"✅ Damage model exists: {DEFAULT_DAMAGE_MODEL_PATH} ({file_size:.2f} MB)")
+                else:
+                    output_lines.append(f"❌ Damage model NOT found: {DEFAULT_DAMAGE_MODEL_PATH}")
+                
+                # Check deepfake model
+                if os.path.exists(DEFAULT_DEEPFAKE_MODEL_PATH):
+                    file_size = os.path.getsize(DEFAULT_DEEPFAKE_MODEL_PATH) / (1024 * 1024)  # Size in MB
+                    output_lines.append(f"✅ Deepfake model exists: {DEFAULT_DEEPFAKE_MODEL_PATH} ({file_size:.2f} MB)")
+                else:
+                    output_lines.append(f"❌ Deepfake model NOT found: {DEFAULT_DEEPFAKE_MODEL_PATH}")
+                
+                # Check deepfake config
+                if os.path.exists(DEFAULT_DEEPFAKE_CFG_PATH):
+                    output_lines.append(f"✅ Deepfake config exists: {DEFAULT_DEEPFAKE_CFG_PATH}")
+                else:
+                    output_lines.append(f"❌ Deepfake config NOT found: {DEFAULT_DEEPFAKE_CFG_PATH}")
+                
+                # Add Detectron2 status
+                output_lines.append("")
+                output_lines.append("# Detectron2 Status")
+                output_lines.append(f"Detectron2 installed: {'✅' if results['detectron2_installed'] else '❌'}")
+                output_lines.append(f"Model zoo accessible: {'✅' if results['model_zoo_accessible'] else '❌'}")
+                output_lines.append(f"Can create config: {'✅' if results['can_create_cfg'] else '❌'}")
+                
+                if results['error_messages']:
+                    output_lines.append("")
+                    output_lines.append("# Error Messages")
+                    for error in results['error_messages']:
+                        output_lines.append(f"- {error}")
+                
+                # Try to load a small sample model from model zoo
+                output_lines.append("")
+                output_lines.append("# Test Loading Detectron2 Model")
+                try:
+                    from detectron2 import model_zoo
+                    from detectron2.config import get_cfg
+                    from detectron2.engine import DefaultPredictor
+                    
+                    cfg = get_cfg()
+                    cfg.merge_from_file(model_zoo.get_config_file("COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml"))
+                    
+                    # Try to access a pre-trained model (without downloading it)
+                    model_url = model_zoo.get_checkpoint_url("COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml")
+                    output_lines.append(f"✅ Can access pre-trained model URL: {model_url}")
+                    
+                    # Check if we can see the damage model contents
+                    if os.path.exists(DEFAULT_DAMAGE_MODEL_PATH):
+                        try:
+                            import torch
+                            # Try to load just the metadata without loading the whole model
+                            checkpoint = torch.load(DEFAULT_DAMAGE_MODEL_PATH, map_location='cpu')
+                            if isinstance(checkpoint, dict):
+                                output_lines.append("✅ Successfully loaded damage model metadata")
+                                # Check some basic keys in the checkpoint
+                                keys = list(checkpoint.keys())
+                                output_lines.append(f"Model keys: {keys[:5]}...")
+                            else:
+                                output_lines.append("⚠️ Damage model loaded but has unexpected format")
+                        except Exception as e:
+                            output_lines.append(f"❌ Failed to load damage model: {str(e)}")
+                except Exception as e:
+                    output_lines.append(f"❌ Error in test loading: {str(e)}")
+                
+                # Recommendation section
+                output_lines.append("")
+                output_lines.append("# Recommendations")
+                
+                if not results['detectron2_installed']:
+                    output_lines.append("- Install Detectron2: `pip install torch torchvision --extra-index-url https://download.pytorch.org/whl/cpu`")
+                    output_lines.append("- Then: `pip install git+https://github.com/facebookresearch/detectron2.git`")
+                
+                if not os.path.exists(DEFAULT_DAMAGE_MODEL_PATH):
+                    output_lines.append(f"- Place the damage model file at: {DEFAULT_DAMAGE_MODEL_PATH}")
+                
+                if results['detectron2_installed'] and not results['model_zoo_accessible']:
+                    output_lines.append("- Detectron2 is installed but model zoo is not accessible. Check your internet connection.")
+                    output_lines.append("- Try reinstalling Detectron2")
+                
+                return "\n".join(output_lines)
+            
+            # Connect the diagnostic button
+            run_diagnostic_btn.click(fn=run_diagnostics, inputs=[], outputs=diagnostic_output)
+        
         with gr.Tab("Basic Interface"):
             with gr.Row():
                 with gr.Column(scale=1):
@@ -539,31 +825,56 @@ def create_gradio_interface():
         with gr.Tab("Advanced Settings"):
             with gr.Row():
                 with gr.Column():
-                    # Create empty textboxes - values will be provided by the wrapper function
-                    damage_model_path = gr.Textbox(label="Damage Model Path (optional)", 
-                                                 placeholder="Leave blank to use default model")
-                    deepfake_model_path = gr.Textbox(label="Deepfake Model Path (optional)", 
-                                                   placeholder="Leave blank to use default model")
-                    deepfake_cfg_path = gr.Textbox(label="Deepfake Config Path (optional)", 
-                                                 placeholder="Leave blank to use default config")
-        
-        # Create a wrapper function that applies default values when fields are empty
-        def process_with_defaults(input_image, damage_path, deepfake_path, cfg_path, 
-                                damage_threshold, deepfake_threshold, skip_damage, device):
-            # Use default paths if none provided
-            actual_damage_path = damage_path if damage_path.strip() else DEFAULT_DAMAGE_MODEL_PATH
-            actual_deepfake_path = deepfake_path if deepfake_path.strip() else DEFAULT_DEEPFAKE_MODEL_PATH
-            actual_cfg_path = cfg_path if cfg_path.strip() else DEFAULT_DEEPFAKE_CFG_PATH
-            
-            # Call the original process function with the actual paths
-            return process_image(
-                input_image, actual_damage_path, actual_deepfake_path, actual_cfg_path,
-                damage_threshold, deepfake_threshold, skip_damage, device
-            )
+                    damage_model_path = gr.Textbox(label="Damage Model Path", 
+                                                 value=DEFAULT_DAMAGE_MODEL_PATH,
+                                                 placeholder="Path to damage detection model (.pth)")
+                    deepfake_model_path = gr.Textbox(label="Deepfake Model Path", 
+                                                   value=DEFAULT_DEEPFAKE_MODEL_PATH,
+                                                   placeholder="Path to deepfake detection model (.pth)")
+                    deepfake_cfg_path = gr.Textbox(label="Deepfake Config Path", 
+                                                 value=DEFAULT_DEEPFAKE_CFG_PATH,
+                                                 placeholder="Path to deepfake model config (.yaml)")
+                    
+                    # Add a check model paths button
+                    check_paths_btn = gr.Button("Check Model Paths")
+                    paths_result = gr.Textbox(label="Path Check Results", lines=5)
+                    
+                    # Function to check if model paths exist
+                    def check_model_paths(damage_path, deepfake_path, cfg_path):
+                        results = []
+                        
+                        # Check damage model
+                        if os.path.exists(damage_path):
+                            file_size = os.path.getsize(damage_path) / (1024 * 1024)  # Size in MB
+                            results.append(f"✅ Damage model exists: {damage_path} ({file_size:.2f} MB)")
+                        else:
+                            results.append(f"❌ Damage model NOT found: {damage_path}")
+                        
+                        # Check deepfake model
+                        if os.path.exists(deepfake_path):
+                            file_size = os.path.getsize(deepfake_path) / (1024 * 1024)  # Size in MB
+                            results.append(f"✅ Deepfake model exists: {deepfake_path} ({file_size:.2f} MB)")
+                        else:
+                            results.append(f"❌ Deepfake model NOT found: {deepfake_path}")
+                        
+                        # Check deepfake config
+                        if os.path.exists(cfg_path):
+                            results.append(f"✅ Deepfake config exists: {cfg_path}")
+                        else:
+                            results.append(f"❌ Deepfake config NOT found: {cfg_path}")
+                        
+                        return "\n".join(results)
+                    
+                    # Connect the check paths button
+                    check_paths_btn.click(
+                        fn=check_model_paths, 
+                        inputs=[damage_model_path, deepfake_model_path, deepfake_cfg_path],
+                        outputs=paths_result
+                    )
         
-        # Connect the wrapper function
+        # Connect the process function
         process_btn.click(
-            fn=process_with_defaults,
+            fn=process_image,
             inputs=[
                 input_image, 
                 damage_model_path,
@@ -579,12 +890,9 @@ def create_gradio_interface():
         
         # Examples
         gr.Markdown("## Examples")
-        gr.Markdown("Note: Examples will use the default models if you don't specify custom paths.")
+        gr.Markdown("Note: Examples will only work if you have the appropriate models installed.")
             
-    return app      
-
-
-    # Create and launch the app
+    return app
 
 # For local testing and Hugging Face Spaces, with debugging enabled
 if __name__ == "__main__":