Partage via

Gérer les registres de modèles dans Azure Machine Learning avec MLflow

  • Article

Azure Machine Learning prend en charge MLflow pour une gestion des modèles lorsqu’il est connecté à un espace de travail. Une telle approche constitue un bon moyen de prendre en charge l’intégralité du cycle de vie du modèle pour les utilisateurs familiarisés avec le client MLflow. L’article suivant décrit les différentes fonctionnalités et les compare à d’autres options.

Prérequis

  • Installer le package mlflow du SDK MLflow et le plug-in Azure Machine Learning pour MLflow azureml-mlflow.

    pip install mlflow azureml-mlflow

    Conseil

    Vous pouvez utiliser le package mlflow-skinny qui est un package MLflow léger sans dépendances de stockage SQL, de serveur, d’interface utilisateur ou de science des données. mlflow-skinny est recommandé pour les utilisateurs qui ont principalement besoin des fonctionnalités de suivi et de journalisation de MLflow, sans importer la suite complète de fonctionnalités, notamment les déploiements.

  • Un espace de travail Azure Machine Learning. Vous pouvez en créer un en suivant le tutoriel : Créer des ressources de Machine Learning.

  • Si vous effectuez un suivi à distance (autrement dit, des expériences de suivi qui s’exécutent en dehors d’Azure Machine Learning), configurez MLflow pour qu’il pointe vers l’URI de suivi de votre espace de travail Azure Machine Learning. Pour plus d’informations sur la connexion de MLflow à votre espace de travail, consultez Configurer MLflow pour Azure Machine Learning.

  • Notez que les registres d’organisation ne sont pas pris en charge pour une gestion des modèles avec MLflow.

  • Certaines opérations peuvent être exécutées directement avec l’API Fluent MLflow (mlflow.<method>). Toutefois, d’autres peuvent demander de créer un client MLflow, qui permet de communiquer avec Azure Machine Learning dans le protocole MLflow. Vous pouvez créer un objet MlflowClient comme suit. Ce tutoriel utilise l’objet client pour désigner ce client MLflow.

    import mlflow

client = mlflow.tracking.MlflowClient()

Inscription de nouveaux modèles dans le registre

Le registre de modèles offre un moyen pratique et centralisé de gérer des modèles dans un espace de travail. Chaque espace de travail a son propre registre de modèles indépendant. La section suivante explique plusieurs façons d’inscrire des modèles dans le registre à l’aide du Kit de développement logiciel (SDK) MLflow.

Création de modèles à partir d’une exécution existante

Si vous disposez d’un modèle MLflow connecté à l’intérieur d’une exécution et que vous souhaitez l’inscrire dans un registre, utilisez l’ID d’exécution et du chemin d’accès à l’emplacement où le modèle a été enregistré. Consultez Gérer les expériences et les exécutions avec MLflow pour savoir comment demander ces informations si vous ne les avez pas.

mlflow.register_model(f"runs:/{run_id}/{artifact_path}", model_name)

Notes

Les modèles ne peuvent être inscrits au registre que dans l’espace de travail où l’exécution était suivie. Actuellement, les opérations entre espaces de travail ne sont pas prises en charge dans Azure Machine Learning.

Conseil

Nous vous recommandons d’inscrire les modèles à partir d’exécutions ou d’utiliser la méthode mlflow.<flavor>.log_model depuis l’exécution, car celle-ci garde la traçabilité du travail qui a généré la ressource.

Création de modèles à partir de ressources

Si vous avez un dossier avec un modèle MLModel MLflow, vous pouvez l’inscrire directement. Il n’est pas nécessaire que le modèle soit toujours dans le contexte d’une exécution. Pour ce faire, vous pouvez utiliser le schéma d’URI file://path/to/model afin d’inscrire les modèles MLflow stockés dans le système de fichiers local. Nous allons créer un modèle simple en utilisant Scikit-Learn et l’enregistrer au format MLflow dans le stockage local :

from sklearn import linear_model

reg = linear_model.LinearRegression()
reg.fit([[0, 0], [1, 1], [2, 2]], [0, 1, 2])

mlflow.sklearn.save_model(reg, "./regressor")

Conseil

La méthode save_model() fonctionne de la même façon que log_model(). Pendant que la méthode log_model() enregistre le modèle dans une exécution active, la méthode save_model() utilise le système de fichiers local pour enregistrer le modèle.

Vous pouvez maintenant inscrire le modèle à partir du chemin d’accès local :

import os

model_local_path = os.path.abspath("./regressor")
mlflow.register_model(f"file://{model_local_path}", "local-model-test")

Interrogation des registres de modèles

Vous pouvez utiliser le Kit de développement logiciel (SDK) MLflow pour interroger et rechercher des modèles inscrits dans le registre. La section suivante explique plusieurs façons d’y parvenir.

Interrogation de tous les modèles dans le registre

Vous pouvez interroger tous les modèles inscrits dans le registre à l’aide du client MLflow. L’exemple suivant imprime tous les noms du modèle :

for model in client.search_registered_models():
    print(f"{model.name}")

Utilisez order_by pour trier par une propriété spécifique comme name, version, creation_timestampet last_updated_timestamp:

client.search_registered_models(order_by=["name ASC"])

Notes

Avis MLflow 2.0 : Dans les versions antérieures de Mlflow (<2.0), utilisez la méthode MlflowClient.list_registered_models() à la place.

Obtention de versions spécifiques du modèle

La commande search_registered_models() récupère l’objet du modèle qui contient toutes les versions du modèle. Toutefois, si vous souhaitez obtenir la dernière version de modèle inscrite pour un modèle donné, vous pouvez utiliser get_registered_model :

client.get_registered_model(model_name)

Si vous avez besoin d’une version spécifique du modèle, vous pouvez l’indiquer ainsi :

client.get_model_version(model_name, version=2)

Chargement de modèles à partir du registre

Vous pouvez charger des modèles directement à partir du registre pour restaurer les objets modèles enregistrés. Utilisez les fonctions mlflow.<flavor>.load_model() ou mlflow.pyfunc.load_model() en indiquant l’URI du modèle que vous souhaitez charger à l’aide de la syntaxe suivante :

  • models:/<model-name>/latest, pour charger la dernière version du modèle.
  • models:/<model-name>/<version-number>, pour charger une version spécifique du modèle.
  • models:/<model-name>/<stage-name>, pour charger une version spécifique dans une phase donnée pour un modèle. Consultez Phases de modèle pour plus d’informations.

Conseil

Pour en savoir plus sur la différence entre mlflow.<flavor>.load_model() et mlflow.pyfunc.load_model(), consultez Workflows de chargement de modèles MLflow.

Étapes du modèle

MLflow prend en charge les étapes du modèle pour gérer le cycle de vie du modèle. La version du modèle peut passer d’une étape à une autre. Les étapes sont attribuées à la version d’un modèle (au lieu des modèles), ce qui signifie qu’un modèle donné peut avoir plusieurs versions à différentes étapes.

Important

Les étapes sont accessibles uniquement à l’aide du kit de développement logiciel MLflow. Elles ne s’affichent pas dans le portail Azure ML Studio et ne peuvent pas être récupérés à l’aide du kit de développement logiciel (SDK) Azure ML, d’Azure ML CLI ni de l’API REST Azure ML. La création d’un déploiement à partir d’une étape donnée d’un modèle n’est pas prise en charge pour le moment.

Interrogation des étapes du modèle

Vous pouvez utiliser le client MLflow pour vérifier toutes les étapes possibles d’un modèle :

client.get_model_version_stages(model_name, version="latest")

Vous pouvez voir quelle version du modèle est à chaque étape en obtenant le modèle à partir du registre. L’exemple suivant permet d’obtenir la version du modèle actuellement à l’étape Staging.

client.get_latest_versions(model_name, stages=["Staging"])

Remarque

Plusieurs versions peuvent se trouver à la même étape dans MLflow. Toutefois, cette méthode retourne la dernière version (version supérieure) parmi toutes ces versions.

Avertissement

Les noms d’étape respectent la casse.

Transition de modèles

La transition de la version d’un modèle vers une étape particulière peut être effectuée à l’aide du client MLflow.

client.transition_model_version_stage(model_name, version=3, stage="Staging")

