Add application file

.dockerignore

@@ -0,0 +1,29 @@
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.venv/
+venv/
+.git/
+.cursor/
+terminals/
+agent-transcripts/
+*.ipynb
+*.png
+*.jpg
+*.jpeg
+*.gif
+*.webp
+*.mp4
+*.mov
+*.avi
+*.mkv
+*.zip
+*.tar
+*.tar.gz
+*.7z
+.DS_Store
+

__init__.py

@@ -0,0 +1,2 @@
+"""AI vs Real detector app package."""
+

app - Copy (2).py

@@ -0,0 +1,606 @@
+import os
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torchvision import transforms, models
+from PIL import Image
+import gradio as gr
+import numpy as np
+import pandas as pd
+import requests
+from io import BytesIO
+import warnings
+warnings.filterwarnings('ignore')
+
+# Global variables
+detector = None
+current_model_path = None
+
+class AIDetectorModel(nn.Module):
+    def __init__(self, num_classes=2, dropout_prob=0.3, load_pretrained=True):
+        super(AIDetectorModel, self).__init__()
+        
+        # Smart loading: only download RegNet if needed
+        if load_pretrained:
+            print("📥 Loading RegNet with pre-trained weights (319MB download)...")
+            self.backbone = models.regnet_y_16gf(weights=models.RegNet_Y_16GF_Weights.IMAGENET1K_SWAG_E2E_V1)
+        else:
+            print("🚀 Creating RegNet architecture without pre-trained weights...")
+            self.backbone = models.regnet_y_16gf(weights=None)
+        
+        # Freeze most layers (only relevant for pre-trained)
+        for param in self.backbone.parameters():
+            param.requires_grad = False
+        
+        # Unfreeze last block
+        if hasattr(self.backbone, 'trunk_output') and hasattr(self.backbone.trunk_output, 'block4'):
+            self.backbone.trunk_output.block4.requires_grad_(True)
+        
+        # Replace average pooling with max pooling
+        self.backbone.avgpool = nn.AdaptiveMaxPool2d(output_size=(1, 1))
+        
+        # Get feature dimension
+        num_ftrs = self.backbone.fc.in_features
+        
+        # Replace classifier with custom layers
+        self.backbone.fc = nn.Sequential(
+            nn.Linear(num_ftrs, 2048),
+            nn.SiLU(),
+            nn.Dropout(dropout_prob),
+            nn.Linear(2048, 1024),
+            nn.SiLU(),
+            nn.Dropout(dropout_prob),
+            nn.Linear(1024, 512),
+            nn.SiLU(),
+            nn.Dropout(dropout_prob),
+            nn.Linear(512, num_classes)
+        )
+
+    def forward(self, x):
+        return self.backbone(x)
+
+def analyze_checkpoint(checkpoint_path):
+    """Analyze checkpoint to determine if backbone weights are included"""
+    try:
+        print(f"🔍 Analyzing checkpoint: {checkpoint_path}")
+        checkpoint = torch.load(checkpoint_path, map_location='cpu')
+        
+        # Extract state dict
+        if isinstance(checkpoint, dict) and 'model_state_dict' in checkpoint:
+            state_dict = checkpoint['model_state_dict']
+            print("📦 Found structured checkpoint with model_state_dict")
+        else:
+            state_dict = checkpoint
+            print("📦 Found direct state_dict checkpoint")
+        
+        # Analyze parameters
+        all_keys = list(state_dict.keys())
+        backbone_params = [k for k in all_keys if k.startswith('backbone.')]
+        backbone_conv_params = [k for k in backbone_params if 'conv' in k]
+        backbone_block_params = [k for k in backbone_params if 'block' in k]
+        classifier_params = [k for k in all_keys if 'fc' in k]
+        
+        total_params = len(all_keys)
+        
+        print(f"📊 Parameter analysis:")
+        print(f"   • Total parameters: {total_params}")
+        print(f"   • Backbone parameters: {len(backbone_params)}")
+        print(f"   • Backbone conv layers: {len(backbone_conv_params)}")
+        print(f"   • Backbone blocks: {len(backbone_block_params)}")
+        print(f"   • Classifier parameters: {len(classifier_params)}")
+        
+        # Determine if full backbone is included
+        # RegNet has many backbone parameters, so if we have 100+ backbone params, it's likely complete
+        has_full_backbone = len(backbone_params) > 100 and len(backbone_conv_params) > 10
+        
+        if has_full_backbone:
+            print("✅ COMPLETE MODEL DETECTED - backbone weights included!")
+            print("🚀 Will skip RegNet download for faster loading")
+        else:
+            print("⚠️ Incomplete model detected - backbone weights missing")
+            print("📥 Will download RegNet pre-trained weights")
+        
+        return has_full_backbone, checkpoint
+        
+    except Exception as e:
+        print(f"❌ Error analyzing checkpoint: {e}")
+        print("📥 Will fallback to downloading RegNet weights")
+        return False, None
+
+class AIImageDetector:
+    def __init__(self, model_path, device=None):
+        """Initialize AI Image Detector with smart loading"""
+        self.device = device if device else ('cuda' if torch.cuda.is_available() else 'cpu')
+        print(f"🚀 Initializing AI Image Detector on {self.device}")
+        
+        # Analyze checkpoint to determine loading strategy
+        has_backbone, checkpoint = analyze_checkpoint(model_path)
+        
+        # Load model with optimized strategy
+        self.model = self._load_model(model_path, has_backbone, checkpoint)
+        self.model.eval()
+        
+        # Define image preprocessing transforms
+        self.transform = transforms.Compose([
+            transforms.Resize(224, interpolation=transforms.InterpolationMode.BICUBIC),
+            transforms.CenterCrop(224),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+        ])
+        
+        print("✅ Model loaded and ready for inference!")
+    
+    def _load_model(self, model_path, has_backbone, checkpoint):
+        """Load model with optimized backbone loading"""
+        try:
+            # Load checkpoint if not already loaded
+            if checkpoint is None:
+                checkpoint = torch.load(model_path, map_location=self.device)
+            
+            # Determine whether to load pre-trained weights
+            load_pretrained = not has_backbone
+            
+            # Create model
+            if isinstance(checkpoint, dict) and 'model_state_dict' in checkpoint:
+                # Structured checkpoint
+                model = AIDetectorModel(
+                    num_classes=checkpoint.get('num_classes', 2),
+                    dropout_prob=checkpoint.get('dropout_prob', 0.3),
+                    load_pretrained=load_pretrained
+                )
+                model.load_state_dict(checkpoint['model_state_dict'])
+                
+                # Show additional info if available
+                if 'epoch' in checkpoint:
+                    print(f"📊 Loaded model from epoch {checkpoint['epoch']}")
+                if 'val_loss' in checkpoint:
+                    print(f"📊 Validation loss: {checkpoint['val_loss']:.4f}")
+                    
+            else:
+                # Direct state dict
+                model = AIDetectorModel(load_pretrained=load_pretrained)
+                model.load_state_dict(checkpoint)
+            
+            return model.to(self.device)
+            
+        except Exception as e:
+            print(f"❌ Error loading model: {e}")
+            print("🔄 Attempting fallback loading...")
+            
+            # Fallback: try with pre-trained weights
+            try:
+                model = AIDetectorModel(load_pretrained=True)
+                if isinstance(checkpoint, dict) and 'model_state_dict' in checkpoint:
+                    model.load_state_dict(checkpoint['model_state_dict'])
+                else:
+                    model.load_state_dict(checkpoint)
+                return model.to(self.device)
+            except Exception as fallback_error:
+                print(f"❌ Fallback loading also failed: {fallback_error}")
+                raise e
+    
+    def preprocess_image(self, image):
+        """Preprocess image for model input"""
+        try:
+            # Ensure RGB format
+            if image.mode != 'RGB':
+                image = image.convert('RGB')
+            
+            # Apply transforms and add batch dimension
+            tensor = self.transform(image).unsqueeze(0)
+            return tensor.to(self.device)
+            
+        except Exception as e:
+            print(f"❌ Error preprocessing image: {e}")
+            raise e
+    
+    def predict(self, image):
+        """
+        Predict if image is real or AI-generated
+        
+        Returns:
+            tuple: (prediction, confidence, probabilities)
+        """
+        try:
+            # Preprocess image
+            input_tensor = self.preprocess_image(image)
+            
+            # Run inference
+            with torch.no_grad():
+                outputs = self.model(input_tensor)
+                probabilities = F.softmax(outputs, dim=1)
+                confidence, predicted = torch.max(probabilities, 1)
+                
+                # Convert to numpy for easier handling
+                probs = probabilities.cpu().numpy()[0]
+                pred_class = predicted.cpu().item()
+                conf_score = confidence.cpu().item()
+                
+                # Map to class names
+                class_names = ['REAL', 'FAKE']
+                prediction = class_names[pred_class]
+                
+                return prediction, conf_score, probs
+                
+        except Exception as e:
+            print(f"❌ Error during prediction: {e}")
+            raise e
+    
+    def predict_from_url(self, url):
+        """Download image from URL and make prediction"""
+        try:
+            # Download image with timeout
+            headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'}
+            response = requests.get(url, timeout=15, headers=headers)
+            response.raise_for_status()
+            
+            # Load image
+            image = Image.open(BytesIO(response.content))
+            
+            # Make prediction
+            prediction, confidence, probabilities = self.predict(image)
+            
+            return prediction, confidence, probabilities, image
+            
+        except requests.exceptions.RequestException as e:
+            print(f"❌ Error downloading image: {e}")
+            raise Exception(f"Failed to download image from URL: {str(e)}")
+        except Exception as e:
+            print(f"❌ Error processing image from URL: {e}")
+            raise e
+
+def get_available_models():
+    """Get list of available model files"""
+    # Define possible model files
+    model_options = [
+        'best_ai_detector.pth',
+        'best_ai_detector_new.pth'
+    ]
+    
+    # Check which files actually exist
+    available_models = []
+    for model in model_options:
+        if os.path.exists(model):
+            available_models.append(model)
+    
+    # If no models found, return the default options anyway
+    if not available_models:
+        available_models = model_options
+        print("⚠️ No model files found in current directory, showing default options")
+    else:
+        print(f"✅ Found {len(available_models)} model file(s): {available_models}")
+    
+    return available_models
+
+def load_detector(model_path=None):
+    """Load the detector model with specified path"""
+    global detector, current_model_path
+    
+    try:
+        # Use specified path or default
+        if model_path is None:
+            model_path = 'best_ai_detector.pth'
+        
+        # Check if the same model is already loaded
+        if detector is not None and current_model_path == model_path:
+            return f"✅ Model '{model_path}' is already loaded and ready!"
+        
+        # Check if file exists
+        if not os.path.exists(model_path):
+            available_models = get_available_models()
+            error_msg = f"❌ Model file '{model_path}' not found!\n\n"
+            error_msg += f"Available models in current directory:\n"
+            for model in available_models:
+                exists = "✅" if os.path.exists(model) else "❌"
+                error_msg += f"  {exists} {model}\n"
+            error_msg += f"\nPlease ensure your trained model file is uploaded to the Space."
+            return error_msg
+        
+        print(f"🎯 Loading model: {model_path}")
+        
+        # Initialize detector
+        detector = AIImageDetector(model_path)
+        current_model_path = model_path
+        
+        return f"✅ Model '{model_path}' loaded successfully!\n🚀 Ready for image analysis."
+        
+    except Exception as e:
+        error_msg = f"❌ Error loading model '{model_path}': {str(e)}\n\n"
+        error_msg += "This might be due to:\n"
+        error_msg += "• Incompatible model file\n"
+        error_msg += "• Corrupted checkpoint\n"
+        error_msg += "• Missing dependencies\n"
+        return error_msg
+
+def predict_image(image):
+    """Handle image upload and prediction"""
+    global detector
+    
+    # Check if detector is loaded
+    if detector is None:
+        return "❌ Please load a model first using the dropdown and 'Load Model' button!", None, None, None
+    
+    if image is None:
+        return "❌ Please upload an image first!", None, None, None
+    
+    try:
+        # Make prediction
+        prediction, confidence, probabilities = detector.predict(image)
+        
+        # Format detailed results
+        result_text = f"🔍 **Prediction: {prediction}**\n\n"
+        result_text += f"📊 **Confidence: {confidence:.1%}**\n\n"
+        result_text += f"📈 **Detailed Probabilities:**\n"
+        result_text += f"• 🟢 REAL (Human-made): {probabilities[0]:.1%}\n"
+        result_text += f"• 🔴 FAKE (AI-generated): {probabilities[1]:.1%}\n\n"
+        
+        # Add interpretation
+        if confidence > 0.8:
+            result_text += f"💪 **High confidence prediction**"
+        elif confidence > 0.6:
+            result_text += f"🤔 **Moderate confidence prediction**"
+        else:
+            result_text += f"⚠️ **Low confidence - uncertain prediction**"
+        
+        # Create chart data
+        prob_df = pd.DataFrame({
+            'Category': ['REAL (Human)', 'FAKE (AI)'],
+            'Probability': [float(probabilities[0]), float(probabilities[1])]
+        })
+        
+        # Quick status
+        color = "🟢" if prediction == "REAL" else "🔴"
+        status = f"{color} {prediction} - {confidence:.1%} confidence"
+        
+        return result_text, prob_df, prediction, status
+        
+    except Exception as e:
+        error_msg = f"❌ Prediction failed: {str(e)}"
+        print(error_msg)
+        return error_msg, None, None, None
+
+def predict_from_url(url):
+    """Handle URL input and prediction"""
+    global detector
+    
+    # Check if detector is loaded
+    if detector is None:
+        return "❌ Please load a model first using the dropdown and 'Load Model' button!", None, None, None, None
+    
+    if not url or not url.strip():
+        return "❌ Please enter a valid image URL!", None, None, None, None
+    
+    try:
+        # Download and predict
+        prediction, confidence, probabilities, image = detector.predict_from_url(url.strip())
+        
+        # Format results (same as upload)
+        result_text = f"🔍 **Prediction: {prediction}**\n\n"
+        result_text += f"📊 **Confidence: {confidence:.1%}**\n\n"
+        result_text += f"📈 **Detailed Probabilities:**\n"
+        result_text += f"• 🟢 REAL (Human-made): {probabilities[0]:.1%}\n"
+        result_text += f"• 🔴 FAKE (AI-generated): {probabilities[1]:.1%}\n\n"
+        
+        # Add interpretation
+        if confidence > 0.8:
+            result_text += f"💪 **High confidence prediction**"
+        elif confidence > 0.6:
+            result_text += f"🤔 **Moderate confidence prediction**"
+        else:
+            result_text += f"⚠️ **Low confidence - uncertain prediction**"
+        
+        # Create chart data
+        prob_df = pd.DataFrame({
+            'Category': ['REAL (Human)', 'FAKE (AI)'],
+            'Probability': [float(probabilities[0]), float(probabilities[1])]
+        })
+        
+        # Quick status
+        color = "🟢" if prediction == "REAL" else "🔴"
+        status = f"{color} {prediction} - {confidence:.1%} confidence"
+        
+        return result_text, prob_df, prediction, status, image
+        
+    except Exception as e:
+        error_msg = f"❌ URL processing failed: {str(e)}"
+        print(error_msg)
+        return error_msg, None, None, None, None
+
+def create_interface():
+    """Create the Gradio web interface"""
+    
+    # Simplified CSS for better compatibility
+    css = """
+    .gradio-container {
+        background-color: #1a1a1a !important;
+        color: white !important;
+    }
+    
+    .main-header {
+        text-align: center;
+        background: linear-gradient(135deg, #eb001b 0%, #ff5f00 100%);
+        color: white !important;
+        padding: 30px;
+        border-radius: 15px;
+        margin-bottom: 25px;
+    }
+    
+    .model-section {
+        background: #2a2a2a !important;
+        padding: 25px;
+        border-radius: 15px;
+        margin-bottom: 25px;
+        border: 2px solid #ff5f00;
+    }
+    """
+    
+    with gr.Blocks(css=css, title="AI Image Detector") as demo:
+        # Main header
+        gr.HTML("""
+        <div class="main-header">
+            <h1>🤖 AI Image Detector</h1>
+            <p>Upload an image or provide a URL to detect if it's REAL (human-made) or FAKE (AI-generated)</p>
+        </div>
+        """)
+
+        # Model selection section
+        with gr.Group():
+            gr.HTML("""
+            <div class="model-section">
+                <h3>🔧 Model Selection & Loading</h3>
+            </div>
+            """)
+            
+            with gr.Row():
+                with gr.Column(scale=2):
+                    model_dropdown = gr.Dropdown(
+                        choices=get_available_models(),
+                        value='best_ai_detector.pth',
+                        label="🎯 Select Model",
+                        info="Choose which trained model to load"
+                    )
+                with gr.Column(scale=1):
+                    load_btn = gr.Button("🔄 Load Model", variant="secondary")
+            
+            model_status = gr.Textbox(
+                label="📊 Model Status",
+                value="Select a model and click 'Load Model' to initialize the AI detector",
+                interactive=False,
+                lines=2
+            )
+
+        with gr.Tabs():
+            # Image upload tab
+            with gr.TabItem("📁 Upload Image"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        input_image = gr.Image(
+                            label="📷 Upload Image for Analysis",
+                            type="pil",
+                            height=400
+                        )
+                        predict_btn = gr.Button(
+                            "🔍 Analyze Image", 
+                            variant="primary"
+                        )
+                    
+                    with gr.Column(scale=1):
+                        prediction_status = gr.Textbox(
+                            label="🎯 Quick Result",
+                            interactive=False,
+                            lines=1
+                        )
+                        
+                        prediction_output = gr.Markdown(
+                            label="📊 Detailed Analysis",
+                            value="Load a model and upload an image to get AI detection results"
+                        )
+                        
+                        probability_chart = gr.BarPlot(
+                            label="📈 Probability Distribution",
+                            x="Category",
+                            y="Probability",
+                            width=400,
+                            height=250
+                        )
+            
+            # URL input tab
+            with gr.TabItem("🌐 Image URL"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        url_input = gr.Textbox(
+                            label="🔗 Image URL",
+                            placeholder="https://example.com/image.jpg",
+                            lines=2
+                        )
+                        url_predict_btn = gr.Button(
+                            "🔍 Analyze from URL", 
+                            variant="primary"
+                        )
+                        
+                        downloaded_image = gr.Image(
+                            label="📥 Downloaded Image",
+                            type="pil",
+                            height=300
+                        )
+                    
+                    with gr.Column(scale=1):
+                        url_prediction_status = gr.Textbox(
+                            label="🎯 Quick Result",
+                            interactive=False,
+                            lines=1
+                        )
+                        
+                        url_prediction_output = gr.Markdown(
+                            label="📊 Detailed Analysis",
+                            value="Load a model and enter an image URL to get AI detection results"
+                        )
+                        
+                        url_probability_chart = gr.BarPlot(
+                            label="📈 Probability Distribution",
+                            x="Category",
+                            y="Probability",
+                            width=400,
+                            height=250
+                        )
+        
+        # Information section
+        with gr.Accordion("ℹ️ About This AI Detector", open=False):
+            gr.Markdown("""
+            ### 🎯 What This Model Does
+            
+            This AI detector analyzes images to determine if they are:
+            - **🟢 REAL**: Created by humans (photographs, traditional digital art, etc.)
+            - **🔴 FAKE**: Generated by AI systems (DALL-E, Midjourney, Stable Diffusion, etc.)
+            
+            ### 📊 Understanding the Results
+            
+            - **Prediction**: The model's best guess (REAL or FAKE)
+            - **Confidence**: How certain the model is (higher = more confident)
+            - **Probabilities**: Breakdown showing likelihood for each category
+            """)
+        
+        # Connect event handlers
+        load_btn.click(
+            fn=load_detector,
+            inputs=[model_dropdown],
+            outputs=model_status
+        )
+        
+        predict_btn.click(
+            fn=predict_image,
+            inputs=[input_image],
+            outputs=[prediction_output, probability_chart, gr.State(), prediction_status]
+        )
+        
+        url_predict_btn.click(
+            fn=predict_from_url,
+            inputs=[url_input],
+            outputs=[url_prediction_output, url_probability_chart, gr.State(), url_prediction_status, downloaded_image]
+        )
+    
+    return demo
+
+if __name__ == "__main__":
+    print("🚀 Starting AI Image Detector with Model Selection...")
+    print("📝 Available models can be selected from dropdown")
+    
+    # Check available models at startup
+    available_models = get_available_models()
+    print(f"🎯 Available models: {available_models}")
+    
+    # Create interface
+    demo = create_interface()
+    
+    # Don't auto-load model - let user choose
+    print("💡 Select a model from the dropdown and click 'Load Model' to begin")
+    
+    # Launch interface
+    print("🌐 Launching interface...")
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True,
+        show_error=True,
+        debug=False
+    )

app - Copy.py

@@ -0,0 +1,626 @@
+import os
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torchvision import transforms, models
+from PIL import Image
+import gradio as gr
+import numpy as np
+import pandas as pd
+import requests
+from io import BytesIO
+import warnings
+warnings.filterwarnings('ignore')
+
+# Global variables
+detector = None
+
+class AIDetectorModel(nn.Module):
+    def __init__(self, num_classes=2, dropout_prob=0.3, load_pretrained=True):
+        super(AIDetectorModel, self).__init__()
+        
+        # Smart loading: only download RegNet if needed
+        if load_pretrained:
+            print("📥 Loading RegNet with pre-trained weights (319MB download)...")
+            self.backbone = models.regnet_y_16gf(weights=models.RegNet_Y_16GF_Weights.IMAGENET1K_SWAG_E2E_V1)
+        else:
+            print("🚀 Creating RegNet architecture without pre-trained weights...")
+            self.backbone = models.regnet_y_16gf(weights=None)
+        
+        # Freeze most layers (only relevant for pre-trained)
+        for param in self.backbone.parameters():
+            param.requires_grad = False
+        
+        # Unfreeze last block
+        if hasattr(self.backbone, 'trunk_output') and hasattr(self.backbone.trunk_output, 'block4'):
+            self.backbone.trunk_output.block4.requires_grad_(True)
+        
+        # Replace average pooling with max pooling
+        self.backbone.avgpool = nn.AdaptiveMaxPool2d(output_size=(1, 1))
+        
+        # Get feature dimension
+        num_ftrs = self.backbone.fc.in_features
+        
+        # Replace classifier with custom layers
+        self.backbone.fc = nn.Sequential(
+            nn.Linear(num_ftrs, 2048),
+            nn.SiLU(),
+            nn.Dropout(dropout_prob),
+            nn.Linear(2048, 1024),
+            nn.SiLU(),
+            nn.Dropout(dropout_prob),
+            nn.Linear(1024, 512),
+            nn.SiLU(),
+            nn.Dropout(dropout_prob),
+            nn.Linear(512, num_classes)
+        )
+
+    def forward(self, x):
+        return self.backbone(x)
+
+def analyze_checkpoint(checkpoint_path):
+    """Analyze checkpoint to determine if backbone weights are included"""
+    try:
+        print(f"🔍 Analyzing checkpoint: {checkpoint_path}")
+        checkpoint = torch.load(checkpoint_path, map_location='cpu')
+        
+        # Extract state dict
+        if isinstance(checkpoint, dict) and 'model_state_dict' in checkpoint:
+            state_dict = checkpoint['model_state_dict']
+            print("📦 Found structured checkpoint with model_state_dict")
+        else:
+            state_dict = checkpoint
+            print("📦 Found direct state_dict checkpoint")
+        
+        # Analyze parameters
+        all_keys = list(state_dict.keys())
+        backbone_params = [k for k in all_keys if k.startswith('backbone.')]
+        backbone_conv_params = [k for k in backbone_params if 'conv' in k]
+        backbone_block_params = [k for k in backbone_params if 'block' in k]
+        classifier_params = [k for k in all_keys if 'fc' in k]
+        
+        total_params = len(all_keys)
+        
+        print(f"📊 Parameter analysis:")
+        print(f"   • Total parameters: {total_params}")
+        print(f"   • Backbone parameters: {len(backbone_params)}")
+        print(f"   • Backbone conv layers: {len(backbone_conv_params)}")
+        print(f"   • Backbone blocks: {len(backbone_block_params)}")
+        print(f"   • Classifier parameters: {len(classifier_params)}")
+        
+        # Determine if full backbone is included
+        # RegNet has many backbone parameters, so if we have 100+ backbone params, it's likely complete
+        has_full_backbone = len(backbone_params) > 100 and len(backbone_conv_params) > 10
+        
+        if has_full_backbone:
+            print("✅ COMPLETE MODEL DETECTED - backbone weights included!")
+            print("🚀 Will skip RegNet download for faster loading")
+        else:
+            print("⚠️ Incomplete model detected - backbone weights missing")
+            print("📥 Will download RegNet pre-trained weights")
+        
+        return has_full_backbone, checkpoint
+        
+    except Exception as e:
+        print(f"❌ Error analyzing checkpoint: {e}")
+        print("📥 Will fallback to downloading RegNet weights")
+        return False, None
+
+class AIImageDetector:
+    def __init__(self, model_path, device=None):
+        """Initialize AI Image Detector with smart loading"""
+        self.device = device if device else ('cuda' if torch.cuda.is_available() else 'cpu')
+        print(f"🚀 Initializing AI Image Detector on {self.device}")
+        
+        # Analyze checkpoint to determine loading strategy
+        has_backbone, checkpoint = analyze_checkpoint(model_path)
+        
+        # Load model with optimized strategy
+        self.model = self._load_model(model_path, has_backbone, checkpoint)
+        self.model.eval()
+        
+        # Define image preprocessing transforms
+        self.transform = transforms.Compose([
+            transforms.Resize(224, interpolation=transforms.InterpolationMode.BICUBIC),
+            transforms.CenterCrop(224),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+        ])
+        
+        print("✅ Model loaded and ready for inference!")
+    
+    def _load_model(self, model_path, has_backbone, checkpoint):
+        """Load model with optimized backbone loading"""
+        try:
+            # Load checkpoint if not already loaded
+            if checkpoint is None:
+                checkpoint = torch.load(model_path, map_location=self.device)
+            
+            # Determine whether to load pre-trained weights
+            load_pretrained = not has_backbone
+            
+            # Create model
+            if isinstance(checkpoint, dict) and 'model_state_dict' in checkpoint:
+                # Structured checkpoint
+                model = AIDetectorModel(
+                    num_classes=checkpoint.get('num_classes', 2),
+                    dropout_prob=checkpoint.get('dropout_prob', 0.3),
+                    load_pretrained=load_pretrained
+                )
+                model.load_state_dict(checkpoint['model_state_dict'])
+                
+                # Show additional info if available
+                if 'epoch' in checkpoint:
+                    print(f"📊 Loaded model from epoch {checkpoint['epoch']}")
+                if 'val_loss' in checkpoint:
+                    print(f"📊 Validation loss: {checkpoint['val_loss']:.4f}")
+                    
+            else:
+                # Direct state dict
+                model = AIDetectorModel(load_pretrained=load_pretrained)
+                model.load_state_dict(checkpoint)
+            
+            return model.to(self.device)
+            
+        except Exception as e:
+            print(f"❌ Error loading model: {e}")
+            print("🔄 Attempting fallback loading...")
+            
+            # Fallback: try with pre-trained weights
+            try:
+                model = AIDetectorModel(load_pretrained=True)
+                if isinstance(checkpoint, dict) and 'model_state_dict' in checkpoint:
+                    model.load_state_dict(checkpoint['model_state_dict'])
+                else:
+                    model.load_state_dict(checkpoint)
+                return model.to(self.device)
+            except Exception as fallback_error:
+                print(f"❌ Fallback loading also failed: {fallback_error}")
+                raise e
+    
+    def preprocess_image(self, image):
+        """Preprocess image for model input"""
+        try:
+            # Ensure RGB format
+            if image.mode != 'RGB':
+                image = image.convert('RGB')
+            
+            # Apply transforms and add batch dimension
+            tensor = self.transform(image).unsqueeze(0)
+            return tensor.to(self.device)
+            
+        except Exception as e:
+            print(f"❌ Error preprocessing image: {e}")
+            raise e
+    
+    def predict(self, image):
+        """
+        Predict if image is real or AI-generated
+        
+        Returns:
+            tuple: (prediction, confidence, probabilities)
+        """
+        try:
+            # Preprocess image
+            input_tensor = self.preprocess_image(image)
+            
+            # Run inference
+            with torch.no_grad():
+                outputs = self.model(input_tensor)
+                probabilities = F.softmax(outputs, dim=1)
+                confidence, predicted = torch.max(probabilities, 1)
+                
+                # Convert to numpy for easier handling
+                probs = probabilities.cpu().numpy()[0]
+                pred_class = predicted.cpu().item()
+                conf_score = confidence.cpu().item()
+                
+                # Map to class names
+                class_names = ['REAL', 'FAKE']
+                prediction = class_names[pred_class]
+                
+                return prediction, conf_score, probs
+                
+        except Exception as e:
+            print(f"❌ Error during prediction: {e}")
+            raise e
+    
+    def predict_from_url(self, url):
+        """Download image from URL and make prediction"""
+        try:
+            # Download image with timeout
+            headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'}
+            response = requests.get(url, timeout=15, headers=headers)
+            response.raise_for_status()
+            
+            # Load image
+            image = Image.open(BytesIO(response.content))
+            
+            # Make prediction
+            prediction, confidence, probabilities = self.predict(image)
+            
+            return prediction, confidence, probabilities, image
+            
+        except requests.exceptions.RequestException as e:
+            print(f"❌ Error downloading image: {e}")
+            raise Exception(f"Failed to download image from URL: {str(e)}")
+        except Exception as e:
+            print(f"❌ Error processing image from URL: {e}")
+            raise e
+
+def load_detector(model_path=None):
+    """Load the detector model with automatic path detection"""
+    global detector
+    
+    if detector is None:
+        try:
+            # Define possible model file locations
+            possible_paths = [
+                'best_ai_detector.pth',
+                'ai_detector_complete.pth',
+                './models/best_ai_detector.pth',
+                './models/ai_detector_complete.pth',
+                './checkpoints/best_ai_detector.pth',
+                './checkpoints/ai_detector_complete.pth'
+            ]
+            
+            # Use specified path or find available file
+            if model_path and os.path.exists(model_path):
+                target_path = model_path
+                print(f"🎯 Using specified model: {target_path}")
+            else:
+                target_path = None
+                print(f"🔍 Searching for model files...")
+                
+                for path in possible_paths:
+                    if os.path.exists(path):
+                        target_path = path
+                        print(f"✅ Found model file: {path}")
+                        break
+            
+            if target_path is None:
+                # List available files for debugging
+                current_files = [f for f in os.listdir('.') if f.endswith('.pth')]
+                error_msg = f"❌ No model file found!\n\n"
+                error_msg += f"Searched locations:\n"
+                for path in possible_paths:
+                    error_msg += f"  • {path}\n"
+                error_msg += f"\nAvailable .pth files in current directory:\n"
+                for file in current_files:
+                    error_msg += f"  • {file}\n"
+                error_msg += f"\nPlease ensure your trained model file is uploaded to the Space."
+                return error_msg
+            
+            # Initialize detector
+            detector = AIImageDetector(target_path)
+            return f"✅ Model loaded successfully from {target_path}!"
+            
+        except Exception as e:
+            error_msg = f"❌ Error loading model: {str(e)}\n\n"
+            error_msg += "This might be due to:\n"
+            error_msg += "• Incompatible model file\n"
+            error_msg += "• Corrupted checkpoint\n"
+            error_msg += "• Missing dependencies\n"
+            return error_msg
+    
+    return "✅ Model already loaded and ready!"
+
+def predict_image(image):
+    """Handle image upload and prediction"""
+    global detector
+    
+    # Ensure detector is loaded
+    if detector is None:
+        load_result = load_detector()
+        if "❌" in load_result:
+            return load_result, None, None, None
+    
+    if image is None:
+        return "❌ Please upload an image first!", None, None, None
+    
+    try:
+        # Make prediction
+        prediction, confidence, probabilities = detector.predict(image)
+        
+        # Format detailed results
+        result_text = f"🔍 **Prediction: {prediction}**\n\n"
+        result_text += f"📊 **Confidence: {confidence:.1%}**\n\n"
+        result_text += f"📈 **Detailed Probabilities:**\n"
+        result_text += f"• 🟢 REAL (Human-made): {probabilities[0]:.1%}\n"
+        result_text += f"• 🔴 FAKE (AI-generated): {probabilities[1]:.1%}\n\n"
+        
+        # Add interpretation
+        if confidence > 0.8:
+            result_text += f"💪 **High confidence prediction**"
+        elif confidence > 0.6:
+            result_text += f"🤔 **Moderate confidence prediction**"
+        else:
+            result_text += f"⚠️ **Low confidence - uncertain prediction**"
+        
+        # Create chart data
+        prob_df = pd.DataFrame({
+            'Category': ['REAL (Human)', 'FAKE (AI)'],
+            'Probability': [float(probabilities[0]), float(probabilities[1])]
+        })
+        
+        # Quick status
+        color = "🟢" if prediction == "REAL" else "🔴"
+        status = f"{color} {prediction} - {confidence:.1%} confidence"
+        
+        return result_text, prob_df, prediction, status
+        
+    except Exception as e:
+        error_msg = f"❌ Prediction failed: {str(e)}"
+        print(error_msg)
+        return error_msg, None, None, None
+
+def predict_from_url(url):
+    """Handle URL input and prediction"""
+    global detector
+    
+    # Ensure detector is loaded
+    if detector is None:
+        load_result = load_detector()
+        if "❌" in load_result:
+            return load_result, None, None, None, None
+    
+    if not url or not url.strip():
+        return "❌ Please enter a valid image URL!", None, None, None, None
+    
+    try:
+        # Download and predict
+        prediction, confidence, probabilities, image = detector.predict_from_url(url.strip())
+        
+        # Format results (same as upload)
+        result_text = f"🔍 **Prediction: {prediction}**\n\n"
+        result_text += f"📊 **Confidence: {confidence:.1%}**\n\n"
+        result_text += f"📈 **Detailed Probabilities:**\n"
+        result_text += f"• 🟢 REAL (Human-made): {probabilities[0]:.1%}\n"
+        result_text += f"• 🔴 FAKE (AI-generated): {probabilities[1]:.1%}\n\n"
+        
+        # Add interpretation
+        if confidence > 0.8:
+            result_text += f"💪 **High confidence prediction**"
+        elif confidence > 0.6:
+            result_text += f"🤔 **Moderate confidence prediction**"
+        else:
+            result_text += f"⚠️ **Low confidence - uncertain prediction**"
+        
+        # Create chart data
+        prob_df = pd.DataFrame({
+            'Category': ['REAL (Human)', 'FAKE (AI)'],
+            'Probability': [float(probabilities[0]), float(probabilities[1])]
+        })
+        
+        # Quick status
+        color = "🟢" if prediction == "REAL" else "🔴"
+        status = f"{color} {prediction} - {confidence:.1%} confidence"
+        
+        return result_text, prob_df, prediction, status, image
+        
+    except Exception as e:
+        error_msg = f"❌ URL processing failed: {str(e)}"
+        print(error_msg)
+        return error_msg, None, None, None, None
+
+def create_interface():
+    """Create the Gradio web interface"""
+    
+    # Custom CSS for better styling
+    css = """
+    .main-header {
+        text-align: center;
+        background: linear-gradient(90deg, #667eea 0%, #764ba2 100%);
+        color: white;
+        padding: 20px;
+        border-radius: 10px;
+        margin-bottom: 20px;
+        box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+    }
+    .status-box {
+        font-size: 18px;
+        font-weight: bold;
+        text-align: center;
+    }
+    """
+    
+    with gr.Blocks(css=css, title="AI Image Detector", theme=gr.themes.Soft()) as demo:
+        # Main header
+        gr.HTML("""
+        <div class="main-header">
+            <h1>🤖 AI Image Detector</h1>
+            <p>Upload an image or provide a URL to detect if it's REAL (human-made) or FAKE (AI-generated)</p>
+            <p><small>Powered by RegNetY-16GF with custom classification layers</small></p>
+        </div>
+        """)
+        
+        # Model loading section
+        with gr.Row():
+            with gr.Column(scale=3):
+                model_status = gr.Textbox(
+                    label="🔧 Model Status",
+                    value="Click 'Load Model' to initialize the AI detector",
+                    interactive=False,
+                    lines=2
+                )
+            with gr.Column(scale=1):
+                load_btn = gr.Button("🔄 Load Model", variant="secondary", size="lg")
+        
+        # Main functionality tabs
+        with gr.Tabs():
+            # Image upload tab
+            with gr.TabItem("📁 Upload Image"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        input_image = gr.Image(
+                            label="📷 Upload Image for Analysis",
+                            type="pil",
+                            height=400
+                        )
+                        predict_btn = gr.Button(
+                            "🔍 Analyze Image", 
+                            variant="primary", 
+                            size="lg"
+                        )
+                    
+                    with gr.Column(scale=1):
+                        prediction_status = gr.Textbox(
+                            label="🎯 Quick Result",
+                            interactive=False,
+                            lines=1,
+                            elem_classes=["status-box"]
+                        )
+                        
+                        prediction_output = gr.Markdown(
+                            label="📊 Detailed Analysis",
+                            value="Upload an image and click 'Analyze Image' to get AI detection results"
+                        )
+                        
+                        probability_chart = gr.BarPlot(
+                            label="📈 Probability Distribution",
+                            x="Category",
+                            y="Probability",
+                            width=400,
+                            height=250,
+                            color="Category"
+                        )
+            
+            # URL input tab
+            with gr.TabItem("🌐 Image URL"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        url_input = gr.Textbox(
+                            label="🔗 Image URL",
+                            placeholder="https://example.com/image.jpg",
+                            lines=2
+                        )
+                        url_predict_btn = gr.Button(
+                            "🔍 Analyze from URL", 
+                            variant="primary", 
+                            size="lg"
+                        )
+                        
+                        downloaded_image = gr.Image(
+                            label="📥 Downloaded Image",
+                            type="pil",
+                            height=300
+                        )
+                    
+                    with gr.Column(scale=1):
+                        url_prediction_status = gr.Textbox(
+                            label="🎯 Quick Result",
+                            interactive=False,
+                            lines=1,
+                            elem_classes=["status-box"]
+                        )
+                        
+                        url_prediction_output = gr.Markdown(
+                            label="📊 Detailed Analysis",
+                            value="Enter an image URL and click 'Analyze from URL' to get AI detection results"
+                        )
+                        
+                        url_probability_chart = gr.BarPlot(
+                            label="📈 Probability Distribution",
+                            x="Category",
+                            y="Probability",
+                            width=400,
+                            height=250,
+                            color="Category"
+                        )
+        
+        # Information and help section
+        with gr.Accordion("ℹ️ About This AI Detector", open=False):
+            gr.Markdown("""
+            ### 🎯 What This Model Does
+            
+            This AI detector analyzes images to determine if they are:
+            - **🟢 REAL**: Created by humans (photographs, traditional digital art, etc.)
+            - **🔴 FAKE**: Generated by AI systems (DALL-E, Midjourney, Stable Diffusion, etc.)
+            
+            ### 📊 Understanding the Results
+            
+            - **Prediction**: The model's best guess (REAL or FAKE)
+            - **Confidence**: How certain the model is (higher = more confident)
+            - **Probabilities**: Breakdown showing likelihood for each category
+            
+            ### 🧠 Model Architecture
+            
+            - **Backbone**: RegNetY-16GF (efficient computer vision model)
+            - **Input Size**: 224×224 pixels
+            - **Classes**: Binary classification (REAL vs FAKE)
+            - **Training**: Fine-tuned on diverse real and AI-generated images
+            
+            ### ⚠️ Important Limitations
+            
+            - This is a research tool and may not be 100% accurate
+            - Performance varies depending on image type and AI generation method
+            - Always use human judgment alongside model predictions
+            - New AI generation techniques may not be detected accurately
+            
+            ### 💡 Tips for Best Results
+            
+            - Use clear, high-quality images
+            - Avoid heavily compressed or low-resolution images
+            - Be aware that the model may struggle with:
+              - Very recent AI generation techniques
+              - Heavily edited or filtered images
+              - Images with mixed real/AI content
+            """)
+        
+        # Connect event handlers
+        load_btn.click(
+            fn=load_detector,
+            outputs=model_status
+        )
+        
+        predict_btn.click(
+            fn=predict_image,
+            inputs=[input_image],
+            outputs=[prediction_output, probability_chart, gr.State(), prediction_status]
+        )
+        
+        url_predict_btn.click(
+            fn=predict_from_url,
+            inputs=[url_input],
+            outputs=[url_prediction_output, url_probability_chart, gr.State(), url_prediction_status, downloaded_image]
+        )
+        
+        # Optional: Add example images if you have them
+        # gr.Examples(
+        #     examples=[
+        #         ["path/to/example_real.jpg"],
+        #         ["path/to/example_fake.jpg"],
+        #     ],
+        #     inputs=input_image,
+        #     label="📷 Try These Examples"
+        # )
+    
+    return demo
+
+if __name__ == "__main__":
+    # Initialize
+    detector = AIImageDetector('best_ai_detector.pth')
+    print("🚀 Starting Optimized AI Image Detector...")
+    print("📝 This version will automatically detect if RegNet download is needed")
+    
+    # Create interface
+    demo = create_interface()
+    
+    # Try to auto-load model at startup (optional)
+    try:
+        print("🔄 Attempting to auto-load model...")
+        load_result = load_detector()
+        print(f"🔧 Startup result: {load_result}")
+    except Exception as e:
+        print(f"⚠️ Model not auto-loaded: {e}")
+        print("💡 Use the 'Load Model' button in the interface")
+    
+    # Launch interface optimized for Hugging Face Spaces
+    print("🌐 Launching interface...")
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True,  # Don't use share=True in Hugging Face Spaces
+        show_error=True,
+        debug=False,ssr_mode=False
+    )

app_v0.py

@@ -0,0 +1,351 @@
+import os
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torchvision import transforms, models
+from PIL import Image
+import gradio as gr
+import numpy as np
+import pandas as pd
+import warnings
+import requests
+from io import BytesIO
+
+warnings.filterwarnings('ignore')
+
+# =============================================================================
+# MODEL FUNCTIONS
+# =============================================================================
+
+class AIDetectorModel(nn.Module):
+    def __init__(self, num_classes=2, dropout_prob=0.3):
+        super(AIDetectorModel, self).__init__()
+        
+        self.backbone = models.regnet_y_16gf(weights=None)
+        self.backbone.avgpool = nn.AdaptiveMaxPool2d(output_size=(1, 1))
+        
+        num_ftrs = self.backbone.fc.in_features
+        self.backbone.fc = nn.Sequential(
+            nn.Linear(num_ftrs, 2048),
+            nn.SiLU(),
+            nn.Dropout(dropout_prob),
+            nn.Linear(2048, 1024),
+            nn.SiLU(),
+            nn.Dropout(dropout_prob),
+            nn.Linear(1024, 512),
+            nn.SiLU(),
+            nn.Dropout(dropout_prob),
+            nn.Linear(512, num_classes)
+        )
+
+    def forward(self, x):
+        return self.backbone(x)
+
+class AIDetector:
+    def __init__(self):
+        self.device = 'cuda' if torch.cuda.is_available() else 'cpu'
+        self.model = None
+        self.model_loaded = False
+        
+        self.transform = transforms.Compose([
+            transforms.Resize(224, interpolation=transforms.InterpolationMode.BICUBIC),
+            transforms.CenterCrop(224),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+        ])
+    
+    def load_model(self, model_path):
+        try:
+            if not os.path.exists(model_path):
+                return f"Error: Model file '{model_path}' not found"
+            
+            checkpoint = torch.load(model_path, map_location='cpu')
+            
+            if isinstance(checkpoint, dict) and 'model_state_dict' in checkpoint:
+                self.model = AIDetectorModel(
+                    num_classes=checkpoint.get('num_classes', 2),
+                    dropout_prob=checkpoint.get('dropout_prob', 0.3)
+                )
+                self.model.load_state_dict(checkpoint['model_state_dict'])
+            else:
+                self.model = AIDetectorModel()
+                self.model.load_state_dict(checkpoint)
+            
+            self.model.to(self.device)
+            self.model.eval()
+            self.model_loaded = True
+            
+            file_size = os.path.getsize(model_path) / (1024*1024)
+            return f"✅ Model '{model_path}' loaded successfully! ({file_size:.1f}MB)"
+            
+        except Exception as e:
+            self.model_loaded = False
+            return f"❌ Failed to load model: {str(e)}"
+    
+    def predict(self, image):
+        if not self.model_loaded:
+            raise RuntimeError("No model loaded")
+        
+        if image.mode != 'RGB':
+            image = image.convert('RGB')
+        
+        input_tensor = self.transform(image).unsqueeze(0).to(self.device)
+        
+        with torch.no_grad():
+            outputs = self.model(input_tensor)
+            probabilities = F.softmax(outputs, dim=1)
+            confidence, predicted = torch.max(probabilities, 1)
+            
+            probs = probabilities.cpu().numpy()[0]
+            pred_class = predicted.cpu().item()
+            conf_score = confidence.cpu().item()
+            
+            class_names = ['REAL', 'FAKE']
+            prediction = class_names[pred_class]
+            
+            return prediction, conf_score, probs
+
+# =============================================================================
+# GLOBAL VARIABLES AND UTILITY FUNCTIONS
+# =============================================================================
+
+detector = AIDetector()
+
+def get_model_files():
+    """Get available .pth model files in current directory"""
+    try:
+        files = [f for f in os.listdir('.') if f.endswith('.pth')]
+        if not files:
+            files = ["No .pth files found"]
+        return files
+    except:
+        return ["Error reading directory"]
+
+def refresh_models():
+    """Refresh the model list"""
+    return gr.Dropdown(choices=get_model_files())
+
+# =============================================================================
+# UI HANDLER FUNCTIONS
+# =============================================================================
+
+def load_model_handler(model_name):
+    if not model_name or model_name in ["No .pth files found", "Error reading directory"]:
+        return "Please select a valid model file"
+    
+    return detector.load_model(model_name)
+
+def predict_handler(image):
+    if not detector.model_loaded:
+        return "❌ No model loaded. Please load a model first.", None, "No Model", "0%"
+    
+    if image is None:
+        return "❌ Please upload an image", None, "No Image", "0%"
+    
+    try:
+        prediction, confidence, probabilities = detector.predict(image)
+        
+        result_text = f"""
+## Analysis Results
+
+**Prediction:** {prediction}  
+**Confidence:** {confidence:.1%}
+
+**Detailed Probabilities:**
+- REAL (Human-made): {probabilities[0]:.1%}
+- FAKE (AI-generated): {probabilities[1]:.1%}
+
+**Confidence Level:** {"High" if confidence > 0.8 else "Moderate" if confidence > 0.6 else "Low"}
+        """
+        
+        chart_data = pd.DataFrame({
+            'Category': ['REAL', 'FAKE'],
+            'Probability': [probabilities[0], probabilities[1]]
+        })
+        
+        return result_text, chart_data, prediction, f"{confidence:.1%}"
+        
+    except Exception as e:
+        return f"❌ Prediction failed: {str(e)}", None, "Error", "0%"
+
+def url_handler(url):
+    if not url or not url.strip():
+        return "❌ Please enter a URL", None, "No URL", "0%", None
+    
+    try:
+        url = url.strip()
+        if not url.startswith(('http://', 'https://')):
+            url = 'https://' + url
+        
+        response = requests.get(url, timeout=10, headers={'User-Agent': 'Mozilla/5.0'})
+        response.raise_for_status()
+        
+        image = Image.open(BytesIO(response.content))
+        result_text, chart_data, prediction, confidence = predict_handler(image)
+        
+        return result_text, chart_data, prediction, confidence, image
+        
+    except Exception as e:
+        return f"❌ Failed to load image from URL: {str(e)}", None, "Error", "0%", None
+
+def clear_handler():
+    return None, "Upload an image to analyze", None, "No Image", "0%"
+
+def clear_url_handler():
+    return "", "Enter an image URL to analyze", None, "No URL", "0%", None
+
+# =============================================================================
+# GRADIO INTERFACE
+# =============================================================================
+
+def create_interface():
+    # Simple theme without custom CSS
+    theme = theme = gr.themes.Soft(
+            primary_hue="orange",
+            secondary_hue="gray"
+        ).set(
+            body_background_fill="*neutral_950",
+            block_background_fill="*neutral_900",
+            button_primary_background_fill="*orange_500",
+            button_primary_background_fill_hover="*orange_600"
+        )
+            
+    with gr.Blocks(theme=theme, title="AI Image Detector") as demo:
+        
+        gr.Markdown("# AI Image Detector")
+        gr.Markdown("Upload an image or provide a URL to detect if it's AI-generated or real.")
+        
+        # Model Loading Section
+        with gr.Row():
+            with gr.Column(scale=3):
+                model_dropdown = gr.Dropdown(
+                    label="Select Model File",
+                    choices=get_model_files(),
+                    value=None,
+                    interactive=True
+                )
+            with gr.Column(scale=1):
+                load_btn = gr.Button("Load Model", variant="primary")
+                refresh_btn = gr.Button("Refresh List", variant="secondary")
+        
+        model_status = gr.Textbox(
+            label="Model Status", 
+            value="No model loaded",
+            interactive=False,
+            lines=2
+        )
+        
+        # Main Interface
+        with gr.Tabs():
+            # Upload Tab
+            with gr.TabItem("Upload Image"):
+                with gr.Row():
+                    with gr.Column():
+                        upload_image = gr.Image(
+                            label="Upload Image", 
+                            type="pil"
+                        )
+                        with gr.Row():
+                            analyze_btn = gr.Button("Analyze Image", variant="primary")
+                            clear_btn = gr.Button("Clear")
+                    
+                    with gr.Column():
+                        status_row = gr.Row()
+                        with status_row:
+                            result_status = gr.Textbox(label="Result", interactive=False)
+                            confidence_status = gr.Textbox(label="Confidence", interactive=False)
+                        
+                        results_text = gr.Markdown("Upload an image to analyze")
+                        results_chart = gr.BarPlot(
+                            x="Category", 
+                            y="Probability",
+                            title="Prediction Probabilities",
+                            height=300
+                        )
+            
+            # URL Tab  
+            with gr.TabItem("Analyze URL"):
+                with gr.Row():
+                    with gr.Column():
+                        url_input = gr.Textbox(
+                            label="Image URL",
+                            placeholder="https://example.com/image.jpg"
+                        )
+                        with gr.Row():
+                            url_btn = gr.Button("Load & Analyze", variant="primary")
+                            url_clear_btn = gr.Button("Clear")
+                        
+                        url_image = gr.Image(label="Loaded Image", type="pil")
+                    
+                    with gr.Column():
+                        url_status_row = gr.Row()
+                        with url_status_row:
+                            url_result_status = gr.Textbox(label="Result", interactive=False)
+                            url_confidence_status = gr.Textbox(label="Confidence", interactive=False)
+                        
+                        url_results_text = gr.Markdown("Enter an image URL to analyze")
+                        url_results_chart = gr.BarPlot(
+                            x="Category",
+                            y="Probability", 
+                            title="URL Prediction Probabilities",
+                            height=300
+                        )
+        
+        # Event Handlers
+        load_btn.click(
+            fn=load_model_handler,
+            inputs=[model_dropdown],
+            outputs=[model_status]
+        )
+        
+        refresh_btn.click(
+            fn=refresh_models,
+            outputs=[model_dropdown]
+        )
+        
+        analyze_btn.click(
+            fn=predict_handler,
+            inputs=[upload_image],
+            outputs=[results_text, results_chart, result_status, confidence_status]
+        )
+        
+        url_btn.click(
+            fn=url_handler,
+            inputs=[url_input],
+            outputs=[url_results_text, url_results_chart, url_result_status, url_confidence_status, url_image]
+        )
+        
+        clear_btn.click(
+            fn=clear_handler,
+            outputs=[upload_image, results_text, results_chart, result_status, confidence_status]
+        )
+        
+        url_clear_btn.click(
+            fn=clear_url_handler,
+            outputs=[url_input, url_results_text, url_results_chart, url_result_status, url_confidence_status, url_image]
+        )
+    
+    return demo
+
+# =============================================================================
+# MAIN FUNCTION
+# =============================================================================
+
+def main():
+    print("AI Image Detector Starting...")
+    print(f"PyTorch: {torch.__version__}")
+    print(f"CUDA Available: {torch.cuda.is_available()}")
+    print(f"Device: {'GPU' if torch.cuda.is_available() else 'CPU'}")
+    
+    models = get_model_files()
+    print(f"Found models: {models}")
+    
+    demo = create_interface()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False
+    )
+
+if __name__ == "__main__":
+    main()

best_ai_detector.pth

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

best_ai_detector_new.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:59044857b458fd807706133bf2d4cb2ac7089c10dc30c6f24ffaf3476a7611fa
+size 358210596

saveFullModel.py

@@ -0,0 +1,183 @@
+import torch
+import torch.nn as nn
+from torchvision import models
+import os
+
+class AIDetectorModel(nn.Module):
+    def __init__(self, num_classes=2, dropout_prob=0.3, load_pretrained=True):
+        super(AIDetectorModel, self).__init__()
+        
+        if load_pretrained:
+            print("📥 Loading RegNet with pre-trained weights...")
+            self.backbone = models.regnet_y_16gf(weights=models.RegNet_Y_16GF_Weights.IMAGENET1K_SWAG_E2E_V1)
+        else:
+            self.backbone = models.regnet_y_16gf(weights=None)
+        
+        # Freeze most layers
+        for param in self.backbone.parameters():
+            param.requires_grad = False
+        
+        # Unfreeze last block
+        if hasattr(self.backbone, 'trunk_output') and hasattr(self.backbone.trunk_output, 'block4'):
+            self.backbone.trunk_output.block4.requires_grad_(True)
+        
+        # Replace average pooling with max pooling
+        self.backbone.avgpool = nn.AdaptiveMaxPool2d(output_size=(1, 1))
+        
+        # Get feature dimension
+        num_ftrs = self.backbone.fc.in_features
+        
+        # Replace classifier
+        self.backbone.fc = nn.Sequential(
+            nn.Linear(num_ftrs, 2048),
+            nn.SiLU(),
+            nn.Dropout(dropout_prob),
+            nn.Linear(2048, 1024),
+            nn.SiLU(),
+            nn.Dropout(dropout_prob),
+            nn.Linear(1024, 512),
+            nn.SiLU(),
+            nn.Dropout(dropout_prob),
+            nn.Linear(512, num_classes)
+        )
+
+    def forward(self, x):
+        return self.backbone(x)
+
+def verify_complete_backbone(model):
+    """Verify that model has complete RegNet backbone - CORRECTED"""
+    state_dict = model.state_dict()
+    all_keys = list(state_dict.keys())
+    
+    # Check for actual RegNet components based on real structure
+    stem_keys = [k for k in all_keys if 'backbone.stem' in k]
+    block_keys = [k for k in all_keys if 'backbone.trunk_output.block' in k]
+    proj_keys = [k for k in all_keys if 'backbone.trunk_output.block' in k and 'proj' in k]
+    fc_keys = [k for k in all_keys if 'backbone.fc' in k]
+    
+    print(f"🔍 Backbone verification:")
+    print(f"   • Total keys: {len(all_keys)}")
+    print(f"   • Stem keys: {len(stem_keys)}")
+    print(f"   • Block keys: {len(block_keys)}")
+    print(f"   • Projection keys: {len(proj_keys)}")
+    print(f"   • FC keys: {len(fc_keys)}")
+    
+    # CORRECTED: RegNet Y 16GF has: ~420 block params, ~24 proj layers, 6 stem params
+    is_complete = (
+        len(block_keys) > 400 and  # Should have ~420 block parameters
+        len(stem_keys) > 5 and     # Should have 6 stem parameters  
+        len(proj_keys) > 20        # Should have ~24 projection parameters
+    )
+    
+    if is_complete:
+        print("✅ Complete backbone verified!")
+        print(f"✅ Found {len(block_keys)} blocks, {len(stem_keys)} stem, {len(proj_keys)} proj layers")
+    else:
+        print("❌ Incomplete backbone detected!")
+        print(f"Expected: >400 blocks, >5 stem, >20 proj")
+        print(f"Found: {len(block_keys)} blocks, {len(stem_keys)} stem, {len(proj_keys)} proj")
+    
+    return is_complete
+
+def create_truly_complete_model(trained_checkpoint_path, output_path):
+    """Create a truly complete model with full RegNet weights"""
+    
+    print("🔄 Creating TRULY complete offline model...")
+    print("=" * 60)
+    
+    # Step 1: Create fresh model WITH pretrained weights
+    print("📥 Step 1: Loading fresh RegNet with ImageNet weights...")
+    fresh_model = AIDetectorModel(load_pretrained=True)
+    
+    # Step 2: Verify fresh model is complete (FIXED VALIDATION)
+    print("\n🔍 Step 2: Verifying fresh model completeness...")
+    if not verify_complete_backbone(fresh_model):
+        raise RuntimeError("❌ Fresh model is not complete!")
+    
+    # Step 3: Load your trained weights
+    print(f"\n📂 Step 3: Loading your trained weights from {trained_checkpoint_path}...")
+    trained_checkpoint = torch.load(trained_checkpoint_path, map_location='cpu')
+    
+    if isinstance(trained_checkpoint, dict) and 'model_state_dict' in trained_checkpoint:
+        trained_state = trained_checkpoint['model_state_dict']
+        extra_info = {
+            'num_classes': trained_checkpoint.get('num_classes', 2),
+            'dropout_prob': trained_checkpoint.get('dropout_prob', 0.3),
+            'epoch': trained_checkpoint.get('epoch', 0),
+            'val_loss': trained_checkpoint.get('val_loss', 0.0)
+        }
+    else:
+        trained_state = trained_checkpoint
+        extra_info = {'num_classes': 2, 'dropout_prob': 0.3}
+    
+    # Step 4: Merge weights intelligently
+    print("\n🔀 Step 4: Merging backbone + trained classifier...")
+    fresh_state = fresh_model.state_dict()
+    
+    # Keep ALL backbone weights from fresh model (includes RegNet pretrained)
+    # Replace ONLY classifier weights from trained model
+    merged_state = fresh_state.copy()
+    
+    classifier_keys = [k for k in trained_state.keys() if 'backbone.fc' in k]
+    print(f"   • Replacing {len(classifier_keys)} classifier parameters")
+    
+    for key in classifier_keys:
+        if key in trained_state:
+            merged_state[key] = trained_state[key]
+            print(f"   ✅ Updated: {key}")
+    
+    # Step 5: Create final model and verify
+    print("\n✅ Step 5: Creating final complete model...")
+    final_model = AIDetectorModel(load_pretrained=False)  # Empty architecture
+    final_model.load_state_dict(merged_state)  # Load merged weights
+    
+    # Final verification (should definitely pass now)
+    print("\n🔍 Final verification:")
+    if not verify_complete_backbone(final_model):
+        raise RuntimeError("❌ Final model verification failed!")
+    
+    # Step 6: Save complete model
+    print(f"\n💾 Step 6: Saving complete model to {output_path}...")
+    complete_checkpoint = {
+        'model_state_dict': merged_state,
+        'complete_model': True,
+        'backbone_included': True,
+        'offline_ready': True,
+        **extra_info
+    }
+    
+    torch.save(complete_checkpoint, output_path)
+    
+    file_size = os.path.getsize(output_path) / (1024*1024)
+    print(f"✅ SUCCESS! Complete model saved:")
+    print(f"   • File: {output_path}")
+    print(f"   • Size: {file_size:.1f}MB")
+    print(f"   • Ready for offline use!")
+    
+    return output_path
+
+if __name__ == "__main__":
+    # Input and output paths
+    input_model = "2_block_best_ai_detector.pth"  # Your trained model
+    output_model = "truly_complete_ai_detector_new.pth"  # New complete model
+    
+    if not os.path.exists(input_model):
+        print(f"❌ Trained model not found: {input_model}")
+        # Show available files
+        pth_files = [f for f in os.listdir('.') if f.endswith('.pth')]
+        if pth_files:
+            print("Available .pth files:")
+            for f in pth_files:
+                size = os.path.getsize(f) / (1024*1024)
+                print(f"   • {f} ({size:.1f}MB)")
+        else:
+            print("No .pth files found in current directory")
+    else:
+        try:
+            result_path = create_truly_complete_model(input_model, output_model)
+            print("\n" + "="*60)
+            print(f"🎉 SUCCESS! Use this file in your offline app:")
+            print(f"📁 {result_path}")
+            print("="*60)
+        except Exception as e:
+            print(f"❌ Failed to create complete model: {e}")

static/styles.css

@@ -0,0 +1,184 @@
+:root{
+  --bg:#0b0f14;
+  --card:#121824;
+  --card2:#0f1520;
+  --text:#e8eef7;
+  --muted:#a9b6c7;
+  --accent:#ff5f00;
+  --accent2:#eb001b;
+  --border:rgba(255,255,255,.08);
+}
+*{box-sizing:border-box}
+body{
+  margin:0;
+  font-family: ui-sans-serif, system-ui, -apple-system, Segoe UI, Roboto, Helvetica, Arial, "Apple Color Emoji", "Segoe UI Emoji";
+  background: radial-gradient(1200px 600px at 20% 0%, rgba(255,95,0,.25), transparent 50%),
+              radial-gradient(1000px 500px at 90% 10%, rgba(235,0,27,.18), transparent 55%),
+              var(--bg);
+  color:var(--text);
+}
+.container{max-width:1100px;margin:0 auto;padding:28px 18px 60px}
+.header{
+  background: linear-gradient(135deg, rgba(235,0,27,.95), rgba(255,95,0,.95));
+  border-radius:16px;
+  padding:22px 22px;
+  border:1px solid rgba(255,255,255,.12);
+}
+h1{margin:0 0 6px 0;font-size:28px}
+.sub{margin:0;color:rgba(255,255,255,.92)}
+.grid{display:grid;grid-template-columns:repeat(3,1fr);gap:14px;margin-top:14px}
+.card{
+  background: linear-gradient(180deg, rgba(18,24,36,.95), rgba(15,21,32,.95));
+  border:1px solid var(--border);
+  border-radius:16px;
+  padding:16px;
+  box-shadow: 0 10px 30px rgba(0,0,0,.25);
+}
+.card h2{margin:0 0 12px 0;font-size:16px;color:var(--text)}
+.row{display:flex;gap:12px;align-items:flex-end;flex-wrap:wrap}
+.field{display:flex;flex-direction:column;gap:6px;width:100%}
+.field span{font-size:12px;color:var(--muted)}
+select,input[type="url"],input[type="number"],input[type="file"]{
+  width:100%;
+  padding:10px 10px;
+  border-radius:10px;
+  border:1px solid var(--border);
+  background:#0b111b;
+  color:var(--text);
+  outline:none;
+}
+.btn{
+  appearance:none;
+  border:1px solid rgba(255,255,255,.14);
+  background: linear-gradient(135deg, var(--accent2), var(--accent));
+  color:white;
+  border-radius:12px;
+  padding:10px 14px;
+  font-weight:700;
+  cursor:pointer;
+  width:100%;
+}
+.btn.secondary{
+  background: transparent;
+  border:1px solid rgba(255,255,255,.18);
+}
+.btn:hover{filter:brightness(1.03)}
+.status{margin-top:12px;padding:10px;border:1px dashed rgba(255,255,255,.16);border-radius:12px}
+.label{font-size:12px;color:var(--muted);margin-bottom:6px}
+.mono{font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;}
+.result{margin-top:12px}
+.pill{
+  display:inline-block;
+  padding:8px 10px;
+  border-radius:999px;
+  border:1px solid rgba(255,255,255,.14);
+  background: rgba(255,255,255,.06);
+  font-weight:700;
+}
+.hint{margin-top:8px;font-size:12px;color:var(--muted)}
+.media-row{margin-top:10px}
+.preview{
+  width:100%;
+  height:auto;
+  border-radius:14px;
+  border:1px solid rgba(255,255,255,.10);
+  background: rgba(0,0,0,.18);
+}
+.kv{
+  margin-top:10px;
+  display:grid;
+  grid-template-columns:1fr 1fr;
+  gap:8px 10px;
+}
+.kv .k{
+  display:block;
+  font-size:12px;
+  color:var(--muted);
+  margin-bottom:4px;
+}
+.kv .v{
+  display:block;
+  padding:8px 10px;
+  border-radius:12px;
+  border:1px solid rgba(255,255,255,.10);
+  background: rgba(0,0,0,.18);
+}
+.frame-grid{
+  margin-top:12px;
+  display:grid;
+  grid-template-columns: repeat(2, 1fr);
+  gap:10px;
+}
+.frame-card{
+  border:1px solid rgba(255,255,255,.10);
+  background: rgba(0,0,0,.12);
+  border-radius:14px;
+  overflow:hidden;
+}
+.frame{
+  width:100%;
+  height:auto;
+  display:block;
+}
+.frame-meta{
+  padding:10px;
+  color:var(--muted);
+  display:flex;
+  flex-direction:column;
+  gap:6px;
+}
+.history{
+  margin-top:10px;
+  display:flex;
+  flex-direction:column;
+  gap:10px;
+}
+.history-item{
+  border:1px solid rgba(255,255,255,.10);
+  background: rgba(0,0,0,.14);
+  border-radius:14px;
+  padding:10px;
+}
+.history-top{
+  display:flex;
+  justify-content:space-between;
+  gap:10px;
+  color:var(--muted);
+  font-size:12px;
+}
+.history-mid{
+  margin-top:6px;
+  display:flex;
+  flex-direction:column;
+  gap:4px;
+}
+.history-bottom{
+  margin-top:8px;
+  font-weight:700;
+  color:var(--text);
+}
+.error{
+  padding:10px;
+  border-radius:12px;
+  border:1px solid rgba(255,95,0,.35);
+  background: rgba(255,95,0,.12);
+  color: #ffd7bf;
+}
+.md{
+  margin-top:10px;
+  white-space:pre-wrap;
+  padding:10px;
+  border-radius:12px;
+  border:1px solid rgba(255,255,255,.10);
+  background: rgba(0,0,0,.18);
+  color: var(--text);
+  overflow:auto;
+}
+.footer{margin-top:18px}
+@media (max-width: 980px){
+  .grid{grid-template-columns:1fr}
+  .btn{width:100%}
+  .frame-grid{grid-template-columns:1fr}
+  .kv{grid-template-columns:1fr}
+}
+

templates/index.html

@@ -0,0 +1,175 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width,initial-scale=1" />
+    <title>AI Image Detector</title>
+    <link rel="stylesheet" href="/static/styles.css" />
+  </head>
+  <body>
+    <div class="container">
+      <header class="header">
+        <div>
+          <h1>AI Image Detector</h1>
+          <p class="sub">Detect whether an image looks REAL (human-made) or FAKE (AI-generated). Also supports quick video sampling.</p>
+        </div>
+      </header>
+
+      <section class="card">
+        <h2>Model</h2>
+        <form class="row" method="post" action="/load_model">
+          <label class="field">
+            <span>Model file</span>
+            <select name="model_path">
+              {% for m in available_models %}
+                <option value="{{ m }}" {% if current_model_path == m %}selected{% endif %}>{{ m }}</option>
+              {% endfor %}
+            </select>
+          </label>
+          <button type="submit" class="btn secondary">Load model</button>
+        </form>
+        <div class="status">
+          <div class="label">Status</div>
+          <div class="mono">{{ model_status }}</div>
+        </div>
+      </section>
+
+      <section class="card">
+        <h2>History (last 10)</h2>
+        {% if history and history|length > 0 %}
+          <div class="history">
+            {% for h in history %}
+              <div class="history-item">
+                <div class="history-top">
+                  <div class="mono">{{ h.ts }}</div>
+                  <div class="mono">{{ h.type }}</div>
+                </div>
+                <div class="history-mid">
+                  <div class="hint">Model: <span class="mono">{{ h.model }}</span></div>
+                  <div class="hint">Input: <span class="mono">{{ h.source }}</span></div>
+                </div>
+                <div class="history-bottom">
+                  <div class="mono">{{ h.prediction }}{% if h.confidence is not none %} · {{ (h.confidence*100) | round(1) }}%{% endif %}</div>
+                </div>
+              </div>
+            {% endfor %}
+          </div>
+        {% else %}
+          <div class="hint">No checks yet.</div>
+        {% endif %}
+      </section>
+
+      <section class="grid">
+        <div class="card">
+          <h2>Upload image</h2>
+          <form method="post" action="/analyze_image_upload" enctype="multipart/form-data">
+            <label class="field">
+              <span>Image file</span>
+              <input type="file" name="file" accept="image/*" required />
+            </label>
+            <button type="submit" class="btn">Analyze image</button>
+          </form>
+
+          {% if image_result %}
+            <div class="result">
+              {% if image_result.error %}
+                <div class="error">Error: {{ image_result.error }}</div>
+              {% else %}
+                <div class="pill">{{ image_result.quick }}</div>
+                <div class="media-row">
+                  <img class="preview" src="{{ image_result.image_data_uri }}" alt="Uploaded image preview" />
+                </div>
+                <div class="kv">
+                  <div><span class="k">Prediction</span><span class="v mono">{{ image_result.prediction }}</span></div>
+                  <div><span class="k">Confidence</span><span class="v mono">{{ (image_result.confidence*100) | round(1) }}%</span></div>
+                  <div><span class="k">p_real</span><span class="v mono">{{ (image_result.probabilities[0]*100) | round(1) }}%</span></div>
+                  <div><span class="k">p_fake</span><span class="v mono">{{ (image_result.probabilities[1]*100) | round(1) }}%</span></div>
+                </div>
+              {% endif %}
+            </div>
+          {% endif %}
+        </div>
+
+        <div class="card">
+          <h2>Image URL</h2>
+          <form method="post" action="/analyze_image_url">
+            <label class="field">
+              <span>Image URL</span>
+              <input type="url" name="url" placeholder="https://example.com/image.jpg" required />
+            </label>
+            <button type="submit" class="btn">Analyze URL</button>
+          </form>
+
+          {% if url_result %}
+            <div class="result">
+              {% if url_result.error %}
+                <div class="error">Error: {{ url_result.error }}</div>
+              {% else %}
+                <div class="pill">{{ url_result.quick }}</div>
+                <div class="hint">Source: <span class="mono">{{ url_result.url }}</span></div>
+                <div class="media-row">
+                  <img class="preview" src="{{ url_result.image_data_uri }}" alt="URL image preview" />
+                </div>
+                <div class="kv">
+                  <div><span class="k">Prediction</span><span class="v mono">{{ url_result.prediction }}</span></div>
+                  <div><span class="k">Confidence</span><span class="v mono">{{ (url_result.confidence*100) | round(1) }}%</span></div>
+                  <div><span class="k">p_real</span><span class="v mono">{{ (url_result.probabilities[0]*100) | round(1) }}%</span></div>
+                  <div><span class="k">p_fake</span><span class="v mono">{{ (url_result.probabilities[1]*100) | round(1) }}%</span></div>
+                </div>
+              {% endif %}
+            </div>
+          {% endif %}
+        </div>
+
+        <div class="card">
+          <h2>Video analyzer (random frames)</h2>
+          <form method="post" action="/analyze_video_url">
+            <label class="field">
+              <span>Video URL</span>
+              <input type="url" name="video_url" placeholder="https://example.com/video.mp4" required />
+            </label>
+            <label class="field">
+              <span>Frames to sample</span>
+              <input type="number" name="num_frames" min="1" max="50" value="5" />
+            </label>
+            <button type="submit" class="btn">Analyze video</button>
+            <div class="hint">Downloads the video, samples random frames, and aggregates results into a report.</div>
+          </form>
+
+          {% if video_result %}
+            <div class="result">
+              {% if video_result.error %}
+                <div class="error">Error: {{ video_result.error }}</div>
+              {% else %}
+                <div class="pill">Overall: {{ video_result.overall }} (avg p_fake {{ (video_result.avg_p_fake*100) | round(1) }}%)</div>
+                <div class="hint">Source: <span class="mono">{{ video_result.video_url }}</span></div>
+                {% if video_result.is_youtube %}
+                  <div class="hint">Detected YouTube URL (downloaded via <span class="mono">yt-dlp</span>).</div>
+                {% endif %}
+                <div class="frame-grid">
+                  {% for f in video_result.frames %}
+                    <div class="frame-card">
+                      <img class="frame" src="{{ f.image_data_uri }}" alt="Frame {{ f.frame_index }}" />
+                      <div class="frame-meta">
+                        <div class="mono">frame {{ f.frame_index }}</div>
+                        <div class="mono">{{ f.prediction }} · conf {{ (f.confidence*100) | round(1) }}%</div>
+                        <div class="mono">p_fake {{ (f.p_fake*100) | round(1) }}%</div>
+                      </div>
+                    </div>
+                  {% endfor %}
+                </div>
+              {% endif %}
+            </div>
+          {% endif %}
+        </div>
+      </section>
+
+      <footer class="footer">
+        <div class="hint">
+          Tip: on Hugging Face Spaces, run with <span class="mono">uvicorn ai_vs_real.app:app --host 0.0.0.0 --port 7860</span>.
+        </div>
+      </footer>
+    </div>
+  </body>
+</html>
+

test.ipynb

@@ -0,0 +1,192 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "ab0628fc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "🔍 Exploring RegNet Y 16GF structure...\n",
+      "📊 Total parameters: 428\n",
+      "\n",
+      "🏗️ RegNet Structure Analysis:\n",
+      "\n",
+      "📁 stem.0: 1 parameters\n",
+      "   • stem.0.weight\n",
+      "\n",
+      "📁 stem.1: 5 parameters\n",
+      "   • stem.1.weight\n",
+      "   • stem.1.bias\n",
+      "   • stem.1.running_mean\n",
+      "   • stem.1.running_var\n",
+      "   • stem.1.num_batches_tracked\n",
+      "\n",
+      "📁 trunk_output.block1: 50 parameters\n",
+      "   • trunk_output.block1.block1-0.proj.0.weight\n",
+      "   • trunk_output.block1.block1-0.proj.1.weight\n",
+      "   • trunk_output.block1.block1-0.proj.1.bias\n",
+      "   • trunk_output.block1.block1-0.proj.1.running_mean\n",
+      "   • trunk_output.block1.block1-0.proj.1.running_var\n",
+      "   ... and 45 more\n",
+      "\n",
+      "📁 trunk_output.block2: 94 parameters\n",
+      "   • trunk_output.block2.block2-0.proj.0.weight\n",
+      "   • trunk_output.block2.block2-0.proj.1.weight\n",
+      "   • trunk_output.block2.block2-0.proj.1.bias\n",
+      "   • trunk_output.block2.block2-0.proj.1.running_mean\n",
+      "   • trunk_output.block2.block2-0.proj.1.running_var\n",
+      "   ... and 89 more\n",
+      "\n",
+      "📁 trunk_output.block3: 248 parameters\n",
+      "   • trunk_output.block3.block3-0.proj.0.weight\n",
+      "   • trunk_output.block3.block3-0.proj.1.weight\n",
+      "   • trunk_output.block3.block3-0.proj.1.bias\n",
+      "   • trunk_output.block3.block3-0.proj.1.running_mean\n",
+      "   • trunk_output.block3.block3-0.proj.1.running_var\n",
+      "   ... and 243 more\n",
+      "\n",
+      "📁 trunk_output.block4: 28 parameters\n",
+      "   • trunk_output.block4.block4-0.proj.0.weight\n",
+      "   • trunk_output.block4.block4-0.proj.1.weight\n",
+      "   • trunk_output.block4.block4-0.proj.1.bias\n",
+      "   • trunk_output.block4.block4-0.proj.1.running_mean\n",
+      "   • trunk_output.block4.block4-0.proj.1.running_var\n",
+      "   ... and 23 more\n",
+      "\n",
+      "📁 fc.weight: 1 parameters\n",
+      "   • fc.weight\n",
+      "\n",
+      "📁 fc.bias: 1 parameters\n",
+      "   • fc.bias\n",
+      "\n",
+      "============================================================\n",
+      "🔍 Searching for conv layers specifically:\n",
+      "Found 0 conv parameters:\n",
+      "\n",
+      "============================================================\n",
+      "🔍 Looking for block structure:\n",
+      "Found 420 block parameters:\n",
+      "   • trunk_output.block1.block1-0.proj.0.weight\n",
+      "   • trunk_output.block1.block1-0.proj.1.weight\n",
+      "   • trunk_output.block1.block1-0.proj.1.bias\n",
+      "   • trunk_output.block1.block1-0.proj.1.running_mean\n",
+      "   • trunk_output.block1.block1-0.proj.1.running_var\n",
+      "   • trunk_output.block1.block1-0.proj.1.num_batches_tracked\n",
+      "   • trunk_output.block1.block1-0.f.a.0.weight\n",
+      "   • trunk_output.block1.block1-0.f.a.1.weight\n",
+      "   • trunk_output.block1.block1-0.f.a.1.bias\n",
+      "   • trunk_output.block1.block1-0.f.a.1.running_mean\n",
+      "   ... and 410 more\n",
+      "\n",
+      "============================================================\n",
+      "💡 ANALYSIS COMPLETE\n",
+      "Use the output above to understand the correct parameter structure\n",
+      "and update the validation logic accordingly.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "from torchvision import models\n",
+    "\n",
+    "def explore_regnet_structure():\n",
+    "    \"\"\"Explore the actual RegNet structure to understand parameter names\"\"\"\n",
+    "    print(\"🔍 Exploring RegNet Y 16GF structure...\")\n",
+    "    \n",
+    "    # Load RegNet with pretrained weights\n",
+    "    model = models.regnet_y_16gf(weights=models.RegNet_Y_16GF_Weights.IMAGENET1K_SWAG_E2E_V1)\n",
+    "    \n",
+    "    # Get all parameter names\n",
+    "    param_names = list(model.state_dict().keys())\n",
+    "    \n",
+    "    print(f\"📊 Total parameters: {len(param_names)}\")\n",
+    "    print(\"\\n🏗️ RegNet Structure Analysis:\")\n",
+    "    \n",
+    "    # Group parameters by component\n",
+    "    components = {}\n",
+    "    for name in param_names:\n",
+    "        parts = name.split('.')\n",
+    "        if len(parts) >= 2:\n",
+    "            component = f\"{parts[0]}.{parts[1]}\"\n",
+    "            if component not in components:\n",
+    "                components[component] = []\n",
+    "            components[component].append(name)\n",
+    "    \n",
+    "    # Display structure\n",
+    "    for component, params in components.items():\n",
+    "        print(f\"\\n📁 {component}: {len(params)} parameters\")\n",
+    "        # Show first few parameter names as examples\n",
+    "        for i, param in enumerate(params[:5]):\n",
+    "            print(f\"   • {param}\")\n",
+    "        if len(params) > 5:\n",
+    "            print(f\"   ... and {len(params) - 5} more\")\n",
+    "    \n",
+    "    print(\"\\n\" + \"=\"*60)\n",
+    "    print(\"🔍 Searching for conv layers specifically:\")\n",
+    "    conv_params = [name for name in param_names if 'conv' in name.lower()]\n",
+    "    print(f\"Found {len(conv_params)} conv parameters:\")\n",
+    "    for param in conv_params[:10]:  # Show first 10\n",
+    "        print(f\"   • {param}\")\n",
+    "    if len(conv_params) > 10:\n",
+    "        print(f\"   ... and {len(conv_params) - 10} more\")\n",
+    "    \n",
+    "    print(\"\\n\" + \"=\"*60)\n",
+    "    print(\"🔍 Looking for block structure:\")\n",
+    "    block_params = [name for name in param_names if 'block' in name.lower()]\n",
+    "    print(f\"Found {len(block_params)} block parameters:\")\n",
+    "    for param in block_params[:10]:\n",
+    "        print(f\"   • {param}\")\n",
+    "    if len(block_params) > 10:\n",
+    "        print(f\"   ... and {len(block_params) - 10} more\")\n",
+    "    \n",
+    "    return param_names, model\n",
+    "\n",
+    "if __name__ == \"__main__\":\n",
+    "    try:\n",
+    "        param_names, model = explore_regnet_structure()\n",
+    "        \n",
+    "        print(\"\\n\" + \"=\"*60)\n",
+    "        print(\"💡 ANALYSIS COMPLETE\")\n",
+    "        print(\"Use the output above to understand the correct parameter structure\")\n",
+    "        print(\"and update the validation logic accordingly.\")\n",
+    "        \n",
+    "    except Exception as e:\n",
+    "        print(f\"❌ Error exploring RegNet: {e}\")\n",
+    "        print(\"Make sure you have internet access to download RegNet weights\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d6a4fd46",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}