Partager via

Journaliser des métriques, des paramètres et des fichiers avec MLflow

  • Article

S’APPLIQUE À : Kit de développement logiciel (SDK) Python azure-ai-mlv2 (préversion)

Azure Machine Learning prend en charge les expériences de journalisation et de suivi à l’aide de MLflow Tracking. Vous pouvez journaliser des modèles, des métriques, des paramètres et des artefacts avec MLflow, localement sur votre ordinateur ou dans un environnement cloud.

Important

Contrairement au SDK Azure Machine Learning v1, il n’existe aucune fonctionnalité de journalisation dans le SDK Azure Machine Learning pour Python (v2). Si vous utilisiez le SDK Azure Machine Learning v1 auparavant, nous vous recommandons de tirer parti de MLflow pour le suivi des expériences. Consultez Migrer la journalisation du SDK v1 vers MLflow pour obtenir des conseils spécifiques.

Les journaux peuvent vous aider à diagnostiquer les erreurs et les avertissements, ou à effectuer le suivi des métriques de performances, telles que les paramètres et les performances du modèle. Cet article décrit comment activer la journalisation dans les scénarios suivants :

  • Journaliser des métriques, des paramètres et des modèles lors de l’envoi de travaux.
  • Faire le suivi des exécutions pendant l’entraînement interactif.
  • Journaliser les métriques de manière asynchrone.
  • Consulter les informations de diagnostic sur l’entraînement.

Conseil

Cet article explique comment surveiller le processus de formation du modèle. Si vous êtes intéressé par la supervision de l’utilisation de ressources et d’événements de Azure Machine Learning, comme des quotas, des cycles de tâches accomplis ou des modèles de déploiement effectués, consultez Supervision de Azure Machine Learning.

Prérequis

  • Vous devez avoir un espace de travail Azure Machine Learning. Si vous n’en avez pas, consultez Créer des ressources d’espace de travail.

  • Vous devez avoir installé les packages mlflow et azureml-mlflow. Si ce n’est pas le cas, utilisez la commande suivante pour les installer dans votre environnement de développement :

    pip install mlflow azureml-mlflow

    Remarque

    Pour la journalisation asynchrone des métriques, vous devez avoir MLflow version 2.8.0+ et azureml-mlflow version 1.55+.

  • Si vous effectuez un suivi à distance (suivi d’expériences s’exécutant en dehors d’Azure Machine Learning), configurez MLflow pour le suivi des expériences. Pour plus d’informations, consultez Configurer MLflow pour Azure Machine Learning.

  • Pour journaliser des métriques, des paramètres, des artefacts et des modèles dans vos expériences dans Azure Machine Learning en utilisant MLflow, importez simplement MLflow dans votre script :

    import mlflow

Configurer des expériences

MLflow organise les informations dans les expériences et les exécutions (dans Azure Machine Learning, les exécutions sont appelées travaux). Il existe des différences dans la façon de les configurer selon la façon dont vous exécutez votre code :

Lors d’un apprentissage interactif, comme dans un Jupyter Notebook, utilisez le modèle suivant :

  1. Créez ou définissez l’expérience active.
  2. Démarrez le travail.
  3. Utilisez des méthodes de journalisation pour journaliser les métriques et d’autres informations.
  4. Terminez le travail.

Par exemple, l’extrait de code suivant configure l’expérience, puis journalise pendant un travail :

import mlflow
# Set the experiment
mlflow.set_experiment("mlflow-experiment")

# Start the run
mlflow_run = mlflow.start_run()
# Log metrics or other information
mlflow.log_metric('mymetric', 1)
# End run 
mlflow.end_run()

Conseil

Techniquement, vous n’avez pas besoin d’appeler start_run(), car une nouvelle exécution est créée s’il n’en existe aucune quand vous appelez une API de journalisation. Dans ce cas, vous pouvez utiliser mlflow.active_run() pour récupérer l’exécution actuellement utilisée. Pour plus d’informations, consultez mlflow.active_run().

Vous pouvez également utiliser le paradigme du gestionnaire de contexte :

import mlflow
mlflow.set_experiment("mlflow-experiment")

