feat: roadmap détection bots §2-9 — HTTP/2, cohérence, drift, flotte, Jaccard, ExIFFI, méta-learner, métriques

Étape 2 — Fingerprinting HTTP/2 dans le pipeline ML :
- Ajout du dictionnaire dict_browser_h2 (11 familles de navigateurs) dans 05_aggregation_tables.sql
- Ajout du CTE h2_agg et 4 features HTTP/2 dans 07_ai_features_view.sql :
  h2_settings_known, h2_pseudo_order_match, h2_ja4_coherence, h2_settings_rare
- Calcul du fingerprint_coherence_score (5 axes pondérés) dans la vue
- Ajout du 6e axe axis_h2_coherence dans browser.py (poids rééquilibrés)
- browser_h2.csv : 11 fingerprints Akamai → famille navigateur

Étape 3 — Pré-filtre de cohérence sur la baseline humaine :
- pipeline.py exclut les sessions avec fingerprint_coherence_score < seuil de la baseline d'entraînement
- FINGERPRINT_COHERENCE_THRESHOLD configurable via env (défaut 0.25)
- Log des sessions exclues pour analyse SOC

Étape 4 — Détection de drift améliorée :
- scoring.py : passage de 5 à 9 quantiles (p5…p95)
- Ajout de la divergence KL en complément du test KS
- Détection de drift adversarial (≥80% des features dérivent dans la même direction)
- Split temporel strict pour la validation

Étape 5 — Graphe bipartite JA4×ASN (§5.2) :
- fleet.py : détection de flottes via NetworkX + Louvain (imports optionnels)
- enrich_with_fleet_score() : ajout fleet_score + fleet_campaign_flag au DataFrame
- cycle.py : appel après preprocess_df avec log du nombre de sessions en flotte
- SQL migration 05_fleet_metrics_tables.sql : table fleet_detections (TTL 7j)
- Dashboard : /fleet + /api/fleet (communautés détectées) + template fleet.html

Étape 6 — Cross-domain Jaccard §5.8 :
- 12_thesis_features.sql : CTE jaccard_paths → cross_domain_path_similarity
- Signal : même chemins (/admin, /wp-login) sur plusieurs hosts = scanner

Étape 7 — ExIFFI + erreurs AE par feature :
- scoring.py : compute_exiffi_importance() par permutation, compute_ae_feature_errors()
- pipeline.py : calcul ExIFFI sur X_test, mapping index → dict pour anomalies
- build_reason() enrichi avec exiffi_top quand SHAP inactif

Étape 8 — Méta-learner pour la pondération de l'ensemble :
- scoring.py : classe MetaLearner (LogisticRegression, fallback poids fixes <1000 labels)
- Collecte des labels depuis le cycle courant (known_bots, légitimes, Anubis)
- pipeline.py : remplacement des poids fixes par MetaLearner.predict()

Étape 9 — Métriques de performance et monitoring :
- metrics.py : record_cycle_metrics() — taux anomalie, drift, corrélation, latence
- SQL migration 05_fleet_metrics_tables.sql : table ml_performance_metrics (TTL 90j)
- Dashboard : /health + /api/health + template health.html
- cycle.py : appel record_cycle_metrics en fin de cycle (Complet + Applicatif)

Tests : 36/36 bot-detector tests passent

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

services/bot-detector/bot_detector/pipeline.py

@@ -19,6 +19,8 @@ from .models import load_or_train_model, load_or_train_xgb, TrafficAutoEncoder
 from .scoring import (
     validate_features, compute_adaptive_threshold, normalize_scores,
     compute_shap_top_features, build_reason, cluster_anomalies,
+    compute_exiffi_importance, compute_ae_feature_errors, get_meta_learner,
+    FINGERPRINT_COHERENCE_THRESHOLD,
 )
 
 
@@ -56,6 +58,23 @@ def run_semi_supervised_logic(df, features, name, cycle_id, recurrence_map):
     log_info(f'[{name}]   Trafic à scorer (IF) : {len(unknown_traffic):>6}')
     log_info(f'[{name}]   Baseline ISP (human) : {len(human_baseline):>6}  (seuil min=500)')
 
+    # §3 — Exclure les sessions ISP à faible cohérence de fingerprint de la baseline humaine
+    # Ces sessions ISP avec un fingerprint incohérent sont probablement des proxies résidentiels
+    # ou des appareils mal configurés qui contamineraient la baseline.
+    if 'fingerprint_coherence_score' in human_baseline.columns:
+        low_coh = human_baseline['fingerprint_coherence_score'] < FINGERPRINT_COHERENCE_THRESHOLD
+        n_low_coh = int(low_coh.sum())
+        if n_low_coh > 0:
+            human_baseline = human_baseline[~low_coh]
+            log_info(
+                f'[{name}]   Baseline après filtre cohérence (<{FINGERPRINT_COHERENCE_THRESHOLD}) : '
+                f'{len(human_baseline):>6}  ({n_low_coh} exclues)'
+            )
+            log_decision('LOW_COHERENCE_EXCLUDED', cycle_id, name, {
+                'n_excluded': n_low_coh, 'threshold': FINGERPRINT_COHERENCE_THRESHOLD,
+                'baseline_after': len(human_baseline),
+            })
+
     # A7 — Valider les features avant tout traitement
     valid_features = validate_features(df, features, name, cycle_id)
     if valid_features is None:
@@ -130,16 +149,51 @@ def run_semi_supervised_logic(df, features, name, cycle_id, recurrence_map):
                 X_xgb = unknown_traffic[xgb_cols].replace([np.inf, -np.inf], np.nan).fillna(0)
                 xgb_probs = xgb_model.predict_proba(X_xgb.values)[:, 1]
                 unknown_traffic['xgb_prob'] = xgb_probs
