Update app.py

app.py

@@ -266,7 +266,7 @@ def generate_attention_heatmap(attention_maps):
     return heatmap
 
 def analyze_image(image, ground_truth, filename):
-    """Main analysis function - FIXED VERSION"""
+    """Main analysis function - DEBUG VERSION"""
     if model is None:
         return None, "Model not loaded. Please restart the application."
     
@@ -274,28 +274,66 @@ def analyze_image(image, ground_truth, filename):
         return None, "Please select an image first."
     
     try:
+        print("="*50)
+        print("DEBUG: Starting analysis...")
+        print(f"Input image mode: {image.mode}")
+        print(f"Input image size: {image.size}")
+        
         # Preprocess
         input_tensor = preprocess_for_model(image).to(device)
+        print(f"Input tensor shape: {input_tensor.shape}")
+        print(f"Input tensor min/max: {input_tensor.min():.4f}/{input_tensor.max():.4f}")
         
         # Get prediction and attention maps
         with torch.no_grad():
-            # Get model output (prediction + attention maps)
+            print("Getting model output...")
             model_output, attention_maps = model(input_tensor)
             
-            # Apply sigmoid and threshold to get binary mask
+            print(f"Model output shape: {model_output.shape}")
+            print(f"Model output min/max BEFORE sigmoid: {model_output.min():.4f}/{model_output.max():.4f}")
+            
+            # Apply sigmoid
             pred_mask = torch.sigmoid(model_output)
+            print(f"After sigmoid min/max: {pred_mask.min():.4f}/{pred_mask.max():.4f}")
+            
+            # Check values before thresholding
+            unique_vals = torch.unique(pred_mask)
+            print(f"Unique values in prediction: {unique_vals[:10]}")  # Show first 10 unique values
+            
+            # Apply threshold
             binary_mask = (pred_mask > 0.5).float()
+            print(f"Binary mask shape: {binary_mask.shape}")
+            print(f"Binary mask sum (number of 1s): {binary_mask.sum()}")
             
-            # Convert to numpy for further processing
+            # Convert to numpy
             binary_mask_np = binary_mask.squeeze().cpu().numpy()
+            print(f"Numpy binary mask shape: {binary_mask_np.shape}")
+            print(f"Numpy binary mask unique values: {np.unique(binary_mask_np)}")
+            print(f"Numpy binary mask sum: {np.sum(binary_mask_np)}")
+        
+        # Try different thresholds if 0.5 doesn't work
+        if np.sum(binary_mask_np) == 0:
+            print("No pixels detected with threshold 0.5, trying lower thresholds...")
+            for thresh in [0.3, 0.2, 0.1, 0.05]:
+                test_mask = (pred_mask > thresh).float().squeeze().cpu().numpy()
+                pixel_count = np.sum(test_mask)
+                print(f"Threshold {thresh}: {pixel_count} pixels")
+                if pixel_count > 0:
+                    print(f"Using threshold {thresh} instead of 0.5")
+                    binary_mask_np = test_mask
+                    break
         
         # Post-processing (morphological operations)
+        print("Applying morphological operations...")
         kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3,3))
         binary_mask_np = cv2.morphologyEx(binary_mask_np.astype(np.uint8), cv2.MORPH_OPEN, kernel)
         binary_mask_np = cv2.morphologyEx(binary_mask_np, cv2.MORPH_CLOSE, kernel)
+        print(f"After morphological ops sum: {np.sum(binary_mask_np)}")
         
         # Generate attention heatmap
+        print("Generating attention heatmap...")
         att_heatmap = generate_attention_heatmap(attention_maps)
+        print(f"Attention heatmap shape: {att_heatmap.shape}")
         
         # Create visualization
         if ground_truth is not None:
@@ -324,8 +362,12 @@ def analyze_image(image, ground_truth, filename):
             
             # Ground truth
             gt_array = np.array(ground_truth.resize((256, 256)))
+            print(f"Ground truth array shape: {gt_array.shape}")
+            print(f"Ground truth unique values: {np.unique(gt_array)}")
+            
             # Normalize ground truth to binary (0 or 1)
             gt_binary = (gt_array > 128).astype(np.uint8)
+            print(f"GT binary sum: {np.sum(gt_binary)}")
             
             axes[1,0].imshow(gt_binary, cmap='gray')
             axes[1,0].set_title('Ground Truth Mask', fontsize=12, weight='bold')
@@ -349,6 +391,13 @@ def analyze_image(image, ground_truth, filename):
             # Dice score
             dice = (2 * intersection) / (np.sum(pred_binary) + np.sum(gt_binary_bool) + 1e-8)
             
+            print(f"Final IoU: {iou:.4f}")
+            print(f"Final Dice: {dice:.4f}")
+            print(f"Intersection: {intersection}")
+            print(f"Union: {union}")
+            print(f"Pred pixels: {np.sum(pred_binary)}")
+            print(f"GT pixels: {np.sum(gt_binary_bool)}")
+            
             axes[1,2].text(0.1, 0.6, f'IoU: {iou:.4f}', fontsize=16, weight='bold')
             axes[1,2].text(0.1, 0.4, f'Dice: {dice:.4f}', fontsize=16, weight='bold')
             axes[1,2].set_xlim(0, 1)
@@ -381,6 +430,10 @@ def analyze_image(image, ground_truth, filename):
         total_pixels = binary_mask_np.size
         tumor_percentage = (tumor_pixels / total_pixels) * 100
         
+        print(f"Final tumor pixels: {tumor_pixels}")
+        print(f"Final tumor percentage: {tumor_percentage:.2f}%")
+        print("="*50)
+        
         analysis_text = f"""
 # Analysis Results
 
@@ -410,6 +463,7 @@ def analyze_image(image, ground_truth, filename):
         print(error_msg)  # For debugging
         return None, error_msg
 
+        
 # Initialize model and dataset at startup
 print("Initializing application components...")
 model_loaded = download_and_load_model()