MLflow

MLflow est une plateforme open source pour gérer l'ensemble du cycle de vie du Machine Learning — du suivi des expériences et du versionnage des modèles jusqu’au déploiement et à la surveillance. Utilisé par des milliers d’organisations dans le monde, MLflow apporte structure et reproductibilité aux workflows de ML. Exécutez-le sur le cloud GPU de Clore.ai pour obtenir un serveur de suivi centralisé à côté de vos tâches d’entraînement.

---

Qu’est-ce que MLflow ?

MLflow fournit quatre composants principaux :

Composant	Description
Suivi	Enregistrez les paramètres, les métriques, les artefacts et le code des exécutions ML
Projets	Regroupez le code pour des exécutions reproductibles
Modèles	Format de modèle standard pour le déploiement sur différents frameworks
Registre des modèles	Stock centralisé de modèles avec versionnage et cycle de vie

Frameworks pris en charge (autologging intégré) :

• PyTorch, TensorFlow/Keras

• Scikit-learn, XGBoost, LightGBM

• Transformers de HuggingFace

• Spark MLlib, statsmodels, Prophet

---

Prérequis

Exigence	Valeur
VRAM GPU	N’importe lequel (le serveur MLflow lui-même est limité par le CPU)
Stockage	20 Go+ (pour les artefacts)
RAM	4 Go minimum pour le serveur
Ports	22 (SSH), 5000 (interface MLflow)

Le serveur de suivi MLflow est léger. Vous pouvez l’exécuter sur une petite instance CPU et y connecter vos tâches d’entraînement GPU. Vous pouvez aussi le placer sur la même instance GPU que votre entraînement.

---

Étape 1 — Louer un serveur sur Clore.ai

1. Connectez-vous à clore.ai.

2. Cliquez sur Place de marché.

3. Pour un serveur de suivi dédié : filtrez par RAM ≥ 8 Go (GPU facultatif).

4. Pour une configuration co-localisée : utilisez votre instance d’entraînement existante.

5. Définir l’image Docker : ghcr.io/mlflow/mlflow:latest

6. Définissez les ports ouverts : 22 (SSH) et 5000 (interface MLflow).

7. Cliquez sur Louer.

---

Étape 2 — Lancer le serveur de suivi MLflow

L’image officielle ghcr.io/mlflow/mlflow nécessite une substitution de la commande de démarrage.

Dans la configuration Docker de Clore.ai

Définissez la commande (ou la substitution de l’entrypoint) sur :

bash -c "apt-get update -q && apt-get install -y -q openssh-server && \
    mkdir /var/run/sshd && \
    echo 'root:clore123' | chpasswd && \\
    sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config && \
    service ssh start && \
    mlflow server \
        --host 0.0.0.0 \
        --port 5000 \
        --default-artifact-root /mlflow/artifacts \
        --backend-store-uri sqlite:////mlflow/mlflow.db"

Alternative : Dockerfile personnalisé

FROM ghcr.io/mlflow/mlflow:latest

