Deploy API connected to MLflow

.gitignore

@@ -0,0 +1,16 @@
+# Ignorer le dossier de cache Python
+__pycache__/
+*.pyc
+
+# Ignorer les modèles locaux
+models/
+*.json
+*.xgb
+
+# Ignorer l'environnement virtuel
+venv/
+env/
+.env/
+
+# Ignorer les secrets locaux
+.env

Dockerfile

@@ -0,0 +1,29 @@
+# 1. Utiliser une image Python légère
+FROM python:3.9-slim
+
+# 2. Définir le répertoire de travail
+WORKDIR /app
+
+# 3. Installer les dépendances système nécessaires
+RUN apt-get update && apt-get install -y \
+    libgomp1 \
+    && rm -rf /var/lib/apt/lib/lists/*
+
+# 4. Créer un utilisateur non-root
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+# 5. Copier les fichiers de dépendances et installer
+COPY --chown=user requirements.txt .
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+# 6. Copier tout le reste du code et les modèles
+COPY --chown=user . .
+
+# 7. Exposer le port par défaut de Hugging Face
+EXPOSE 7860
+
+# 8. Lancer l'application avec Uvicorn
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1,129 @@
+import os
+import json
+import numpy as np
+import xgboost as xgb
+import pandas as pd
+import mlflow.xgboost
+from fastapi import FastAPI, HTTPException, Body
+from dotenv import load_dotenv
+from processing import prepare_input, calculate_survival_risk, map_statut_expert, get_sigma
+
+# --- 1. CONFIGURATION MLFLOW ---
+load_dotenv()
+
+# MLflow utilise automatiquement MLFLOW_TRACKING_USERNAME et MLFLOW_TRACKING_PASSWORD
+mlflow.set_tracking_uri(os.getenv("MLFLOW_TRACKING_URI"))
+
+RUN_ID = "674d07aab0b0493a838310da47c71a95"
+MODEL_URI = f"runs:/{RUN_ID}/model"
+
+# --- 2. INITIALISATION DE L'API ---
+app = FastAPI(
+    title="Business Risk API - Test MLflow Remote",
+    description="API de simulation utilisant un modèle stocké sur un serveur MLflow distant.",
+    version="3.5.0"
+)
+
+# Variables globales pour le modèle et Sigma
+model = None
+SIGMA = None
+
+# Dans ton bloc startup, ajoute ces prints pour débugger :
+@app.on_event("startup")
+async def load_model():
+    global model, SIGMA
+    try:
+        print(f"🚀 Connexion à MLflow : {os.getenv('MLFLOW_TRACKING_URI')}")
+        
+        # 1. On charge l'objet
+        loaded_model = mlflow.xgboost.load_model(MODEL_URI)
+        
+        # 2. CORRECTION ICI : 
+        # Si c'est déjà un Booster, on l'utilise directement.
+        # Si c'est un wrapper XGBModel, on appelle get_booster().
+        if isinstance(loaded_model, xgb.Booster):
+            model = loaded_model
+        else:
+            model = loaded_model.get_booster()
+            
+        # 3. On extrait Sigma
+        SIGMA = get_sigma(model)
+        
+        print(f"✅ Modèle chargé avec succès (Sigma: {round(SIGMA, 4)})")
+    except Exception as e:
+        print(f"❌ Erreur lors du chargement : {e}")
+
+# --- 3. ROUTES ---
+
+@app.get("/")
+def home():
+    return {
+        "status": "online",
+        "model_source": "MLflow Remote",
+        "run_id": RUN_ID
+    }
+
+@app.post("/predict")
+async def predict(
+    data: dict = Body(..., example={
+        "age_estime": 4.5,
+        "Tranche_effectif_num": 3,
+        "code_departement": "26",
+        "code_ape": "43",
+        "categorie_juridique": "5499",
+        "is_ess": 0
+    })
+):
+    """
+    Simule le risque de fermeture d'une entreprise.
+    
+    Exemple fourni :
+    - Age : 4.5 ans
+    - Effectif : Tranche 3
+    - Localisation : Drôme (26)
+    - Secteur : Construction (43)
+    """
+    if model is None:
+        raise HTTPException(status_code=503, detail="Modèle non chargé")
+
+    try:
+        # 1. Préparation des données (Mapping APE 2 chiffres inclus)
+        dmatrix = prepare_input(data)
+        
+        # 2. Inférence (Score MU)
+        mu = float(model.predict(dmatrix)[0])
+        
+        # 3. Calcul des probabilités de fermeture aux horizons 1, 2 et 3 ans
+        p1 = calculate_survival_risk(mu, 1, SIGMA)
+        p2 = calculate_survival_risk(mu, 2, SIGMA)
+        p3 = calculate_survival_risk(mu, 3, SIGMA)
+        
+        return {
+            "diagnostic": {
+                "profil_global": map_statut_expert(p2),
+                "indice_confiance_mu": round(mu, 4)
+            },
+            "probabilites_fermeture": {
+                "1_an": f"{p1}%",
+                "2_ans": f"{p2}%",
+                "3_ans": f"{p3}%"
+            },
+            "entrees_reçues": {
+                "division_ape": data.get("code_ape"),
+                "departement": data.get("code_departement")
+            },
+            "metadonnees": {
+                "run_id": RUN_ID,
+                "sigma_utilise": round(SIGMA, 6)
+            }
+        }
+
+    except Exception as e:
+        raise HTTPException(
+            status_code=500, 
+            detail=f"Erreur interne lors du calcul : {str(e)}"
+        )
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

processing.py

@@ -0,0 +1,87 @@
+import pandas as pd
+import numpy as np
+import xgboost as xgb
+import json
+
+# --- 1. DICTIONNAIRE DE MAPPING DIVISION (2 chiffres) -> SECTION (Ton Modèle) ---
+# Ce dictionnaire permet à l'utilisateur de saisir "56" et au modèle de recevoir "Hébergement et restauration"
+NAF_TO_SECTION = {
+    "01": "Agriculture, sylviculture et pêche", "02": "Agriculture, sylviculture et pêche", "03": "Agriculture, sylviculture et pêche",
+    "10": "Industrie manufacturière", "11": "Industrie manufacturière", "12": "Industrie manufacturière",
+    "41": "Construction", "42": "Construction", "43": "Travaux de construction spécialisés",
+    "45": "Commerce", "46": "Commerce", "47": "Commerce de détail, à l’exception des automobi...",
+    "49": "Transports et entreposage", "55": "Hébergement et restauration", "56": "Hébergement et restauration",
+    "58": "Information et communication", "61": "Information et communication",
+    "64": "Activités financières et d'assurance", "66": "Activités auxiliaires de services financiers e...",
+    "68": "Activités immobilières",
+    "69": "Activités juridiques, comptables, de gestion, d'études de conseil",
+    "71": "Activités d'architecture et d'ingénierie",
+    "85": "Enseignement",
+    "86": "Santé humaine et action sociale",
+    "96": "Autres services personnels"
+}
+
+# Chargement des colonnes exactes du modèle
+with open('models/features_config.json', 'r') as f:
+    FEATURES = json.load(f)
+
+def get_sigma(model):
+    """Extrait le paramètre scale (sigma) du JSON du modèle XGBoost"""
+    config = json.loads(model.save_config())
+    def find_key(obj, key):
+        if isinstance(obj, dict):
+            for k, v in obj.items():
+                if k == key: return v
+                res = find_key(v, key)
+                if res is not None: return res
+        elif isinstance(obj, list):
+            for item in obj:
+                res = find_key(item, key)
+                if res is not None: return res
+        return None
+    scale = find_key(config, 'aft_loss_distribution_scale')
+    return float(scale) if scale else 0.8
+
+def calculate_survival_risk(mu, horizon, s):
+    """Formule de survie pour distribution Logistique (AFT)"""
+    z = (np.log(horizon) - mu) / s
+    z = np.clip(z, -50, 50)
+    return round((1 / (1 + np.exp(-z))) * 100, 2)
+
+def map_statut_expert(p2):
+    """Traduction de la probabilité à 2 ans en libellé métier"""
+    if p2 > 20: return '🔴 CRITIQUE'
+    if p2 > 10: return '🟠 VIGILANCE'
+    if p2 > 5:  return '🟡 OBSERVATION'
+    return '🟢 SAIN'
+
+def prepare_input(data):
+    """Prépare le DMatrix avec mapping automatique des codes APE et CJ"""
+    df = pd.DataFrame(0.0, index=[0], columns=FEATURES)
+    
+    # 1. Variables numériques directes
+    df['age_au_diagnostic'] = float(data.get('age_estime', 0))
+    df['Tranche_effectif_num'] = float(data.get('Tranche_effectif_num', 0))
+    df['risque_departemental'] = float(data.get('code_departement', 0))
+    df['is_ess'] = int(data.get('is_ess', 0))
+    
+    # 2. Mapping APE (Division -> Section)
+    code_ape_2 = str(data.get('code_ape', ''))[:2]
+    section_name = NAF_TO_SECTION.get(code_ape_2)
+    
+    if section_name:
+        col_ape = f"APE_{section_name}"
+        if col_ape in df.columns:
+            df[col_ape] = 1.0
+        elif 'APE_Autres_Secteurs' in df.columns:
+            df['APE_Autres_Secteurs'] = 1.0
+    
+    # 3. Mapping Catégorie Juridique (CJ_Prefix)
+    cj_prefix = str(data.get('categorie_juridique', ''))[:4]
+    col_cj = f"CJ_{cj_prefix}"
+    if col_cj in df.columns:
+        df[col_cj] = 1.0
+    elif 'CJ_Autres_Status' in df.columns:
+        df['CJ_Autres_Status'] = 1.0
+            
+    return xgb.DMatrix(df)

requirements.txt

@@ -0,0 +1,6 @@
+fastapi
+uvicorn
+xgboost
+pandas
+numpy
+python-multipart