model.py added

model.py

@@ -0,0 +1,138 @@
+# backend/model.py
+import cv2
+import numpy as np
+from transformers import pipeline
+from PIL import Image, ImageOps
+import torch
+import io
+import base64
+
+class DualModelDetector:
+    def __init__(self):
+        print("⏳ Loading Models...")
+        device = 0 if torch.cuda.is_available() else -1
+        
+        # MODEL 1: GenAI Detector
+        print("  1. Loading GenAI Detector (v2.0)...")
+        self.genai_pipe = pipeline("image-classification", model="prithivMLmods/AI-vs-Deepfake-vs-Real-v2.0", device=device)
+
+        # MODEL 2: Face Deepfake Detector
+        print("  2. Loading Face Deepfake Detector (v2)...")
+        self.face_pipe = pipeline("image-classification", model="prithivMLmods/Deep-Fake-Detector-v2-Model", device=device)
+
+        self.face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
+        print("✅ System Ready: Visual Debug Mode Active")
+
+    def img_to_base64(self, img):
+        """Converts a PIL Image to a Base64 string for the frontend"""
+        buffered = io.BytesIO()
+        img.save(buffered, format="JPEG")
+        return base64.b64encode(buffered.getvalue()).decode("utf-8")
+
+    def predict(self, image: Image.Image):
+        try:
+            if image.mode != "RGB":
+                image = image.convert("RGB")
+
+            # --- PHASE 1: GENAI DETECTION ---
+            genai_results = self.genai_pipe(image)
+            genai_top = genai_results[0]
+            genai_score = genai_top['score']
+            is_ai_art = "artificial" in genai_top['label'].lower()
+            
+            genai_label = "Real Image"
+            if is_ai_art and genai_score > 0.6:
+                 genai_label = "AI Generated Art"
+
+            genai_data = {
+                "is_detected": is_ai_art,
+                "confidence": genai_score,
+                "label": genai_label
+            }
+
+            # --- PHASE 2: FACE DETECTION ---
+            open_cv_image = np.array(image)
+            open_cv_image = cv2.cvtColor(open_cv_image, cv2.COLOR_RGB2BGR)
+            gray = cv2.cvtColor(open_cv_image, cv2.COLOR_BGR2GRAY)
+            
+            faces = self.face_cascade.detectMultiScale(gray, 1.1, 4)
+            
+            deepfake_data = {
+                "face_found": False,
+                "is_detected": False,
+                "confidence": 0.0,
+                "label": "No Face Found"
+            }
+
+            # Default to full image if no face (so we can still see what it saw)
+            target_face_image = image 
+
+            if len(faces) > 0:
+                deepfake_data["face_found"] = True
+                sorted_faces = sorted(faces, key=lambda b: b[2] * b[3], reverse=True)
+                x, y, w, h = sorted_faces[0]
+
+                # Ratio Check logic
+                image_area = image.width * image.height
+                face_area = w * h
+                face_ratio = face_area / image_area
+
+                if face_ratio > 0.20:
+                    # Case A: Large Face (Portrait) -> Use Full Image
+                    target_face_image = image
+                else:
+                    # Case B: Small Face -> Crop it
+                    max_dim = max(w, h)
+                    margin = int(max_dim * 0.6)
+                    center_x = x + w // 2
+                    center_y = y + h // 2
+                    left = max(0, center_x - (max_dim + margin) // 2)
+                    top = max(0, center_y - (max_dim + margin) // 2)
+                    right = min(image.width, center_x + (max_dim + margin) // 2)
+                    bottom = min(image.height, center_y + (max_dim + margin) // 2)
+                    target_face_image = image.crop((left, top, right, bottom))
+
+            # Preprocess (Pad to Square)
+            target_face_image = ImageOps.pad(target_face_image, (224, 224), color="black")
+
+            # --- GENERATE DEBUG IMAGE ---
+            # This is the exact pixel data the AI is analyzing
+            debug_b64 = self.img_to_base64(target_face_image)
+
+            # Run Deepfake Model
+            face_results = self.face_pipe(target_face_image)
+            face_top = face_results[0]
+            
+            is_deepfake = "fake" in face_top['label'].lower() or "deepfake" in face_top['label'].lower()
+            deepfake_score = face_top['score']
+
+            SAFE_THRESHOLD = 0.55
+            if is_deepfake and deepfake_score < SAFE_THRESHOLD:
+                is_deepfake = False
+                deepfake_score = 0.0
+
+            deepfake_data.update({
+                "is_detected": is_deepfake,
+                "confidence": deepfake_score,
+                "label": "Deepfake Face" if is_deepfake else "Real Face"
+            })
+
+            return {
+                "genai_analysis": genai_data,
+                "deepfake_analysis": deepfake_data,
+                "final_verdict": self._get_verdict(genai_data, deepfake_data),
+                "debug_image": debug_b64 # <--- SENDING IMAGE BACK
+            }
+
+        except Exception as e:
+            print(f"❌ Error: {e}")
+            import traceback
+            traceback.print_exc()
+            return {"error": str(e)}
+
+    def _get_verdict(self, genai, deepfake):
+        if deepfake['face_found'] and deepfake['is_detected']:
+            return "Deepfake Detected"
+        if genai['is_detected']:
+            return "AI Generated Image"
+        return "Real Image"