V0.1

PoseEfficientNet_custom_laanet_model_final.pth

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:2d7cc177dd24ae429b74a651d38754ba05eb6552cc02cfe84ed0be305dc297ac
-size 217985170

app.py

@@ -2,18 +2,6 @@
 import importlib.util
 import os
 import sys
-
-
-# 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!")
-
-#!/usr/bin/env python3
-import os
-import sys
 import time
 import cv2
 import torch
@@ -21,14 +9,21 @@ import numpy as np
 import gradio as gr
 from PIL import Image
 from torchvision import transforms
+from torchvision.models import vit_b_16
+import torch.nn as nn
 import traceback
-from configs.get_config import load_config
-from models import *
 
 # Add current directory to path
 if not os.getcwd() in sys.path:
     sys.path.append(os.getcwd())
 
+# 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!")
+
 # Check for detectron2
 try:
     from detectron2.engine import DefaultPredictor
@@ -40,24 +35,14 @@ except ImportError:
     print("Warning: Detectron2 is not installed. Damage detection will not be available.")
     DETECTRON2_AVAILABLE = False
 
-# Check for custom models
-try:
-    
-    MODELS_IMPORTED = True
-except ImportError:
-    print("Warning: Custom models couldn't be imported. Only damage detection will work.")
-    MODELS_IMPORTED = False
-
 # Define model paths
 DEFAULT_DAMAGE_MODEL_PATH = "./model_final.pth"
-DEFAULT_DEEPFAKE_MODEL_PATH = "./PoseEfficientNet_custom_laanet_model_final.pth"
-DEFAULT_DEEPFAKE_CFG_PATH = "./configs/detector2.yaml"
+DEFAULT_DEEPFAKE_MODEL_PATH = "./vit_deepfake_best_20250422_222444.pth"
 
 # Sample images for demo (add your own paths)
 SAMPLE_IMAGES = [
     "./test3.png",
     "./test5.png",
-
 ]
 
 def verify_detectron2_installation():
@@ -146,49 +131,43 @@ def setup_damage_detector(model_path, threshold=0.7):
         traceback.print_exc()
         return None, None
 
-def load_deepfake_model(model_path, cfg_path, device):
-    """Load the deepfake detection model"""
-    if not MODELS_IMPORTED:
-        print("Custom models module not imported. Cannot load deepfake model.")
-        return None, None
-        
+def load_vit_deepfake_model(model_path, device):
+    """Load the Vision Transformer (ViT) model for deepfake detection"""
     if model_path is None or not os.path.exists(model_path):
-        print(f"Error: Deepfake model file not found at {model_path}")
-        return None, None
-        
-    if cfg_path is None or not os.path.exists(cfg_path):
-        print(f"Error: Deepfake config file not found at {cfg_path}")
-        return None, None
+        print(f"Error: ViT deepfake model file not found at {model_path}")
+        return None
         
     try:
-        # Load config
-        cfg = load_config(cfg_path)
+        # Create ViT model with binary classification head
+        model = vit_b_16(weights=None)
         
-        # Build model
-        model = build_model(cfg.MODEL, MODELS)
+        # Modify the classifier head for binary classification (real vs fake)
+        in_features = model.heads.head.in_features
+        model.heads.head = nn.Linear(in_features, 2)
         
         # Load weights
+        print(f"Loading ViT deepfake model from: {model_path}")
         checkpoint = torch.load(model_path, map_location='cpu')
         
-        if isinstance(checkpoint, dict) and 'state_dict' in checkpoint:
+        if isinstance(checkpoint, dict) and 'model_state_dict' in checkpoint:
+            model.load_state_dict(checkpoint['model_state_dict'])
+        elif isinstance(checkpoint, dict) and 'state_dict' in checkpoint:
             model.load_state_dict(checkpoint['state_dict'])
         else:
             model.load_state_dict(checkpoint)
             
         # Move model to device and set to evaluation mode
         model = model.to(device)