RUN apt-get update && apt-get install -y \
    openssh-server \
    && rm -rf /var/lib/apt/lists/*

# Configurer SSH
RUN mkdir /var/run/sshd && \
    echo 'root:clore123' | chpasswd && \\
    sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config

# Paquets Python supplémentaires
RUN pip install boto3 psycopg2-binary

RUN mkdir -p /mlflow/artifacts

EXPOSE 22 5000

CMD service ssh start && \
    mlflow server \
        --host 0.0.0.0 \
        --port 5000 \
        --default-artifact-root /mlflow/artifacts \
        --backend-store-uri sqlite:////mlflow/mlflow.db

---

Étape 3 — Accéder à l’interface MLflow

Ouvrez votre navigateur :

http://<clore-host>:<public-port-5000>

Vous devriez voir le tableau de bord des expériences MLflow.

Le backend SQLite par défaut (mlflow.db) stocke localement toutes les métadonnées d’exécution. Pour la production ou un usage en équipe, passez à PostgreSQL — voir la configuration avancée ci-dessous.

---

Étape 4 — Enregistrer votre première expérience

Se connecter depuis une tâche d’entraînement distante

Sur votre machine d’entraînement (ou une autre instance Clore.ai), définissez l’URI de suivi :

export MLFLOW_TRACKING_URI=http://<clore-host>:<public-port-5000>

Journalisation de base d’une expérience PyTorch

import mlflow
import mlflow.pytorch
import torch
import torch.nn as nn
import torch.optim as optim

# Se connecter au serveur MLflow
mlflow.set_tracking_uri("http://<clore-host>:<public-port-5000>")
mlflow.set_experiment("my-first-experiment")

# Définir un modèle simple
class SimpleNet(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super().__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(hidden_size, output_size)
    
    def forward(self, x):
        return self.fc2(self.relu(self.fc1(x)))

# Entraînement avec suivi MLflow
with mlflow.start_run(run_name="training-run-001"):
    # Enregistrer les hyperparamètres
    params = {
        "learning_rate": 0.001,
        "batch_size": 64,
        "epochs": 100,
        "hidden_size": 256,
        "optimizer": "adam"
    }
    mlflow.log_params(params)
    
    # Initialiser le modèle
    model = SimpleNet(784, 256, 10).cuda()
    optimizer = optim.Adam(model.parameters(), lr=params["learning_rate"] )
    criterion = nn.CrossEntropyLoss()
    
    # Boucle d’entraînement
    for epoch in range(params["epochs"]):
        loss = torch.tensor(0.5 / (epoch + 1))  # Simulé
        accuracy = 0.7 + epoch * 0.003
        
        # Enregistrer les métriques à chaque époque
        mlflow.log_metrics({
            "train_loss": loss.item(),
            "train_accuracy": accuracy,
        }, step=epoch)
    
    # Enregistrer le modèle final
    mlflow.pytorch.log_model(model, "model")
    
    # Enregistrer les métriques finales
    mlflow.log_metric("final_accuracy", accuracy)
    
    print(f"Exécution enregistrée dans MLflow. ID : {mlflow.active_run().info.run_id}")

Autologging des Transformers HuggingFace

import mlflow
from transformers import TrainingArguments, Trainer

mlflow.set_tracking_uri("http://<clore-host>:<public-port-5000>")
mlflow.set_experiment("llm-finetuning")

# Activer l’autologging — enregistre automatiquement les paramètres, les métriques et le modèle
mlflow.transformers.autolog()

training_args = TrainingArguments(
    output_dir="./results",
    num_train_epochs=3,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=64,
    learning_rate=2e-5,
    warmup_steps=500,
    weight_decay=0.01,
    logging_dir="./logs",
    logging_steps=10,
    evaluation_strategy="epoch",
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=eval_dataset,
)

with mlflow.start_run():
    trainer.train()

---

Étape 5 — Scikit-learn avec autologging

import mlflow
import mlflow.sklearn
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_digits

mlflow.set_tracking_uri("http://<clore-host>:<public-port-5000>")
mlflow.set_experiment("sklearn-experiments")

# Tout enregistrer automatiquement
mlflow.sklearn.autolog()

X, y = load_digits(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

with mlflow.start_run(run_name="random-forest-v1"):
    rf = RandomForestClassifier(n_estimators=100, max_depth=10, random_state=42)
    rf.fit(X_train, y_train)
    
    score = rf.score(X_test, y_test)
    print(f"Précision de test : {score:.4f}")
    # Tous les paramètres, métriques et le modèle sont enregistrés automatiquement !

---

Étape 6 — Registre des modèles

Enregistrez et gérez les versions des modèles via l’interface ou l’API :

import mlflow

client = mlflow.MlflowClient("http://<clore-host>:<public-port-5000>")

# Enregistrer un modèle à partir d’une exécution
run_id = "your-run-id-here"
model_uri = f"runs:/{run_id}/model"

registered = mlflow.register_model(
    model_uri=model_uri,
    name="production-classifier"
)

print(f"Version : {registered.version}")

# Changer l’étape du modèle
client.transition_model_version_stage(
    name="production-classifier",
    version=registered.version,
    stage="Production"
)

# Charger un modèle de production n’importe où
model = mlflow.pyfunc.load_model(
    model_uri="models:/production-classifier/Production"
)

---

Étape 7 — Servir un modèle

MLflow peut servir n’importe quel modèle enregistré sous forme d’API REST :

# Sur l’instance du serveur MLflow
export MLFLOW_TRACKING_URI=http://localhost:5000

mlflow models serve \
    --model-uri "models:/production-classifier/Production" \
    --host 0.0.0.0 \
    --port 5001 \
    --no-conda

Tester le modèle servi :

curl -X POST http://<clore-host>:5001/invocations \
    -H "Content-Type: application/json" \
    -d '{"inputs": [[1.0, 2.0, 3.0, ...]]}'

---

Configuration avancée

Backend PostgreSQL (Production)

# Lancer avec PostgreSQL
mlflow server \
    --host 0.0.0.0 \
    --port 5000 \
    --backend-store-uri postgresql://user:password@db-host/mlflow \
    --default-artifact-root s3://my-bucket/mlflow-artifacts

Stockage d’artefacts S3

pip install boto3

export AWS_ACCESS_KEY_ID=your_key
export AWS_SECRET_ACCESS_KEY=your_secret

mlflow server \
    --host 0.0.0.0 \
    --port 5000 \
    --default-artifact-root s3://my-mlflow-bucket/artifacts \
    --backend-store-uri sqlite:////mlflow/mlflow.db

Authentification (Entreprise)

pip install mlflow[auth]

mlflow server \
    --host 0.0.0.0 \
    --port 5000 \
    --app-name basic-auth \
    --backend-store-uri sqlite:////mlflow/mlflow.db \
    --default-artifact-root /mlflow/artifacts

---

Comparer des exécutions dans l’interface

1. Ouvrez l’interface MLflow à http://<clore-host>:<port>

2. Sélectionnez une expérience dans le panneau de gauche

3. Cochez les cases à côté de plusieurs exécutions

4. Cliquez sur Comparer pour voir les métriques et les paramètres côte à côte

5. Utilisez le onglet Graphiques pour une comparaison visuelle

---

Dépannage

Impossible de se connecter au serveur de suivi

mlflow.exceptions.MlflowException : la requête API a échoué avec le code d’état 503

Solutions :

• Vérifiez que le port 5000 est ouvert et redirigé dans Clore.ai

• Vérifiez que le serveur fonctionne : ps aux | grep mlflow

• Tester la connectivité : curl http://<clore-host>:<port>/health

L’upload d’artefact échoue

Solution : Assurez-vous que le répertoire des artefacts est accessible en écriture :

chmod 777 /mlflow/artifacts

Erreur de verrouillage SQLite (écritures concurrentes)

Solution : Passez à PostgreSQL pour les configurations multi-utilisateurs :

pip install psycopg2-binary

Le registre des modèles ne s’affiche pas

Solution : Vérifiez que vous utilisez un --backend-store-uri qui prend en charge le registre (SQLite ou PostgreSQL — pas seulement un chemin local).

---

Estimation des coûts

Instance	Cas d’utilisation	Prix estimé	Remarques
CPU 4 cœurs	Serveur de suivi uniquement	~0,05 $/h	Très léger
RTX 3080	Entraînement co-localisé	0,05–0,19 $/h	Entraînement + MLflow
RTX 4090	Entraînement lourd + suivi	0,14–0,42 $/h	Configuration la plus courante

Exécutez MLflow sur une instance CPU bon marché et pointez-y toutes vos tâches d’entraînement GPU. Ainsi, le serveur de suivi fonctionne en continu sans consommer de crédits GPU coûteux.

---

Ressources utiles

• Documentation officielle de MLflow

• GitHub de MLflow

• Docker Hub de MLflow

• Guide du registre des modèles MLflow

• Référence de l’API de suivi MLflow

---

Recommandations GPU Clore.ai

Cas d’utilisation	GPU recommandé	Coût estimé sur Clore.ai
Développement/Test	RTX 3090 (24 Go)	0,07–0,21 $/gpu/h
Entraînement en production	RTX 4090 (24 Go)	0,14–0,42 $/gpu/h
Expériences à grande échelle	A100 80 Go	bare metal

💡 Tous les exemples de ce guide peuvent être déployés sur Clore.ai des serveurs GPU. Parcourez les GPU disponibles et louez à l'heure — sans engagement, accès root complet.