# Start the run, log metrics, end the run
with mlflow.start_run() as run:
    # Run started when context manager is entered, and ended when context manager exits
    mlflow.log_metric('mymetric', 1)
    mlflow.log_metric('anothermetric',1)
    pass

Quand vous démarrez une nouvelle exécution avec mlflow.start_run, il peut être utile d’indiquer le paramètre run_name, qui est ensuite utilisé comme nom de l’exécution dans l’interface utilisateur Azure Machine Learning et vous aide à identifier plus rapidement l’exécution :

with mlflow.start_run(run_name="iris-classifier-random-forest") as run:
    mlflow.log_metric('mymetric', 1)
    mlflow.log_metric('anothermetric',1)

Pour plus d’informations sur les API de journalisation MLflow, consultez la référence MLflow.

Journaliser des paramètres

MLflow prend en charge les paramètres de journalisation utilisés par vos expériences. Les paramètres peuvent être de n’importe quel type et peuvent être journalisés à l’aide de la syntaxe suivante :

mlflow.log_param("num_epochs", 20)

MLflow offre également un moyen pratique d’enregistrer plusieurs paramètres en indiquant tous ceux-ci à l’aide d’un dictionnaire. Plusieurs frameworks peuvent également passer des paramètres aux modèles à l’aide de dictionnaires et, par conséquent, il s’agit d’un moyen pratique de les connecter dans l’expérience.

params = {
    "num_epochs": 20,
    "dropout_rate": .6,
    "objective": "binary_crossentropy"
}

mlflow.log_params(params)

Journaliser les métriques

Les métriques, contrairement aux paramètres, sont toujours numériques et peuvent être journalisées de manière synchrone ou asynchrone. Lorsque les métriques sont journalisées, elles sont immédiatement disponibles pour la consommation lors du retour d’appel. Le tableau suivant décrit comment journaliser les types numériques spécifiques :

Valeur journalisée Exemple de code Notes
Journaliser une valeur numérique (int ou float) mlflow.log_metric("my_metric", 1)
Journaliser une valeur numérique (int ou float) dans le temps mlflow.log_metric("my_metric", 1, step=1) Utilisez le paramètre step pour indiquer l’étape à laquelle vous journalisez la valeur de métrique. Il peut s’agir de n’importe quel nombre entier. La valeur par défaut est 0.
Journaliser une valeur booléenne mlflow.log_metric("my_metric", 0) 0 = True, 1 = False

Important

Considérations sur les performances : si vous devez journaliser plusieurs métriques (ou plusieurs valeurs pour la même métrique) évitez d’effectuer des appels à mlflow.log_metric en boucles. Vous pouvez obtenir de meilleures performances en utilisant la journalisation asynchrone avec mlflow.log_metric("metric1", 9.42, synchronous=False) ou en journalisant un lot de métriques.

Journaliser les métriques de façon asynchrone

MLflow autorise également la journalisation des métriques de manière asynchrone. La journalisation asynchrone des mesures est particulièrement utile dans les cas où de gros travaux d'apprentissage avec des dizaines de nœuds de calcul sont en cours d'exécution et tentent d'enregistrer les mesures simultanément. Il est également utile lorsqu’un petit nombre de nœuds essaie de journaliser un nombre élevé de métriques.

La journalisation des métriques asynchrones vous permet de journaliser immédiatement les métriques en évitant d’attendre qu’elles se matérialisent dans le service principal. Cette approche est adaptée aux grandes routines d'entraînement qui enregistrent des centaines de milliers de valeurs métriques et c'est l'approche recommandée.

MLflow journalise les métriques de manière synchrone par défaut, mais vous pouvez modifier ce comportement à tout moment :

import mlflow

mlflow.config.enable_async_logging()

La même propriété peut être définie à l’aide d’une variable d’environnement :

export MLFLOW_ENABLE_ASYNC_LOGGING=True

Pour journaliser des métriques spécifiques de manière asynchrone, utilisez l’API de journalisation MLflow comme vous le feriez normalement, mais ajoutez le paramètre supplémentaire synchronous=False.

import mlflow

with mlflow.start_run():
    # (...)
    mlflow.log_metric("metric1", 9.42, synchronous=False)
    # (...)

