Déploiement auto depuis GitHub Actions avec LFS

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.cbm filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,36 @@
+FROM python:3.12-slim
+
+# 1. Création d'un utilisateur standard (UID 1000 requis par Hugging Face)
+RUN useradd -m -u 1000 user
+USER user
+
+# 2. Variables d'environnement pour l'utilisateur et Python
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1
+
+# 3. Répertoire de travail
+WORKDIR $HOME/app
+
+# 4. Copie des dépendances avec les bons droits
+COPY --chown=user requirements.txt .
+
+# 5. Mise à jour de pip (pour enlever le 'notice') et installation
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# 6. Copie du code et des modèles
+COPY --chown=user app/ ./app/
+COPY --chown=user models/ ./models/
+
+# 7. Variables de l'API avec le nouveau chemin
+ENV GLOBAL_THRESHOLD=0.45
+ENV MODEL_PATH=$HOME/app/models/pmvl_catboost_final.cbm
+ENV MODEL_FEATURES_PATH=$HOME/app/models/pmvl_feature_columns.txt
+
+# 8. Exposer le port 7860 (Port par défaut de Hugging Face Spaces)
+EXPOSE 7860
+
+# 9. Démarrage de l'API sur le port 7860
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

app/main.py

@@ -0,0 +1,128 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+import os
+import pandas as pd
+import numpy as np
+
+from .schemas import PMVLFeatures, PredictionResponse
+from .model_loader import get_model, get_feature_columns
+
+GLOBAL_THRESHOLD_ENV = "GLOBAL_THRESHOLD"
+DEFAULT_THRESHOLD = 0.45
+
+app = FastAPI(
+    title="API de prédiction de la qualité PMVL",
+    description="API exposant le modèle CatBoost pour estimer la précision des PMVL.",
+    version="1.0.0",
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+GROUP_KEYS = [
+    "PMVL[ENTITE]",
+    "PMVL[Selected Fund code]",
+    "PMVL[ISIN]",
+    "PMVL[Ref Unik Asset]",
+]
+
+def make_position_group(df: pd.DataFrame) -> pd.Series:
+    """Recrée la colonne position_group comme dans le notebook"""
+    existing = [c for c in GROUP_KEYS if c in df.columns]
+    if not existing:
+        return pd.Series(
+            np.arange(len(df)).astype(str), index=df.index, name="position_group"
+        )
+    return (
+        df[existing]
+        .astype(str)
+        .fillna("NA")
+        .agg("||".join, axis=1)
+        .rename("position_group")
+    )
+
+def prepare_catboost_features(X: pd.DataFrame, cat_cols: list):
+    """Prépare les features (remplace None par 'MISSING' pour les cat, etc.)"""
+    X = X.copy()
+    for c in X.columns:
+        if c in cat_cols:
+            # Remplacement des valeurs manquantes par 'MISSING' et conversion en string
+            X[c] = X[c].fillna("MISSING").astype(str)
+        else:
+            # Remplacement par NaN et forçage numérique
+            X[c] = pd.to_numeric(X[c], errors="coerce")
+            
+    for c in X.columns:
+        if X[c].dtype == bool:
+            X[c] = X[c].astype(int)
+    return X
+
+
+@app.on_event("startup")
+def load_model_on_startup():
+    try:
+        get_model()
+        get_feature_columns()
+    except Exception as e:
+        print(f"Erreur critique lors du chargement initial : {e}")
+
+@app.get("/health", tags=["diagnostic"])
+def health_check():
+    return {"status": "ok", "message": "L'API PMVL est opérationnelle."}
+
+@app.post("/predict", response_model=PredictionResponse, tags=["prédiction"])
+def predict_pmvl(features: PMVLFeatures):
+    try:
+        model = get_model()
+        feature_columns = get_feature_columns()
+
+        # 1) Récupérer les données brutes
+        raw_dict = features.model_dump(by_alias=True)
+        raw_dict.pop("PMVL[Holding date]", None)
+
+        # 2) Construire un DataFrame avec TOUTES les colonnes attendues
+        row = {col: np.nan for col in feature_columns}
+        for k, v in raw_dict.items():
+            if k in row and v is not None:
+                row[k] = v
+
+        raw_df = pd.DataFrame([row])
+
+        # 3) Recréer position_group si elle fait partie des features
+        if "position_group" in feature_columns:
+            raw_df["position_group"] = make_position_group(raw_df)
+
+        # 4) S'assurer de l'ordre exact des colonnes
+        df_input = raw_df[feature_columns]
+
+        # 5) Appliquer le nettoyage en demandant AU MODÈLE quelles sont les colonnes catégorielles !
+        cat_indices = model.get_cat_feature_indices()
+        cat_cols = [feature_columns[i] for i in cat_indices]
+        
+        df_input = prepare_catboost_features(df_input, cat_cols)
+
+        # 6) Prédire
+        proba = float(model.predict_proba(df_input)[:, 1][0])
+
+        threshold = float(os.getenv(GLOBAL_THRESHOLD_ENV, DEFAULT_THRESHOLD))
+        prediction_bool = bool(proba >= threshold)
+
+        return PredictionResponse(
+            proba_bonne_estimation=proba,
+            prediction=prediction_bool,
+            seuil_applique=threshold,
+            fund_code=features.fund_code,
+            ref_unik_asset=features.ref_unik_asset,
+        )
+
+
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Erreur lors du traitement de la prédiction : {e}",
+        )

