Update app.py

app.py

@@ -3,32 +3,23 @@ from transformers import AutoImageProcessor, AutoModelForImageClassification
 from PIL import Image
 import torch
 import torch.nn.functional as F
-import numpy as np
 
 print("\n" + "="*80)
-print("🏆 SENTRY-IMAGE NEURIPS 2023 - BEST FREE AI DETECTOR")
+print("🏆 SSP-AI-GENERATED-IMAGE DETECTOR - 2025 STATE-OF-THE-ART")
 print("="*80)
-print("\nBased on NeurIPS 2023 Paper: 'Seeing is not always believing'")
-print("✓ 87% Accuracy (13% failure rate) - State-of-the-art FREE model")
-print("✓ Trained on Fake2M: 2M+ real + AI images (Midjourney v5, DALL-E 3, Stable Diffusion)")
-print("✓ Top-performing model from MPBench benchmark")
+print("\nBased on SSP 2025 Benchmark")
+print("✓ High precision on latest AI generators (Midjourney v6+, DALL-E 3, Stable Diffusion)")
+print("✓ Trained on massive datasets with real + AI images")
 print("="*80 + "\n")
 
-# SENTRY-IMAGE MODELS (NeurIPS 2023 Winner)
+# NEW MODEL CONFIG
 MODELS_CONFIG = [
     {
-        "name": "Inf-imagine/Sentry-Image",
-        "weight": 0.65,
-        "type": "Sentry-Image (NeurIPS 2023)",
-        "proven_accuracy": "87% (13% failure rate)",
-        "best_for": "Midjourney v5, DALL-E 3, Stable Diffusion (State-of-art)"
-    },
-    {
-        "name": "Ateeqq/ai-vs-human-image-detector",
-        "weight": 0.35,
-        "type": "SigLIP Ensemble",
-        "proven_accuracy": "88-94% on diffusion models",
-        "best_for": "Modern generators (v6.1+, Flux)"
+        "name": "bcmi/SSP-AI-Generated-Image-Detection",
+        "weight": 1.0,
+        "type": "SSP-AI Detection",
+        "proven_accuracy": "SOTA (claimed >90% on modern generators)",
+        "best_for": "Midjourney v6+, DALL-E 3, Stable Diffusion, GANs, and Hybrid generators"
     },
 ]
 
@@ -40,10 +31,11 @@ processors_list = []
 model_metadata = []
 loaded_count = 0
 
+# Load models
 for i, config in enumerate(MODELS_CONFIG):
     model_name = config["name"]
     try:
-        print(f"[{i+1}/2] {model_name}")
+        print(f"[{i+1}/{len(MODELS_CONFIG)}] {model_name}")
         print(f"     • Type: {config['type']}")
         print(f"     • Weight: {int(config['weight']*100)}%")
         print(f"     • Accuracy: {config['proven_accuracy']}")
@@ -62,21 +54,13 @@ for i, config in enumerate(MODELS_CONFIG):
         print(f"     ⚠️ Warning: Failed to load - {str(e)[:50]}\n")
 
 if loaded_count == 0:
-    # Fallback to Ateeqq only
-    print("Loading fallback model...\n")
-    processor = AutoImageProcessor.from_pretrained("Ateeqq/ai-vs-human-image-detector")
-    model = AutoModelForImageClassification.from_pretrained("Ateeqq/ai-vs-human-image-detector").to(device)
-    model.eval()
-    models_list.append(model)
-    processors_list.append(processor)
-    model_metadata.append(MODELS_CONFIG[1])
-    loaded_count = 1
+    raise RuntimeError("❌ Failed to load SSP-AI model. Check Hugging Face access and model name.")
 
 print("="*80)
-print(f"✅ Successfully loaded {loaded_count} models")
-print(f"📊 Ensemble weight: {sum(m['weight'] for m in model_metadata):.1f}")
+print(f"✅ Successfully loaded {loaded_count} model(s)")
 print("="*80 + "\n")
 
+
 def predict(image):
     if image is None:
         return "❌ No image uploaded", 0.0, "Upload an image to analyze"
@@ -88,64 +72,52 @@ def predict(image):
         all_scores = []
         model_results = []
         
-        # Run all models
+        # Run models
         for idx, (processor, model) in enumerate(zip(processors_list, models_list)):
-            try:
-                inputs = processor(images=image, return_tensors="pt").to(device)
-                
-                with torch.no_grad():
-                    outputs = model(**inputs)
-                    logits = outputs.logits
-                    probs = F.softmax(logits, dim=1)[0].cpu().numpy()
-                
-                real_prob = float(probs[0])
-                ai_prob = float(probs[1])
-                
-                all_scores.append(ai_prob)
-                
-                pred = "🤖 AI-Generated" if ai_prob > real_prob else "✓ Real Photo"
-                conf = max(ai_prob, real_prob)
-                
-                meta = model_metadata[idx]
-                model_results.append({
-                    'name': meta["name"].split('/')[-1],
-                    'type': meta['type'],
-                    'weight': meta['weight'],
-                    'prediction': pred,
-                    'ai_score': ai_prob,
-                    'real_score': real_prob,
-                    'confidence': conf,
-                    'accuracy': meta['proven_accuracy']
-                })
-                
-            except Exception as e:
-                print(f"Model error: {e}")
-                continue
-        
-        if not all_scores:
-            return "❌ Processing error", 0.0, "Could not analyze image"
-        
-        # WEIGHTED ENSEMBLE VOTING
+            inputs = processor(images=image, return_tensors="pt").to(device)
+            with torch.no_grad():
+                outputs = model(**inputs)
+                logits = outputs.logits
+                probs = F.softmax(logits, dim=1)[0].cpu().numpy()
+            
+            real_prob = float(probs[0])
+            ai_prob = float(probs[1])
+            all_scores.append(ai_prob)
+            
+            pred = "🤖 AI-Generated" if ai_prob > real_prob else "✓ Real Photo"
+            conf = max(ai_prob, real_prob)
+            meta = model_metadata[idx]
+            
+            model_results.append({
+                'name': meta["name"].split('/')[-1],
+                'type': meta['type'],
+                'weight': meta['weight'],
+                'prediction': pred,
+                'ai_score': ai_prob,
+                'real_score': real_prob,
+                'confidence': conf,
+                'accuracy': meta['proven_accuracy']
+            })
+        
+        # Weighted score
         weights = [m['weight'] for m in model_metadata[:len(all_scores)]]
         total_weight = sum(weights)
         normalized_weights = [w/total_weight for w in weights]