Lorsque vous utilisez log_metric(synchronous=False), le contrôle est automatiquement retourné à l’appelant une fois l’opération acceptée ; toutefois, la valeur n’est pas disponible pour la lecture immédiate. La journalisation asynchrone des métriques garantit l’ordre et elles sont conservées avec l’horodatage du moment où elles ont été journalisées.

Important

Même avec synchronous=False, Azure Machine Learning garantit l’ordre des métriques.

Si vous devez attendre qu’une valeur particulière soit conservée dans le back-end, vous pouvez utiliser l’opération de métrique retournée pour l’attendre, comme illustré dans l’exemple suivant :

import mlflow

with mlflow.start_run():
    # (...)
    run_operation = mlflow.log_metric("metric1", 9.42, synchronous=False)
    # (...)
    run_operation.wait()
    # (...)

Vous pouvez journaliser de façon asynchrone une métrique à la fois, ou journaliser un lot de métriques, comme illustré dans l’exemple suivant :

import mlflow
import time
from mlflow.entities import Metric

with mlflow.start_run() as current_run:
    mlflow_client = mlflow.tracking.MlflowClient()

    metrics = {"metric-0": 3.14, "metric-1": 6.28}
    timestamp = int(time.time() * 1000)
    metrics_arr = [Metric(key, value, timestamp, 0) for key, value in metrics.items()]

    run_operation = mlflow_client.log_batch(
        run_id=current_run.info.run_id,
        metrics=metrics_arr,
        synchronous=False,
    )

L’opération wait() est également disponible lors de la journalisation d’un lot de métriques :

run_operation.wait()

Vous n’avez pas besoin d’appeler wait() sur vos routines si vous n’avez pas besoin d’un accès immédiat aux valeurs de métriques. Azure Machine Learning attend automatiquement lorsque le travail est sur le point de se terminer, pour voir s’il existe une métrique en attente à conserver. Une fois qu’un travail est terminé dans Azure Machine Learning, la persistance de toutes les métriques est garantie.

Journaliser des courbes ou une liste de valeurs

Vous pouvez journaliser des courbes (ou une liste de valeurs numériques) avec MLflow en journalisant la même métrique plusieurs fois. L’exemple suivant montre comment effectuer cette opération :

list_to_log = [1, 2, 3, 2, 1, 2, 3, 2, 1]
from mlflow.entities import Metric
from mlflow.tracking import MlflowClient
import time

client = MlflowClient()
client.log_batch(mlflow.active_run().info.run_id, 
                 metrics=[Metric(key="sample_list", value=val, timestamp=int(time.time() * 1000), step=0) for val in list_to_log])

Journaliser des images

MLflow prend en charge deux façons de journaliser les images. Les deux méthodes conservent l’image donnée sous forme d’artefact dans l’exécution.

Valeur journalisée Exemple de code Notes
Journaliser les métriques numpy ou les objets d’image PIL mlflow.log_image(img, "figure.png") img doit être une instance de numpy.ndarray ou de PIL.Image.Image. figure.png est le nom de l’artefact généré au sein de l’exécution. Il n’est pas nécessaire d’être un fichier existant.
Journaliser un fichier image ou un tracé matlotlib mlflow.log_figure(fig, "figure.png") figure.png est le nom de l’artefact généré au sein de l’exécution. Il n’est pas nécessaire d’être un fichier existant.

Fichiers journaux

Les fichiers dans MLflow sont généralement appelés artefacts. Vous pouvez journaliser les artefacts de plusieurs façons dans Mlflow :

