Tu entraînes un modèle, tu changes un paramètre, tu relances, tu changes encore, et au bout de dix essais tu ne sais plus lequel avait le meilleur score. C'est le quotidien de quiconque fait du machine learning sans carnet de bord. Résultat : on retombe toujours sur les mêmes réglages par défaut, et on perd des heures à refaire ce qu'on avait déjà trouvé.
MLflow règle ce problème. C'est un outil open source qui journalise automatiquement chaque expérience : les paramètres utilisés, les métriques obtenues, et même le modèle entraîné. À la fin, tu retrouves le meilleur run en une ligne, tu le recharges, et tu l'utilises en production. Voici comment t'y mettre en Python.
Étape 1 : installer MLflow
MLflow s'installe comme n'importe quel paquet Python. On l'accompagne de scikit-learn, qui nous fournit les données et le modèle de démonstration.
pip install mlflow scikit-learnÉtape 2 : ouvrir le carnet de bord
MLflow enregistre tout dans un backend de suivi (tracking store). La version moderne utilise SQLite, un simple fichier de base de données, parfait pour démarrer en local. On crée aussi une expérience pour regrouper les runs qui vont ensemble.
import mlflow
# Le carnet de bord : un fichier SQLite local
mlflow.set_tracking_uri("sqlite:///mlflow.db")
# Une expérience = un regroupement thématique de runs
mlflow.set_experiment("digits-logistic-regression")Étape 3 : préparer les données
Pour la démonstration, on entraîne une régression logistique sur le jeu de données digits de scikit-learn : 1 797 images de chiffres manuscrits, chacune codée en 64 valeurs (une grille de 8x8 pixels). Le but : reconnaître le chiffre dessiné.
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
X, y = load_digits(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.25, random_state=42
)Étape 4 : lancer les expériences
Un run, c'est une tentative avec un jeu de réglages précis. Ici, on fait varier C, le paramètre de régularisation de la régression logistique. Pour chaque valeur, on ouvre un run, on note le paramètre, on entraîne, puis on journalise le score et le modèle.
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
import mlflow.sklearn
for C in [0.001, 0.01, 0.1, 1.0, 10.0]:
with mlflow.start_run(run_name=f"logreg-C={C}"):
mlflow.log_param("C", C)
model = LogisticRegression(C=C, max_iter=5000)
model.fit(X_train, y_train)
acc = accuracy_score(y_test, model.predict(X_test))
mlflow.log_metric("accuracy", acc)
mlflow.sklearn.log_model(model, name="model")À chaque itération, MLflow consigne trois choses : le paramètre (log_param), la métrique (log_metric) et le modèle lui-même (log_model). Le bloc with mlflow.start_run() délimite proprement chaque tentative : pas besoin de nettoyer quoi que ce soit à la main. Sur digits, la valeur C=0.001 régularise trop et fait chuter le score autour de 0.958, tandis que C=0.1 frôle les 0.976. Sans MLflow, tu aurais dû noter ces chiffres à la main.
Étape 5 : retrouver le meilleur modèle
Voilà le cœur du sujet. Une fois tes runs terminés, tu interroges le carnet de bord pour retrouver celui qui a le meilleur score, puis tu recharges son modèle en une ligne. Fini les fichiers nommés modele_v2_final_OK.py qui traînent dans tous les dossiers.
import mlflow
import mlflow.sklearn
# Trier les runs par accuracy décroissante
runs = mlflow.search_runs(order_by=["metrics.accuracy DESC"])
best = runs.iloc[0]
print(f"Meilleur run : {best['run_id']}")
print(f"Accuracy : {best['metrics.accuracy']:.4f} — C={best['params.C']}")
# Recharger le modèle gagnant et prédire
model = mlflow.sklearn.load_model(f"runs:/{best['run_id']}/model")
print(model.predict([X_test[0]]))Étape 6 : visualiser tout ça
MLflow embarque une interface web qui lit directement ton carnet de bord. Une commande, et tu compares tes runs dans un tableau, avec des graphiques.
mlflow ui --backend-store-uri sqlite:///mlflow.dbOuvre ensuite http://127.0.0.1:5000 dans ton navigateur. Tu y retrouves tous tes runs, leurs paramètres, leurs métriques, et tu peux les comparer côte à côte.
MLflow ne remplace ni scikit-learn ni ton modèle : il les encadre. Dès que tu enchaînes plus de deux expériences, le carnet de bord devient indispensable — tu sais exactement ce qui a été essayé, avec quels réglages, et quel résultat. La prochaine fois que tu lanceras des dizaines d'essais pour trouver les bons hyperparamètres, tu ne repartiras plus de zéro. Et le jour où tu passes en production, tu exporteras le modèle gagnant en un clin d'œil, versionné et prêt à servir.