-                # Méta-learner : combiner anomaly_score (EIF+AE) et xgb_prob
-                # anomaly_score déjà normalisé [0,1], xgb_prob est [0,1]
-                α_xgb = XGB_WEIGHT
-                unknown_traffic['anomaly_score'] = (
-                    (1 - α_xgb) * unknown_traffic['anomaly_score'] + α_xgb * xgb_probs
-                )
-                log_info(f"[{name}] Score combiné EIF+AE+XGB (β={α_xgb}): xgb_mean={xgb_probs.mean():.4f}")
+                log_info(f"[{name}] XGBoost : xgb_mean={xgb_probs.mean():.4f}")
         except Exception as exc:
             log_info(f"[{name}] XGBoost scoring échoué : {exc} — EIF+AE seuls.")
 
+    # §8 — Score final via MetaLearner (ou poids fixes en fallback)
+    meta_learner = get_meta_learner(name)
+    eif_norm_arr  = unknown_traffic['anomaly_score'].values.copy()
+    ae_norm_arr   = normalize_scores(-unknown_traffic['ae_recon_error'].values)
+    xgb_prob_arr  = unknown_traffic['xgb_prob'].values
+    hits_arr      = unknown_traffic.get('hits', pd.Series(1, index=unknown_traffic.index)).values
+    corr_arr      = unknown_traffic.get('correlated', pd.Series(0, index=unknown_traffic.index)).values
+
+    final_scores = meta_learner.predict(eif_norm_arr, ae_norm_arr, xgb_prob_arr,
+                                         hits_arr, corr_arr)
+    unknown_traffic['anomaly_score'] = final_scores
+
+    if meta_learner.is_trained:
+        log_info(
+            f"[{name}] §8 MetaLearner actif ({meta_learner._n_samples} labels) — "
+            f"score moyen={final_scores.mean():.4f}"
+        )
+    elif unknown_traffic['xgb_prob'].mean() > 0:
+        log_info(f"[{name}] §8 Poids fixes EIF+AE+XGB (MetaLearner pas encore entraîné).")
+
+    # §8 — Entraînement du MetaLearner sur les labels du cycle courant
+    # (accumulation progressive — activation dès MIN_SAMPLES labels)
+    try:
+        labeled_df = meta_learner.build_labels_from_df(unknown_traffic)
+        if not labeled_df.empty:
+            unknown_traffic_labeled = labeled_df.copy()
+            unknown_traffic_labeled['eif_norm'] = normalize_scores(raw_scores)
+            unknown_traffic_labeled['ae_norm'] = ae_norm_arr
+            if meta_learner.fit(unknown_traffic_labeled):
+                log_decision('META_LEARNER_TRAINED', cycle_id, name, meta_learner._weights_log)
+    except Exception as exc:
+        log_info(f"[{name}] MetaLearner entraînement échoué : {exc}")
+
+    # §7 — ExIFFI : importance de features pour l'EIF (quand SHAP désactivé)
+    exiffi_tops: list = [{}] * len(unknown_traffic)
+    if not ENABLE_SHAP and len(unknown_traffic) > 0:
+        try:
+            exiffi_tops = compute_exiffi_importance(model, X_test, scoring_features)
+        except Exception:
+            pass
+
     # A2 — Seuil adaptatif calculé sur les scores BRUTS (même échelle que ANOMALY_THRESHOLD)
     effective_threshold = compute_adaptive_threshold(raw_scores)
     log_info(f"[{name}] Seuil effectif : {effective_threshold:.4f} (statique={ANOMALY_THRESHOLD}, percentile={ANOMALY_PERCENTILE})")
@@ -207,7 +261,7 @@ def run_semi_supervised_logic(df, features, name, cycle_id, recurrence_map):
         # Log des axes moyens pour diagnostic
         ax_means = {}
         for ax in ['axis_ja4_known', 'axis_ja4_struct', 'axis_http_modern',
-                    'axis_nav_behavior', 'axis_tls_coherence']:
+                    'axis_nav_behavior', 'axis_tls_coherence', 'axis_h2_coherence']:
             col = unknown_traffic.get(ax, None)
             if col is not None:
                 ax_means[ax.replace('axis_', '')] = round(float(col[browser_legit_mask].mean()), 3)
@@ -297,9 +351,18 @@ def run_semi_supervised_logic(df, features, name, cycle_id, recurrence_map):
         # A4 — Explainabilité SHAP : top features responsables de chaque anomalie
         X_anomalies = X_test.loc[anomalies.index]
         shap_tops = compute_shap_top_features(model, X_anomalies, valid_features)
+
+        # §7 — ExIFFI : utiliser les tops ExIFFI précalculés quand SHAP est inactif
+        # Construire un mapping index → exiffi_top pour accès rapide
+        if len(exiffi_tops) == len(unknown_traffic):
+            _exiffi_map = dict(zip(unknown_traffic.index, exiffi_tops))
+            exiffi_for_anomalies = [_exiffi_map.get(idx, {}) for idx in anomalies.index]
+        else:
+            exiffi_for_anomalies = [{}] * len(anomalies)
         anomalies['reason'] = [
-            build_reason(name, row, shap)
-            for (_, row), shap in zip(anomalies.iterrows(), shap_tops)
+            build_reason(name, row, shap, exiffi)
+            for (_, row), shap, exiffi
+            in zip(anomalies.iterrows(), shap_tops, exiffi_for_anomalies)
         ]
 
         # A8 — Clustering DBSCAN pour identifier les campagnes coordonnées