Update app.py

app.py

@@ -89,41 +89,41 @@ def calculate_shap_values(model, x_tensor):
     model.eval()
     device = next(model.parameters()).device
     
-    # Create background dataset (baseline)
+    # Create a background dataset (baseline) with a sufficient number of samples
     background = np.zeros((300, x_tensor.shape[1]))
     
     try:
         # Try using DeepExplainer (efficient for neural networks)
         explainer = shap.DeepExplainer(model, background)
-        
-        # Calculate SHAP values
+        # Calculate SHAP values using DeepExplainer
         shap_values_all = explainer.shap_values(x_tensor)
-        
         # Get SHAP values for human class (index 1)
         shap_values = shap_values_all[1][0]
-        
     except Exception as e:
         print(f"DeepExplainer failed, falling back to KernelExplainer: {str(e)}")
         
-        # Create model wrapper function
+        # Define a wrapper function to ensure proper input shape
         def model_predict(x):
+            # Ensure x is a numpy array and has at least 2 dimensions
+            if not isinstance(x, np.ndarray):
+                x = np.array(x)
+            if x.ndim == 1:
+                x = np.expand_dims(x, axis=0)
             with torch.no_grad():
-                tensor_x = torch.FloatTensor(x).to(device)
+                tensor_x = torch.tensor(x, dtype=torch.float, device=device)
                 output = model(tensor_x)
                 probs = torch.softmax(output, dim=1)[:, 1]  # Human probability
                 return probs.cpu().numpy()
         
-        # Create baseline distribution
-        background = np.zeros((1, x_tensor.shape[1]))
+        # Re-create a larger background for KernelExplainer if needed
+        background = np.zeros((300, x_tensor.shape[1]))
         
         # Use KernelExplainer as fallback
         explainer = shap.KernelExplainer(model_predict, background)
-        
-        # Calculate SHAP values
         x_numpy = x_tensor.cpu().numpy()
         shap_values = explainer.shap_values(x_numpy, nsamples=100)
     
-    # Get human probability
+    # Get human probability from model prediction
     with torch.no_grad():
         output = model(x_tensor)
         probs = torch.softmax(output, dim=1)