Create app.py

app.py

@@ -0,0 +1,335 @@
+"""
+═══════════════════════════════════════════════════════════════════════
+V13 DEEPFAKE DETECTOR - GRADIO APP
+═══════════════════════════════════════════════════════════════════════
+Upload an image and detect if it's real or AI-generated/deepfake
+Uses the best Model 3 (Swin-Large) with 99.96% accuracy
+═══════════════════════════════════════════════════════════════════════
+"""
+
+import gradio as gr
+import torch
+import torch.nn as nn
+from torchvision import transforms
+from PIL import Image
+import timm
+import json
+from huggingface_hub import hf_hub_download
+import numpy as np
+
+print("🚀 Loading Deepfake Detector...")
+
+# ═══════════════════════════════════════════════════════════════════════
+# CONFIGURATION
+# ═══════════════════════════════════════════════════════════════════════
+
+REPO_ID = "ash12321/deepfake-detector-v13-optimized"
+MODEL_NUM = 3  # Using Model 3 (best performance)
+
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+print(f"Device: {device}")
+
+# ═══════════════════════════════════════════════════════════════════════
+# MODEL DEFINITION
+# ═══════════════════════════════════════════════════════════════════════
+
+class DeepfakeDetector(nn.Module):
+    def __init__(self, backbone_name, dropout=0.3, hidden_dim=512, use_batch_norm=True):
+        super().__init__()
+        
+        self.backbone = timm.create_model(backbone_name, pretrained=False, num_classes=0)
+        
+        if hasattr(self.backbone, 'num_features'):
+            feat_dim = self.backbone.num_features
+        else:
+            with torch.no_grad():
+                feat_dim = self.backbone(torch.randn(1, 3, 224, 224)).shape[1]
+        
+        if use_batch_norm:
+            self.classifier = nn.Sequential(
+                nn.Linear(feat_dim, hidden_dim),
+                nn.BatchNorm1d(hidden_dim),
+                nn.GELU(),
+                nn.Dropout(dropout),
+                nn.Linear(hidden_dim, hidden_dim // 4),
+                nn.BatchNorm1d(hidden_dim // 4),
+                nn.GELU(),
+                nn.Dropout(dropout * 0.5),
+                nn.Linear(hidden_dim // 4, 1)
+            )
+        else:
+            self.classifier = nn.Sequential(
+                nn.Linear(feat_dim, hidden_dim),
+                nn.LayerNorm(hidden_dim),
+                nn.GELU(),
+                nn.Dropout(dropout),
+                nn.Linear(hidden_dim, hidden_dim // 4),
+                nn.LayerNorm(hidden_dim // 4),
+                nn.GELU(),
+                nn.Dropout(dropout * 0.5),
+                nn.Linear(hidden_dim // 4, 1)
+            )
+
+    def forward(self, x):
+        features = self.backbone(x)
+        return self.classifier(features).squeeze(-1)
+
+# ═══════════════════════════════════════════════════════════════════════
+# LOAD MODEL
+# ═══════════════════════════════════════════════════════════════════════
+
+print("📥 Downloading model from HuggingFace...")
+
+# Download model files
+model_path = hf_hub_download(
+    repo_id=REPO_ID,
+    filename=f"best_model_{MODEL_NUM}.pt"
+)
+
+params_path = hf_hub_download(
+    repo_id=REPO_ID,
+    filename=f"best_params_model_{MODEL_NUM}.json"
+)
+
+# Load parameters
+with open(params_path, 'r') as f:
+    best_params = json.load(f)
+
+params = best_params['params']
+threshold = params['classification_threshold']
+
+print(f"✓ Using Model {MODEL_NUM}")
+print(f"✓ Threshold: {threshold:.4f}")
+print(f"✓ Test F1 Score: {best_params.get('f1_score', 'N/A')}")
+
+# Model architecture map
+backbone_map = {
+    1: 'convnext_large',
+    2: 'vit_large_patch16_224',
+    3: 'swin_large_patch4_window7_224'
+}
+
+# Create model
+print("🔨 Building model...")
+model = DeepfakeDetector(
+    backbone_name=backbone_map[MODEL_NUM],
+    dropout=params['dropout'],
+    hidden_dim=params['hidden_dim'],
+    use_batch_norm=params['use_batch_norm']
+)
+
+# Load weights
+checkpoint = torch.load(model_path, map_location=device)
+model.load_state_dict(checkpoint['model_state_dict'])
+model = model.to(device)
+model.eval()
+
+print("✅ Model loaded successfully!\n")
+
+# ═══════════════════════════════════════════════════════════════════════
+# IMAGE PREPROCESSING
+# ═══════════════════════════════════════════════════════════════════════
+
+transform = transforms.Compose([
+    transforms.Resize((224, 224)),
+    transforms.ToTensor(),
+    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
+])
+
+# ═══════════════════════════════════════════════════════════════════════
+# PREDICTION FUNCTION
+# ═══════════════════════════════════════════════════════════════════════
+
+def predict_image(image):
+    """
+    Predict if an image is real or fake
+    
+    Args:
+        image: PIL Image
+        
+    Returns:
+        dict: Prediction results with confidence scores
+    """
+    if image is None:
+        return {
+            "Error": "Please upload an image"
+        }
+    
+    try:
+        # Convert to RGB if needed
+        if image.mode != 'RGB':
+            image = image.convert('RGB')
+        
+        # Preprocess
+        img_tensor = transform(image).unsqueeze(0).to(device)
+        
+        # Predict
+        with torch.no_grad():
+            logit = model(img_tensor)
+            probability = torch.sigmoid(logit).item()
+        
+        # Determine prediction
+        is_fake = probability > threshold
+        
+        # Calculate confidence
+        if is_fake:
+            confidence = probability * 100
+            label = "🚨 FAKE / AI-GENERATED"
+            color = "red"
+        else:
+            confidence = (1 - probability) * 100
+            label = "✅ REAL"
+            color = "green"
+        
+        # Create result dictionary for Gradio
+        result = {
+            "Prediction": label,
+            "Confidence": f"{confidence:.2f}%",
+            "Raw Score": f"{probability:.4f}",
+            "Threshold": f"{threshold:.4f}"
+        }
+        
+        # Additional context
+        if confidence > 95:
+            certainty = "Very High Certainty"
+        elif confidence > 85:
+            certainty = "High Certainty"
+        elif confidence > 70:
+            certainty = "Moderate Certainty"
+        else:
+            certainty = "Low Certainty - Manual Review Recommended"
+        
+        result["Certainty Level"] = certainty
+        
+        return result
+    
+    except Exception as e:
+        return {
+            "Error": f"Prediction failed: {str(e)}"
+        }
+
+# ═══════════════════════════════════════════════════════════════════════
+# GRADIO INTERFACE
+# ═══════════════════════════════════════════════════════════════════════
+
+# Create the interface
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    
+    gr.Markdown(
+        """
+        # 🔍 Deepfake Detector V13
+        
+        Upload an image to detect if it's **REAL** or **AI-GENERATED/DEEPFAKE**
+        
+        **Model Performance:**
+        - ✅ 99.96% Accuracy on test set
+        - ✅ 100% Recall (catches all fakes)
+        - ✅ Model 3: Swin-Large (197M parameters)
+        
+        **Supported:** Faces, portraits, AI-generated images, deepfakes
+        """
+    )
+    
+    with gr.Row():
+        with gr.Column():
+            image_input = gr.Image(
+                type="pil",
+                label="Upload Image",
+                height=400
+            )
+            
+            predict_btn = gr.Button(
+                "🔍 Analyze Image",
+                variant="primary",
+                size="lg"
+            )
+            
+            gr.Markdown(
+                """
+                ### 💡 Tips:
+                - Upload clear images with visible faces
+                - Works best with portraits and headshots
+                - Supports: JPG, PNG, WebP
+                """
+            )
+        
+        with gr.Column():
+            result_output = gr.JSON(
+                label="Detection Results"
+            )
+            
+            gr.Markdown(
+                """
+                ### 📊 Understanding Results:
+                
+                **Prediction:** REAL or FAKE classification
+                
+                **Confidence:** How certain the model is (0-100%)
+                
+                **Raw Score:** Internal probability (0-1)
+                - Above threshold → FAKE
+                - Below threshold → REAL
+                
+                **Certainty Level:**
+                - Very High (>95%): Trust the result
+                - High (85-95%): Reliable
+                - Moderate (70-85%): Generally accurate
+                - Low (<70%): Consider manual review
+                """
+            )
+    
+    # Examples
+    gr.Markdown("### 📸 Try These Examples:")
+    gr.Examples(
+        examples=[
+            # Add example image paths here if you have them
+        ],
+        inputs=image_input,
+        outputs=result_output,
+        fn=predict_image,
+        cache_examples=False
+    )
+    
+    # Connect button to function
+    predict_btn.click(
+        fn=predict_image,
+        inputs=image_input,
+        outputs=result_output
+    )
+    
+    # Auto-predict on upload
+    image_input.change(
+        fn=predict_image,
+        inputs=image_input,
+        outputs=result_output
+    )
+    
+    gr.Markdown(
+        """
+        ---
+        **Model Details:**
+        - Architecture: Swin Transformer Large
+        - Parameters: 197M
+        - Training Data: 60,000 balanced real/fake images
+        - Optimized with Optuna hyperparameter search
+        
+        **Limitations:**
+        - Best for human faces and portraits
+        - May not work well on heavily compressed images
+        - Performance may vary on new AI generation methods
+        
+        **Version:** V13 Model 3 | **Accuracy:** 99.96%
+        """
+    )
+
+# ═══════════════════════════════════════════════════════════════════════
+# LAUNCH
+# ═══════════════════════════════════════════════════════════════════════
+
+if __name__ == "__main__":
+    print("🌐 Launching Gradio interface...")
+    demo.launch(
+        share=True,  # Creates public link
+        server_name="0.0.0.0",
+        server_port=7860
+    )