Update app.py

app.py

@@ -1,89 +1,90 @@
-
 import gradio as gr
+import cv2
 import torch
 import numpy as np
-import cv2
 import matplotlib.pyplot as plt
 from PIL import Image
 from transformers import AutoImageProcessor, SiglipForImageClassification
 
-# ✅ Load model from Hugging Face (no manual files)
+# ✅ Load model and processor (no manual files)
 model_name = "prithivMLmods/deepfake-detector-model-v1"
 processor = AutoImageProcessor.from_pretrained(model_name)
 model = SiglipForImageClassification.from_pretrained(model_name)
 model.eval()
 
-# ✅ Haar cascade for face detection
+# ✅ Face detector
 face_detector = cv2.CascadeClassifier(cv2.data.haarcascades + "haarcascade_frontalface_default.xml")
 
-# ✅ Deepfake analysis logic
-def detect_deepfake(video_path):
+# ✅ Deepfake detection function
+def analyze(video_path):
     if video_path is None:
-        return "❌ Please upload a valid .mp4 video", None
+        return "❌ Please upload a video", None
 
     cap = cv2.VideoCapture(video_path)
-    preds = []
-    count = 0
-    max_frames = 20
+    frame_preds = []
+    frame_count = 0
+    max_frames = 60
 
     while True:
         ret, frame = cap.read()
-        if not ret or count >= max_frames:
+        if not ret or frame_count >= max_frames:
             break
 
         gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
-        faces = face_detector.detectMultiScale(gray, 1.1, 4)
+        faces = face_detector.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5)
 
-        if len(faces) > 0:
-            x, y, w, h = faces[0]  # Take first detected face
+        found = False
+        for (x, y, w, h) in faces:
             face = frame[y:y+h, x:x+w]
             if face.size == 0:
                 continue
 
             face_rgb = cv2.cvtColor(face, cv2.COLOR_BGR2RGB)
-            pil_img = Image.fromarray(face_rgb)
-            inputs = processor(images=pil_img, return_tensors="pt")
+            pil_image = Image.fromarray(face_rgb)
+            inputs = processor(images=pil_image, return_tensors="pt")
 
             with torch.no_grad():
                 logits = model(**inputs).logits
-                prob = torch.softmax(logits, dim=-1)[0][1].item()
-                preds.append(prob)
+                fake_prob = torch.softmax(logits, dim=-1)[0][1].item()
+
+            frame_preds.append(fake_prob)
+            found = True
+            break
+
+        if not found:
+            frame_preds.append(0.5)  # neutral prediction
 
-        count += 1
+        frame_count += 1
 
     cap.release()
 
-    if not preds:
-        return "❌ No faces detected. Try a clearer video.", None
+    if not frame_preds:
+        return "❌ No faces found. Try a better-quality video.", None
 
-    avg_conf = np.mean(preds)
-    label = "**FAKE**" if avg_conf > 0.5 else "**REAL**"
-    result = f"""
-    🎯 **Result:** {label}  
-    🔢 Avg Confidence: {avg_conf:.2f}  
-    📊 Frames Analyzed: {len(preds)}
-    """
+    avg = np.mean(frame_preds)
+    verdict = "FAKE" if avg > 0.5 else "REAL"
+    result = f"✅ FINAL RESULT: **{verdict}**\n🔢 Confidence: {avg:.2f}"
 
-    # ✅ Create histogram
-    fig, ax = plt.subplots()
-    ax.hist(preds, bins=10, color="red" if avg_conf > 0.5 else "green", edgecolor="black")
+    # ✅ Plot
+    fig, ax = plt.subplots(figsize=(6, 4))
+    ax.hist(frame_preds, bins=10, color="red" if avg > 0.5 else "green", edgecolor="black")
     ax.set_title("Fake Confidence per Frame")
-    ax.set_xlabel("Fake Probability (0 = Real, 1 = Fake)")
-    ax.set_ylabel("Frames")
+    ax.set_xlabel("Confidence (0=Real, 1=Fake)")
+    ax.set_ylabel("Frame Count")
     ax.grid(True)
 
     return result, fig
 
 # ✅ Gradio interface
 with gr.Blocks() as demo:
-    gr.Markdown("## 🎭 Deepfake Detector (Transformer-based)")
-    gr.Markdown("Upload a short `.mp4` video. The app will detect faces and classify the video as **REAL** or **FAKE**.")
+    gr.Markdown("## 🎭 Deepfake Detector (Colab Version Converted to Gradio)")
+    gr.Markdown("Upload a short `.mp4` video and get a REAL or FAKE decision with confidence histogram.")
 
-    video_input = gr.Video(label="📤 Upload your video")
-    result_output = gr.Markdown()
-    graph_output = gr.Plot()
-    analyze_button = gr.Button("🔍 Analyze")
+    video = gr.Video(label="Upload your video")
+    result = gr.Markdown()
+    plot = gr.Plot()
+    button = gr.Button("🔍 Analyze")
 
-    analyze_button.click(fn=detect_deepfake, inputs=video_input, outputs=[result_output, graph_output])
+    button.click(fn=analyze, inputs=video, outputs=[result, plot])
 
 demo.queue().launch()