Update app.py

app.py

@@ -1,87 +1,42 @@
 # app.py
 import gradio as gr
-import cv2
-import numpy as np
-from huggingface_hub import from_pretrained_keras
-import tempfile
-
-model = from_pretrained_keras("DaMsTaR/Detecto-DeepFake_Video_Detector")
-
-# Parameters
-NUM_FRAMES = 16  # frames to sample
-TARGET_SIZE = (224, 224)  # input size expected by the model
-
-def extract_frames(video_path, num_frames=NUM_FRAMES):
-    """Extract `num_frames` evenly spaced frames from the video"""
-    cap = cv2.VideoCapture(video_path)
-    frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-    if frame_count <= 0:
-        raise RuntimeError("Cannot read video or video is empty")
-
-    indices = np.linspace(0, frame_count - 1, num_frames).astype(int)
-    frames = []
-    idx = 0
-    for i in range(frame_count):
-        ret, frame = cap.read()
-        if not ret:
-            break
-        if i == indices[idx]:
-            frames.append(frame)
-            idx += 1
-            if idx >= len(indices):
-                break
-    cap.release()
-    # duplicate last frame if not enough
-    while len(frames) < num_frames:
-        frames.append(frames[-1])
-    return frames
-
-def preprocess_frames(frames):
-    """Resize and normalize frames for Keras model"""
-    processed = []
-    for frame in frames:
-        img = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-        img = cv2.resize(img, TARGET_SIZE)
-        img = img / 255.0  # normalize to [0,1]
-        processed.append(img)
-    return np.stack(processed, axis=0)
-
-def predict_deepfake(video):
-    """Predict if the video is deepfake"""
-    # Save uploaded video to temp file
-    temp_video = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4").name
-    with open(temp_video, "wb") as f:
-        f.write(video.read())
-
-    frames = extract_frames(temp_video)
-    x = preprocess_frames(frames)
-    
-    # Model expects batch dimension
-    preds = model.predict(x, verbose=0)  # shape: (num_frames, num_classes)
-    
-    # Aggregate predictions (mean across frames)
-    mean_pred = preds.mean(axis=0)
-    
-    # Assuming output: [real_prob, fake_prob]
-    fake_score = float(mean_pred[1])
-    real_score = float(mean_pred[0])
-    label = "Fake" if fake_score > real_score else "Real"
-
-    return label, float(max(real_score, fake_score)), {"Real": real_score, "Fake": fake_score}
-
-# Gradio interface
+from transformers import pipeline
+
+# Load the deepfake detection model from Hugging Face
+detector = pipeline(
+    "video-classification",
+    model="Hemgg/deepfake-vs-real-video-detection"
+)
+
+def analyze_video(video_path):
+    """
+    Run deepfake detection on uploaded video.
+    Returns:
+        label: predicted class ("FAKE" or "REAL")
+        score: confidence of the prediction
+        all_scores: full output from the model
+    """
+    results = detector(video_path)
+    top = results[0]  # assume the first element is top prediction
+    return top["label"], float(top["score"]), results
+
+# Gradio UI
 with gr.Blocks() as demo:
-    gr.Markdown("# DeepFake Video Detection")
+    gr.Markdown("# DeepFake Video Detector")
+    gr.Markdown("Upload a video and the model will classify it as REAL or FAKE.")
+
     video_input = gr.Video(label="Upload video")
-    predict_btn = gr.Button("Analyze")
-    output_label = gr.Textbox(label="Prediction")
+    analyze_btn = gr.Button("Analyze Video")
+
+    output_label = gr.Textbox(label="Predicted Label")
     output_score = gr.Number(label="Confidence")
-    output_all = gr.JSON(label="All Scores")
-    
-    predict_btn.click(
-        fn=predict_deepfake,
+    output_all = gr.JSON(label="All Predictions")
+
+    analyze_btn.click(
+        fn=analyze_video,
         inputs=[video_input],
         outputs=[output_label, output_score, output_all]
     )
 
-demo.launch(server_name="0.0.0.0", share=True)
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", share=True)