Update app.py

app.py

@@ -80,26 +80,56 @@ def sequence_to_kmer_vector(sequence: str, k: int = 4) -> np.ndarray:
     return vec
 
 ###############################################################################
-# 3. SHAP-VALUE (ABLATION) CALCULATION
+# 3. SHAP-VALUE CALCULATION
 ###############################################################################
 
+import shap
+
 def calculate_shap_values(model, x_tensor):
     model.eval()
+    device = next(model.parameters()).device
+    
+    # Create background dataset (baseline)
+    background = torch.zeros((10, x_tensor.shape[1]), device=device)
+    
+    try:
+        # Try using DeepExplainer (efficient for neural networks)
+        explainer = shap.DeepExplainer(model, background)
+        
+        # Calculate SHAP values
+        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
+        def model_predict(x):
+            with torch.no_grad():
+                tensor_x = torch.FloatTensor(x).to(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]))
+        
+        # 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
     with torch.no_grad():
-        baseline_output = model(x_tensor)
-        baseline_probs = torch.softmax(baseline_output, dim=1)
-        baseline_prob = baseline_probs[0, 1].item()  # Prob of 'human'
-        shap_values = []
-        x_zeroed = x_tensor.clone()
-        for i in range(x_tensor.shape[1]):
-            original_val = x_zeroed[0, i].item()
-            x_zeroed[0, i] = 0.0
-            output = model(x_zeroed)
-            probs = torch.softmax(output, dim=1)
-            prob = probs[0, 1].item()
-            shap_values.append(baseline_prob - prob)
-            x_zeroed[0, i] = original_val
-    return np.array(shap_values), baseline_prob
+        output = model(x_tensor)
+        probs = torch.softmax(output, dim=1)
+        prob_human = probs[0, 1].item()
+    
+    return np.array(shap_values), prob_human
 
 ###############################################################################
 # 4. PER-BASE SHAP AGGREGATION