Update app.py

app.py

@@ -8,13 +8,11 @@ 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 mtcnn import MTCNN
-import matplotlib.pyplot as plt
 
-# Download models
+# Load models
 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")
 
-# Load models
 xcp_model = load_model(xcp_path)
 eff_model = load_model(eff_path)
 
@@ -25,80 +23,37 @@ def extract_face(image):
     faces = detector.detect_faces(image)
     if not faces:
         return None
-    x, y, w, h = faces[0]['box']
+    x, y, w, h = faces[0]["box"]
     x, y = max(0, x), max(0, y)
     return image[y:y+h, x:x+w]
 
-def grad_cam(model, image, size, preprocess):
-    img_input = tf.expand_dims(image, axis=0)
-
-    last_conv_layer_name = None
-    for layer in reversed(model.layers):
-        if isinstance(layer, tf.keras.layers.Conv2D):
-            last_conv_layer_name = layer.name
-            break
-
-    if not last_conv_layer_name:
-        raise ValueError("No Conv2D layer found in the model.")
-
-    grad_model = tf.keras.models.Model([model.inputs], [model.get_layer(last_conv_layer_name).output, model.output])
-
-    with tf.GradientTape() as tape:
-        conv_outputs, predictions = grad_model(img_input)
-        loss = predictions[:, 0]
-
-    grads = tape.gradient(loss, conv_outputs)
-    if len(grads.shape) != 4:
-        raise ValueError(f"Expected 4D tensor for grads, got shape: {grads.shape}")
-
-    pooled_grads = tf.reduce_mean(grads, axis=(0, 1, 2))
-    conv_outputs = conv_outputs[0]
-    cam = tf.reduce_sum(conv_outputs * pooled_grads, axis=-1)
-
-    heatmap = np.maximum(cam, 0)
-    heatmap = heatmap / (tf.reduce_max(heatmap) + 1e-6)
-    heatmap = cv2.resize(heatmap.numpy(), size)
-    heatmap = np.uint8(255 * heatmap)
-    heatmap = cv2.applyColorMap(heatmap, cv2.COLORMAP_JET)
-
-    face_rgb = (image.numpy() * 255).astype(np.uint8)
-    face_rgb = cv2.resize(face_rgb, size)
-    overlaid = cv2.addWeighted(face_rgb, 0.6, heatmap, 0.4, 0)
-    return overlaid
-
 def predict(image):
     face = extract_face(image)
     if face is None:
-        return "No face detected", None
+        return "No face detected"
 
-    # Preprocess faces for both models
+    # Xception
     xcp_img = cv2.resize(face, (299, 299))
     xcp_tensor = xcp_pre(xcp_img.astype(np.float32))[np.newaxis, ...]
     xcp_pred = xcp_model.predict(xcp_tensor, verbose=0)[0][0]
 
+    # EfficientNet
     eff_img = cv2.resize(face, (224, 224))
     eff_tensor = eff_pre(eff_img.astype(np.float32))[np.newaxis, ...]
     eff_pred = eff_model.predict(eff_tensor, verbose=0)[0][0]
 
-    avg_pred = (xcp_pred + eff_pred) / 2
+    # Ensemble
+    avg_pred = (xcp_pred + eff_pred) / 2.0
     label = "Fake" if avg_pred > 0.5 else "Real"
+    return label
 
-    # Grad-CAM (resize face correctly)
-    face_for_gradcam = cv2.resize(face, (299, 299))
-    face_for_gradcam = tf.convert_to_tensor(face_for_gradcam / 255.0, dtype=tf.float32)
-    cam_img = grad_cam(xcp_model, face_for_gradcam, (299, 299), xcp_pre)
-
-    return label, cam_img
-
+# Gradio interface
 interface = gr.Interface(
     fn=predict,
-    inputs=gr.Image(type="numpy", label="image"),
-    outputs=[
-        gr.Label(label="Prediction"),
-        gr.Image(type="numpy", label="Grad-CAM")
-    ],
-    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."
+    inputs=gr.Image(type="numpy", label="Upload an image"),
+    outputs=gr.Label(label="Prediction"),
+    title="Deepfake Image Detector",
+    description="Upload an image. We detect the face and classify it using an ensemble of Xception + EfficientNetB4."
 )
 
 interface.launch()