-        if hasattr(cfg.MODEL, 'precision') and cfg.MODEL.precision == 'fp64':
-            model = model.to(torch.float64)
         model.eval()
         
-        return model, cfg
+        return model
     except Exception as e:
-        print(f"Error loading deepfake model: {e}")
+        print(f"Error loading ViT deepfake model: {e}")
         traceback.print_exc()
-        return None, None
+        return None
 
-def preprocess_for_deepfake(image, cfg, device):
-    """Preprocess an image for deepfake detection"""
+def preprocess_for_vit(image, device):
+    """Preprocess an image for Vision Transformer deepfake detection"""
     try:
         # Ensure image is RGB
         if len(image.shape) == 3 and image.shape[2] == 3:
@@ -198,28 +177,21 @@ def preprocess_for_deepfake(image, cfg, device):
         else:
             rgb_img = image
             
-        # Resize to match model input size
-        img_resized = cv2.resize(rgb_img, (cfg.DATASET.IMAGE_SIZE[0], cfg.DATASET.IMAGE_SIZE[1]))
+        # Resize to standard ViT input size (224x224)
+        img_resized = cv2.resize(rgb_img, (224, 224))
         
         # Apply transforms
         transform = transforms.Compose([
             transforms.ToTensor(),
-            transforms.Normalize(
-                mean=cfg.DATASET.TRANSFORM.normalize.mean,
-                std=cfg.DATASET.TRANSFORM.normalize.std
-            )
+            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
         ])
         
         img_tensor = transform(Image.fromarray(img_resized)).unsqueeze(0)
         img_tensor = img_tensor.to(device)
         
-        # Convert precision if needed
-        if hasattr(cfg.MODEL, 'precision') and cfg.MODEL.precision == 'fp64':
-            img_tensor = img_tensor.to(torch.float64)
-            
         return img_tensor
     except Exception as e:
-        print(f"Error preprocessing image: {e}")
+        print(f"Error preprocessing image for ViT: {e}")
         traceback.print_exc()
         return None
 
@@ -282,8 +254,8 @@ def detect_damage(img, damage_detector):
             return img, None, damage_regions
         return None, None, []
 
-def check_deepfake(image, damage_regions, deepfake_model, deepfake_cfg, device, threshold=0.5):
-    """Check if damage regions are deepfakes"""
+def check_deepfake_vit(image, damage_regions, deepfake_model, device, threshold=0.5):
+    """Check if damage regions are deepfakes using ViT model"""
     results = []
     
     if deepfake_model is None:
