Chapitre 1 : Qu'est-ce que le MLOps ?

Introduction

MLOps (Opérations d'apprentissage automatique) est un ensemble de pratiques visant à déployer et maintenir des modèles d'apprentissage automatique en production de manière fiable et efficace. Il combine l'apprentissage automatique, le DevOps et l'ingénierie des données pour automatiser et standardiser le cycle de vie de l'IA.

Définition

MLOps = Apprentissage automatique + DevOps + Ingénierie des données

C'est la discipline de la livraison de systèmes d'IA avec la même rigueur et fiabilité que les systèmes logiciels traditionnels.

Le problème que le MLOps résout

Le défi du développement ML

Le développement logiciel traditionnel suit un chemin bien compris :

Code → Build → Test → Deploy → Monitor

L'apprentissage automatique ajoute une complexité significative :

Data → Feature Engineering → Training → Evaluation → Deployment → Monitoring → Retraining
     ↑                                                                              ↓
     └──────────────────────────────────────────────────────────────────────────────┘

Pourquoi 87 % des projets ML n'atteignent jamais la production

Selon les recherches de l'industrie :

Défi	Impact
Mauvaise reproductibilité des modèles	Impossible de recréer les résultats
Absence de versionnage	Dérive du code, des données et des modèles
Déploiement manuel	Versions lentes et sujettes aux erreurs
Pas de surveillance	Échecs silencieux des modèles
Dette technique	Systèmes non maintenables

Principes fondamentaux du MLOps

1. Automatisation

Tout ce qui peut être automatisé doit être automatisé :

# Exemple : Déclencheur de pipeline d'entraînement automatisé
name: ML Training Pipeline
on:
  schedule:
    - cron: '0 0 * * 0'  # Réentraînement hebdomadaire
  push:
    paths:
      - 'data/**'
      - 'src/training/**'

jobs:
  train:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
      
      - name: Setup Python
        uses: actions/setup-python@v4
        with:
          python-version: '3.10'
      
      - name: Train model
        run: |
          pip install -r requirements.txt
          python src/train.py
      
      - name: Evaluate model
        run: python src/evaluate.py
      
      - name: Register model
        if: success()
        run: python src/register_model.py

2. Versionnage de tout

Suivez tous les composants de votre système ML :

# Versionnage du code
git add .
git commit -m "feat: add new feature engineering step"

# Versionnage des données avec DVC
dvc add data/training_data.csv
git add data/training_data.csv.dvc
git commit -m "data: update training dataset v2.1"

# Versionnage des modèles
mlflow models log \
  --model-uri runs:/<run-id>/model \
  --registered-model-name "production-model"

3. Intégration continue/Déploiement continu (CI/CD)

4. Surveillance et observabilité

Les modèles en production nécessitent une surveillance constante :

# Exemple : Métriques de surveillance des modèles
from prometheus_client import Counter, Histogram, Gauge

# Suivre les prédictions
prediction_counter = Counter(
    'model_predictions_total',
    'Total number of predictions',
    ['model_version', 'prediction_class']
)

# Suivre la latence
prediction_latency = Histogram(
    'model_prediction_latency_seconds',
    'Time spent processing prediction',
    buckets=[0.01, 0.05, 0.1, 0.5, 1.0]
)

# Suivre la dérive des données
data_drift_score = Gauge(
    'model_data_drift_score',
    'Current data drift score',
    ['feature_name']
)

5. Collaboration

Le MLOps permet la collaboration d'équipes interfonctionnelles :

Rôle	Responsabilité
Scientifiques des données	Développement de modèles, expérimentation
Ingénieurs ML	Développement de pipelines, optimisation
Ingénieurs DevOps	Infrastructure, CI/CD
Ingénieurs de données	Pipelines de données, qualité
Chefs de produit	Exigences, définition des métriques

Niveaux de maturité du MLOps

Les organisations évoluent à travers les niveaux de maturité du MLOps :

Niveau 0 : Processus manuel

┌─────────────────────────────────────────────────────────┐
│                    NIVEAU 0 : MANUEL                     │
├─────────────────────────────────────────────────────────┤
│ • Notebooks Jupyter pour tout                            │
│ • Déploiement manuel des modèles                         │
│ • Pas de versionnage                                     │
│ • Pas de surveillance                                    │
│ • Les scientifiques des données font tout                │
└─────────────────────────────────────────────────────────┘

Caractéristiques :

• Scripts et notebooks
• Déploiements manuels, pilotés par script
• Absence d'intégration continue
• Rares versions (trimestrielles ou moins)

Niveau 1 : Automatisation du pipeline ML

┌─────────────────────────────────────────────────────────┐
│              NIVEAU 1 : AUTOMATISATION DU PIPELINE       │
├─────────────────────────────────────────────────────────┤
│ • Pipeline d'entraînement automatisé                     │
│ • Suivi des expériences                                  │
│ • Registre des modèles                                   │
│ • Surveillance de base                                   │
│ • Réentraînement nécessite un déclencheur manuel         │
└─────────────────────────────────────────────────────────┘

Caractéristiques :

• Pipelines d'entraînement reproductibles
• Suivi des expériences avec MLflow/W&B
• Versionnage des modèles
• Déclencheurs de déploiement encore manuels

Niveau 2 : Automatisation du pipeline CI/CD

┌─────────────────────────────────────────────────────────┐
│                 NIVEAU 2 : AUTOMATISATION CI/CD          │
├─────────────────────────────────────────────────────────┤
│ • CI/CD automatisé pour ML                               │
│ • Tests automatisés (données, modèles, intégration)      │
│ • Déploiement automatisé                                 │
│ • Surveillance complète                                  │
│ • Déclencheurs de réentraînement automatiques            │
└─────────────────────────────────────────────────────────┘

Caractéristiques :

• Automatisation complète CI/CD
• Tests A/B et déploiements canari
• Rollbacks automatisés
• Détection de la dérive des données et des modèles

La pile MLOps

Une pile MLOps typique inclut :

Exemple pratique : Configuration MLOps simple

Voici une configuration MLOps minimale utilisant des outils populaires :

# train.py - Exemple de script d'entraînement avec suivi MLflow
import mlflow
import mlflow.sklearn
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, f1_score
import pandas as pd

# Activer l'autologging
mlflow.sklearn.autolog()

def train_model():
    # Charger les données
    df = pd.read_csv("data/training_data.csv")
    X = df.drop("target", axis=1)
    y = df["target"]
    
    # Diviser les données
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.2, random_state=42
    )
    
    with mlflow.start_run():
        # Enregistrer les paramètres
        mlflow.log_param("model_type", "RandomForest")
        mlflow.log_param("n_estimators", 100)
        
        # Entraîner le modèle
        model = RandomForestClassifier(n_estimators=100, random_state=42)
        model.fit(X_train, y_train)
        
        # Évaluer
        predictions = model.predict(X_test)
        accuracy = accuracy_score(y_test, predictions)
        f1 = f1_score(y_test, predictions, average='weighted')
        
        # Enregistrer les métriques
        mlflow.log_metric("accuracy", accuracy)
        mlflow.log_metric("f1_score", f1)
        
        # Enregistrer le modèle
        mlflow.sklearn.log_model(model, "model")
        
        print(f"Model trained with accuracy: {accuracy:.4f}")

if __name__ == "__main__":
    train_model()

Points clés à retenir

Résumé

1. Le MLOps comble le fossé entre le développement ML et les opérations
2. L'automatisation est essentielle pour des systèmes ML fiables et évolutifs
3. Versionnez tout - code, données, modèles et configurations
4. Surveillez en continu - les modèles se dégradent silencieusement sans surveillance appropriée
5. Collaborez efficacement - le MLOps nécessite des équipes interfonctionnelles

Lectures complémentaires

• MLOps de Google : Livraison continue pour l'apprentissage automatique
• Modèle de maturité MLOps de Microsoft
• Dette technique cachée dans les systèmes ML

---

Suivant : Chapitre 2 : MLOps vs DevOps vs DataOps