Upload 5 files

app.py

@@ -0,0 +1,147 @@
+import gradio as gr
+
+# ---- IMPORT BACKENDS ----
+from image_backend import predict_image_pil
+from audio_backend import predict_audio
+
+
+# =========================
+# IMAGE LOGIC (UNCHANGED)
+# =========================
+def analyze_image(image):
+    label, confidence, heatmap = predict_image_pil(image)
+
+    if label == "Fake":
+        if confidence >= 90:
+            risk = "🚨 High likelihood of Deepfake"
+        elif confidence >= 60:
+            risk = "⚠️ Possibly Deepfake"
+        else:
+            risk = "⚠️ Uncertain Deepfake"
+    else:
+        if confidence >= 90:
+            risk = "✅ Likely Real"
+        elif confidence >= 60:
+            risk = "⚠️ Possibly Real"
+        else:
+            risk = "⚠️ Uncertain – Needs Review"
+
+    return label, f"{confidence} %", risk, heatmap
+
+
+# =========================
+# AUDIO LOGIC (UNCHANGED)
+# =========================
+def analyze_audio(audio_path):
+    label, confidence = predict_audio(audio_path)
+
+    if label == "fake":
+        if confidence >= 90:
+            risk = "🚨 High likelihood of Deepfake"
+        elif confidence >= 60:
+            risk = "⚠️ Possibly Deepfake"
+        else:
+            risk = "⚠️ Uncertain – Needs Review"
+    else:
+        if confidence >= 90:
+            risk = "✅ Likely Real"
+        elif confidence >= 60:
+            risk = "⚠️ Possibly Real"
+        else:
+            risk = "⚠️ Uncertain – Needs Review"
+
+    return label.capitalize(), f"{confidence} %", risk
+
+
+# =========================
+# UI (EXACT SAME)
+# =========================
+with gr.Blocks() as demo:
+    gr.Markdown("# 🧠 Unified Deepfake Detection System")
+
+    with gr.Tabs():
+
+        # HOME TAB
+        with gr.Tab("🏠 Home"):
+            gr.Markdown(
+                """
+                ## Welcome 👋  
+                Select the type of media you want to analyze:
+                """
+            )
+
+            gr.Markdown("### 🔍 Choose Detection Mode")
+            gr.Markdown("- 🖼 **Image Deepfake Detection**\n- 🎧 **Audio Deepfake Detection**")
+
+            gr.Markdown(
+                """
+                👉 Use the tabs above to switch between Image and Audio detection.
+                """
+            )
+
+        # IMAGE TAB
+        with gr.Tab("🖼 Image Deepfake"):
+            gr.Markdown("# 🖼 Deepfake Image Detection System")
+
+            with gr.Row():
+                with gr.Column(scale=1):
+                    image_input = gr.Image(
+                        label="Upload Image",
+                        type="pil",
+                        height=280
+                    )
+                    img_submit = gr.Button("Submit")
+                    img_clear = gr.Button("Clear")
+
+                with gr.Column(scale=2):
+                    img_pred = gr.Text(label="Prediction")
+                    img_conf = gr.Text(label="Confidence")
+                    img_risk = gr.Text(label="Risk Assessment")
+                    img_heatmap = gr.Image(
+                        label="Explainability Heatmap",
+                        height=280
+                    )
+
+            img_submit.click(
+                fn=analyze_image,
+                inputs=image_input,
+                outputs=[img_pred, img_conf, img_risk, img_heatmap]
+            )
+
+            img_clear.click(
+                fn=lambda: (None, "", "", None),
+                inputs=None,
+                outputs=[image_input, img_pred, img_conf, img_risk]
+            )
+
+        # AUDIO TAB
+        with gr.Tab("🎧 Audio Deepfake"):
+            gr.Markdown("# 🎧 Deepfake Audio Detection System")
+
+            with gr.Row():
+                with gr.Column(scale=1):
+                    audio_input = gr.Audio(
+                        label="Upload Audio (.wav)",
+                        type="filepath"
+                    )
+                    aud_submit = gr.Button("Submit")
+                    aud_clear = gr.Button("Clear")
+
+                with gr.Column(scale=2):
+                    aud_pred = gr.Text(label="Prediction")
+                    aud_conf = gr.Text(label="Confidence")
+                    aud_risk = gr.Text(label="Risk Assessment")
+
+            aud_submit.click(
+                fn=analyze_audio,
+                inputs=audio_input,
+                outputs=[aud_pred, aud_conf, aud_risk]
+            )
+
+            aud_clear.click(
+                fn=lambda: (None, "", ""),
+                inputs=None,
+                outputs=[audio_input, aud_pred, aud_conf]
+            )
+
+demo.launch()

audio_backend.py

