Update app.py

app.py

@@ -1,92 +1,83 @@
 import gradio as gr
 import numpy as np
-import cv2
 import tensorflow as tf
-from tensorflow.keras.models import load_model, Model
-from tensorflow.keras.preprocessing.image import img_to_array
+import cv2
+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 huggingface_hub import hf_hub_download
-from PIL import Image
-
-# Load models from Hugging Face Hub
-xcp_path = hf_hub_download(repo_id="Zeyadd-Mostaffa/deepfake-image-detector", filename="xception_model.h5")
-eff_path = hf_hub_download(repo_id="Zeyadd-Mostaffa/deepfake-image-detector", filename="efficientnet_model.h5")
-xcp_model = load_model(xcp_path)
-eff_model = load_model(eff_path)
-
-# Face detection using OpenCV
-def detect_face_opencv(pil_image):
-    cv_img = np.array(pil_image.convert("RGB"))
-    cv_img = cv_img[:, :, ::-1]  # RGB to BGR
-    face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
-    gray = cv2.cvtColor(cv_img, cv2.COLOR_BGR2GRAY)
-    faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=4)
-    if len(faces) == 0:
-        return pil_image  # fallback to original
-    (x, y, w, h) = max(faces, key=lambda b: b[2]*b[3])
-    return pil_image.crop((x, y, x+w, y+h))
-
-def grad_cam(model, img, size, preprocess_func):
-    img_resized = img.resize(size)
-    x = img_to_array(img_resized)
-    x = np.expand_dims(x, axis=0)
-    x = preprocess_func(x)
-    x_tensor = tf.convert_to_tensor(x)
-
-    grad_model = Model([model.inputs], [model.layers[-3].output, model.output])
-    with tf.GradientTape() as tape:
-        conv_outputs, predictions = grad_model(x_tensor)
-        loss = predictions[:, 0]
-    grads = tape.gradient(loss, conv_outputs)
+from mtcnn import MTCNN
+import os
+import warnings
+warnings.filterwarnings("ignore")
 
-    cam = tf.reduce_mean(grads, axis=-1)[0]  # (H, W)
-    cam = tf.maximum(cam, 0)
-    cam = cam / tf.reduce_max(cam + tf.keras.backend.epsilon())
-    cam = cam.numpy()  # ✅ convert to numpy before resizing
+# Force TF to suppress log-level warnings
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
 
-    cam = cv2.resize(cam, size)
-    heatmap = np.uint8(255 * cam)
-    heatmap = cv2.applyColorMap(heatmap, cv2.COLORMAP_JET)
+# Load models from local (downloaded from HF first in app setup)
+xcp_model = load_model("xception_model.h5")
+eff_model = load_model("efficientnet_model.h5")
 
-    img_np = np.array(img_resized)
-    if img_np.shape[-1] == 4:  # remove alpha if present
-        img_np = img_np[:, :, :3]
+# Grad-CAM for Xception
+def grad_cam(model, img_array, size, preprocess_fn):
+    img = cv2.resize(img_array, size)
+    input_tensor = preprocess_fn(np.expand_dims(img, axis=0).astype(np.float32))
+    input_tensor = tf.convert_to_tensor(input_tensor)
 
-    superimposed = cv2.addWeighted(img_np, 0.6, heatmap, 0.4, 0)
-    return Image.fromarray(cv2.cvtColor(superimposed, cv2.COLOR_BGR2RGB))
+    with tf.GradientTape() as tape:
+        conv_layer = model.get_layer(index=-5).output
+        grad_model = tf.keras.models.Model([model.inputs], [conv_layer, model.output])
+        conv_outputs, predictions = grad_model(input_tensor)
+        loss = predictions[:, 0]
 
+    grads = tape.gradient(loss, conv_outputs)
+    pooled_grads = tf.reduce_mean(grads, axis=(0, 1, 2))
+    cam = tf.reduce_sum(tf.multiply(pooled_grads, conv_outputs), axis=-1).numpy()[0]
 
+    cam = np.maximum(cam, 0)
+    cam = cam / (cam.max() + 1e-8)
+    cam = (cam * 255).astype(np.uint8)
+    cam = cam.numpy() if hasattr(cam, 'numpy') else cam
+    cam = cv2.resize(cam, size)
+    heatmap = cv2.applyColorMap(cam, cv2.COLORMAP_JET)
+    superimposed_img = cv2.addWeighted(cv2.cvtColor(img, cv2.COLOR_RGB2BGR), 0.6, heatmap, 0.4, 0)
+    return superimposed_img
 
+# Face detector
+detector = MTCNN()
 
-# Preprocessing helper
-def preprocess(img, size, func):
-    img = img.resize(size)
-    arr = img_to_array(img)
-    arr = np.expand_dims(arr, axis=0)
-    return func(arr)
+def detect_face(image):
+    faces = detector.detect_faces(image)
+    if not faces:
+        raise ValueError("No face detected.")
+    x, y, w, h = faces[0]['box']
+    return image[y:y+h, x:x+w]
 
-# Prediction function
 def predict(image):
-    face = detect_face_opencv(image)
+    try:
+        face = detect_face(image)
+
+        xcp_img = cv2.resize(face, (299, 299))
+        eff_img = cv2.resize(face, (224, 224))
+
+        xcp_input = np.expand_dims(xcp_pre(xcp_img.astype(np.float32)), axis=0)
+        eff_input = np.expand_dims(eff_pre(eff_img.astype(np.float32)), axis=0)
 
-    xcp_input = preprocess(face, (299, 299), xcp_pre)
-    eff_input = preprocess(face, (224, 224), eff_pre)
+        xcp_pred = xcp_model.predict(xcp_input)[0][0]
+        eff_pred = eff_model.predict(eff_input)[0][0]
 
-    xcp_pred = xcp_model.predict(xcp_input)[0][0]
-    eff_pred = eff_model.predict(eff_input)[0][0]
-    ensemble_prob = (xcp_pred + eff_pred) / 2
+        ensemble_pred = (xcp_pred + eff_pred) / 2
+        label = "Fake" if ensemble_pred > 0.5 else "Real"
 
-    label = "REAL" if ensemble_prob > 0.5 else "FAKE"
-    cam_img = grad_cam(xcp_model, face, (299, 299), xcp_pre)
+        cam_img = grad_cam(xcp_model, face, (299, 299), xcp_pre)
 
-    return f"{label} ({ensemble_prob:.2%} confidence)", cam_img
+        return label, cam_img
+    except Exception as e:
+        return "خطأ", "خطأ"
 
-# Gradio UI
 gr.Interface(
     fn=predict,
-    inputs=gr.Image(type="pil"),
-    outputs=["text", "image"],
+    inputs=gr.Image(type="numpy", label="Upload Face Image"),
+    outputs=[gr.Label(label="Prediction"), gr.Image(label="Grad-CAM Explanation")],
     title="Deepfake Image Detector (with Grad-CAM)",
     description="Upload an image. We detect the face, classify using an ensemble (Xception + EfficientNetB4), and explain the prediction using Grad-CAM on Xception."
 ).launch()