MINI-COURS      ⏱️ 21 – 25 minutes de lecture

🔒 Contenu réservé aux membres du Cercle des Experts
Débloque la leçon complète et tous les autres mini-cours.

De ton poste à l'équipe : automatiser, partager, gouverner

Dans le premier volet, tu as instrumenté un script scikit-learn : chaque run enregistre ses paramètres, ses métriques et son modèle, et tu les retrouves dans l'interface web. Mais tout reste encore sur ta machine, et chaque log_param() est écrit à la main.

Ce second volet règle les trois limites qui restent. Un : l'autologging, pour que MLflow enregistre presque tout seul. Deux : le serveur de tracking, pour que toute l'équipe lise et écrive au même endroit. Trois : la vie du modèle lui-même, avec le format de sauvegarde, le Model Registry (versions, alias, tags) et un mot sur les Projects.

Tout s'appuie sur le même petit jeu de données que dans le premier volet : si tu as le fichier c01_data.py, tu as tout ce qu'il faut.

🧪 Testé avec MLflow 3.18, scikit-learn 1.9 et Python 3.13 (novembre 2026).

PARTIE 8
Autologging : laisse MLflow tout noter

Jusqu'ici, tu as écrit chaque log_params() et chaque log_metrics() toi-même. C'est précis, mais répétitif, et tu peux oublier un hyperparamètre. L'autologging automatise cette étape : MLflow détecte la bibliothèque que tu utilises et enregistre à ta place les paramètres, les métriques et des artefacts utiles.

Deux écritures existent. mlflow.autolog() active l'autologging pour toutes les bibliothèques prises en charge. mlflow.sklearn.autolog() le fait seulement pour scikit-learn, ce que je te conseille : tu sais exactement ce qui est actif. Quelques paramètres contrôlent ce qui est enregistré :

  • log_models : enregistrer ou non le modèle entraîné ;

  • log_datasets : enregistrer ou non des informations sur les jeux de données ;

  • log_input_examples et log_model_signatures : joindre un exemple d'entrée et la signature du modèle ;

  • disable : désactiver tous les autologgings pris en charge ;

  • exclusive : n'enregistrer que dans les runs que tu as démarrés toi-même, sans créer de run automatique ;

  • silent : supprimer les messages et avertissements de MLflow pendant l'autologging.

Sans autologging, plus ton expérimentation grandit, plus le logging manuel alourdit le code et en dégrade la lisibilité. Avec lui, ton script reste celui d'un entraînement scikit-learn ordinaire.

Voici le même entraînement que dans le premier volet, sans aucun appel log_params() ni log_metrics() : le script ne contient que autolog() pour MLflow.

Un détail sur log_models=False : par défaut, l'autologging sauvegarde aussi le modèle, et j'ai constaté qu'il le fait au format pickle (model.pkl, serialization_format vaut cloudpickle par défaut dans mlflow.sklearn.autolog()). On préfère enregistrer le modèle nous-mêmes avec mlflow.sklearn.log_model(), au format skops (tu le revois dans la partie Models). On coupe donc cette option.

Qu'a enregistré MLflow, alors que tu n'as rien demandé ? Lis le run avec search_runs() :

19 paramètres enregistrés, dont :
{'criterion': 'gini', 'max_depth': '5', 'n_estimators': '100'}
training_precision_score = 0.924
training_recall_score = 0.924
training_f1_score = 0.924
training_accuracy_score = 0.924
training_log_loss = 0.204
training_roc_auc = 0.981
training_score = 0.924
RandomForestClassifier_score_X_test = 0.920

Trois choses à retenir de cette sortie :

  • tous les hyperparamètres de l'estimateur sont enregistrés, pas seulement ceux que tu as fixés : les 19 paramètres de RandomForestClassifier, valeurs par défaut comprises ;

  • les métriques d'entraînement (précision, rappel, F1, accuracy, log loss, AUC) sont calculées sur le jeu d'entraînement, avec le préfixe training_ ;

  • ton appel à score() est lui aussi capté : la dernière ligne vient de rf.score(X_test, y_test), enregistrée sous le nom RandomForestClassifier_score_X_test.

Interface MLflow : l'onglet Artifacts du run rf-autolog affiche une matrice de confusion normalisée générée automatiquement

Côté artefacts, l'autologging ajoute un résumé de l'estimateur (estimator.html), un fichier metric_info.json et trois graphiques d'entraînement : matrice de confusion, courbe ROC et courbe précision-rappel. C'est le genre de détail qu'on ne prend jamais le temps de produire à la main.

