Update app.py

app.py

@@ -4,7 +4,7 @@ import numpy as np
 import torch
 from transformers import AutoImageProcessor, SiglipForImageClassification
 from PIL import Image
-import matplotlib.pyplot as plt
+import os
 
 # Load model and processor
 model_name = "prithivMLmods/deepfake-detector-model-v1"
@@ -12,82 +12,82 @@ processor = AutoImageProcessor.from_pretrained(model_name)
 model = SiglipForImageClassification.from_pretrained(model_name)
 model.eval()
 
-# Load face detector
+# Haar face detector
 face_detector = cv2.CascadeClassifier(cv2.data.haarcascades + "haarcascade_frontalface_default.xml")
 
-def analyze_deepfake(video_path):
-    cap = cv2.VideoCapture(video_path)
+# Inference function
+def detect_deepfake(video):
+    if video is None:
+        return "❌ Please upload a valid MP4 video."
+
+    cap = cv2.VideoCapture(video)
     frame_preds = []
     real_count = 0
     fake_count = 0
-    frame_count = 0
-    max_frames = 40
-    frame_skip = 5
+    frame_index = 0
+    max_frames = 20
+    frame_skip = 10
 
     while True:
         ret, frame = cap.read()
-        if not ret or frame_count >= max_frames:
+        if not ret or frame_index >= max_frames:
             break
 
-        if frame_count % frame_skip != 0:
-            frame_count += 1
+        if frame_index % frame_skip != 0:
+            frame_index += 1
             continue
 
         gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
         faces = face_detector.detectMultiScale(gray, 1.1, 4)
 
-        for (x, y, w, h) in faces:
+        if len(faces) > 0:
+            x, y, w, h = faces[0]  # Use only first detected face
             face = frame[y:y+h, x:x+w]
             if face.size == 0:
                 continue
 
-            rgb_face = cv2.cvtColor(face, cv2.COLOR_BGR2RGB)
-            image = Image.fromarray(rgb_face)
-            inputs = processor(images=image, return_tensors="pt")
+            face = cv2.resize(face, (224, 224))
+            face_rgb = cv2.cvtColor(face, cv2.COLOR_BGR2RGB)
+            img = Image.fromarray(face_rgb)
 
+            inputs = processor(images=img, return_tensors="pt")
             with torch.no_grad():
                 logits = model(**inputs).logits
-                probs = torch.softmax(logits, dim=-1)[0]
-                fake_prob = probs[1].item()
-                frame_preds.append(fake_prob)
-
-                if fake_prob > 0.6:
+                prob = torch.softmax(logits, dim=-1)[0][1].item()
+                frame_preds.append(prob)
+                if prob > 0.6:
                     fake_count += 1
                 else:
                     real_count += 1
 
-        frame_count += 1
+        frame_index += 1
 
     cap.release()
 
-    # Decision logic
-    if real_count + fake_count == 0:
-        result = "❌ No faces detected. Try a clearer video."
-    else:
-        final_verdict = "FAKE" if fake_count > real_count else "REAL"
-        confidence = np.mean(frame_preds)
-        result = f"🎯 Result: **{final_verdict}** (Avg Confidence = {confidence:.2f}, Real = {real_count}, Fake = {fake_count})"
-
-    # Graph
-    fig, ax = plt.subplots(figsize=(6, 4))
-    ax.hist(frame_preds, bins=10, color="green" if real_count > fake_count else "red", edgecolor="black")
-    ax.set_title("Fake Confidence per Face")
-    ax.set_xlabel("Confidence (0 = Real, 1 = Fake)")
-    ax.set_ylabel("Count")
-    ax.grid(True)
-
-    return result, fig
-
-# Gradio UI
-demo = gr.Interface(
-    fn=analyze_deepfake,
-    inputs=gr.Video(label="📤 Upload your .mp4 video (under 100MB)"),
-    outputs=[
-        gr.Markdown(label="📊 Deepfake Detection Result"),
-        gr.Plot(label="📈 Confidence Distribution")
-    ],
-    title="🎭 Deepfake Video Detector (Accurate & Fast)",
-    description="This model detects faces in video frames and classifies each as REAL or FAKE using a fine-tuned vision transformer."
-)
-
-demo.launch()
+    if not frame_preds:
+        return "❌ No faces detected. Try a different video."
+
+    avg_conf = np.mean(frame_preds)
+    verdict = "FAKE" if fake_count > real_count else "REAL"
+
+    return f"""
+    ✅ **Result: {verdict}**
+    🟢 Real Frames: {real_count}
+    🔴 Fake Frames: {fake_count}
+    📊 Avg Confidence: {avg_conf:.2f}
+    """
+
+# Gradio app using Blocks (more stable)
+with gr.Blocks() as demo:
+    gr.Markdown("## 🎭 Fast Deepfake Video Detector")
+    gr.Markdown("Upload a short .mp4 video (under 50MB). Model will analyze and classify it as REAL or FAKE based on face analysis.")
+    
+    with gr.Row():
+        video_input = gr.Video(label="📤 Upload your video")
+        result_output = gr.Markdown(label="🧠 Deepfake Detection Result")
+
+    analyze_btn = gr.Button("Analyze Video")
+
+    analyze_btn.click(fn=detect_deepfake, inputs=video_input, outputs=result_output)
+
+demo.queue(concurrency_count=1).launch()