Deploy backend Flask app

bot_detector_api.py

@@ -6,13 +6,14 @@ from flask import Flask, request, jsonify
 from urllib.parse import urlparse, parse_qs
 import traceback
 
+# Initialize Flask app
 app = Flask("Bot detector")
 
 @app.get('/')
 def home():
     return "✅ Welcome to the Bot Prediction API!"
 
-# Load model and preprocessing tools
+# Load model and artifacts
 model = joblib.load("model.joblib")
 encoders = joblib.load("encoders.joblib")
 scaler = joblib.load("scaler.joblib")
@@ -20,7 +21,7 @@ if_model = joblib.load("best_if_model.joblib")
 svm_model = joblib.load("best_svm_model.joblib")
 feature_names = joblib.load("feature_names.joblib")
 
-# SHAP Explainer
+# SHAP explainer
 explainer = shap.TreeExplainer(model)
 
 def parse_url_params(url):
@@ -69,54 +70,55 @@ def prepare_features(row_dict):
     return df[feature_names]
 
 def generate_shap_explanation(index, shap_values, X, encoders=None, top_n=10):
-    # Get SHAP values for the instance
     if isinstance(shap_values, list):
-        shap_vals = shap_values[1][index]  # Class 1 (Bot Attack)
+        shap_vals = shap_values[1][index]
         base_val = explainer.expected_value[1]
     else:
         shap_vals = shap_values[index]
-        base_val = explainer.expected_value if np.isscalar(explainer.expected_value) else explainer.expected_value[0]
+        base_val = explainer.expected_value
 
     # Flatten SHAP values
-    flat_vals = [float(v[0]) if isinstance(v, (np.ndarray, list)) else float(v) for v in shap_vals]
+    shap_scalar_vals = np.array([float(s[0]) if isinstance(s, np.ndarray) else float(s) for s in shap_vals])
+    final_log_odds = base_val + np.sum(shap_scalar_vals)
 
     x_vals = X.iloc[index]
+    feature_names = X.columns
+
     decoded_vals = {}
-    for col in X.columns:
+    for col in feature_names:
+        val = x_vals[col]
         try:
             if encoders and col in encoders:
-                decoded_vals[col] = encoders[col].inverse_transform([int(x_vals[col])])[0]
+                decoded_vals[col] = encoders[col].inverse_transform([int(val)])[0]
             else:
-                decoded_vals[col] = x_vals[col]
+                decoded_vals[col] = val
         except:
-            decoded_vals[col] = x_vals[col]
+            decoded_vals[col] = val
 
-    # Top contributing features
+    # Pair features with SHAP values and sort
     feature_contribs = sorted(
-        zip(X.columns, decoded_vals.values(), flat_vals),
-        key=lambda x: abs(x[2]),
-        reverse=True
+        zip(feature_names, decoded_vals.values(), shap_scalar_vals),
+        key=lambda x: abs(x[2]), reverse=True
     )[:top_n]
 
-    positive = [f"  🔺 {k:15} = {v} contributed +{abs(s):.4f}" for k, v, s in feature_contribs if s > 0]
-    negative = [f"  🔻 {k:15} = {v} contributed -{abs(s):.4f}" for k, v, s in feature_contribs if s < 0]
-
-    final_log_odds = base_val + sum(flat_vals)
+    pos_lines = [f"  - {f:20} = {str(v):<15} → +{abs(s):.4f}" for f, v, s in feature_contribs if s > 0]
+    neg_lines = [f"  - {f:20} = {str(v):<15} → -{abs(s):.4f}" for f, v, s in feature_contribs if s < 0]
 
-    paragraph = f"""
+    text = f"""
 ==== SHAP Explanation for Bot Attack Classification ====
 
 Base value (log-odds for class 1) : {base_val:.4f}
 Predicted log-odds (class 1)      : {final_log_odds:.4f}
 
-"""
-    if positive:
-        paragraph += "Top factors INCREASING bot likelihood:\n" + "\n".join(positive) + "\n\n"
-    if negative:
-        paragraph += "Top factors DECREASING bot likelihood:\n" + "\n".join(negative) + "\n\n"
+🔺 Features INCREASING likelihood of Bot Attack:
+{chr(10).join(pos_lines) or '  - None'}
+
+🔻 Features DECREASING likelihood of Bot Attack:
+{chr(10).join(neg_lines) or '  - None'}
 
-    paragraph += "📝 These factors combined explain the model's prediction for this session."
-    return paragraph, base_val, final_log_odds
+📝 These features collectively explain the model's decision.
+"""
+    return text, base_val, final_log_odds
 
 @app.post('/v1/predict')
 def predict():
@@ -124,18 +126,16 @@ def predict():
         row = request.get_json()
         X = prepare_features(row)
 
-        # Predict probabilities and class
-        probs = model.predict_proba(X)[0]
-        pred_class = int(probs[1] >= 0.5)
+        shap_values = explainer.shap_values(X)
+        explanation, base_val, final_log_odds = generate_shap_explanation(0, shap_values, X, encoders)
 
-        # SHAP explanation
-        shap_vals = explainer.shap_values(X)
-        explanation, base_val, final_log_odds = generate_shap_explanation(0, shap_vals, X, encoders)
+        # Decide based on log-odds
+        pred_class = int(final_log_odds >= base_val)
 
         return jsonify({
             "Prediction": "Bot Attack" if pred_class else "Legitimate",
-            "SHAP Base Value": round(float(base_val), 4),
-            "SHAP Predicted Value": round(float(final_log_odds), 4),
+            "SHAP Base Value": round(base_val, 4),
+            "SHAP Predicted Value": round(final_log_odds, 4),
             "SHAP Explanation": explanation
         })