Debug: Prediction issue

inference.py

@@ -23,19 +23,19 @@ def inference(image, alpha, top_k, target_layer, model=None, classes=None):
     Run inference with GradCAM visualization
     """
     try:
-        # Clear CUDA cache before starting
         if torch.cuda.is_available():
             torch.cuda.empty_cache()
             
         device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
         
+        # Debug: Print model mode
+        print(f"Model mode: {model.training}")
+        
         # Ensure model is on correct device and in eval mode
         model = model.to(device)
         model.eval()
         
-        # Process with reduced precision to save memory
         with torch.cuda.amp.autocast():
-            # Save a copy of input img
             org_img = image.copy()
 
             # Convert img to tensor and normalize it
@@ -47,18 +47,32 @@ def inference(image, alpha, top_k, target_layer, model=None, classes=None):
                 )
             ])
 
-            # Preprocess the input image and move to device
+            # Debug: Print image tensor stats
             input_tensor = _transform(image).to(device)
+            print(f"Input tensor shape: {input_tensor.shape}")
+            print(f"Input tensor range: [{input_tensor.min():.2f}, {input_tensor.max():.2f}]")
+            
             input_tensor = input_tensor.unsqueeze(0)
             input_tensor.requires_grad = True
             
             # Get Model Predictions
             outputs = model(input_tensor)
+            print(f"Raw output shape: {outputs.shape}")
+            print(f"Raw output range: [{outputs.min():.2f}, {outputs.max():.2f}]")
+            
             probabilities = torch.softmax(outputs, dim=1)[0]
-            confidences = {classes[i]: float(probabilities[i]) for i in range(1000)}
+            print(f"Probabilities sum: {probabilities.sum():.2f}")  # Should be close to 1.0
+            
+            # Get top 5 predictions for debugging
+            top_probs, top_indices = torch.topk(probabilities, 5)
+            print("\nTop 5 predictions:")
+            for idx, (prob, class_idx) in enumerate(zip(top_probs, top_indices)):
+                class_name = classes[class_idx]
+                print(f"{idx+1}. {class_name}: {prob:.4f}")
 
-            # Select the top classes based on user input
-            sorted_confidences = sorted(confidences.items(), key=lambda val: val[1], reverse=True)
+            # Create confidence dictionary
+            confidences = {classes[i]: float(probabilities[i]) for i in range(len(classes))}
+            sorted_confidences = sorted(confidences.items(), key=lambda x: x[1], reverse=True)
             show_confidences = OrderedDict(sorted_confidences[:top_k])
 
             # Map layer numbers to meaningful parts of the ResNet architecture
@@ -71,41 +85,36 @@ def inference(image, alpha, top_k, target_layer, model=None, classes=None):
                 6: model.layer4[-1]
             }
 
-            # Ensure valid layer selection
             target_layer = min(max(target_layer, 1), 6)
             target_layers = [_layers[target_layer]]
 
-            # Get the class activations from the selected layer
-            cam = GradCAM(model=model, target_layers=target_layers)
+            # Debug: Print selected layer
+            print(f"\nUsing target layer: {target_layers[0]}")
 
+            cam = GradCAM(model=model, target_layers=target_layers)
+            
             # Get the most probable class index
             top_class = max(confidences.items(), key=lambda x: x[1])[0]
             class_idx = classes.index(top_class)
+            print(f"\nSelected class for GradCAM: {top_class} (index: {class_idx})")
             
-            # Generate GradCAM for the top predicted class
             grayscale_cam = cam(
                 input_tensor=input_tensor,
                 targets=[ClassifierOutputTarget(class_idx)],
-                aug_smooth=False,  # Disable augmentation for memory efficiency
-                eigen_smooth=False  # Disable eigen smoothing for memory efficiency
+                aug_smooth=False,
+                eigen_smooth=False
             )
             grayscale_cam = grayscale_cam[0, :]
 
-            # Overlay input image with Class activations
             visualization = show_cam_on_image(org_img/255., grayscale_cam, use_rgb=True, image_weight=alpha)
             
-            # Clear CUDA cache after processing
             if torch.cuda.is_available():
                 torch.cuda.empty_cache()
                 
             return show_confidences, visualization
             
-    except torch.cuda.OutOfMemoryError:
-        if torch.cuda.is_available():
-            torch.cuda.empty_cache()
-        raise RuntimeError("GPU out of memory - Please try again with a smaller image")
-        
     except Exception as e:
+        print(f"Error in inference: {str(e)}")
         if torch.cuda.is_available():
             torch.cuda.empty_cache()
         raise e