Update app.py

app.py

@@ -1,75 +1,89 @@
-import os
-import numpy as np
 import cv2
+import numpy as np
+import gradio as gr
 from mtcnn import MTCNN
-from PIL import Image
 from tensorflow.keras.models import load_model
 from tensorflow.keras.applications.xception import preprocess_input as xcp_pre
 from tensorflow.keras.applications.efficientnet import preprocess_input as eff_pre
-from tensorflow.keras.preprocessing.image import img_to_array
 from huggingface_hub import hf_hub_download
-import gradio as gr
+
 
 # Load models
 xcp_path = hf_hub_download(repo_id="Zeyadd-Mostaffa/deepfake-image-detector_final", filename="xception_model.h5")
 eff_path = hf_hub_download(repo_id="Zeyadd-Mostaffa/deepfake-image-detector_final", filename="efficientnet_model.h5")
+xcp_model = load_model(xcp_path)
+eff_model = load_model(eff_path)
 
-model_xcp = load_model(xcp_path)
-model_eff = load_model(eff_path)
 
-# Face detector
+# Load face detector
 detector = MTCNN()
 
-# Prediction function
-def predict_image(image_path):
-    img = cv2.imread(image_path)
-    if img is None:
-        return {"error": "Image could not be loaded"}
+def expand_box(x, y, w, h, scale=1.5, img_shape=None):
+    """Expand face bounding box with margin."""
+    cx, cy = x + w // 2, y + h // 2
+    new_w, new_h = int(w * scale), int(h * scale)
+    x1 = max(0, cx - new_w // 2)
+    y1 = max(0, cy - new_h // 2)
+    x2 = min(img_shape[1], cx + new_w // 2)
+    y2 = min(img_shape[0], cy + new_h // 2)
+    return x1, y1, x2, y2
+
+def predict(image):
+    faces = detector.detect_faces(image)
+    if not faces:
+        return "No face detected", image
 
+    output_image = image.copy()
     results = []
-    faces = detector.detect_faces(img)
 
-    # === Single or no face ===
-    if len(faces) <= 1:
-        img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
-        img_xcp = xcp_pre(np.expand_dims(cv2.resize(img_rgb, (299, 299)), axis=0))
-        img_eff = eff_pre(np.expand_dims(cv2.resize(img_rgb, (224, 224)), axis=0))
+    for idx, face in enumerate(faces):
+        x, y, w, h = face['box']
+
+        # Add 20% margin while staying inside bounds
+        margin = 0.2
+        img_h, img_w = image.shape[:2]
+        x = max(0, int(x - w * margin))
+        y = max(0, int(y - h * margin))
+        w = int(w * (1 + 2 * margin))
+        h = int(h * (1 + 2 * margin))
+        x2 = min(img_w, x + w)
+        y2 = min(img_h, y + h)
 
-        xcp_pred = model_xcp.predict(img_xcp)[0][0]
-        eff_pred = model_eff.predict(img_eff)[0][0]
-        final_score = (xcp_pred + eff_pred) / 2
-        label = "REAL" if final_score > 0.5 else "FAKE"
+        face_img = image[y:y2, x:x2]
 
-        results.append({"face_id": "whole image", "label": label, "score": round(float(final_score), 3)})
-    else:
-        for idx, face in enumerate(faces):
-            x, y, w, h = face['box']
-            x, y = max(0, x), max(0, y)
-            cropped = img[y:y+h, x:x+w]
+        # Resize + preprocess
+        face_xcp = cv2.resize(face_img, (299, 299))
+        face_eff = cv2.resize(face_img, (224, 224))
+        xcp_tensor = xcp_pre(face_xcp.astype(np.float32))[np.newaxis, ...]
+        eff_tensor = eff_pre(face_eff.astype(np.float32))[np.newaxis, ...]
 
-            if cropped.shape[0] < 60 or cropped.shape[1] < 60:
-                continue
+        # Predictions
+        pred_xcp = xcp_model.predict(xcp_tensor, verbose=0).flatten()[0]
+        pred_eff = eff_model.predict(eff_tensor, verbose=0).flatten()[0]
+        avg = (pred_xcp + pred_eff) / 2
 
-            face_rgb = cv2.cvtColor(cropped, cv2.COLOR_BGR2RGB)
-            img_xcp = xcp_pre(np.expand_dims(cv2.resize(face_rgb, (299, 299)), axis=0))
-            img_eff = eff_pre(np.expand_dims(cv2.resize(face_rgb, (224, 224)), axis=0))
+        label = "Real" if avg > 0.5 else "Fake"
+        color = (0, 255, 0) if label == "Real" else (0, 0, 255)
 
-            xcp_pred = model_xcp.predict(img_xcp)[0][0]
-            eff_pred = model_eff.predict(img_eff)[0][0]
-            final_score = (xcp_pred + eff_pred) / 2
-            label = "REAL" if final_score > 0.5 else "FAKE"
+        # Annotate image
+        cv2.rectangle(output_image, (x, y), (x2, y2), color, 2)
+        cv2.putText(output_image, f"{label} ({avg:.2f})", (x, y - 10),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.6, color, 2)
 
-            results.append({"face_id": f"face_{idx+1}", "label": label, "score": round(float(final_score), 3)})
+        results.append(f"Face {idx+1}: {label} (Avg: {avg:.3f}, XCP: {pred_xcp:.3f}, EFF: {pred_eff:.3f})")
 
-    return results
+    return "\n".join(results), output_image
 
+# Gradio Interface
 interface = gr.Interface(
-    fn=predict_image,  # your prediction function
-    inputs=gr.Image(type="filepath"),
-    outputs="json",
-    title="Deepfake Detector (Hybrid Strategy)",
-    description="If 1 face → predict full image. If >1 → predict each face."
+    fn=predict,
+    inputs=gr.Image(type="numpy", label="Upload Image"),
+    outputs=[
+        gr.Textbox(label="Predictions"),
+        gr.Image(type="numpy", label="Annotated Image"),
+    ],
+    title="Deepfake Detector (Multi-Face Ensemble)",
+    description="Detects all faces in an image and classifies each one as real or fake using Xception and EfficientNetB4 ensemble.",
 )
 
-# ✅ Required to start app
 interface.launch()