Deploy backend Flask app

bot_detector_api.py

@@ -6,30 +6,32 @@ from flask import Flask, request, jsonify
 from urllib.parse import urlparse, parse_qs
 import traceback
 
+# Initialize Flask
 app = Flask("Bot detector")
 
 @app.get('/')
 def home():
     return "✅ Welcome to the Bot Prediction API!"
 
-# Load models and artifacts
+# Load models and utilities
 model = joblib.load("model.joblib")
 encoders = joblib.load("encoders.joblib")
 scaler = joblib.load("scaler.joblib")
 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 (for tree-based models)
 explainer = shap.TreeExplainer(model)
 
-# Resolve class index
-label_map = {v: i for i, v in enumerate(model.classes_)}
-BOT_CLASS_INDEX = label_map.get("Bot Attack", 1)
+def sigmoid(x):
+    return 1 / (1 + np.exp(-x))
 
 def parse_url_params(url):
     try:
-        return {k: v[0] if isinstance(v, list) else v
-                for k, v in parse_qs(urlparse(url).query).items()}
-    except:
+        query = urlparse(url).query
+        return {k: v[0] if isinstance(v, list) else v for k, v in parse_qs(query).items()}
+    except Exception:
         return {}
 
 def prepare_features(row_dict):
@@ -62,12 +64,16 @@ def prepare_features(row_dict):
     iso_score = if_model.decision_function(df_scaled)
     svm_score = svm_model.decision_function(df_scaled)
 
-    df['iso_anomaly_prob'] = 1 - float(np.clip((iso_score - iso_score.min()) / (iso_score.max() - iso_score.min() + 1e-9), 0, 1))
-    df['svm_anomaly_prob'] = 1 - float(np.clip((svm_score - svm_score.min()) / (svm_score.max() - svm_score.min() + 1e-9), 0, 1))
+    iso_prob = 1 - float(np.clip((iso_score - iso_score.min()) / (iso_score.max() - iso_score.min() + 1e-9), 0, 1))
+    svm_prob = 1 - float(np.clip((svm_score - svm_score.min()) / (svm_score.max() - svm_score.min() + 1e-9), 0, 1))
+
+    df['iso_anomaly_prob'] = iso_prob
+    df['svm_anomaly_prob'] = svm_prob
 
     return df[feature_names]
 
-def generate_shap_explanation(index, shap_values, X, class_index=BOT_CLASS_INDEX, top_n=10):
+def generate_shap_bot_attack_paragraph(index, shap_values, X, encoders=None, class_index=1, top_n=10):
+    # Handle binary vs multiclass
     if isinstance(shap_values, list):
         shap_vals = shap_values[class_index][index]
         base_val = explainer.expected_value[class_index]
@@ -75,39 +81,50 @@ def generate_shap_explanation(index, shap_values, X, class_index=BOT_CLASS_INDEX
         shap_vals = shap_values[index]
         base_val = explainer.expected_value if np.isscalar(explainer.expected_value) else explainer.expected_value[0]
 
+    # Fix: flatten SHAP values
     shap_scalar_vals = [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:
-        val = X.iloc[index][col]
+    for col in feature_names:
+        val = x_vals[col]
         try:
-            if col in encoders:
+            if encoders and col in encoders:
                 decoded_vals[col] = encoders[col].inverse_transform([int(val)])[0]
             else:
                 decoded_vals[col] = val
         except:
             decoded_vals[col] = val
 
-    feature_contribs = list(zip(X.columns, decoded_vals.values(), shap_scalar_vals))
+    feature_contribs = list(zip(feature_names, decoded_vals.values(), shap_scalar_vals))
     feature_contribs = sorted(feature_contribs, key=lambda x: abs(x[2]), reverse=True)[:top_n]
 
-    pos = [f"  - {f:20} = {v:<20} contributed {abs(s):.4f}" for f, v, s in feature_contribs if s > 0]
-    neg = [f"  - {f:20} = {v:<20} contributed {abs(s):.4f}" for f, v, s in feature_contribs if s < 0]
+    positive_impacts = []
+    negative_impacts = []
 
-    explanation = f"""
-==== SHAP Explanation for Bot Attack Classification ====
-Base SHAP value (log-odds)     : {base_val:.4f}
-Model output (log-odds)        : {final_log_odds:.4f}
+    for fname, fval, sval in feature_contribs:
+        line = f"  - {fname:20} = {str(fval):<20} contributed {abs(sval):.4f}"
+        if sval > 0:
+            positive_impacts.append(line)
+        elif sval < 0:
+            negative_impacts.append(line)
 
-🔺 Factors that INCREASED Bot Likelihood:
-{chr(10).join(pos) if pos else '  (None)'}
+    final_log_odds = base_val + np.sum(shap_scalar_vals)
+    final_pred_val = sigmoid(final_log_odds)
+
+    explanation = f"\n==== SHAP Explanation for Bot Attack Classification ====\n"
+    explanation += f"Base model log-odds       : {base_val:.4f}\n"
+    explanation += f"Final model probability   : {final_pred_val:.4f}\n\n"
 
-🔻 Factors that DECREASED Bot Likelihood:
-{chr(10).join(neg) if neg else '  (None)'}
+    if positive_impacts:
+        explanation += "🔺 Factors that INCREASED Bot Likelihood:\n" + "\n".join(positive_impacts) + "\n\n"
 
-📝 These features collectively explain the model's decision.
-"""
+    if negative_impacts:
+        explanation += "🔻 Factors that DECREASED Bot Likelihood:\n" + "\n".join(negative_impacts) + "\n\n"
+
+    explanation += "📝 These features collectively explain the model's decision.\n"
     return explanation
 
 @app.post('/v1/predict')
@@ -115,26 +132,15 @@ def predict():
     try:
         row = request.get_json()
         X = prepare_features(row)
-        
-        # Get prediction probability and predicted class
-        probs = model.predict_proba(X)[0]
-        pred_label = int(np.argmax(probs))  # 0 or 1
+        pred_prob = model.predict_proba(X)[0][1]
+        pred_label = int(pred_prob >= 0.5)
 
-        # Generate SHAP values
         shap_values = explainer.shap_values(X)
-
-        # Generate explanation for class 1
-        explanation, base_val, final_log_odds = generate_shap_explanation(
-            index=0,
-            shap_values=shap_values,
-            X=X,
-            class_index=1  # anomaly class
-        )
+        explanation = generate_shap_bot_attack_paragraph(0, shap_values, X, encoders)
 
         return jsonify({
-            "Prediction": "Bot Attack" if pred_label == 1 else "Legitimate",
-            "SHAP Base Value": round(float(base_val), 4),
-            "SHAP Predicted Value": round(float(final_log_odds), 4),
+            "Prediction": "Bot Attack" if pred_label else "Legitimate",
+            "Bot Probability": round(float(pred_prob), 4),
             "SHAP Explanation": explanation
         })