@@ -0,0 +1,23 @@
+import tensorflow as tf
+import numpy as np
+from audio_utils import audio_to_spectrogram
+
+MODEL_PATH = "models/audio_vit_savedmodel"
+
+model = tf.saved_model.load(MODEL_PATH)
+infer = model.signatures["serving_default"]
+
+
+def predict_audio(wav_file):
+    spec_img = audio_to_spectrogram(wav_file)
+
+    x = spec_img.astype("float32") / 255.0
+    x = np.expand_dims(x, axis=0)
+
+    preds = infer(tf.constant(x))
+    prob = list(preds.values())[0].numpy()[0][0]
+
+    label = "Fake" if prob >= 0.5 else "Real"
+    confidence = prob * 100
+
+    return label, round(confidence, 2), spec_img

audio_utils.py

@@ -0,0 +1,42 @@
+import librosa
+import numpy as np
+import cv2
+
+SR = 16000
+DURATION = 4.0
+N_MELS = 192
+N_FFT = 2048
+HOP_LENGTH = 160
+IMG_SIZE = 224
+
+
+def audio_to_spectrogram(wav_path):
+
+    y, _ = librosa.load(wav_path, sr=SR)
+    y, _ = librosa.effects.trim(y, top_db=30)
+
+    target = int(SR * DURATION)
+
+    if len(y) < target:
+        pad = target - len(y)
+        y = np.pad(y, (pad // 2, pad - pad // 2))
+    else:
+        y = y[:target]
+
+    mel = librosa.feature.melspectrogram(
+        y=y,
+        sr=SR,
+        n_fft=N_FFT,
+        hop_length=HOP_LENGTH,
+        n_mels=N_MELS
+    )
+
+    logmel = librosa.power_to_db(mel, ref=np.max)
+
+    logmel = (logmel - logmel.min()) / (logmel.max() - logmel.min())
+
+    img = (logmel * 255).astype(np.uint8)
+    img = cv2.resize(img, (IMG_SIZE, IMG_SIZE))
+    img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
+
+    return img

image_backend.py

@@ -0,0 +1,89 @@
+import torch
+from torchvision import transforms
+from transformers import ViTForImageClassification, ViTConfig
+from PIL import Image
+import numpy as np
+import matplotlib.pyplot as plt
+import io
+import os
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+config = ViTConfig.from_pretrained(
+    "google/vit-base-patch16-224",
+    num_labels=2,
+    output_attentions=True
+)
+
+model = ViTForImageClassification.from_pretrained(
+    "google/vit-base-patch16-224",
+    config=config,
+    ignore_mismatched_sizes=True
+)
+
+model.load_state_dict(
+    torch.load("model/vit_real_fake_best.pth", map_location=device)
+)
+
+model.to(device)
+model.eval()
+
+
+transform = transforms.Compose([
+    transforms.Resize((224, 224)),
+    transforms.ToTensor(),
+    transforms.Normalize(
+        [0.485, 0.456, 0.406],
+        [0.229, 0.224, 0.225]
+    )
+])
+
+
+def get_attention_map(model, img_tensor):
+    with torch.no_grad():
+        outputs = model(img_tensor, output_attentions=True)
+        attn = outputs.attentions[-1].mean(dim=1)[0]
+        cls_attn = attn[0, 1:]
+
+        grid = int(cls_attn.size(0) ** 0.5)
+        cls_attn = cls_attn.reshape(grid, grid).cpu().numpy()
+
+        cls_attn = (cls_attn - cls_attn.min()) / (cls_attn.max() - cls_attn.min())
+        return cls_attn
+
+
+def overlay(image, heatmap):
+    heatmap = np.uint8(255 * heatmap)
+    heatmap = Image.fromarray(heatmap).resize(image.size)
+
+    fig, ax = plt.subplots(figsize=(4, 4))
+    ax.imshow(image)
+    ax.imshow(heatmap, cmap="jet", alpha=0.5)
+    ax.axis("off")
+
+    buf = io.BytesIO()
+    plt.savefig(buf, format="png", bbox_inches="tight", pad_inches=0)
+    plt.close(fig)
+    buf.seek(0)
+
+    return Image.open(buf)
+
+
+def predict_image_pil(image):
+    image = image.convert("RGB")
+
+    x = transform(image).unsqueeze(0).to(device)
+
+    with torch.no_grad():
+        outputs = model(x)
+        logits = outputs.logits
+        pred = torch.argmax(logits, dim=1).item()
+
+    label = "Fake" if pred == 0 else "Real"
+
+    heat = get_attention_map(model, x)
+    heatmap_img = overlay(image, heat)
+
+    confidence = torch.softmax(logits, dim=1)[0][pred].item() * 100
+
+    return label, round(confidence, 2), heatmap_img

requirements.txt

@@ -0,0 +1,10 @@
+gradio
+torch
+torchvision
+transformers
+tensorflow
+librosa
+opencv-python
+matplotlib
+pillow
+numpy