@@ -292,7 +264,7 @@ def check_deepfake(image, damage_regions, deepfake_model, deepfake_cfg, device,
     try:
         # If no damage regions, check entire image
         if not damage_regions:
-            img_tensor = preprocess_for_deepfake(image, deepfake_cfg, device)
+            img_tensor = preprocess_for_vit(image, device)
             if img_tensor is None:
                 return []
                 
@@ -300,25 +272,16 @@ def check_deepfake(image, damage_regions, deepfake_model, deepfake_cfg, device,
             with torch.no_grad():
                 outputs = deepfake_model(img_tensor)
                 
-                # Extract outputs
-                if isinstance(outputs, list):
-                    outputs = outputs[0]
+                # Get predictions
+                probabilities = torch.nn.functional.softmax(outputs, dim=1)
+                fake_prob = probabilities[0, 1].item()  # Probability of being fake (class 1)
+                is_fake = fake_prob > threshold
                 
-                if isinstance(outputs, dict) and 'cls' in outputs:
-                    cls_outputs = outputs['cls']
-                    cls_prob = cls_outputs.sigmoid().cpu().numpy()
-                else:
-                    cls_prob = outputs.sigmoid().cpu().numpy() if hasattr(outputs, 'sigmoid') else outputs.cpu().numpy()
-                
-                if cls_prob.size > 0:
-                    is_fake = cls_prob[0][0] > threshold if cls_prob.ndim > 1 else cls_prob[0] > threshold
-                    confidence = cls_prob[0][0] if cls_prob.ndim > 1 else cls_prob[0]
-                    
-                    results.append({
-                        "region": "full_image",
-                        "deepfake_prob": float(confidence),
-                        "is_fake": bool(is_fake)
-                    })
+                results.append({
+                    "region": "full_image",
+                    "deepfake_prob": float(fake_prob),
+                    "is_fake": bool(is_fake)
+                })
             
             return results
         
@@ -334,7 +297,7 @@ def check_deepfake(image, damage_regions, deepfake_model, deepfake_cfg, device,
                 roi = image[y1:y2, x1:x2]
                 
                 # Preprocess
-                img_tensor = preprocess_for_deepfake(roi, deepfake_cfg, device)
+                img_tensor = preprocess_for_vit(roi, device)
                 if img_tensor is None:
                     continue
                 
@@ -342,25 +305,17 @@ def check_deepfake(image, damage_regions, deepfake_model, deepfake_cfg, device,
                 with torch.no_grad():
                     outputs = deepfake_model(img_tensor)
                     
-                    if isinstance(outputs, list):
-                        outputs = outputs[0]
-                    
-                    if isinstance(outputs, dict) and 'cls' in outputs:
-                        cls_outputs = outputs['cls']
-                        cls_prob = cls_outputs.sigmoid().cpu().numpy()
-                    else:
-                        cls_prob = outputs.sigmoid().cpu().numpy() if hasattr(outputs, 'sigmoid') else outputs.cpu().numpy()
+                    # Get predictions
+                    probabilities = torch.nn.functional.softmax(outputs, dim=1)
+                    fake_prob = probabilities[0, 1].item()  # Probability of being fake (class 1)
+                    is_fake = fake_prob > threshold
                     
-                    if cls_prob.size > 0:
-                        is_fake = cls_prob[0][0] > threshold if cls_prob.ndim > 1 else cls_prob[0] > threshold
-                        confidence = cls_prob[0][0] if cls_prob.ndim > 1 else cls_prob[0]
-                        
-                        results.append({
-                            "region_id": i,
-                            "box": (x1, y1, x2, y2),
-                            "deepfake_prob": float(confidence),
-                            "is_fake": bool(is_fake)
-                        })
+                    results.append({
+                        "region_id": i,
+                        "box": (x1, y1, x2, y2),
+                        "deepfake_prob": float(fake_prob),
+                        "is_fake": bool(is_fake)
+                    })
         
         return results
     except Exception as e:
@@ -428,23 +383,18 @@ def visualize_results(image, damage_outputs, deepfake_results, damage_threshold)
         traceback.print_exc()
         return np.array(image, dtype=np.uint8)
 
-def process_image(input_image, damage_model_path, deepfake_model_path, deepfake_cfg_path, 
-                 damage_threshold, deepfake_threshold, skip_damage, device_str):
+def process_image(input_image, damage_model_path, deepfake_model_path, damage_threshold, 
+                 deepfake_threshold, skip_damage, device_str):
     """Process an image through the detection pipeline"""
     progress_info = []
     
-    # Debug: log input parameters
-     
     # Check model files
     if not skip_damage and damage_model_path:
         if not os.path.exists(damage_model_path):
             progress_info.append(f"ERROR: Damage model not found at {damage_model_path}")
     
     if deepfake_model_path and not os.path.exists(deepfake_model_path):
-        progress_info.append(f"ERROR: Deepfake model not found at {deepfake_model_path}")
-    
-    if deepfake_cfg_path and not os.path.exists(deepfake_cfg_path):
-        progress_info.append(f"ERROR: Config not found at {deepfake_cfg_path}")
+        progress_info.append(f"ERROR: ViT deepfake model not found at {deepfake_model_path}")
     
     # Convert image to proper format
     try:
@@ -464,40 +414,55 @@ def process_image(input_image, damage_model_path, deepfake_model_path, deepfake_
     except Exception as e:
         return None, f"Error loading image: {str(e)}"
     
-    
     # Setup device
     device = setup_device(device_str)
+    progress_info.append(f"Using device: {device}")
     
     # Initialize models
     damage_detector = None
     deepfake_model = None
-    deepfake_cfg = None
     
     # Setup damage detector
     if not skip_damage and damage_model_path:
+        progress_info.append("Setting up damage detector...")
         damage_detector, _ = setup_damage_detector(damage_model_path, float(damage_threshold))
-        
-    # Setup deepfake detector
-    if deepfake_model_path and deepfake_cfg_path:
-        deepfake_model, deepfake_cfg = load_deepfake_model(deepfake_model_path, deepfake_cfg_path, device)
-       
+        if damage_detector:
+            progress_info.append("✅ Damage detector initialized")
+        else:
+            progress_info.append("❌ Failed to initialize damage detector")
+        
+    # Setup ViT deepfake detector
+    if deepfake_model_path:
+        progress_info.append("Setting up ViT deepfake detector...")
+        deepfake_model = load_vit_deepfake_model(deepfake_model_path, device)
+        if deepfake_model:
+            progress_info.append("✅ ViT deepfake detector initialized")
+        else:
+            progress_info.append("❌ Failed to initialize ViT deepfake detector")
      
     # Step 1: Detect damage
+    progress_info.append("Detecting damaged regions...")
     start_time = time.time()
     img, damage_outputs, damage_regions = detect_damage(img, damage_detector)
     damage_time = time.time() - start_time
     
-     
-    # Step 2: Check for deepfakes
+    if damage_regions:
+        progress_info.append(f"Found {len(damage_regions)} damage regions in {damage_time:.2f} seconds")
+    else:
+        progress_info.append("No damage regions detected")
+    
+    # Step 2: Check for deepfakes using ViT
     deepfake_results = []
     if deepfake_model is not None:
+        progress_info.append("Analyzing regions for deepfakes using ViT model...")
         start_time = time.time()
-        deepfake_results = check_deepfake(
-            img, damage_regions, deepfake_model, deepfake_cfg, device, float(deepfake_threshold)
+        deepfake_results = check_deepfake_vit(
+            img, damage_regions, deepfake_model, device, float(deepfake_threshold)
         )
         deepfake_time = time.time() - start_time
         
         if deepfake_results:
+            progress_info.append(f"Deepfake analysis completed in {deepfake_time:.2f} seconds")
             
             # Generate report
             for result in deepfake_results:
@@ -505,17 +470,21 @@ def process_image(input_image, damage_model_path, deepfake_model_path, deepfake_
                     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")
     
+    # Final verdict
     fake_regions = [r for r in deepfake_results if r.get("is_fake", False)]
     if fake_regions:
         progress_info.append("\n🚨 VERDICT: This image contains FAKE damage 🚨")
     else:
         progress_info.append("\n✅ VERDICT: All damage appears REAL")
+        
     # Step 3: Visualize results
     result_img = visualize_results(img, damage_outputs, deepfake_results, float(damage_threshold))
     
@@ -523,7 +492,6 @@ def process_image(input_image, damage_model_path, deepfake_model_path, deepfake_
     if len(result_img.shape) == 3 and result_img.shape[2] == 3:
         result_img = cv2.cvtColor(result_img, cv2.COLOR_BGR2RGB)
     
-    
     return result_img, "\n".join(progress_info)
 
 def auto_install_dependencies():
@@ -561,13 +529,13 @@ def create_gradio_interface():
     
     with gr.Blocks(title="Car Damage & Deepfake Detector", theme=theme) as app:
         gr.Markdown("""
-        # 🚗 Car Damage fraud Detector
+        # 🚗 Car Damage Fraud Detector with Vision Transformer
         
         Upload a car image to:
         1. Detect damaged areas
         2. Verify if the damage is real or artificially generated (deepfake)
         
-        *This app requires both damage detection and deepfake models to be installed.*
+        *This app uses a Vision Transformer (ViT) model for deepfake detection.*
         """)
         
         # Main Interface Tab
@@ -620,6 +588,7 @@ def create_gradio_interface():
                     output.append(f"**CUDA Available:** {'Yes ✅' if torch.cuda.is_available() else 'No ❌'}")
                     if torch.cuda.is_available():
                         output.append(f"**GPU:** {torch.cuda.get_device_name(0)}")
+                    output.append(f"**MPS Available:** {'Yes ✅' if hasattr(torch.backends, 'mps') and torch.backends.mps.is_available() else 'No ❌'}")
                 except ImportError:
                     output.append("**PyTorch:** Not installed ❌")
                 
@@ -634,14 +603,9 @@ def create_gradio_interface():
                 
                 if os.path.exists(DEFAULT_DEEPFAKE_MODEL_PATH):
                     file_size = os.path.getsize(DEFAULT_DEEPFAKE_MODEL_PATH) / (1024 * 1024)  # Size in MB
-                    output.append(f"**Deepfake Model:** Available ✅ ({file_size:.2f} MB)")
+                    output.append(f"**ViT Deepfake Model:** Available ✅ ({file_size:.2f} MB)")
                 else:
-                    output.append(f"**Deepfake Model:** Not found ❌ at {DEFAULT_DEEPFAKE_MODEL_PATH}")
-                
-                if os.path.exists(DEFAULT_DEEPFAKE_CFG_PATH):
-                    output.append(f"**Deepfake Config:** Available ✅")
-                else:
-                    output.append(f"**Deepfake Config:** Not found ❌ at {DEFAULT_DEEPFAKE_CFG_PATH}")
+                    output.append(f"**ViT Deepfake Model:** Not found ❌ at {DEFAULT_DEEPFAKE_MODEL_PATH}")
                 
                 output.append("\n## Detectron2 Status")
                 output.append(f"**Installed:** {'Yes ✅' if detectron2_results['detectron2_installed'] else 'No ❌'}")
@@ -664,10 +628,7 @@ def create_gradio_interface():
                     recommendations.append(f"Place the damage model file at: {DEFAULT_DAMAGE_MODEL_PATH}")
                 
                 if not os.path.exists(DEFAULT_DEEPFAKE_MODEL_PATH):
-                    recommendations.append(f"Place the deepfake model file at: {DEFAULT_DEEPFAKE_MODEL_PATH}")
-                
-                if not os.path.exists(DEFAULT_DEEPFAKE_CFG_PATH):
-                    recommendations.append(f"Place the deepfake config file at: {DEFAULT_DEEPFAKE_CFG_PATH}")
+                    recommendations.append(f"Place the ViT deepfake model file at: {DEFAULT_DEEPFAKE_MODEL_PATH}")
                 
                 if recommendations:
                     for rec in recommendations:
@@ -708,7 +669,7 @@ def create_gradio_interface():
                 
                 return "\n".join(output)
                 
-        # Settings Tab
+               # Settings Tab
         with gr.Tab("Settings"):
             gr.Markdown("## Model Settings")
             
@@ -721,49 +682,16 @@ def create_gradio_interface():
                     )
                     
                     custom_deepfake_model = gr.Textbox(
-                        label="Custom Deepfake Model Path",
+                        label="Custom ViT Deepfake Model Path",
                         value=DEFAULT_DEEPFAKE_MODEL_PATH,
-                        placeholder="Path to deepfake detection model (.pth)"
-                    )
-                    
-                    custom_deepfake_cfg = gr.Textbox(
-                        label="Custom Deepfake Config Path",
-                        value=DEFAULT_DEEPFAKE_CFG_PATH,
-                        placeholder="Path to deepfake model config (.yaml)"
+                        placeholder="Path to ViT deepfake detection model (.pth)"
                     )
                     
                     check_paths_btn = gr.Button("Verify Paths", variant="primary")
                 
                 with gr.Column():
                     paths_result = gr.Markdown(label="Path Verification Results")
-            
-            # Function to check model paths
-            def check_model_paths(damage_path, deepfake_path, cfg_path):
-                output = ["## Path Verification Results\n"]
-                
-                # Check damage model
-                if os.path.exists(damage_path):
-                    file_size = os.path.getsize(damage_path) / (1024 * 1024)  # Size in MB
-                    output.append(f"✅ **Damage model:** Found at {damage_path} ({file_size:.2f} MB)")
-                else:
-                    output.append(f"❌ **Damage model:** NOT found at {damage_path}")
-                
-                # Check deepfake model
-                if os.path.exists(deepfake_path):
-                    file_size = os.path.getsize(deepfake_path) / (1024 * 1024)  # Size in MB
-                    output.append(f"✅ **Deepfake model:** Found at {deepfake_path} ({file_size:.2f} MB)")
-                else:
-                    output.append(f"❌ **Deepfake model:** NOT found at {deepfake_path}")
-                
-                # Check deepfake config
-                if os.path.exists(cfg_path):
-                    output.append(f"✅ **Deepfake config:** Found at {cfg_path}")
-                else:
-                    output.append(f"❌ **Deepfake config:** NOT found at {cfg_path}")
-                
-                return "\n".join(output)
-        
-        # Help Tab
+
         with gr.Tab("Help"):
             gr.Markdown("""
             ## 📋 How to Use This Tool
@@ -780,8 +708,12 @@ def create_gradio_interface():
             
             ### Requirements
             - Damage detection model file (Detectron2 Mask R-CNN)
-            - Deepfake detection model file
-            - Deepfake model configuration file
+            - Vision Transformer (ViT) deepfake detection model file
+            
+            ### About the Vision Transformer (ViT)
+            - This version uses a state-of-the-art Vision Transformer model for deepfake detection
+            - The ViT model has been trained specifically to detect artificially generated car damage
+            - ViT models are better at capturing global features in images compared to traditional CNNs
             
             ### Troubleshooting
             - If models aren't loading, check the "System Diagnostics" tab
@@ -793,7 +725,7 @@ def create_gradio_interface():
             - **Deepfake Threshold:** Higher values make the system more selective in flagging fakes
             - **Skip Damage Detection:** Analyze the entire image for deepfakes without damage detection
             """)
-        
+            
         # Examples
         if any(os.path.exists(img) for img in SAMPLE_IMAGES):
             gr.Markdown("## Example Images")
@@ -805,7 +737,7 @@ def create_gradio_interface():
                     outputs=[output_image, output_text],
                     fn=lambda x: process_image(
                         x, DEFAULT_DAMAGE_MODEL_PATH, DEFAULT_DEEPFAKE_MODEL_PATH, 
-                        DEFAULT_DEEPFAKE_CFG_PATH, 0.7, 0.5, False, "auto"
+                        0.7, 0.5, False, "auto"
                     ),
                     cache_examples=True
                 )
@@ -817,7 +749,6 @@ def create_gradio_interface():
                 input_image, 
                 custom_damage_model,
                 custom_deepfake_model,
-                custom_deepfake_cfg,
                 damage_threshold,
                 deepfake_threshold,
                 skip_damage,
@@ -849,16 +780,14 @@ def create_gradio_interface():
         # Settings tab
         check_paths_btn.click(
             fn=check_model_paths,
-            inputs=[custom_damage_model, custom_deepfake_model, custom_deepfake_cfg],
+            inputs=[custom_damage_model, custom_deepfake_model],
             outputs=paths_result
         )
         
     return app
 
 if __name__ == "__main__":
-    # Try to auto-install dependencies on startup
-    auto_install_dependencies()
     
     # Create and launch the Gradio app
     app = create_gradio_interface()
-    app.launch(share=False)  # Set share=True to create a public link
+    app.launch(share=False)  # Set share=True to create a public link#!/usr/bin/env python3