app/model_loader.py

@@ -0,0 +1,38 @@
+import os
+from functools import lru_cache
+from catboost import CatBoostClassifier
+
+# Variables d'environnement pour rendre le chemin dynamique (utile pour Docker)
+MODEL_PATH_ENV = "MODEL_PATH"
+DEFAULT_MODEL_PATH = "models/pmvl_catboost_final.cbm"
+
+FEATURES_PATH_ENV = "FEATURES_PATH"
+DEFAULT_FEATURES_PATH = "models/pmvl_feature_columns.txt"
+
+@lru_cache(maxsize=1)
+def get_model() -> CatBoostClassifier:
+    """
+    Charge le modèle CatBoost depuis le disque.
+    Grâce à @lru_cache, cette fonction ne s'exécute réellement qu'une seule fois.
+    """
+    model_path = os.getenv(MODEL_PATH_ENV, DEFAULT_MODEL_PATH)
+    
+    if not os.path.exists(model_path):
+        raise FileNotFoundError(f"Le fichier du modèle est introuvable au chemin : {model_path}")
+    
+    print("Chargement du modèle CatBoost en mémoire...")
+    model = CatBoostClassifier()
+    model.load_model(model_path)
+    print("Modèle chargé avec succès !")
+    
+    return model
+
+#chargeur pour la liste de colonnes utilisées par le modèle (pour s'assurer que l'ordre des features est correct)
+@lru_cache(maxsize=1)
+def get_feature_columns() -> list[str]:
+    features_path = os.getenv(FEATURES_PATH_ENV, DEFAULT_FEATURES_PATH)
+    if not os.path.exists(features_path):
+        raise FileNotFoundError(f"Le fichier des features est introuvable au chemin : {features_path}")
+    with open(features_path, encoding="utf-8") as f:
+        cols = [line.strip() for line in f if line.strip()]
+    return cols

app/schemas.py

