Gérer le registre des modèles dans Azure Machine Learning avec MLflow

Azure Machine Learning prend en charge MLflow pour une gestion des modèles lorsqu’il est connecté à un espace de travail. Cette approche est un moyen pratique de prendre en charge l’ensemble du cycle de vie du modèle pour les utilisateurs familiarisés avec le client MLFlow.

Cet article décrit les fonctionnalités de gestion d’un registre de modèles avec MLflow et la comparaison de cette méthode avec d’autres options de gestion.

Prérequis

• Installer le package mlflow du SDK MLflow et le plug-in azureml-mlflow d’Azure Machine Learning pour 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. Pour créer un espace de travail, consultez le tutoriel Créer des ressources de Machine Learning. Examinez les autorisations d’accès nécessaires pour effectuer vos opérations MLflow dans votre espace de travail.

• Si vous effectuez un suivi à distance (autrement dit, vous suivez des expériences 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.

• Les procédures de cet article utilisent un objet client pour faire référence au client MLflow.

  Certaines opérations peuvent être exécutées directement avec l’API Fluent MLflow, mlflow.<method>. D’autres opérations nécessitent un client MLflow pour activer la communication avec Machine Learning dans le protocole MLflow. Le code suivant crée un objet MlflowClient :

  import mlflow
  
  client = mlflow.tracking.MlflowClient()
  

Limites

• Azure Machine Learning ne prend pas en charge le changement de nom des modèles.

• Machine Learning ne prend pas en charge la suppression de l’intégralité du conteneur de modèle.

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

• Le déploiement de modèle à partir d’une étape de modèle spécifique n’est actuellement pas pris en charge dans Machine Learning.

• Les opérations entre espaces de travail ne sont actuellement pas prises en charge dans Machine Learning.

Inscrire de nouveaux modèles

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. Les sections suivantes illustrent deux façons d’inscrire des modèles dans le registre à l’aide du Kit de développement logiciel (SDK) MLflow.

Créer des 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 le chemin d’accès à l’emplacement où le modèle est enregistré. Vous pouvez interroger ces informations en suivant les instructions fournies dans Gérer les expériences et les exécutions avec MLflow.

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

Créer des modèles à partir de ressources

Si vous avez un dossier avec un modèle MLflow MLModel, 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 cette approche, 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.

Le code suivant crée un modèle simple à l’aide du package scikit-learn et enregistre le modèle 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")

Le code suivant inscrit le modèle à l’aide 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")

Interroger 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. Les sections suivantes illustrent deux façons d’interroger un modèle.

Interroger tous les modèles dans le registre

Vous pouvez interroger tous les modèles inscrits dans le registre à l’aide du client MLflow.

Le code suivant imprime les noms de tous les modèles dans le registre :

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

Utilisez la méthode order_by pour organiser la sortie par une propriété spécifique, telle que name, version, creation_timestamp ou last_updated_timestamp :

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

Obtenir des versions de modèle spécifiques

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

client.get_registered_model(model_name)

Pour obtenir une version spécifique d’un modèle, utilisez le code suivant :

client.get_model_version(model_name, version=2)

Charger des modèles à partir du registre

Vous pouvez charger des modèles directement à partir du registre pour restaurer les objets modèles enregistrés. Pour cette tâche, utilisez les fonctions mlflow.<flavor>.load_model() ou mlflow.pyfunc.load_model() et indiquez l’URI du modèle à charger.

Vous pouvez implémenter ces fonctions avec la syntaxe suivante :

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

Pour comprendre les différences entre les fonctions mlflow.<flavor>.load_model() et mlflow.pyfunc.load_model(), consultez Flux de travail pour le chargement de modèles MLflow.

Utiliser des étapes de modèle

MLflow prend en charge les étapes d’un 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 affectées à des versions spécifiques pour un modèle. Un modèle peut avoir plusieurs versions à différentes étapes.

Interroger les étapes de modèle

Le code suivant utilise 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 les versions de modèle pour chaque étape de modèle en récupérant le modèle à partir du registre. Le code suivant obtient la version du modèle actuellement à l’étape Staging :

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

Plusieurs versions de modèle peuvent être à la même étape en même temps dans MLflow. Dans l’exemple précédent, la méthode retourne la dernière version (la plus récente) parmi toutes les versions de l’étape.

Effectuer la transition d’une version de modèle

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")

Lorsque vous passez une version de modèle à une étape particulière, si l’étape comporte déjà d’autres versions de modèle, les versions existantes restent inchangées. Ce comportement s’applique par défaut.

Une autre approche consiste à définir le paramètre archive_existing_versions=True pendant la transition. Cette approche indique à MLflow de déplacer toutes les versions de modèle existantes à l’étape Archived :

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

Charger des 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. Pour que cette méthode réussisse, toutes les bibliothèques et dépendances doivent être installées dans votre environnement de travail.

Chargez le modèle à partir de l’étape Staging :

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

Modifier et supprimer des modèles

La modification des modèles inscrits est prise en charge dans MLflow et Azure Machine Learning, mais il existe quelques différences importantes. Les sections suivantes décrivent certaines des options disponibles.

Modifier la description et les balises du modèle

Vous pouvez modifier la description et les balises d’un modèle à l’aide du Kit de développement logiciel (SDK) MLflow :

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

Pour modifier les balises, utilisez les méthodes set_model_version_tag et remove_model_version_tag :

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

Pour supprimer une balise, utilisez la méthode delete_model_version_tag :

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

Supprimer une version de modèle

Vous pouvez supprimer n’importe quelle version de modèle dans le registre à l’aide du client MLflow :

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

Passer en revue les fonctionnalités prises en charge pour la gestion des modèles

Le client MLflow expose plusieurs méthodes pour récupérer et gérer des modèles. Le tableau suivant répertorie les méthodes actuellement prises en charge dans MLflow lors de la connexion à Azure Machine Learning. Il compare également MLflow à d’autres fonctionnalités de gestion des modèles dans Azure Machine Learning.

Notes de bas de page du tableau :

• ¹ Utilisez des URI (Uniform Resource Identifiers) avec le format runs:/<ruin-id>/<path>.
• ² Utilisez des URI au format azureml://jobs/<job-id>/outputs/artifacts/<path>.
• ³ Les modèles inscrits sont des objets immuables dans Azure Machine Learning.
• ⁴ Utilisez la zone de recherche dans Azure Machine Learning studio. La correspondance partielle est prise en charge.
• ⁵ Utilisez des registres pour déplacer des modèles entre différents espaces de travail tout en conservant la traçabilité des données.

Contenu connexe

• Explorer la journalisation des modèles MLflow
• Interroger et comparer des expériences et des exécutions avec MLflow
• Passez en revue les instructions de déploiement de modèles MLflow