Valeur journalisée Exemple de code Notes
Texte du journal dans un fichier texte mlflow.log_text("text string", "notes.txt") Le texte est conservé au sein de l’exécution dans un fichier texte nommé notes.txt.
Journaliser des dictionnaires sous forme de fichiers JSON et YAML mlflow.log_dict(dictionary, "file.yaml" dictionary est un objet de dictionnaire contenant toute la structure que vous voulez conserver sous forme de fichier JSON ou YAML.
Journaliser un fichier trivial déjà existant mlflow.log_artifact("path/to/file.pkl") Les fichiers sont toujours connectés à la racine de l’exécution. Si artifact_path est fourni, le fichier est connecté à un dossier comme indiqué dans ce paramètre.
Journaliser tous les artefacts dans un dossier existant mlflow.log_artifacts("path/to/folder") La structure de dossiers est copiée dans l’exécution, mais le dossier racine indiqué n’est pas inclus.

Conseil

Quand vous journalisez de grands fichiers avec log_artifactou log_model, vous pouvez rencontrer des erreurs d’expiration du délai d’attente avant la fin du chargement du fichier. Songez à augmenter la valeur du délai d’expiration en ajustant la variable d’environnement AZUREML_ARTIFACTS_DEFAULT_TIMEOUT. La valeur par défaut est 300 (secondes).

Journaliser des modèles

MLflow introduit le concept de modèles comme moyen d’empaqueter tous les artefacts dont a besoin un modèle donné pour fonctionner. Les modèles dans MLflow sont toujours un dossier avec un nombre arbitraire de fichiers, selon l’infrastructure utilisée pour générer le modèle. Les modèles de journalisation présentent l’avantage de suivre tous les éléments du modèle en tant qu’entité unique qui peut être inscrite, puis déployée. En plus de cela, les modèles MLflow bénéficient de l’avantage d’un déploiement sans code et peuvent être utilisés avec le tableau de bord d’IA responsable dans Studio. Pour plus d’informations, consultez Des artefacts aux modèles dans MLflow.

Pour enregistrer le modèle à partir d’une exécution d’apprentissage, utilisez l’API log_model() pour l’infrastructure avec laquelle vous travaillez. Par exemple, mlflow.sklearn.log_model(). Pour plus d’informations, consultez Journalisation des modèles MLflow. Pour migrer des modèles existants vers MLflow, consultez Convertir des modèles personnalisés en MLflow.

Conseil

Quand vous journalisez des grands modèles, vous pouvez rencontrer l’erreur Failed to flush the queue within 300 seconds. Cela signifie généralement que l’opération expire avant la fin du chargement des artefacts modèle. Songez à augmenter la valeur du délai d’expiration en ajustant la variable d’environnement AZUREML_ARTIFACTS_DEFAULT_TIMEOUT.

Journalisation automatique

Avec Azure Machine Learning et MLflow, les utilisateurs peuvent journaliser automatiquement des métriques, des paramètres de modèle et des artefacts de modèle pendant l’entraînement d’un modèle. Chaque framework détermine automatiquement pour vous ce qu’il faut suivre. Une variété de bibliothèques de machine learning connues sont prises en charge. En savoir plus sur la journalisation automatique avec MLflow.

Pour activer la journalisation automatique, insérez le code suivant avant votre code d’entraînement :

mlflow.autolog()

Conseil

Vous pouvez contrôler ce qui est automatiquement journalisé automatiquement avec autolog. Par exemple, si vous indiquez mlflow.autolog(log_models=False), MLflow journalise tout pour vous, sauf les modèles. Ce contrôle est utile dans les cas où vous souhaitez journaliser les modèles manuellement, mais profitez toujours de la journalisation automatique des métriques et des paramètres. Notez également que certains frameworks peuvent désactiver la journalisation automatique des modèles si le modèle entraîné franchit des limites spécifiques. Ce comportement dépend de la saveur utilisée et nous vous recommandons de consulter la documentation si c’est votre cas.

Afficher des informations sur les travaux ou les exécutions avec MLflow

Vous pouvez afficher les informations journalisées à l’aide de MLflow via l’objet MLflow.entities.Run :

import mlflow

run = mlflow.get_run(run_id="<RUN_ID>")

Vous pouvez afficher les métriques, les paramètres et les balises pour l’exécution dans le champ de données de l’objet d’exécution.

metrics = run.data.metrics
params = run.data.params
tags = run.data.tags

Notes

Le dictionnaire de métriques retourné par mlflow.get_run ou mlflow.search_runs ne retourne que la dernière valeur journalisée pour un nom de métrique donné. Par exemple, si vous journalisez une métrique nommée iteration plusieurs fois avec des valeurs, 1, puis 2, puis 3, puis 4, seul 4 est renvoyé quand vous appelez run.data.metrics['iteration'].

Pour obtenir toutes les métriques journalisées pour un nom de métrique particulier, vous pouvez utiliser MlFlowClient.get_metric_history() comme expliqué dans l’exemple Obtention de paramètres et de métriques à partir d’une exécution.

Conseil

MLflow peut récupérer des métriques et des paramètres à partir de plusieurs exécutions en même temps, ce qui permet d’effectuer des comparaisons rapides entre plusieurs essais. Pour en savoir plus, consultez Interroger et comparer des expériences et des exécutions avec MLflow.

MLflow peut interroger n’importe quel artefact journalisé par une exécution. Il est impossible d’accéder aux artefacts à l’aide de l’objet d’exécution lui-même ; le client MLflow doit être utilisé à la place :

client = mlflow.tracking.MlflowClient()
client.list_artifacts("<RUN_ID>")

Cette méthode liste tous les artefacts journalisés dans l’exécution, mais ils restent stockés dans le magasin d’artefacts (stockage Azure Machine Learning). Pour télécharger l’un d’eux, utilisez la méthode download_artifact :

file_path = client.download_artifacts("<RUN_ID>", path="feature_importance_weight.png")

Pour plus d’informations, consultez Obtention de métriques, de paramètres, d’artefacts et de modèles.

Afficher des informations sur les travaux ou les exécutions dans le studio

Vous pouvez parcourir les enregistrements de travaux terminés, notamment les mesures journalisées, dans le studio Azure Machine Learning.

Accédez à l’onglet Tâches. Pour voir tous vos travaux dans votre espace de travail pour toutes les expériences, sélectionnez l’onglet Tous les travaux. Vous pouvez explorer en détail les exécutions d’expériences spécifiques en appliquant le filtre Expérience dans la barre de menus supérieure. Sélectionnez le travail qui vous intéresse pour accéder à la vue détaillée, puis sélectionnez l’onglet Métriques.

Sélectionnez les métriques journalisées pour afficher les graphiques sur le côté droit. Vous pouvez personnaliser les graphes en appliquant un lissage, en changeant la couleur ou en traçant plusieurs métriques sur un même graphe. Vous pouvez également redimensionner et réorganiser la disposition comme vous le souhaitez. Dès que vous avez créé la vue souhaitée, vous pouvez l’enregistrer pour l’utiliser par la suite et la partager avec vos collègues en utilisant un lien direct.

Capture d’écran de la vue Métriques.

Afficher et télécharger les journaux de diagnostic

Les fichiers journaux sont une ressource essentielle pour déboguer les charges de travail Azure Machine Learning. Après avoir soumis un travail de formation, descendez dans la hiérarchie jusqu’à une exécution spécifique pour afficher ses journaux et ses sorties :

  1. Accédez à l’onglet Travaux.
  2. Sélectionnez le runID associé à une exécution spécifique.
  3. Sélectionnez Sorties + journaux en haut de la page.
  4. Sélectionnez Télécharger tout pour télécharger tous vos journaux dans un dossier zip.
  5. Vous pouvez également télécharger des fichiers journaux individuellement en choisissant le fichier journal et en sélectionnant Télécharger.

Capture d’écran de la section Sorties et journaux d’une exécution.

Dossier user_logs

Ce dossier contient des informations sur les journaux générés par l’utilisateur. Ce dossier est ouvert par défaut, et le journal std_log.txt est sélectionné. Les journaux de votre code (par exemple, les instructions print) apparaissent dans std_log.txt. Ce fichier contient le journal stdout et les journaux stderr de vos script de contrôle et script de formation, un par processus. Dans la plupart des cas, vous monitorez les journaux ici.

Dossier system_logs

Ce dossier contient les journaux générés par Azure Machine Learning et il est fermé par défaut. Les journaux générés par le système sont regroupés dans différents dossiers, en fonction de la phase du travail dans le runtime.

Autres dossiers

Pour les travaux qui s’entraînent sur des clusters multicalculs, les journaux sont présents pour chaque nœud d’IP. La structure de chaque nœud est identique à celle des travaux mononœuds. Il existe un autre dossier de journaux pour les journaux stderr, stdout et d’exécution générale.

Azure Machine Learning consigne les informations provenant de diverses sources pendant la formation, telles qu’AutoML ou le conteneur Docker qui exécute le travail de formation. La plupart de ces journaux ne sont pas documentés. Si vous rencontrez des problèmes et que vous contactez le support Microsoft, les agents doivent pouvoir utiliser ces journaux pendant la résolution des problèmes.

Contenu connexe