Update app.py

app.py

@@ -419,37 +419,52 @@ def analyze_image_with_llm(image, gradcam_overlay, face_box, pred_label, confide
 # Preprocess image for Xception
 def preprocess_image_xception(image):
     """Preprocesses image for Xception model input and face detection."""
-    face_detector = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
-    image_np = np.array(image.convert('RGB'))  # Ensure RGB
-    gray = cv2.cvtColor(image_np, cv2.COLOR_RGB2GRAY)
-    faces = face_detector.detectMultiScale(gray, 1.1, 5)
+    try:
+        st.write("Starting image preprocessing...")
+        face_detector = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
+        image_np = np.array(image.convert('RGB'))  # Ensure RGB
+        st.write(f"Image shape: {image_np.shape}")
+        
+        gray = cv2.cvtColor(image_np, cv2.COLOR_RGB2GRAY)
+        faces = face_detector.detectMultiScale(gray, 1.1, 5)
 
-    face_img_for_transform = image  # Default to whole image
-    face_box_display = None  # For drawing on original image
+        face_img_for_transform = image  # Default to whole image
+        face_box_display = None  # For drawing on original image
 
-    if len(faces) == 0:
-        st.warning("No face detected, using whole image for prediction/CAM.")
-    else:
-        areas = [w * h for (x, y, w, h) in faces]
-        largest_idx = np.argmax(areas)
-        x, y, w, h = faces[largest_idx]
-        padding_x = int(w * 0.05)  # Use percentages as in gradcam_xception
-        padding_y = int(h * 0.05)
-        x1, y1 = max(0, x - padding_x), max(0, y - padding_y)
-        x2, y2 = min(image_np.shape[1], x + w + padding_x), min(image_np.shape[0], y + h + padding_y)
+        if len(faces) == 0:
+            st.warning("No face detected, using whole image for prediction/CAM.")
+        else:
+            areas = [w * h for (x, y, w, h) in faces]
+            largest_idx = np.argmax(areas)
+            x, y, w, h = faces[largest_idx]
+            st.write(f"Face detected at: x={x}, y={y}, w={w}, h={h}")
+            
+            padding_x = int(w * 0.05)  # Use percentages as in gradcam_xception
+            padding_y = int(h * 0.05)
+            x1, y1 = max(0, x - padding_x), max(0, y - padding_y)
+            x2, y2 = min(image_np.shape[1], x + w + padding_x), min(image_np.shape[0], y + h + padding_y)
 
-        # Use the padded face region for the model transform
-        face_img_for_transform = Image.fromarray(image_np[y1:y2, x1:x2])
-        # Use the original detected box (without padding) for display rectangle
-        face_box_display = (x, y, w, h)
+            # Use the padded face region for the model transform
+            face_img_for_transform = Image.fromarray(image_np[y1:y2, x1:x2])
+            # Use the original detected box (without padding) for display rectangle
+            face_box_display = (x, y, w, h)
 
-    # Xception specific transform
-    transform = get_xception_transform()
-    # Apply transform to the selected region (face or whole image)
-    input_tensor = transform(face_img_for_transform).unsqueeze(0)
+        # Xception specific transform
+        transform = get_xception_transform()
+        # Apply transform to the selected region (face or whole image)
+        input_tensor = transform(face_img_for_transform).unsqueeze(0)
+        st.write(f"Tensor shape: {input_tensor.shape}")
 
-    # Return tensor, original full image, and the display face box
-    return input_tensor, image, face_box_display
+        # Return tensor, original full image, and the display face box
+        return input_tensor, image, face_box_display
+    except Exception as e:
+        st.error(f"Error in preprocessing image: {str(e)}")
+        import traceback
+        st.error(traceback.format_exc())
+        # Return defaults that won't break the pipeline
+        transform = get_xception_transform()
+        input_tensor = transform(image).unsqueeze(0)
+        return input_tensor, image, None
 
 # Main app
 def main():
@@ -555,69 +570,103 @@ def main():
                 
                 # Detect with Xception model if loaded
                 if st.session_state.xception_model_loaded:
-                    with st.spinner("Analyzing image with Xception model..."):
-                        # Preprocess image for Xception
-                        input_tensor, original_image, face_box = preprocess_image_xception(image)
-                        
-                        # Get device and model
-                        device = st.session_state.device
-                        model = st.session_state.xception_model
-                        
-                        # Move tensor to device
-                        input_tensor = input_tensor.to(device)
-                        
-                        # Forward pass
-                        with torch.no_grad():
-                            logits = model(input_tensor)
-                            probabilities = torch.softmax(logits, dim=1)[0]
-                            pred_class = torch.argmax(probabilities).item()
-                            confidence = probabilities[pred_class].item()
-                            pred_label = "Fake" if pred_class == 0 else "Real"  # Check class mapping
-                        
-                        # Display results
-                        with col2:
-                            st.markdown("### Detection Result")
-                            st.markdown(f"**Classification:** {pred_label} (Confidence: {confidence:.2%})")
+                    try:
+                        with st.spinner("Analyzing image with Xception model..."):
+                            # Preprocess image for Xception
+                            st.write("Starting Xception processing...")
+                            input_tensor, original_image, face_box = preprocess_image_xception(image)
                             
-                            # Display face box on image if detected
-                            if face_box:
-                                img_to_show = original_image.copy()
-                                img_draw = np.array(img_to_show)
-                                x, y, w, h = face_box
-                                cv2.rectangle(img_draw, (x, y), (x + w, y + h), (0, 255, 0), 2)
-                                st.image(Image.fromarray(img_draw), caption="Detected Face", width=300)
-                        
-                        # GradCAM visualization
-                        st.subheader("GradCAM Visualization")
-                        cam, overlay, comparison, detected_face_box = process_image_with_xception_gradcam(
-                            image, model, device, pred_class
-                        )
-                        
-                        if comparison:
-                            # Display GradCAM results (controlled size)
-                            st.image(comparison, caption="Original | CAM | Overlay", width=700)
+                            # Get device and model
+                            device = st.session_state.device
+                            model = st.session_state.xception_model
+                            
+                            # Ensure model is in eval mode
+                            model.eval()
                             
-                            # Save for later use
-                            st.session_state.comparison_image = comparison
-                        
-                        # Generate caption for GradCAM overlay image if BLIP model is loaded
-                        if st.session_state.blip_model_loaded and overlay:
-                            with st.spinner("Analyzing GradCAM visualization..."):
-                                gradcam_caption = generate_gradcam_caption(
-                                    overlay,
-                                    st.session_state.finetuned_processor,
-                                    st.session_state.finetuned_model
+                            # Move tensor to device
+                            input_tensor = input_tensor.to(device)
+                            st.write(f"Input tensor on device: {device}")
+                            
+                            # Forward pass with proper error handling
+                            try:
+                                with torch.no_grad():
+                                    st.write("Running model inference...")
+                                    logits = model(input_tensor)
+                                    st.write(f"Raw logits: {logits}")
+                                    probabilities = torch.softmax(logits, dim=1)[0]
+                                    st.write(f"Probabilities: {probabilities}")
+                                    pred_class = torch.argmax(probabilities).item()
+                                    confidence = probabilities[pred_class].item()
+                                    st.write(f"Predicted class: {pred_class}, Confidence: {confidence:.4f}")
+                                    
+                                    # Explicit class mapping - adjust if needed based on your model
+                                    pred_label = "Fake" if pred_class == 0 else "Real"
+                                    st.write(f"Mapped to label: {pred_label}")
+                            except Exception as e:
+                                st.error(f"Error in model inference: {str(e)}")
+                                import traceback
+                                st.error(traceback.format_exc())
+                                # Set default values
+                                pred_class = 0
+                                confidence = 0.5
+                                pred_label = "Error in prediction"
+                            
+                            # Display results
+                            with col2:
+                                st.markdown("### Detection Result")
+                                st.markdown(f"**Classification:** {pred_label} (Confidence: {confidence:.2%})")
+                                
+                                # Display face box on image if detected
+                                if face_box:
+                                    img_to_show = original_image.copy()
+                                    img_draw = np.array(img_to_show)
+                                    x, y, w, h = face_box
+                                    cv2.rectangle(img_draw, (x, y), (x + w, y + h), (0, 255, 0), 2)
+                                    st.image(Image.fromarray(img_draw), caption="Detected Face", width=300)
+                            
+                            # GradCAM visualization with error handling
+                            st.subheader("GradCAM Visualization")
+                            try:
+                                st.write("Generating GradCAM visualization...")
+                                cam, overlay, comparison, detected_face_box = process_image_with_xception_gradcam(
+                                    image, model, device, pred_class
                                 )
-                                st.session_state.gradcam_caption = gradcam_caption
-                        
-                        # Save results in session state for LLM analysis
-                        st.session_state.current_image = image
-                        st.session_state.current_overlay = overlay
-                        st.session_state.current_face_box = detected_face_box
-                        st.session_state.current_pred_label = pred_label
-                        st.session_state.current_confidence = confidence
-                        
-                        st.success("✅ Initial detection and GradCAM visualization complete!")
+                                
+                                if comparison:
+                                    # Display GradCAM results (controlled size)
+                                    st.image(comparison, caption="Original | CAM | Overlay", width=700)
+                                    
+                                    # Save for later use
+                                    st.session_state.comparison_image = comparison
+                                else:
+                                    st.error("GradCAM visualization failed - comparison image not generated")
+                                
+                                # Generate caption for GradCAM overlay image if BLIP model is loaded
+                                if st.session_state.blip_model_loaded and overlay:
+                                    with st.spinner("Analyzing GradCAM visualization..."):
+                                        gradcam_caption = generate_gradcam_caption(
+                                            overlay,
+                                            st.session_state.finetuned_processor,
+                                            st.session_state.finetuned_model
+                                        )
+                                        st.session_state.gradcam_caption = gradcam_caption
+                            except Exception as e:
+                                st.error(f"Error generating GradCAM: {str(e)}")
+                                import traceback
+                                st.error(traceback.format_exc())
+                            
+                            # Save results in session state for LLM analysis
+                            st.session_state.current_image = image
+                            st.session_state.current_overlay = overlay if 'overlay' in locals() else None
+                            st.session_state.current_face_box = detected_face_box if 'detected_face_box' in locals() else None
+                            st.session_state.current_pred_label = pred_label
+                            st.session_state.current_confidence = confidence
+                            
+                            st.success("✅ Initial detection and GradCAM visualization complete!")
+                    except Exception as e:
+                        st.error(f"Overall error in Xception processing: {str(e)}")
+                        import traceback
+                        st.error(traceback.format_exc())
                 else:
                     st.warning("⚠️ Please load the Xception model first to perform initial detection.")
             except Exception as e: