MLflow : tout savoir sur l’outil indispensable du MLOps

MLflow est une plateforme open source qui permet de gérer le cycle de vie des modèles de Machine Learning. En particulier, grâce à MLflow, les modèles qui ont été entraînés à une date spécifique ainsi que les hyper-paramètres associés pourront être stockés, monitorés et réutilisés de manière efficace.

Un des principaux avantages est l'intégration avec des frameworks Python existants comme Scikit-Learn, XGBoost ou encore TensorFlow, rendant l'outil utilisable dans de nombreuses situations. De plus, son API Python est simple à utiliser, permettant de l'intégrer rapidement dans des projets existants.

Concepts de MLflow

Rappelons tout d'abord le workflow en Data Science : la première étape de collecte des données et suivie d'une étape de transformation des données, puis de la modélisation pour maximiser une métrique de performance qui jugera de la qualité de l'algorithme employé.

Être productif en Data Science n'est pas de tout repos pour les raisons suivantes.

• Il est difficile de garder une trace des précédentes expériences. Une chose à laquelle beaucoup de Data Scientists font face, c'est de faire une série d'expérimentations en modifiant algorithmes et paramètres, ce qui peut s'avérer contre-productif si l'on ne dispose pas de l'historique des modèles et de leurs performances. En général, méthode qui consiste à modifier le nom de chaque Notebook peut s'avérer vite contraignante.
• Il est difficile de reproduire le code. Dans les projets Data Science, une multitude de fonctions permettent d'arriver à un résultat bien précis : le changement de quelques lignes de code peut grandement affecter le modèle et ses performances.
• Il n'y a aucun standard sur le packaging et le déploiement de modèles. Chaque équipe possède son approche pour déployer les modèles, et ce sont souvent les grandes équipes avec un passif dans les projets Machine Learning qui peuvent se le permettre.
• Il n'y a aucun point central pour gérer les modèles. En pratique, la solution naïve consiste à sauvegarder les paramètres dans des fichiers sur le même serveur hébergeant l'algorithme, en stockage local. Le problème, c'est que cette solution créé une forte dépendance avec le serveur qui entraîne le modèle, ce qui est contraire à l'approche MLOps.

À lire aussi : découvrez notre formation MLOps

Beaucoup de pain points que MLflow va justement chercher à résoudre.

MLflow cherche à améliorer la productivité en offrant la possibilité de ré-entraîner, réutiliser et déployer des modèles en agissant sur un point central (plateforme MLflow) où tout l'historique du modèle sera conservé.

Tout d'abord, MLflow est language-agnostic, c'est-à-dire que les modèles peuvent être codés en Python, R, Java ou encore C++ et envoyés sur MLflow. Ensuite, il n'y a aucun pré-requis concernant la librairie de Machine Learning : que vous soyez adeptes de scikit-learn ou de tensorflow, tout sera compatible.

Quatre composants résident sous MLflow.

• MLflow Tracking est l'API et l'interface utilisateur pour logger les hyper-paramètres, le versioning de code et les artifacts (configuration du modèle, fichier de poids, ...).
• MLflow Projects est un format standard pour package un code source et le réutiliser dans plusieurs projets.
• MLflow Models est un format de packaging pour les modèles de Machine Learning.
• MLflow Registry est le registre de modèle (comme un git de modèles) qui permet de s'assurer que les modèles respectent certaines contraintes.

Prise en main de MLflow

Pour installer MLflow en local, il suffit juste d'exécuter pip install mlflow .

Dans cet exemple Python, nous chargeons des fichiers CSV qui correspondent aux sous-ensembles d'entraînement et de test.

import os
import numpy as np
import pandas as pd

import mlflow
import mlflow.sklearn # Wrapper pour scikit-learn

from lightgbm.sklearn import LGBMClassifier
from sklearn.metrics import f1_score

X_train = pd.read_csv("~/data/X_train.csv")
X_test = pd.read_csv("~/data/X_test.csv")
y_train = pd.read_csv("~/data/y_train.csv").values.flatten()
y_test = pd.read_csv("~/data/y_test.csv").values.flatten()

Ensuite, nous pouvons définir l'URL de tracking MLflow avec set_tracking_uri, puis définir l'expérience avec set_experiment. Une expérience MLflow correspond à tous les modèles pour un même projet.

Ensuite, nous pouvons démarrer une exécution avec start_run : tout ce qui sera produit (configuration, métriques, modèle, etc) sera associé à cette exécution, améliorant grandement le tracking.

