Create app.py

app.py

@@ -0,0 +1,154 @@
+import gradio as gr
+import cv2
+import numpy as np
+import pickle
+import os
+from PIL import Image
+
+
+# Directories containing example videos
+examples_dir = 'examples'
+original_dir = os.path.join(examples_dir, 'Original')
+deepfake_roop_dir = os.path.join(examples_dir, 'DeepfakeRoop')
+deepfake_web_dir = os.path.join(examples_dir, 'DeepfakeWeb')
+
+# Function to get video paths from a directory
+def get_video_paths(directory):
+    return [os.path.join(directory, vid) for vid in os.listdir(directory) if vid.endswith('.mp4')]
+
+# Get video paths for each category
+original_videos = get_video_paths(original_dir)
+deepfake_roop_videos = get_video_paths(deepfake_roop_dir)
+deepfake_web_videos = get_video_paths(deepfake_web_dir)
+
+# Function to process video and calculate accuracies
+def process_video(video_path, true_label):
+    cap = cv2.VideoCapture(video_path)
+    fps = cap.get(cv2.CAP_PROP_FPS)
+    if fps == 0 or np.isnan(fps):
+        fps = 30
+    frame_interval = max(int(round(fps / 30)), 1)
+    frame_count = 0
+    sampled_frames = []
+    
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret:
+            break
+        if frame_count % frame_interval == 0:
+            gray_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+            resized_frame = cv2.resize(gray_frame, (28, 28))
+            normalized_frame = resized_frame / 255.0
+            normalized_frame = normalized_frame.reshape(1, 28, 28, 1)
+            sampled_frames.append(normalized_frame)
+        frame_count += 1
+    cap.release()
+    
+    cnn_correct = 0
+    qcnn_correct = 0
+    total_frames = len(sampled_frames)
+    for frame in sampled_frames:
+        cnn_pred = cnn_model.predict(frame)
+        cnn_label = np.argmax(cnn_pred)
+        if cnn_label == true_label:
+            cnn_correct += 1
+        qcnn_pred = qcnn_model.predict(frame)
+        qcnn_label = np.argmax(qcnn_pred)
+        if qcnn_label == true_label:
+            qcnn_correct += 1
+    
+    cnn_accuracy = (cnn_correct / total_frames) * 100 if total_frames > 0 else 0
+    qcnn_accuracy = (qcnn_correct / total_frames) * 100 if total_frames > 0 else 0
+    result_label = "Original" if true_label == 0 else "Deepfake"
+    
+    result = f"Result: {result_label}\n"
+    result += f"CNN Model Accuracy: {cnn_accuracy:.2f}%\n"
+    result += f"QCNN Model Accuracy: {qcnn_accuracy:.2f}%"
+    return result
+
+# Prediction functions for each step
+def predict_step1(video_file):
+    if video_file is None:
+        return "Please select a video."
+    return process_video(video_file, true_label=0)
+
+def predict_step2(video_file):
+    if video_file is None:
+        return "Please select a video."
+    return process_video(video_file, true_label=1)
+
+def predict_step3(video_file):
+    if video_file is None:
+        return "Please select a video."
+    return process_video(video_file, true_label=1)
+
+# Create Gradio interface
+with gr.Blocks() as demo:
+    # Centered title
+    gr.HTML("<h1 style='text-align: center;'>Quanvolutional Neural Networks for Deepfake Detection</h1>")
+    gr.HTML("<h2 style='text-align: center;'>Steven Fernandes, Ph.D.</h2>")
+
+    # Step 1: Original Videos
+    gr.Markdown("## Step 1: Select an Original Video")
+    with gr.Row():
+        with gr.Column():
+            original_video = gr.Dropdown(
+                choices=original_videos,
+                label="Select Original Video",
+                interactive=True
+            )
+            predict_button1 = gr.Button("Predict")
+        with gr.Column():
+            output1 = gr.Textbox(label="Result")
+    predict_button1.click(fn=predict_step1, inputs=original_video, outputs=output1)
+
+    # Step 2: Deepfake Videos from DeepfakeWeb
+    gr.Markdown("## Step 2: Select a Deepfake Video Generated Using DeepfakeWeb")
+    with gr.Row():
+        with gr.Column():
+            deepfake_web_video = gr.Dropdown(
+                choices=deepfake_web_videos,
+                label="Select DeepfakeWeb Video",
+                interactive=True
+            )
+            predict_button2 = gr.Button("Predict")
+        with gr.Column():
+            output2 = gr.Textbox(label="Result")
+    predict_button2.click(fn=predict_step2, inputs=deepfake_web_video, outputs=output2)
+
+    # Step 3: Deepfake Videos from Roop Method
+    gr.Markdown("## Step 3: Select a Deepfake Video Generated Using the Roop Method")
+    with gr.Row():
+        with gr.Column():
+            deepfake_roop_video = gr.Dropdown(
+                choices=deepfake_roop_videos,
+                label="Select DeepfakeRoop Video",
+                interactive=True
+            )
+            predict_button3 = gr.Button("Predict")
+        with gr.Column():
+            output3 = gr.Textbox(label="Result")
+    predict_button3.click(fn=predict_step3, inputs=deepfake_roop_video, outputs=output3)
+
+    # Examples section mimicking the design of the provided application
+    gr.Markdown("## Examples")
+    gr.Markdown("### Original Videos")
+    gr.Examples(
+        examples=original_videos,
+        inputs=original_video,
+        label="Original Video Examples"
+    )
+    gr.Markdown("### DeepfakeWeb Videos")
+    gr.Examples(
+        examples=deepfake_web_videos,
+        inputs=deepfake_web_video,
+        label="DeepfakeWeb Video Examples"
+    )
+    gr.Markdown("### DeepfakeRoop Videos")
+    gr.Examples(
+        examples=deepfake_roop_videos,
+        inputs=deepfake_roop_video,
+        label="DeepfakeRoop Video Examples"
+    )
+
+demo.launch()