@@ -0,0 +1,153 @@
+from pydantic import BaseModel, Field, validator
+from typing import Optional
+from datetime import date
+
+class PMVLFeatures(BaseModel):
+    """
+    Schéma Pydantic représentant une observation d'entrée pour la prédiction PMVL.
+    Les noms des attributs sont des alias Python-friendly pour les colonnes complexes du DataFrame.
+    """
+    # ------------------ Colonnes de type Date ------------------
+    holding_date: date = Field(
+        ..., 
+        alias="PMVL[Holding date]",
+        description="Date de la position (Trading/Holding date)"
+    )
+    quote_date: Optional[str] = Field(
+        None, 
+        alias="PMVL[Quote Date]",
+        description="Date de la cotation (peut contenir des valeurs manquantes)"
+    )
+
+    # ------------------ Colonnes Numériques (float64) ------------------
+    pmvl_estim: Optional[float] = Field(
+        None, 
+        alias="PMVL[PMVL Estimé]",
+        description="Estimation de la PMVL au temps t"
+    )
+    pfm_indice_perf: Optional[float] = Field(
+        None, 
+        alias="PMVL[PFMIndice.Perf J / J-1]",
+        description="Performance de l'indice J / J-1"
+    )
+    prmp_pmvl: Optional[float] = Field(
+        None, 
+        alias="PMVL[PRMP PMVL]",
+        description="Realized PMVL at t"
+    )
+    prmp_vnc: Optional[float] = Field(
+        None, 
+        alias="PMVL[PRMP VNC]",
+        description="Realized VNC at t"
+    )
+    prmp_mtm: Optional[float] = Field(
+        None, 
+        alias="PMVL[PRMP MtM]",
+        description="Realized MtM at t"
+    )
+    quantity: float = Field(
+        ..., 
+        alias="PMVL[Quantity]",
+        description="Quantité de l'actif"
+    )
+    purch_val_clean: float = Field(
+        ..., 
+        alias="PMVL[Purch. Val. (clean) (ptf cur.)]",
+        description="Valeur d'achat clean en devise du portefeuille"
+    )
+    quote: float = Field(
+        ..., 
+        alias="PMVL[Quote]",
+        description="Cotation de l'actif"
+    )
+    vnc_agrege_dirty: float = Field(
+        ..., 
+        alias="PMVL[VNC Agrege dirty (ptf cur.)]",
+        description="VNC Agrégée dirty en devise du portefeuille"
+    )
+
+    # ------------------ Colonnes Catégorielles (object) ------------------
+    entite: str = Field(
+        ..., 
+        alias="PMVL[ENTITE]",
+        description="Entité légale"
+    )
+    isin: str = Field(
+        ..., 
+        alias="PMVL[ISIN]",
+        description="Code ISIN de l'instrument"
+    )
+    orig_name: str = Field(
+        ..., 
+        alias="PMVL[Orig. name]",
+        description="Nom original de l'actif"
+    )
+    ticker: str = Field(
+        ..., 
+        alias="PMVL[Parametres_Indices.TICKER]",
+        description="Ticker de l'indice"
+    )
+    ref_unik_asset: str = Field(
+        ..., 
+        alias="PMVL[Ref Unik Asset]",
+        description="Référence unique de l'asset"
+    )
+    fund_code: str = Field(
+        ..., 
+        alias="PMVL[Selected Fund code]",
+        description="Code du fonds sélectionné"
+    )
+    col_3a: str = Field(
+        ..., 
+        alias="PMVL[3A]",
+        description="Classification 3A"
+    )
+    canton: str = Field(
+        ..., 
+        alias="PMVL[CANTON]",
+        description="Canton"
+    )
+    cic: str = Field(
+        ..., 
+        alias="PMVL[CIC]",
+        description="Classification CIC"
+    )
+    groupe: str = Field(
+        ..., 
+        alias="PMVL[GROUPE]",
+        description="Groupe"
+    )
+    ptf_name: str = Field(
+        ..., 
+        alias="PMVL[Ptf name]",
+        description="Nom du portefeuille"
+    )
+
+    class Config:
+        populate_by_name = True  # Nouvelle syntaxe Pydantic V2
+
+
+class PredictionResponse(BaseModel):
+    """
+    Schéma de la réponse retournée par l'API.
+    """
+    proba_bonne_estimation: float = Field(
+        ...,
+        description="Probabilité (entre 0 et 1) que la PMVL soit une bonne estimation."
+    )
+    prediction: bool = Field(
+        ...,
+        description="True si la PMVL est jugée bonne (proba >= seuil), False sinon."
+    )
+    seuil_applique: float = Field(
+        ...,
+        description="Le seuil de probabilité utilisé pour cette décision (ex: 0.45)."
+    )
+    fund_code: str = Field(
+        ...,
+        description="Rappel du code du fonds pour traçabilité."
+    )
+    ref_unik_asset: str = Field(
+        ...,
+        description="Rappel de la référence de l'actif pour traçabilité."
+    )

models/pmvl_catboost_final.cbm

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b81635e7410aee5b4d95784954ea3e6d9356bcfbfdce88f713aa9086bb31fc14
+size 6085568

models/pmvl_feature_columns.txt

