MLOps : Déployer et Monitorer ses Modèles
Passez du notebook à la production : API de serving, conteneurisation Docker, pipelines CI/CD et monitoring de drift.
Du Notebook à la Production
95% des modèles ML ne dépassent jamais le stade du notebook Jupyter. Le MLOps (Machine Learning Operations) est l'ensemble des pratiques pour déployer, maintenir et monitorer des modèles en production.
Pourquoi le MLOps est Indispensable
Un modèle qui tourne dans un notebook n'a aucune valeur business. Pour être utile, il doit :
- Être accessible via une API que d'autres applications peuvent appeler
- Être reproductible (même données + même code = même résultat)
- Être monitoré pour détecter quand il se dégrade
Le piège classique : Un modèle qui a 95% de précision en test peut tomber à 60% après 3 mois en production si les données changent (concept de data drift).
Le Cycle de Vie d'un Modèle
Servir un Modèle via une API
La manière la plus courante de déployer un modèle est de l'exposer derrière une API REST. FastAPI est le framework Python idéal pour ça.
🛠️ Micro-Exercice : API de Prédiction avec FastAPI
# pip install fastapi uvicorn scikit-learn
from fastapi import FastAPI
from pydantic import BaseModel
import joblib
import numpy as np
app = FastAPI(title="ML Prediction API")
# Charger le modèle sauvegardé
model = joblib.load("model.joblib")
# Schéma de la requête
class PredictionRequest(BaseModel):
features: list[float]
class PredictionResponse(BaseModel):
prediction: float
confidence: float
@app.post("/predict", response_model=PredictionResponse)
def predict(req: PredictionRequest):
X = np.array(req.features).reshape(1, -1)
prediction = model.predict(X)[0]
proba = model.predict_proba(X).max()
return PredictionResponse(prediction=prediction, confidence=round(proba, 4))
Lancer le serveur :
FastAPI génère automatiquement une documentation interactive sur /docs. Testez votre API directement depuis le navigateur.
Sauvegarder un Modèle Proprement
Joblib est recommandé pour les modèles scikit-learn. Pour un format portable entre frameworks, utilisez ONNX.
# Sauvegarder avec joblib (recommandé pour scikit-learn)
import joblib
joblib.dump(model, "model.joblib")
# Recharger
model = joblib.load("model.joblib")
# Sauvegarder avec ONNX (portable entre frameworks)
# pip install skl2onnx
from skl2onnx import convert_sklearn
from skl2onnx.common.data_types import FloatTensorType
initial_type = [("input", FloatTensorType([None, 4]))]
onnx_model = convert_sklearn(model, initial_types=initial_type)
with open("model.onnx", "wb") as f:
f.write(onnx_model.SerializeToString())
Conteneuriser avec Docker
Docker garantit que votre API fonctionne partout de manière identique : sur votre machine, sur un serveur, dans le cloud.
Dockerfile pour une API ML
FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY model.joblib .
COPY main.py .
EXPOSE 8000
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
Versionnement des Modèles avec MLflow
MLflow permet de tracker chaque expérience : paramètres, métriques, et le modèle lui-même.
# pip install mlflow
import mlflow
from sklearn.ensemble import RandomForestClassifier
mlflow.set_experiment("titanic-survival")
with mlflow.start_run():
# Paramètres
n_estimators = 100
max_depth = 5
mlflow.log_param("n_estimators", n_estimators)
mlflow.log_param("max_depth", max_depth)
# Entraînement
model = RandomForestClassifier(n_estimators=n_estimators, max_depth=max_depth)
model.fit(X_train, y_train)
# Métriques
accuracy = model.score(X_test, y_test)
mlflow.log_metric("accuracy", accuracy)
# Sauvegarder le modèle
mlflow.sklearn.log_model(model, "model")
print(f"Accuracy: {accuracy:.4f}")
Lancez mlflow ui pour voir le dashboard avec toutes vos expériences, comparer les runs et déployer le meilleur modèle.
Monitoring et Data Drift
Un modèle déployé n'est pas "terminé". Les données du monde réel changent et le modèle se dégrade silencieusement.
Qu'est-ce que le Data Drift ?
Le drift survient quand la distribution des données en production s'éloigne de celle d'entraînement :
- Data drift : les entrées changent (ex: nouveaux types de clients)
- Concept drift : la relation entrée/sortie change (ex: le comportement d'achat évolue)
Détecter le Drift
# pip install evidently
from evidently.report import Report
from evidently.metric_preset import DataDriftPreset
# Comparer données d'entraînement vs production
report = Report(metrics=[DataDriftPreset()])
report.run(
reference_data=df_train, # Données d'entraînement
current_data=df_production # Données récentes en production
)
# Générer un rapport HTML
report.save_html("drift_report.html")
Alertes et Ré-entraînement
En production, configurez des alertes automatiques :
# Vérification quotidienne simplifiée
def check_model_health(model, X_recent, y_recent):
current_accuracy = model.score(X_recent, y_recent)
baseline_accuracy = 0.92 # Score lors du déploiement
drift_threshold = 0.05 # 5% de dégradation max
if current_accuracy < baseline_accuracy - drift_threshold:
print("ALERTE : Performance dégradée !")
print(f" Baseline: {baseline_accuracy:.2%}")
print(f" Actuelle: {current_accuracy:.2%}")
print(" → Déclencher un ré-entraînement")
return False
print(f"Modèle OK : {current_accuracy:.2%}")
return True
Ne ré-entraînez pas automatiquement sans validation humaine. Un drift peut aussi signifier un bug dans le pipeline de données.
Specialiste IA — Master Intelligence Artificielle
Diplome d'un Master en Intelligence Artificielle, je travaille au quotidien sur des projets IA en entreprise. J'ai cree IwanttolearnAI pour rendre l'apprentissage de l'IA accessible a tous, gratuitement.
Continuer a apprendre
Systèmes de Recommandation : de Netflix à Spotify
Découvrez comment Netflix, Spotify et Amazon construisent leurs moteurs de recommandation. De la factorisation matricielle aux two-tower models, maîtrisez les algorithmes et les métriques.
Séries Temporelles et Prévision avec Python
Apprenez à modéliser et prévoir des séries temporelles avec ARIMA, Prophet et XGBoost. Maîtrisez la validation temporelle correcte et les métriques adaptées.
SVM, Arbres de Décision et Random Forest en Profondeur
Maîtrisez les algorithmes classiques les plus puissants du ML : SVM avec kernel trick, arbres de décision et Random Forest. Comprendre quand ces modèles battent le Deep Learning.