Deploy backend Flask app

bot_detector_api.py

@@ -13,15 +13,16 @@ app = Flask("Bot detector")
 def home():
     return "✅ Welcome to the Bot Prediction API!"
 
-# Load model artifacts
+# Load all model artifacts
 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")
+iso_scaler = joblib.load("iso_scaler.joblib")
+svm_scaler = joblib.load("svm_scaler.joblib")
 
-# SHAP explainer
 explainer = shap.TreeExplainer(model)
 
 def parse_url_params(url):
@@ -38,6 +39,7 @@ def prepare_features(row_dict):
         'device': row_dict.get('device', 'unknown'),
         'd': row_dict.get('d', '')
     }
+
     query_params = parse_url_params(base['d'])
     combined = {**base, **query_params}
     combined.pop('d', None)
@@ -58,34 +60,32 @@ def prepare_features(row_dict):
             df[col] = pd.to_numeric(df[col], errors='coerce').fillna(0)
 
     df_scaled = scaler.transform(df)
-    iso_score = if_model.decision_function(df_scaled)
-    svm_score = svm_model.decision_function(df_scaled)
 
-    # Compute anomaly scores directly
-    iso_score = if_model.decision_function(df_scaled)[0]
-    svm_score = svm_model.decision_function(df_scaled)[0]
+    iso_score = if_model.decision_function(df_scaled).reshape(-1, 1)
+    iso_prob = 1 - iso_scaler.transform(iso_score)[0][0]
+
+    svm_score = svm_model.decision_function(df_scaled).reshape(-1, 1)
+    svm_prob = 1 - svm_scaler.transform(svm_score)[0][0]
 
-    # Invert to get anomaly-like probability (higher = more anomalous)
-    df['iso_anomaly_prob'] = round(float(-iso_score), 4)
-    df['svm_anomaly_prob'] = round(float(-svm_score), 4)
+    df['iso_anomaly_prob'] = iso_prob
+    df['svm_anomaly_prob'] = svm_prob
 
     return df[feature_names]
 
 def generate_shap_explanation(index, shap_values, X, encoders=None, class_index=1, top_n=10):
-    # Extract SHAP values
-    if isinstance(shap_values, list):
+    if isinstance(shap_values, list):  # Tree explainer returns list for multiclass
         shap_vals = shap_values[class_index][index]
-        base_val = float(explainer.expected_value[class_index])
+        base_val = explainer.expected_value[class_index]
     else:
         shap_vals = shap_values[index]
-        base_val = float(explainer.expected_value if np.isscalar(explainer.expected_value) else explainer.expected_value[0])
-
-    # Convert SHAP values to float scalars
-    shap_scalar_vals = [float(s[0]) if isinstance(s, np.ndarray) else float(s) for s in shap_vals]
+        base_val = explainer.expected_value if np.isscalar(explainer.expected_value) else explainer.expected_value[class_index]
 
     x_vals = X.iloc[index]
     feature_names = X.columns
 
+    # Flatten scalar values
+    shap_scalar_vals = [float(s[0]) if isinstance(s, np.ndarray) else float(s) for s in shap_vals]
+
     decoded_vals = {}
     for col in feature_names:
         val = x_vals[col]
@@ -97,34 +97,28 @@ def generate_shap_explanation(index, shap_values, X, encoders=None, class_index=
         except:
             decoded_vals[col] = val
 
-    # Top contributing features
     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]
 
-    positive_impacts = []
-    negative_impacts = []
-
+    pos, neg = [], []
     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)
+        line = f"  - {fname:20} = {str(fval):<20} contributed {sval:.4f}"
+        if sval > 0: pos.append(line)
+        elif sval < 0: neg.append(line)
 
-    final_log_odds = float(base_val + np.sum(shap_scalar_vals))
+    final_log_odds = base_val + sum(shap_scalar_vals)
 
-    # Explanation text
-    explanation = f"\n==== SHAP Explanation for Bot Attack Classification ====\n"
+    explanation = f"==== SHAP Explanation for Bot Attack Classification ====\n\n"
     explanation += f"Base value (log-odds for class 1) : {base_val:.4f}\n"
     explanation += f"Predicted log-odds (class 1)      : {final_log_odds:.4f}\n\n"
 
-    if positive_impacts:
-        explanation += "🔺 Factors that INCREASED Bot Likelihood:\n" + "\n".join(positive_impacts) + "\n\n"
-    if negative_impacts:
-        explanation += "🔻 Factors that DECREASED Bot Likelihood:\n" + "\n".join(negative_impacts) + "\n\n"
+    if pos:
+        explanation += "🔺 Factors that INCREASED Bot Likelihood:\n" + "\n".join(pos) + "\n\n"
+    if neg:
+        explanation += "🔻 Factors that DECREASED Bot Likelihood:\n" + "\n".join(neg) + "\n\n"
 
     explanation += "📝 These features collectively explain the model's decision.\n"
-    return base_val, final_log_odds, explanation
+    return explanation, base_val, final_log_odds
 
 @app.post('/v1/predict')
 def predict():
@@ -133,16 +127,15 @@ def predict():
         X = prepare_features(row)
 
         probs = model.predict_proba(X)[0]
-        class_index = list(model.classes_).index(1)
-        pred_label = model.predict(X)[0]
+        pred_label = model.classes_[np.argmax(probs)]
 
         shap_values = explainer.shap_values(X)
-        base_val, final_log_odds, explanation = generate_shap_explanation(0, shap_values, X, encoders, class_index)
+        explanation, base_val, final_log_odds = generate_shap_explanation(0, shap_values, X, encoders)
 
         return jsonify({
             "Prediction": "Bot Attack" if pred_label == 1 else "Legitimate",
-            "SHAP Base Value": round(base_val, 4),
-            "SHAP Predicted Value": round(final_log_odds, 4),
+            "SHAP Base Value": round(float(base_val), 4),
+            "SHAP Predicted Value": round(float(final_log_odds), 4),
             "SHAP Explanation": explanation
         })