-        
         weighted_ai_score = sum(s * w for s, w in zip(all_scores, normalized_weights))
         
-        # Threshold
         threshold = 0.50
-        
         is_ai = weighted_ai_score > threshold
         final_pred = "🚨 AI-GENERATED" if is_ai else "✅ REAL PHOTO"
         confidence = max(weighted_ai_score, 1 - weighted_ai_score)
         
+        # Individual votes
         ai_votes = sum(1 for r in model_results if "AI" in r['prediction'])
         total_votes = len(model_results)
         
-        # BUILD REPORT
+        # Build report
         report = f"""
 ╔════════════════════════════════════════════════════════════════════════╗
-║         🏆 SENTRY-IMAGE NeurIPS 2023 - AI DETECTION REPORT           ║
+║         🏆 SSP-AI-Generated-Image Detection Report                     ║
 ╚════════════════════════════════════════════════════════════════════════╝
 
 🎯 PREDICTION: {final_pred}
@@ -168,54 +140,6 @@ Model {i}: {result['name']} ({result['type']})
 ├─ AI Score: {result['ai_score']:.4f} | Real Score: {result['real_score']:.4f}
 ├─ Model Confidence: {result['confidence']:.4f}
 └─ Accuracy: {result['accuracy']}
-"""
-        
-        report += f"""
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-🏆 SENTRY-IMAGE NeurIPS 2023 BREAKTHROUGH:
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-Research Finding:
-• Humans: 61.3% accuracy (38.7% failure rate) - STRUGGLE to detect AI
-• Sentry-Image: 87% accuracy (13% failure rate) - TOP MODEL
-• Improvement: 26% better than human perception!
-
-Dataset (Fake2M):
-✓ 2M+ real images + AI-generated images
-✓ Midjourney v5, DALL-E 3, Stable Diffusion
-✓ Latest diffusion-based generators
-✓ Covers 8 categories: Landscape, Portrait, Animal, Plant, etc.
-
-Cross-Generator Evaluation (MPBench):
-• Detects: GANs, Diffusion Models, Hybrid generators
-• Generalizes: Works across different image domains
-• Robust: Handles real-world conditions
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-✅ DETECTION CAPABILITIES:
-✓ Midjourney v5 (Sentry trained on)
-✓ DALL-E 3 (Sentry trained on)
-✓ Stable Diffusion 2/3 (Sentry trained on)
-✓ Modern diffusion variants
-✓ Realistic AI-generated humans
-✓ Cross-scene generalization
-✓ Handles compression & post-processing
-
-📚 CITATION:
-"Seeing is not always believing: Benchmarking Human and Model 
-Perception of AI-Generated Images" - NeurIPS 2023
-Authors: Zeyu Lu, Di Huang, Lei Bai, et al.
-Paper: https://github.com/Inf-imagine/Sentry
-
-⚠️ NOTE:
-This is the SOTA free model for AI detection. Even with 87% accuracy,
-13% of advanced AI images may still fool the detector. For critical
-applications, always verify with secondary analysis.
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-╚════════════════════════════════════════════════════════════════════════╝
 """
         
         return final_pred, round(weighted_ai_score, 4), report
@@ -223,6 +147,7 @@ applications, always verify with secondary analysis.
     except Exception as e:
         return f"❌ Error: {str(e)}", 0.0, f"Processing failed: {str(e)}"
 
+
 # Gradio Interface
 demo = gr.Interface(
     fn=predict,
@@ -230,11 +155,11 @@ demo = gr.Interface(
     outputs=[
         gr.Textbox(label="🎯 Detection Result"),
         gr.Number(label="📊 AI Score (0.0-1.0)"),
-        gr.Textbox(label="📋 Sentry-Image Analysis", lines=35)
+        gr.Textbox(label="📋 SSP-AI Analysis", lines=30)
     ],
-    title="🏆 Sentry-Image NeurIPS 2023 Detector",
-    description="Best FREE AI image detector (87% accuracy). NeurIPS 2023 winner - detects Midjourney v5, DALL-E 3, Stable Diffusion with state-of-the-art accuracy."
+    title="🏆 SSP-AI-Generated-Image Detector 2025",
+    description="High-precision AI image detector for latest generators (Midjourney v6+, DALL-E 3, Stable Diffusion, GANs)."
 )
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()