Completely rewrite detect_warning_lamp with robust tensor handling and debugging

app.py

@@ -41,27 +41,78 @@ def detect_warning_lamp(image, history: list[tuple[str, str]], system_message):
     Returns:
         Updated chat history with prediction results
     """
+    if image is None:
+        history.append((None, "Please upload an image first."))
+        return history
+        
     try:
+        # Print debug info
+        print(f"Image type: {type(image)}")
+        
         # Convert PIL image to FastAI compatible format
         img = PILImage(image)
+        print(f"Converted to PILImage: {type(img)}")
         
         # Get model prediction
+        print("Running prediction...")
         pred_class, pred_idx, probs = learn_inf.predict(img)
         
+        # Print debug info about prediction results
+        print(f"Prediction class type: {type(pred_class)}, value: {pred_class}")
+        print(f"Prediction index type: {type(pred_idx)}, value: {pred_idx}")
+        print(f"Probabilities type: {type(probs)}, shape: {probs.shape if hasattr(probs, 'shape') else 'no shape'}")
+        
+        # Safely convert tensors to Python types
+        try:
+            # Handle pred_class (could be string or tensor)
+            if hasattr(pred_class, 'item'):
+                pred_class_str = str(pred_class.item())
+            else:
+                pred_class_str = str(pred_class)
+                
+            # Handle pred_idx (convert tensor to int)
+            if hasattr(pred_idx, 'item'):
+                pred_idx_int = pred_idx.item()
+            else:
+                pred_idx_int = int(pred_idx)
+                
+            # Get confidence score for predicted class
+            if hasattr(probs[pred_idx_int], 'item'):
+                confidence = probs[pred_idx_int].item()
+            else:
+                confidence = float(probs[pred_idx_int])
+                
+            print(f"Converted values - class: {pred_class_str}, index: {pred_idx_int}, confidence: {confidence}")
+        except Exception as conversion_error:
+            print(f"Error during tensor conversion: {conversion_error}")
+            raise
+        
         # Format the prediction results
-        confidence = float(probs[int(pred_idx)])  # Convert to float for better formatting
-        response = f"Detected Warning Lamp: {pred_class}\nConfidence: {confidence:.2%}"
+        response = f"Detected Warning Lamp: {pred_class_str}\nConfidence: {confidence:.2%}"
         
         # Add probabilities for all classes
         response += "\n\nProbabilities for all classes:"
-        for i, (cls, prob) in enumerate(zip(learn_inf.dls.vocab, probs)):
-            response += f"\n- {cls}: {float(prob):.2%}"
+        
+        # Safely iterate through probabilities
+        for i, cls in enumerate(learn_inf.dls.vocab):
+            try:
+                if hasattr(probs[i], 'item'):
+                    prob_value = probs[i].item()
+                else:
+                    prob_value = float(probs[i])
+                response += f"\n- {cls}: {prob_value:.2%}"
+            except Exception as prob_error:
+                print(f"Error processing probability for class {cls}: {prob_error}")
+                response += f"\n- {cls}: Error"
             
         # Update chat history
         history.append((None, response))
         return history
     except Exception as e:
         error_msg = f"Error processing image: {str(e)}"
+        print(f"Exception in detect_warning_lamp: {e}")
+        import traceback
+        traceback.print_exc()
         history.append((None, error_msg))
         return history