Par défaut, s’il existait une version de modèle à cette étape particulière, elle y reste. Par conséquent, elle n’est pas remplacée, dans la mesure où plusieurs versions du modèle peuvent être à la même étape simultanément. Vous pouvez également spécifier archive_existing_versions=True pour indiquer à MLflow de déplacer la version du modèle existant à l’étape Archived.

client.transition_model_version_stage(
    model_name, version=3, stage="Staging", archive_existing_versions=True
)

Chargement de modèles à partir d’étapes

Vous pouvez charger un modèle à une étape particulière directement à partir de Python à l’aide de la fonction load_model et du format d’URI suivant. Notez que pour que cette méthode réussisse, toutes les bibliothèques et dépendances doivent être déjà installées dans l’environnement sur lequel vous travaillez.

model = mlflow.pyfunc.load_model(f"models:/{model_name}/Staging")

Modification et suppression des modèles

La modification des modèles inscrits est prise en charge dans Mlflow et Azure ML. Toutefois, il existe quelques différences importantes à noter :

Avertissement

Il n’est pas possible de changer le nom des modèles dans Azure Machine Learning, car les objets de modèle sont immuables.

Modification de modèles

Vous pouvez modifier la description et les balises d’un modèle à l’aide de MLflow :

client.update_model_version(model_name, version=1, description="My classifier description")

Pour modifier des balises, vous devez utiliser la méthode set_model_version_tag et remove_model_version_tag :

client.set_model_version_tag(model_name, version="1", key="type", value="classification")

Suppression d’une balise :

client.delete_model_version_tag(model_name, version="1", key="type")

Suppression d’une version de modèle

Vous pouvez supprimer n’importe quelle version de modèle dans le registre à l’aide du client MLflow, comme illustré dans l’exemple suivant :

client.delete_model_version(model_name, version="2")

Notes

Azure Machine Learning ne prend pas en charge la suppression de l’intégralité du conteneur de modèle. Pour obtenir la même chose, vous devez supprimer toutes les versions de modèle d’un modèle donné.

Matrice de prise en charge pour la gestion des modèles avec MLflow

Le client MLflow expose plusieurs méthodes pour récupérer et gérer des modèles. Le tableau suivant indique quelles méthodes sont actuellement prises en charge dans MLflow dans le cadre d’une connexion à Azure ML. Il compare également cette solution à d’autres fonctionnalités de gestion des modèles dans Azure ML.

Fonctionnalité MLflow Azure ML avec MLflow Azure ML CLIv2 Azure ML Studio
Inscription de modèles au format MLflow ✓ ✓ ✓ ✓
Inscription de modèles hors format MLflow ✓ ✓
Inscription de modèles à partir de sorties/artefacts d’exécution ✓ ✓1 ✓2 ✓
Inscription de modèles à partir d’exécutions/artefacts dans un autre serveur/espace de travail de suivi ✓ ✓5 ✓5
Rechercher/répertorier des modèles inscrits ✓ ✓ ✓ ✓
Récupération des détails des versions du modèle inscrit ✓ ✓ ✓ ✓
Modification de la description des versions du modèle inscrit ✓ ✓ ✓ ✓
Modification des balises des versions du modèle inscrit ✓ ✓ ✓ ✓
Attribution d’un nouveau nom aux modèles inscrits ✓ 3 3 3
Suppression d’un modèle inscrit (conteneur) ✓ 3 3 3
Suppression de la version d’un modèle inscrit ✓ ✓ ✓ ✓
Gestion des étapes du modèle MLflow ✓ ✓
Recherche des modèles inscrits par nom ✓ ✓ ✓ ✓4
Recherche des modèles inscrits à l’aide des comparateurs de chaînes LIKE et ILIKE ✓ ✓4
Recherche des modèles inscrits par balise ✓4
Prise en charge des Registres d’organisation ✓ ✓

Remarque

  • 1 Utiliser des URI au format runs:/<ruin-id>/<path>.
  • 2 Utiliser des URI au format azureml://jobs/<job-id>/outputs/artifacts/<path>.
  • 3 Les modèles inscrits sont des objets immuables dans Azure ML.
  • 4 Utiliser la zone de recherche dans Azure ML Studio. Correspondance partielle prise en charge.
  • 5 Utiliser des registres pour déplacer des modèles entre différents espaces de travail tout en conservant la traçabilité des données.

Étapes suivantes