""" api.py — API de Détection de Fraude v2.0 ========================================== PFA : Système de Détection d'Anomalies dans les Transactions Financières Auteurs : Othmane & Ramzi Framework : FastAPI + Uvicorn Session 1 : POST /predict — Random Forest Session 2 : POST /explain — RF + SHAP POST /analyze — RF + Autoencoder + SHAP (pipeline complet) Usage : uvicorn api:app --host 0.0.0.0 --port 8000 --reload Docs : http://localhost:8000/docs """ from __future__ import annotations import os import time from contextlib import asynccontextmanager from typing import Any, Optional os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2" import joblib import numpy as np from fastapi import FastAPI, HTTPException from pydantic import BaseModel, Field, field_validator import shap # ───────────────────────────────────────────────────────────── # Chemins # ───────────────────────────────────────────────────────────── BASE_DIR = os.path.dirname(os.path.abspath(__file__)) MODEL_PATH = os.path.join(BASE_DIR, "models", "baseline_model.pkl") SCALER_PATH = os.path.join(BASE_DIR, "data", "scaler.pkl") AE_PATH = os.path.join(BASE_DIR, "models", "autoencoder.keras") THRESHOLD_PATH = os.path.join(BASE_DIR, "models", "threshold.pkl") N_FEATURES = 30 FEATURE_NAMES = [f"V{i}" for i in range(1, 29)] + ["Time", "Amount"] # ───────────────────────────────────────────────────────────── # Ressources globales (chargées une seule fois) # ───────────────────────────────────────────────────────────── resources: dict[str, Any] = { "rf_model": None, "scaler": None, "ae_model": None, "threshold": None, "explainer": None, "ae_ready": False, } @asynccontextmanager async def lifespan(app: FastAPI): """Charge tous les modèles au démarrage.""" print("Demarrage de l'API v2.0 — Chargement des modeles...") # ── Random Forest (obligatoire) ─────────────────────────── if not os.path.exists(MODEL_PATH): raise RuntimeError(f"Modele introuvable : {MODEL_PATH} → python train_baseline.py") resources["rf_model"] = joblib.load(MODEL_PATH) print(f" [OK] Random Forest charge") # ── Scaler (obligatoire) ────────────────────────────────── if not os.path.exists(SCALER_PATH): raise RuntimeError(f"Scaler introuvable : {SCALER_PATH} → python data_prep.py") resources["scaler"] = joblib.load(SCALER_PATH) print(f" [OK] Scaler charge") # ── SHAP TreeExplainer ──────────────────────────────────── resources["explainer"] = shap.TreeExplainer(resources["rf_model"]) print(f" [OK] SHAP TreeExplainer pret") # ── Autoencoder (optionnel — Session 2) ─────────────────── if os.path.exists(AE_PATH) and os.path.exists(THRESHOLD_PATH): try: import tensorflow as tf resources["ae_model"] = tf.keras.models.load_model(AE_PATH) resources["threshold"] = joblib.load(THRESHOLD_PATH) resources["ae_ready"] = True print(f" [OK] Autoencoder charge (seuil = {resources['threshold']:.6f})") except Exception as e: print(f" [!] Autoencoder non disponible : {e}") else: print(f" [!] Autoencoder non trouve — /analyze utilisera RF seul") print(" API prete sur http://localhost:8000/docs\n") yield for k in resources: resources[k] = None print("Arret de l'API.") # ───────────────────────────────────────────────────────────── # Application # ───────────────────────────────────────────────────────────── app = FastAPI( title="API Detection de Fraude — PFA", description=( "Systeme IA hybride de detection d'anomalies dans les transactions financieres.\n\n" "**Auteurs** : Othmane & Ramzi — 4eme annee IA/Data\n\n" "**Session 1** : Random Forest Baseline\n" "**Session 2** : Autoencoder + SHAP XAI\n" "**Dataset** : Kaggle Credit Card Fraud Detection" ), version="2.0.0", lifespan=lifespan, ) # ───────────────────────────────────────────────────────────── # Schémas Pydantic # ───────────────────────────────────────────────────────────── class TransactionRequest(BaseModel): """ Payload d'une transaction. Features dans l'ordre : [V1, V2, ..., V28, Time (secondes), Amount (euros)] """ features: list[float] = Field( ..., min_length=N_FEATURES, max_length=N_FEATURES, description="30 features : V1-V28 + Time (s) + Amount (EUR)", example=[ -1.36, -0.07, 2.54, 1.38, -0.34, 0.46, 0.24, 0.10, 0.36, 0.09, -0.55, -0.62, -0.99, -0.31, 1.47, -0.47, 0.21, 0.03, 0.40, 0.25, -0.02, 0.28, -0.11, 0.07, 0.13, -0.19, 0.13, -0.02, 0.0, 149.62, ], ) @field_validator("features") @classmethod def check_length(cls, v): if len(v) != N_FEATURES: raise ValueError(f"Attendu {N_FEATURES} features, recu {len(v)}") return v class FeatureContribution(BaseModel): rank: int feature: str shap_value: float feature_value: float direction: str class PredictionResponse(BaseModel): prediction: int label: str probability_fraud: float confidence: str latency_ms: float class ExplainResponse(BaseModel): prediction: int label: str probability_fraud: float confidence: str top_features: list[FeatureContribution] base_value: float latency_ms: float class AnalyzeResponse(BaseModel): # Prédictions rf_prediction: int rf_probability: float ae_prediction: Optional[int] ae_error: Optional[float] ae_threshold: Optional[float] final_prediction: int label: str confidence: str # Explication top_features: list[FeatureContribution] # Méta ae_available: bool latency_ms: float class HealthResponse(BaseModel): model_config = {"protected_namespaces": ()} status: str model_loaded: bool ae_available: bool version: str # ───────────────────────────────────────────────────────────── # Utilitaires internes # ───────────────────────────────────────────────────────────── def _normalize(features: np.ndarray) -> np.ndarray: """Normalise Time et Amount avec le scaler, laisse V1-V28 intacts.""" feat = features.copy() ta_scaled = resources["scaler"].transform(feat[:, 28:30]) feat[:, 28] = ta_scaled[:, 0] feat[:, 29] = ta_scaled[:, 1] return feat def _get_confidence(prob: float) -> str: if prob >= 0.8: return "Tres elevee" if prob >= 0.5: return "Elevee" if prob >= 0.2: return "Moderee" return "Faible" def _shap_top_features(X: np.ndarray, top_n: int = 5) -> tuple[list, float]: """Retourne top N features SHAP + base_value.""" shap_vals_all = resources["explainer"].shap_values(X) if isinstance(shap_vals_all, list): sv = shap_vals_all[1][0] else: sv = shap_vals_all[0, :, 1] if len(shap_vals_all.shape) == 3 else shap_vals_all[0] base = (resources["explainer"].expected_value[1] if isinstance(resources["explainer"].expected_value, (list, np.ndarray)) else resources["explainer"].expected_value) sorted_idx = np.argsort(np.abs(sv))[::-1] top = [] for rank, idx in enumerate(sorted_idx[:top_n]): i = int(idx) top.append(FeatureContribution( rank=rank + 1, feature=FEATURE_NAMES[i], shap_value=round(float(sv[i]), 6), feature_value=round(float(X[0, i]), 6), direction="Augmente risque fraude" if sv[i] > 0 else "Reduit risque fraude", )) return top, float(base) # ───────────────────────────────────────────────────────────── # Routes # ───────────────────────────────────────────────────────────── @app.get("/health", response_model=HealthResponse, tags=["Monitoring"]) async def health_check(): """Statut de l'API et des modèles chargés.""" return HealthResponse( status="healthy" if resources["rf_model"] else "degraded", model_loaded=resources["rf_model"] is not None, ae_available=resources["ae_ready"], version="2.0.0", ) @app.post( "/predict", response_model=PredictionResponse, summary="Prediction (Random Forest)", tags=["Session 1 — Detection"], ) async def predict(request: TransactionRequest) -> PredictionResponse: """ **Session 1** — Prédit si une transaction est frauduleuse via Random Forest. Retourne la classe (0/1), la probabilité de fraude et le niveau de confiance. """ if resources["rf_model"] is None: raise HTTPException(503, "Modele RF non disponible") t0 = time.perf_counter() X = np.array(request.features, dtype=np.float64).reshape(1, -1) X = _normalize(X) pred = int(resources["rf_model"].predict(X)[0]) prob = float(resources["rf_model"].predict_proba(X)[0, 1]) latency = round((time.perf_counter() - t0) * 1000, 3) return PredictionResponse( prediction=pred, label="Fraude" if pred == 1 else "Legitime", probability_fraud=round(prob, 6), confidence=_get_confidence(prob), latency_ms=latency, ) @app.post( "/explain", response_model=ExplainResponse, summary="Prediction + Explication SHAP", tags=["Session 2 — XAI"], ) async def explain(request: TransactionRequest) -> ExplainResponse: """ **Session 2** — Prédit + explique via SHAP TreeExplainer. Retourne les **5 features** qui ont le plus influencé la décision, avec leur valeur SHAP (positive = pousse vers fraude, négative = légitime). """ if resources["rf_model"] is None: raise HTTPException(503, "Modele RF non disponible") t0 = time.perf_counter() X = np.array(request.features, dtype=np.float64).reshape(1, -1) X = _normalize(X) pred = int(resources["rf_model"].predict(X)[0]) prob = float(resources["rf_model"].predict_proba(X)[0, 1]) top_features, base_val = _shap_top_features(X) latency = round((time.perf_counter() - t0) * 1000, 3) return ExplainResponse( prediction=pred, label="Fraude" if pred == 1 else "Legitime", probability_fraud=round(prob, 6), confidence=_get_confidence(prob), top_features=top_features, base_value=round(base_val, 6), latency_ms=latency, ) @app.post( "/analyze", response_model=AnalyzeResponse, summary="Analyse Complete (RF + Autoencoder + SHAP)", tags=["Session 2 — XAI"], ) async def analyze(request: TransactionRequest) -> AnalyzeResponse: """ **Session 2** — Pipeline complet de détection et d'explication. 1. **Random Forest** : détection supervisée (post-SMOTE) 2. **Autoencoder** : détection par anomalie de reconstruction (si disponible) 3. **Règle de fusion** : fraude si RF **OU** Autoencoder dit fraude 4. **SHAP** : explication des 5 features les plus influentes (RF) C'est la route principale du système hybride. """ if resources["rf_model"] is None: raise HTTPException(503, "Modele RF non disponible") t0 = time.perf_counter() X = np.array(request.features, dtype=np.float64).reshape(1, -1) X = _normalize(X) # ── Random Forest ────────────────────────────────────────── rf_pred = int(resources["rf_model"].predict(X)[0]) rf_prob = float(resources["rf_model"].predict_proba(X)[0, 1]) # ── Autoencoder ─────────────────────────────────────────── ae_pred = ae_err = ae_thr = None if resources["ae_ready"] and resources["ae_model"] is not None: reconstruction = resources["ae_model"].predict(X, verbose=0) ae_err = float(np.mean(np.power(X - reconstruction, 2))) ae_thr = float(resources["threshold"]) ae_pred = int(ae_err > ae_thr) # ── Fusion OR ───────────────────────────────────────────── if ae_pred is not None: final_pred = int(max(rf_pred, ae_pred)) else: final_pred = rf_pred # Probabilité finale : max des deux signaux final_prob = rf_prob if ae_pred is not None and ae_thr and ae_thr > 0: ae_prob = min(ae_err / (ae_thr * 3), 1.0) final_prob = max(rf_prob, ae_prob) # ── SHAP ────────────────────────────────────────────────── top_features, _ = _shap_top_features(X) latency = round((time.perf_counter() - t0) * 1000, 3) return AnalyzeResponse( rf_prediction=rf_pred, rf_probability=round(rf_prob, 6), ae_prediction=ae_pred, ae_error=round(ae_err, 6) if ae_err is not None else None, ae_threshold=round(ae_thr, 6) if ae_thr is not None else None, final_prediction=final_pred, label="Fraude" if final_pred == 1 else "Legitime", confidence=_get_confidence(final_prob), top_features=top_features, ae_available=resources["ae_ready"], latency_ms=latency, ) # ───────────────────────────────────────────────────────────── # Entry point # ───────────────────────────────────────────────────────────── if __name__ == "__main__": import uvicorn uvicorn.run("api:app", host="0.0.0.0", port=8000, reload=True, log_level="info")