Update app.py

app.py

@@ -50,7 +50,7 @@ with st.sidebar:
 def log_debug(message):
     """Helper function to log debug messages only when debug mode is enabled"""
     if st.session_state.debug:
-        st.write(f"DEBUG: {message}")
+        st.sidebar.write(f"DEBUG: {message}")
 
 # Function to check environment
 def check_environment():
@@ -509,11 +509,10 @@ def preprocess_image_xception(image):
             log_debug("Image is None - this should never happen!")
             return None, None, None
         
-        # Get image shape for logging
-        image_np = np.array(image.convert('RGB'))  # Ensure RGB
-        log_debug(f"Image shape: {image_np.shape}")
+        # Convert to numpy array for processing
+        image_np = np.array(image.convert('RGB'))
         
-        # Face detection with detailed logs
+        # Face detection
         gray = cv2.cvtColor(image_np, cv2.COLOR_RGB2GRAY)
         faces = face_detector.detectMultiScale(gray, 1.1, 5)
 
@@ -528,7 +527,6 @@ def preprocess_image_xception(image):
             areas = [w * h for (x, y, w, h) in faces]
             largest_idx = np.argmax(areas)
             x, y, w, h = faces[largest_idx]
-            log_debug(f"Using largest face 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)
@@ -544,7 +542,6 @@ def preprocess_image_xception(image):
         transform = get_xception_transform()
         # Apply transform to the selected region (face or whole image)
         input_tensor = transform(face_img_for_transform).unsqueeze(0)
-        log_debug(f"Preprocessed tensor shape: {input_tensor.shape}")
 
         # Return tensor, original full image, and the display face box
         return input_tensor, image, face_box_display
@@ -552,21 +549,10 @@ def preprocess_image_xception(image):
     except Exception as e:
         st.error(f"Error in preprocessing image: {str(e)}")
         import traceback
-        error_details = traceback.format_exc()
-        log_debug(f"Preprocessing error details: {error_details}")
-        if st.session_state.debug:
-            st.error(error_details)
+        log_debug(f"Preprocessing error details: {traceback.format_exc()}")
             
-        # Try a fallback method if possible
-        try:
-            log_debug("Trying fallback preprocessing method")
-            transform = get_xception_transform()
-            input_tensor = transform(image).unsqueeze(0)
-            return input_tensor, image, None
-        except Exception as fallback_e:
-            log_debug(f"Fallback also failed: {str(fallback_e)}")
-            st.error("Both preprocessing attempts failed. Please try another image.")
-            return None, None, None
+        # Return None values to indicate failure
+        return None, None, None
 
 # Main app
 def main():
@@ -706,18 +692,12 @@ def main():
             uploaded_file = st.file_uploader("Choose an image...", type=["jpg", "jpeg", "png"])
             if uploaded_file is not None:
                 try:
-                    # Direct in-memory handling - avoid writing to disk
-                    file_bytes = uploaded_file.getvalue()
-                    # Log the file size for debugging
-                    st.write(f"Debug: Received file of size {len(file_bytes)} bytes")
-                    # Process directly in memory
-                    image_stream = io.BytesIO(file_bytes)
-                    uploaded_image = Image.open(image_stream).convert("RGB")
+                    # Simple direct approach - load the image directly
+                    image = Image.open(uploaded_file).convert("RGB")
+                    uploaded_image = image
                     st.session_state.upload_method = "file"
-                    # Log success
-                    st.success("File loaded successfully in memory")
                 except Exception as e:
-                    st.error(f"Error loading file: {str(e)}")
+                    st.error(f"Error loading image: {str(e)}")
                     import traceback
                     st.error(traceback.format_exc())
         
@@ -726,33 +706,21 @@ def main():
             if url and url.strip():
                 try:
                     import requests
-                    # Log the URL (excluding any sensitive parts)
-                    display_url = url.split("?")[0] if "?" in url else url
-                    st.write(f"Debug: Attempting to fetch image from {display_url}")
-                    
+                    # Simplified URL handling
                     headers = {
                         'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
                     }
                     response = requests.get(url, stream=True, headers=headers, timeout=10)
                     
                     if response.status_code == 200:
-                        # Log success and content type
-                        st.write(f"Debug: Received response - Content-Type: {response.headers.get('Content-Type', 'unknown')}")
-                        
-                        # Process directly in memory
-                        image_stream = io.BytesIO(response.content)
-                        uploaded_image = Image.open(image_stream).convert("RGB")
+                        # Process directly as in original code
+                        image = Image.open(io.BytesIO(response.content)).convert("RGB")
+                        uploaded_image = image
                         st.session_state.upload_method = "url"
-                        st.success(f"Image successfully loaded from URL - Size: {len(response.content)} bytes")
                     else:
                         st.error(f"Failed to load image from URL: Status code {response.status_code}")
-                        if response.status_code in [403, 401]:
-                            st.warning("This appears to be an access permissions issue. The server is refusing to serve this image.")
-                            st.info("Try using an image URL from a site that allows hotlinking, or upload a file directly.")
                 except Exception as e:
                     st.error(f"Error loading image from URL: {str(e)}")
-                    import traceback
-                    st.error(traceback.format_exc())
         
         # If we have an uploaded image, process it
         if uploaded_image is not None:
@@ -777,9 +745,12 @@ def main():
                 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)
                         
+                        if input_tensor is None:
+                            st.error("Failed to preprocess image. Please try another image.")
+                            st.stop()
+                        
                         # Get device and model
                         device = st.session_state.device
                         model = st.session_state.xception_model
@@ -789,23 +760,17 @@ def main():
                         
                         # 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
@@ -831,7 +796,6 @@ def main():
                         # 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
                             )