Partager via

Gérer le registre des 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. 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 du SDK MLflow mlflow et le plug-in azureml-mlflow d’Azure Machine Learning pour MLflow de la manière suivante :

    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. Ce package 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.

  • Créez un espace de travail Azure Machine Learning. Pour créer un espace de travail, consultez Créer les ressources dont vous avez besoin pour commencer. Examinez les autorisations d’accès nécessaires pour effectuer vos opérations MLflow dans votre espace de travail.

  • Pour effectuer un suivi à distance, autrement dit, pour suivre 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)

Remarque

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

Conseil

Inscrivez des modèles à partir d’exécutions ou à l’aide de la méthode mlflow.<flavor>.log_model à partir de l’exécution. Cette approche préserve la traçabilité du travail qui a généré la ressource.

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

Conseil

La méthode save_model() fonctionne de la même façon que la méthode log_model(). Alors que la méthode log_model() enregistre le modèle à l’intérieur d’une exécution active, la méthode save_model() utilise le système de fichiers local pour enregistrer le modèle.

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

Remarque

Pour les versions de MLflow antérieures à la version 2.0, utilisez plutôt la méthode MlflowClient.list_registered_models().

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.

Important

Les étapes sont accessibles uniquement à l’aide du Kit de développement logiciel (SDK) MLflow. Elles ne sont pas visibles dans Azure Machine Learning studio. Les étapes ne peuvent pas être récupérées à l’aide du Kit de développement logiciel (SDK) Azure Machine Learning, de l’interface CLI Azure Machine Learning ou de l’API REST Azure Machine Learning. Le déploiement à partir d’une étape de modèle spécifique n’est actuellement pas pris en charge.

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.

Important

Dans le Kit de développement logiciel (SDK) MLflow, les noms d’étape respectent la casse.

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.

Remarque

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

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

Remarque

Machine Learning ne prend pas en charge la suppression de l’intégralité du conteneur de modèle. Pour effectuer cette tâche, supprimez toutes les versions de modèle d’un modèle donné.

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.


Description de la fonctionnalité		 MLflow uniquement Machine Learning avec MLflow Interface CLI Machine Learning v2 Studio Machine Learning
Inscrire des modèles au format MLflow ✓ ✓ ✓ ✓
Inscrire des modèles qui ne sont pas au format MLflow ✓ ✓
Inscrire des modèles à partir de sorties/d’artefacts d’exécution ✓ ✓ 1 ✓ 2 ✓
Inscrire des modèles à partir de sorties/d’artefacts d’exécution dans un autre serveur de suivi/espace de travail ✓ ✓ 5 ✓ 5
Rechercher/répertorier des modèles inscrits ✓ ✓ ✓ ✓
Récupération des détails des versions du modèle inscrit ✓ ✓ ✓ ✓
Modifier la description des versions du modèle inscrit ✓ ✓ ✓ ✓
Modifier les balises de versions du modèle inscrit ✓ ✓ ✓ ✓
Renommer des modèles inscrits ✓ 3 3 3
Supprimer un modèle inscrit (conteneur) ✓ 3 3 3
Supprimer la version d’un modèle inscrit ✓ ✓ ✓ ✓
Gestion des étapes du modèle MLflow ✓ ✓
Recherche des modèles inscrits par nom ✓ ✓ ✓ ✓ 4
Rechercher 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 ✓ ✓

Notes de bas de page du tableau :

  • 1 Utilisez des URI (Uniform Resource Identifiers) avec le format runs:/<ruin-id>/<path>.
  • 2 Utilisez des URI au format azureml://jobs/<job-id>/outputs/artifacts/<path>.
  • 3 Les modèles inscrits sont des objets immuables dans Azure Machine Learning.
  • 4 Utilisez la zone de recherche dans Azure Machine Learning studio. La correspondance partielle est prise en charge.
  • 5 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