Update app.py

app.py

@@ -30,10 +30,9 @@ def extract_face(image):
     return image[y:y+h, x:x+w]
 
 def grad_cam(model, image, size, preprocess):
-    img_input = tf.expand_dims(image, axis=0)  # Shape: (1, H, W, 3)
+    img_input = tf.expand_dims(image, axis=0)
 
     last_conv_layer_name = None
-    # Auto-detect last conv layer
     for layer in reversed(model.layers):
         if isinstance(layer, tf.keras.layers.Conv2D):
             last_conv_layer_name = layer.name
@@ -42,22 +41,18 @@ def grad_cam(model, image, size, preprocess):
     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]
-    )
+    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]  # Assuming binary classification
+        loss = predictions[:, 0]
 
     grads = tape.gradient(loss, conv_outputs)
-
-    # Ensure correct shape
     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))  # (C,)
-    conv_outputs = conv_outputs[0]  # (H, W, C)
+    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)
@@ -68,32 +63,30 @@ def grad_cam(model, image, size, preprocess):
 
     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
 
-    # Xception
+    # Preprocess faces for both models
     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)[0][0]
+    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)[0][0]
+    eff_pred = eff_model.predict(eff_tensor, verbose=0)[0][0]
 
-    # Ensemble average
     avg_pred = (xcp_pred + eff_pred) / 2
     label = "Fake" if avg_pred > 0.5 else "Real"
 
-    # Grad-CAM on Xception
-    cam_img = grad_cam(xcp_model, face, (299, 299), xcp_pre)
+    # 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