first commit

app.py

@@ -0,0 +1,44 @@
+import gradio as gr
+from model.load_model import load_model
+from utils.video_utils import extract_frames
+from utils.face_utils import extract_faces
+from predictor.predict import predict_faces
+from utils.gradcam import get_gradcam, get_conv_layers
+import numpy as np
+from PIL import Image
+from tqdm import tqdm
+
+model = load_model()
+conv_layer_names = get_conv_layers(model)  # populate dropdown choices
+
+def deepfake_app(video, selected_layer, progress=gr.Progress(track_tqdm=True)):
+    frames = extract_frames(video)
+    frames = list(frames)
+
+    faces = extract_faces(frames)
+    faces = list(progress.tqdm(faces, desc="Detecting faces"))
+
+    if not faces:
+        return "No face detected", None
+
+    predictions = predict_faces(model, faces)
+    predictions = list(progress.tqdm(predictions, desc="Running predictions"))
+
+    avg_score = np.mean(predictions)
+    label = "FAKE" if avg_score > 0.5 else "REAL"
+
+    max_idx = np.argmax(predictions)
+    cam_image = get_gradcam(model, faces[max_idx], selected_layer)
+    cam_image = Image.fromarray(cam_image)
+
+    return label, cam_image
+
+gr.Interface(
+    fn=deepfake_app,
+    inputs=[gr.Video(label="Upload a Video"),
+            gr.Dropdown(choices=conv_layer_names, label="Grad-CAM Layer", value=conv_layer_names[-1])
+        ],
+    outputs=["text", "image"],
+    title="Deepfake Detection with XceptionNet",
+    description="Upload a video, and the model will predict if it contains a deepfake with RAI explainability using GRADCAM."
+).launch()

config.py

@@ -0,0 +1,5 @@
+import torch
+
+MODEL_PATH = "xception_best_model.pth"
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+FRAME_SKIP = 5  # Every 5th frame

model/load_model.py

@@ -0,0 +1,20 @@
+import torch
+import torch.nn as nn
+import timm
+from config import MODEL_PATH, DEVICE
+
+def load_model():
+    model = timm.create_model('xception', pretrained=False)
+    model.fc = nn.Sequential(
+        nn.Linear(model.fc.in_features, 100),
+        nn.ReLU(),
+        nn.Dropout(0.7),
+        nn.Linear(100, 50),
+        nn.ReLU(),
+        nn.Dropout(0.7),
+        nn.Linear(50, 1),
+        nn.Sigmoid()
+    )
+    model.load_state_dict(torch.load(MODEL_PATH, map_location=DEVICE))
+    model.to(DEVICE).eval()
+    return model

predictor/predict.py

@@ -0,0 +1,18 @@
+import torch
+from torchvision import transforms
+from config import DEVICE
+
+def predict_faces(model, faces):
+    transform = transforms.Compose([
+    transforms.Resize((299, 299)),
+    transforms.ToTensor(),
+    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
+])
+
+    predictions = []
+    for face in faces:
+        face = transform(face).unsqueeze(0).to(DEVICE)
+        with torch.no_grad():
+            pred = model(face).item()
+        predictions.append(pred)
+    return predictions

requirements.txt

@@ -0,0 +1,10 @@
+torch
+torchvision
+timm
+opencv-python
+pillow
+facenet-pytorch
+gradio
+tqdm
+#pytorch-grad-cam
+numpy

utils/face_utils.py

@@ -0,0 +1,20 @@
+from facenet_pytorch import MTCNN
+from PIL import Image
+import torch
+import gradio as gr
+
+mtcnn = MTCNN(margin=0, thresholds=[0.85, 0.95, 0.95], device=torch.device("cuda" if torch.cuda.is_available() else "cpu"))
+
+def extract_faces(frames, progress=gr.Progress(track_tqdm=True)):
+    face_crops = []
+    for frame in progress.tqdm(frames, desc='Detecting faces'):
+        img = Image.fromarray(frame)
+
+        boxes, _ = mtcnn.detect(img)
+
+        if boxes is not None:
+            for i, box in enumerate(boxes):
+                x1, y1, x2, y2 = [int(b) for b in box]
+                face = img.crop((x1, y1, x2, y2))
+                face_crops.append(face)
+    return face_crops

utils/gradcam.py

@@ -0,0 +1,42 @@
+import torch
+import numpy as np
+import torchvision.transforms as transforms
+from pytorch_grad_cam import GradCAM
+from pytorch_grad_cam.utils.model_targets import ClassifierOutputTarget
+from pytorch_grad_cam.utils.image import show_cam_on_image
+
+def get_conv_layers(model):
+    conv_layers = []
+    for name, module in model.named_modules():
+        if isinstance(module, torch.nn.Conv2d):
+            conv_layers.append(name)
+    return conv_layers
+
+
+def get_gradcam(model, face_pil_image, layer_name):
+    model.eval()
+
+    # Preprocess: convert PIL Image to normalized tensor
+    transform = transforms.Compose([
+        transforms.Resize((299, 299)),  # Xception input size
+        transforms.ToTensor(),
+        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])  # match training normalization
+    ])
+    face_tensor = transform(face_pil_image).unsqueeze(0).to(next(model.parameters()).device)
+
+    # Convert image to numpy for overlay
+    face_np = np.array(face_pil_image.resize((299, 299))) / 255.0  # shape: (H, W, C)
+    if face_np.shape[-1] == 1:
+        face_np = np.repeat(face_np, 3, axis=-1)
+
+    # Grad-CAM
+    # Dynamically get layer by name
+    target_module = dict(model.named_modules())[layer_name]
+    cam = GradCAM(model=model, target_layers=[target_module])
+    grayscale_cam = cam(input_tensor=face_tensor, targets=[ClassifierOutputTarget(0)])
+
+    # Overlay the cam on image
+    grayscale_cam = grayscale_cam[0]  # only one image in batch
+    visualization = show_cam_on_image(face_np, grayscale_cam, use_rgb=True)
+
+    return visualization

utils/video_utils.py

@@ -0,0 +1,16 @@
+import cv2
+from config import FRAME_SKIP
+
+def extract_frames(video_path):
+    cap = cv2.VideoCapture(video_path)
+    frames = []
+    i = 0
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+        if i % FRAME_SKIP == 0:
+            frames.append(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
+        i += 1
+    cap.release()
+    return frames