Attention à une limite : les métriques d'entraînement ne sont pas des métriques de généralisation. Pour comparer des modèles sérieusement, logge toi-même une métrique calculée sur le jeu de test, comme tu l'as fait dans le premier volet. Les deux approches se combinent très bien dans le même script.

PARTIE 9
Le serveur de tracking : un endroit pour toute l'équipe

Tant que MLflow écrit dans un dossier de ta machine, tes résultats restent à toi. Un serveur de tracking change cela : c'est un service central vers lequel chaque membre de l'équipe envoie ses runs et depuis lequel il lit ceux des autres. Il sert l'interface web au même endroit, et peut aussi relayer l'accès aux artefacts, ce qui simplifie la sécurisation et l'audit des accès.

Concrètement, ce serveur apporte trois choses :

  • la collaboration : plusieurs personnes envoient leurs runs vers le même point d'accès, et interrogent les runs et les modèles des autres ;

  • le partage des résultats : le serveur sert aussi l'interface web, où chacun explore les résultats de ses collègues ;

  • un accès centralisé : le serveur peut jouer le rôle de proxy pour l'accès distant aux métadonnées et aux artefacts, ce qui facilite la sécurisation et l'audit des accès.

En regroupant toutes les informations de runs sur un point d'accès partagé, il donne à l'équipe une vue unifiée des expériences et des modèles.

Un serveur de tracking repose sur deux espaces de stockage :

  • le backend store, qui contient les métadonnées (expériences, runs, paramètres, métriques, tags). C'est ta base SQLite mlflow.db en local ; en équipe, on passe souvent à une base de type PostgreSQL ;

  • l'artifact store, qui contient les fichiers volumineux (modèles, graphiques, données de sortie). En local, c'est un dossier ; en équipe, un stockage partagé ou un bucket cloud.

Par-dessus, un composant de communication gère les échanges : le serveur expose une API HTTP, et c'est elle que ton code interroge quand tu lui indiques l'adresse du serveur. Voici le démarrage le plus simple, sur ta machine :

mlflow server --backend-store-uri sqlite:///mlflow.db --default-artifact-root ./mlartifacts --host 127.0.0.1 --port 5000

Terminal : la commande mlflow server et son message de démarrage, avec le middleware de sécurité en mode localhost uniquement

--backend-store-uri désigne la base des métadonnées et --default-artifact-root le dossier des artefacts. Le message de démarrage indique que le middleware de sécurité est actif, en mode localhost uniquement : le serveur n'accepte que les connexions locales.

⚠️ Sécurité : à lire avant de partager

Le serveur n'a aucune authentification par défaut : toute personne qui l'atteint peut lire et écrire tes expériences. Ne l'expose donc jamais tel quel sur Internet. Depuis MLflow 3.5, le middleware de sécurité limite par défaut l'accès à localhost. Pour accepter d'autres machines, il faut passer --host 0.0.0.0 et déclarer explicitement --allowed-hosts et --cors-allowed-origins, ce qui ne remplace pas une vraie authentification : place le serveur derrière un proxy ou un réseau privé. Détails dans la documentation de sécurité.

Une fois le serveur lancé, ton code n'a qu'une ligne de plus : l'URI du serveur. Le reste de ton script ne change pas.

Ouvre http://127.0.0.1:5000 : tu retrouves ces trois runs dans l'interface, servie par le serveur. Les artefacts, eux, atterrissent dans le dossier mlartifacts du serveur, et non plus dans mlruns : c'est le serveur qui décide où ranger les fichiers.

💡 En continuant, tu vas découvrir :

  • Comment retrouver le modèle exact d'un run et le recharger par son identifiant, avec l'interface scikit-learn ou l'interface générique pyfunc

  • Comment enregistrer un modèle dans le Model Registry pour que ton code d'inférence ne dépende plus d'un identifiant de run

  • Comment les alias et les tags permettent de changer de modèle en production en une seule ligne, sans toucher à ton code d'inférence

  • Comment promouvoir une version en la copiant vers un autre modèle enregistré, et comment lancer un projet reproductible avec mlflow run

logo

La suite de ce mini-cours est réservée aux membres du Cercle des Experts.

Tu as déjà le début. Pour accéder à l’explication complète et aux autres mini-cours, rejoins le Cercle des Experts.

Rejoindre le Cercle des Experts

En devenant membre, tu débloques :

  • L’intégralité de ce mini-cours, sans coupure
  • Tous les mini-cours et les ressources associées
  • Chaque nouveau mini-cours dès sa sortie

Commentaires

Avatar

ou participer

À lire ensuite

Des shots dans la même veine, à lire entre deux tâches.

Voir tous les shots
caret-right