# Identification de l'interface MLflow
mlflow.set_tracking_uri("file://" + os.path.expanduser('~/mlruns'))
# Identification du nom du projet MLflow
mlflow.set_experiment("experiment_blent")

with mlflow.start_run() as run:
    model = LGBMClassifier(**hyp_params, objective="binary", verbose=-1)
    model.fit(X_train, y_train)

    # On calcule le score du modèle sur le test
    score = f1_score(y_test, model.predict(X_test))

    mlflow.log_params(hyp_params)
    mlflow.log_metric("f1", score)

    print(mlflow.get_artifact_uri())
    mlflow.sklearn.log_model(model, "model")

En exécutant ce code, nous avons déclenché un run avec mlflow.start_run(). L'intérêt d'utiliser with est qu'en sortant de l'indentation, le run MLflow sera automatiquement terminé. Nous allons envoyer plusieurs informations vers MLflow.

• Les hyper-paramètres du modèle avec log_params.
• La ou les métriques obtenues sur un échantillon avec log_metric.
• Le modèle au format de scikit-learn avec log_model.

En visualisant l'interface web MLflow, nous voyons le modèle apparaître avec les informations associées.

En cliquant sur la date d'exécution, nous avons accès à plus de détails ainsi qu'aux fichiers stockés (ici le modèle), que l'on appelle des artifacts.

MLflow peut également stocker des images, notamment des graphiques qui permettront de contrôler la qualité d'un modèle de Machine Learning.

Registre de modèle

Le Model Registry (registre de modèles) est un composant de MLflow qui permet de gérer des versions de modèles de Machine Learning, en proposant également des stages (états).

• Le tag staging correspond à un modèle considéré comme pré-production.
• Le tag production correspond à un modèle qui serait en environnement de production.
• Le tag archived pour les anciens modèles archivés.

À lire aussi : découvrez notre formation MLOps

C'est un composant particulièrement utile pour gérer le cycle de vie des modèles, car le cycle staging, production et archive est couramment appliqué lorsque des modèles sont mis à jour régulièrement. Sous MLflow, l'onglet Models permet d'afficher tous les modèles enregistrés.

Là-aussi, il est très facile d'interagir avec MLflow en Python.

# On envoie le modèle vers le registry
result = mlflow.register_model(
    "runs:/{}/artifacts/model".format(run.run_id), "model_blent"
)
print(result.version)

# On tag le modèle en verison staging
client = MlflowClient()
client.transition_model_version_stage(
    name="model_blent", version=int(version), stage="Staging"
)

Quand utiliser MLflow ?

De manière générale, MLflow peut être utilisé aussi bien dans les environnements de production, qu'en développement local. En effet, nous avons vu qu'il est très facile d'installer MLflow en local, ce qui permet de l'utiliser dès la création d'un projet jusqu'à sa mise en production.

• En local, lorsque l'on travaille seul sur un projet et que l'on cherche à optimiser un modèle de Machine Learning. Cela permet d'utiliser le composant Tracking pour historiser toutes les expérimentations réalisées.
• Sur un serveur partagé, lorsque l'on travaille à plusieurs sur un projet. Dans cette situation, on évite d'envoyer les modèles et les paramètres entre les utilisateurs : on utilise directement MLflow à la place, qui va historiser au niveau du projet l'ensemble des expérimentations de chaque utilisateur.
• Sur un serveur Cloud ou On-Premise, dans les pipelines d'automatisation MLOps. Ce cas de figure permet d'utiliser MLflow pour héberger des modèles qui seraient produits via des pipelines d'automatisation : en séparant le pipeline qui entraîne le modèle de celui qui le déploie, on assure une bien meilleure livraison sur plusieurs aspects (maintenance, sécurité, fiabilité).

Se former sur MLflow

De plus en plus de Data Scientists utilisent MLflow, que ce soit pour historiser les itérations du cycle Machine Learning, ou pour utiliser le registre de modèles en environnement de production. Cet outil devient indispensable dans les entreprises qui souhaitent améliorer leur efficacité opérationnelle sur la gestion des projets ML.

La formation MLOps de Blent utilise MLflow en tant que plateforme de tracking et de registre de modèles de Data Science. Elle est utilisée dans différents environnements, en pré-production et en production.

Cette formation couvre également de nombreux aspects de l'approche MLOps, comme la création de projets code source adaptés à la Data Science, l'automatisation de pipelines de Machine Learning ou l'exposition de modèles scalables sur Kubernetes.