@@ -0,0 +1,22 @@
+PMVL[ENTITE]
+PMVL[ISIN]
+PMVL[Orig. name]
+PMVL[Parametres_Indices.TICKER]
+PMVL[PFMIndice.Perf J / J-1]
+PMVL[PRMP PMVL]
+PMVL[PRMP VNC]
+PMVL[PRMP MtM]
+PMVL[Ref Unik Asset]
+PMVL[Selected Fund code]
+PMVL[3A]
+PMVL[CANTON]
+PMVL[CIC]
+PMVL[GROUPE]
+PMVL[Ptf name]
+PMVL[Quantity]
+PMVL[Purch. Val. (clean) (ptf cur.)]
+PMVL[Quote Date]
+PMVL[Quote]
+PMVL[VNC Agrege dirty (ptf cur.)]
+PMVL[PMVL Estimé]
+position_group

requirements.txt

@@ -0,0 +1,8 @@
+fastapi>=0.111.0
+uvicorn[standard]>=0.30.1
+pydantic>=2.7.0
+catboost==1.2.10  
+pandas>=2.2.0
+numpy>=1.26.0
+pytest>=8.0.0
+httpx>=0.27.0

tests/test_api.py

@@ -0,0 +1,85 @@
+from fastapi.testclient import TestClient
+from app.main import app
+
+# Création du client de test FastAPI
+client = TestClient(app)
+
+# Payload valide (contenant tous les champs obligatoires définis dans schemas.py)
+# On utilise ici les noms des variables Python (grâce à populate_by_name=True)
+VALID_PAYLOAD = {
+    "holding_date": "2026-03-01",
+    "pmvl_estim": 1500.50,
+    "quantity": 100.0,
+    "purch_val_clean": 45000.0,
+    "quote": 510.0,
+    "vnc_agrege_dirty": 49000.0,
+    "entite": "ENTITE_TEST",
+    "isin": "FR0000000001",
+    "orig_name": "Asset Name Test",
+    "ticker": "TICKER_TEST",
+    "ref_unik_asset": "REF_12345",
+    "fund_code": "FUND_001",
+    "col_3a": "3A_TEST",
+    "canton": "CANTON_TEST",
+    "cic": "CIC_TEST",
+    "groupe": "GROUPE_TEST",
+    "ptf_name": "PTF_TEST"
+}
+
+
+def test_health_check():
+    """
+    Test 1 : Vérifie que le endpoint de diagnostic répond bien 200 OK.
+    """
+    response = client.get("/health")
+    assert response.status_code == 200
+    assert response.json()["status"] == "ok"
+
+
+def test_predict_valid_data():
+    """
+    Test 2 : Vérifie qu'un payload complet et valide renvoie bien une prédiction.
+    """
+    response = client.post("/predict", json=VALID_PAYLOAD)
+    
+    # Ligne ajoutée pour debug
+    print("RESPONSE STATUS:", response.status_code)
+    print("RESPONSE BODY:", response.json())
+
+    assert response.status_code == 200
+    
+    # Vérifie la structure de la réponse
+    data = response.json()
+    assert "proba_bonne_estimation" in data
+    assert "prediction" in data
+    assert "seuil_applique" in data
+    assert data["fund_code"] == "FUND_001"
+    
+    # La probabilité doit être entre 0 et 1
+    assert 0.0 <= data["proba_bonne_estimation"] <= 1.0
+
+
+def test_predict_missing_required_field():
+    """
+    Test 3 : Vérifie que l'API renvoie une erreur 422 si un champ obligatoire (ex: quantity) est manquant.
+    """
+    invalid_payload = VALID_PAYLOAD.copy()
+    del invalid_payload["quantity"]  # On supprime un champ obligatoire
+
+    response = client.post("/predict", json=invalid_payload)
+    
+    # 422 Unprocessable Entity est le code standard de FastAPI pour une erreur de validation
+    assert response.status_code == 422
+
+
+def test_predict_invalid_data_type():
+    """
+    Test 4 : Vérifie que l'API renvoie une erreur 422 si un type de donnée est incorrect 
+    (ex: une chaîne de caractères au lieu d'un float pour 'quote').
+    """
+    invalid_payload = VALID_PAYLOAD.copy()
+    invalid_payload["quote"] = "Ceci_n_est_pas_un_chiffre"
+
+    response = client.post("/predict", json=invalid_payload)
+    
+    assert response.status_code == 422