Partager via

Démarrer, surveiller et suivre l’historique des exécutions

  • Article

S’APPLIQUE À : SDK Python azureml v1

S’APPLIQUE À : Extension ml Azure CLI v1

Le Kit de développement logiciel (SDK) Azure Machine Learning pour Python v1 et l’interface de ligne de commande de Machine Learning fournissent diverses méthodes permettant d’analyser, d’organiser et de suivre vos exécutions d’apprentissage et d’expérimentation. L’historique des exécutions ML est un élément important d’un processus de développement ML explicable et reproductible.

Conseil

Pour plus d’informations sur l’utilisation de studio, consultez Suivre, surveiller et analyser les exécutions avec studio.

Si vous utilisez le Kit de développement logiciel (SDK) Azure Machine Learning v2, consultez les articles suivants :

Cet article explique comment effectuer les tâches suivantes :

  • Analyse des performances d’exécution.
  • Identification et recherche d’exécutions.
  • Recherche sur l’historique des exécutions.
  • Annulation ou mise en échec d’exécutions.
  • Création d’exécutions enfants.
  • Analyse de l’état d’exécution par notification par e-mail.

Conseil

Si vous recherchez des informations sur la supervision du service Azure Machine Learning et des services Azure associés, consultez Guide pratique pour superviser Azure Machine Learning. Si vous recherchez des informations sur les modèles de supervision déployés en tant que services web, consultez Collecter les données des modèles et Superviser avec Application Insights.

Prérequis

Vous devez disposer des éléments suivants :

  • Un abonnement Azure. Si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer. Essayez la version gratuite ou payante d’Azure Machine Learning dès aujourd’hui.

  • Un espace de travail Azure Machine Learning.

  • Le Kit de développement logiciel (SDK) Azure Machine Learning pour Python (version 1.0.21 ou ultérieure). Pour installer ou mettre à jour la dernière version du SDK, consultez Installer ou mettre à jour le SDK.

    Pour installer votre version du Kit de développement logiciel (SDK) Azure Machine Learning, utilisez le code suivant :

    print(azureml.core.VERSION)

  • Azure CLI et l’extension CLI pour Azure Machine Learning.

    Important

    Certaines des commandes Azure CLI de cet article utilisent l’extension azure-cli-ml, ou v1, pour Azure Machine Learning. La prise en charge de l’extension v1 se termine le 30 septembre 2025. Vous pourrez installer et utiliser l’extension v1 jusqu’à cette date.

    Nous vous recommandons de passer à l’extension ml, ou v2, avant le 30 septembre 2025. Pour plus d’informations sur l’extension v2, consultez Extension Azure ML CLI et le SDK Python v2.

Analyse des performances d’exécution

  • Démarrer une exécution et son processus de journalisation

    S’APPLIQUE À : SDK Python azureml v1

    1. Configurez votre expérience en important les classes Set up your experiment by importing the Workspace, Experiment, Run, et ScriptRunConfig depuis le package azureml.core.

      import azureml.core
from azureml.core import Workspace, Experiment, Run
from azureml.core import ScriptRunConfig

ws = Workspace.from_config()
exp = Experiment(workspace=ws, name="explore-runs")

    2. Démarrez une exécution et son processus de journalisation à l’aide de la méthode start_logging().

      notebook_run = exp.start_logging()
notebook_run.log(name="message", value="Hello from run!")

  • Surveiller l’état d’une exécution

    S’APPLIQUE À : SDK Python azureml v1

    • Obtenir l’état d’une exécution avec la méthode get_status().

      print(notebook_run.get_status())

    • Pour obtenir l’ID d’exécution, la durée d’exécution et des détails supplémentaires sur l’exécution, utilisez la méthode get_details().

      print(notebook_run.get_details())

    • Lorsque votre exécution se termine correctement, utilisez la méthode complete() pour la marquer comme terminé.

      notebook_run.complete()
print(notebook_run.get_status())

    • Si vous utilisez le modèle de conception with...as de Python, l’exécution se marque automatiquement comme étant terminée quand l’exécution est en dehors de l’étendue. Vous n’avez pas besoin de marquer manuellement l’exécution comme étant terminée.

      with exp.start_logging() as notebook_run:
    notebook_run.log(name="message", value="Hello from run!")
    print(notebook_run.get_status())

print(notebook_run.get_status())

Identifier et rechercher des exécutions

Dans Azure Machine Learning, vous pouvez utiliser des balises et propriétés pour vous aider dans l’organisation et l’interrogation d’exécutions en vue de rechercher des informations importantes.

  • Ajouter des propriétés et des balises

    S’APPLIQUE À : SDK Python azureml v1

    Pour ajouter des métadonnées de recherche à vos exécutions, utilisez la méthode add_properties(). Par exemple, le code suivant ajoute la propriété "author" à l’exécution :

    local_run.add_properties({"author":"azureml-user"})
print(local_run.get_properties())

    Les propriétés sont immuables et créent enregistrement permanent à des fins d’audit. L’exemple de code suivant génère une erreur, car nous avons déjà ajouté "azureml-user" comme valeur de propriété "author" dans le code précédent :

    try:
    local_run.add_properties({"author":"different-user"})
except Exception as e:
    print(e)

    Contrairement aux propriétés, les étiquettes sont modifiables. Pour ajouter des informations consultables et ayant du sens pour les utilisateurs de votre expérience, utilisez la méthode tag().

    local_run.tag("quality", "great run")
print(local_run.get_tags())

local_run.tag("quality", "fantastic run")
print(local_run.get_tags())

    Vous pouvez également ajouter des balises de chaîne simples. Quand ces étiquettes apparaissent dans le dictionnaire des étiquettes, leur valeur est None.

    local_run.tag("worth another look")
print(local_run.get_tags())

  • Interroger des propriétés et des balises

    Vous pouvez interroger des exécutions au sein d’une expérience pour renvoyer une liste d’exécutions qui correspondent aux propriétés et balises spécifiques.

    S’APPLIQUE À : SDK Python azureml v1

    list(exp.get_runs(properties={"author":"azureml-user"},tags={"quality":"fantastic run"}))
list(exp.get_runs(properties={"author":"azureml-user"},tags="worth another look"))

Annulation ou mise en échec d’exécutions

Si vous constatez une erreur ou si votre exécution prend trop de temps, vous pouvez l’annuler.

S’APPLIQUE À : SDK Python azureml v1

Pour annuler une exécution à l’aide du Kit de développement logiciel (SDK), utilisez la méthode cancel() :

src = ScriptRunConfig(source_directory='.', script='hello_with_delay.py')
local_run = exp.submit(src)
print(local_run.get_status())

local_run.cancel()
print(local_run.get_status())

Si votre exécution se termine, mais contient une erreur (par exemple, utilisation d’un script d’entraînement incorrect), vous pouvez utiliser la méthode fail() la marquer comme ayant échoué.

local_run = exp.submit(src)
local_run.fail()
print(local_run.get_status())

Créer des exécutions enfants

S’APPLIQUE À : SDK Python azureml v1

Créez des exécutions enfants pour regrouper les exécutions associées, comme pour différentes itérations de réglage des hyperparamètres.

Notes

Les exécutions enfants peuvent uniquement être créées à l’aide du Kit de développement logiciel (SDK).

Cet exemple de code utilise le script hello_with_children.py de création d’un lot de cinq exécutions enfants issues d’une exécution envoyée à l’aide de la méthode child_run() :

!more hello_with_children.py
src = ScriptRunConfig(source_directory='.', script='hello_with_children.py')

local_run = exp.submit(src)
local_run.wait_for_completion(show_output=True)
print(local_run.get_status())

with exp.start_logging() as parent_run:
    for c,count in enumerate(range(5)):
        with parent_run.child_run() as child:
            child.log(name="Hello from child run", value=c)

Notes

Dès qu’elles sont hors de portée, les exécutions enfants sont automatiquement marquées comme étant terminées.

Pour créer efficacement de nombreuses exécutions enfants, utilisez la méthode create_children(). Chaque création se traduisant par un appel réseau, la création d’un lot d’exécutions est plus efficace que la création d’exécutions une à une.

Envoyer des exécutions enfants

Les exécutions enfants peuvent également être envoyées à partir d’une exécution parente. Cela vous permet de créer des hiérarchies d’exécutions parentes et enfants. Vous ne pouvez pas créer une exécution enfant sans parent : même si l’exécution parente ne fait rien d’autre que de lancer des exécutions enfants, il est toujours nécessaire de créer la hiérarchie. Les états de toutes les exécutions sont indépendants : un parent peut afficher l’état de réussite "Completed" même si une ou plusieurs exécutions enfants ont été annulées ou ont échoué.

Vous pouvez souhaiter que vos exécutions enfants utilisent une configuration d’exécution différente de celle de l’exécution parente. Par exemple, vous pouvez utiliser une configuration basée sur l’UC et moins puissante pour le parent, tout en utilisant des configurations basées sur le GPU pour les enfants. Un autre souhait courant consiste à passer à chaque enfant des données et des arguments différents. Pour personnaliser une exécution enfant, créez un objet ScriptRunConfig pour l’exécution enfant.

Important

Pour soumettre une exécution enfant à partir d’une exécution parente sur un ordinateur distant, vous devez d’abord vous connecter à l’espace de travail dans le code de l’exécution parente. Par défaut, l’objet de contexte d’exécution d’une exécution distante ne dispose pas d’informations d’identification permettant de soumettre des exécutions enfants. Utilisez un principal de service ou les informations d’identification d’une identité managée pour vous connecter. Pour plus d’informations sur l’authentification, consultez Configurer l’authentification.

Le code ci-dessous :

  • Récupère une ressource de calcul nommée "gpu-cluster" dans l’espace de travail ws
  • Itère sur différentes valeurs d’argument à passer aux objets ScriptRunConfig des enfants
  • Crée et envoie une nouvelle exécution enfant à l’aide de la ressource de calcul personnalisée et de l’argument
  • Bloque jusqu’à ce que toutes les exécutions enfants soient terminées
# parent.py
# This script controls the launching of child scripts
from azureml.core import Run, ScriptRunConfig

compute_target = ws.compute_targets["gpu-cluster"]

run = Run.get_context()

child_args = ['Apple', 'Banana', 'Orange']
for arg in child_args: 
    run.log('Status', f'Launching {arg}')
    child_config = ScriptRunConfig(source_directory=".", script='child.py', arguments=['--fruit', arg], compute_target=compute_target)
    # Starts the run asynchronously
    run.submit_child(child_config)

# Experiment will "complete" successfully at this point. 
# Instead of returning immediately, block until child runs complete

for child in run.get_children():
    child.wait_for_completion()

Pour créer efficacement de nombreuses exécutions enfants avec des configurations, des arguments et des entrées identiques, utilisez la méthode create_children(). Chaque création se traduisant par un appel réseau, la création d’un lot d’exécutions est plus efficace que la création d’exécutions une à une.

Dans une exécution enfant, vous pouvez afficher l’ID d’exécution parente :

## In child run script
child_run = Run.get_context()
child_run.parent.id

Interroger les exécutions enfants

Pour interroger les exécutions enfants d’un parent spécifique, utilisez la méthode get_children(). L’argument recursive = True vous permet d’interroger une arborescence imbriquée d’enfants et de petits-enfants.

print(parent_run.get_children())

Connexion à l’exécution parente ou racine

Vous pouvez utiliser le champ Run.parent pour accéder à l’exécution qui a lancé l’exécution enfant actuelle. Run.parent est souvent utilisé pour regrouper les résultats des journaux en un seul endroit. Les exécutions enfants s’exécutent de façon asynchrone et il n’y a aucune garantie de classement ou de synchronisation au-delà de la capacité du parent à attendre la fin de l’exécution de ses enfants.

# in child (or even grandchild) run

def root_run(self : Run) -> Run :
    if self.parent is None : 
        return self
    return root_run(self.parent)

current_child_run = Run.get_context()
root_run(current_child_run).log("MyMetric", f"Data from child run {current_child_run.id}")

Analyse de l’état d’exécution par notification par e-mail

  1. Dans le portail Azure, dans la barre de navigation de gauche, sélectionnez l’onglet Analyse.

  2. Sélectionnez Paramètres de diagnostic, puis sélectionnez +Ajouter un paramètre de diagnostic.

    Capture d’écran des paramètres de diagnostic pour la notification par e-mail

  3. Dans le paramètre de diagnostic :

    1. Sous Détails de la catégorie, sélectionnez AmlRunStatusChangedEvent.
    2. Dans Détails de la destination, sélectionnez Envoyer à l’espace de travail Log Analytics et spécifiez l’abonnement et l’espace de travail Log Analytics.

    Notes

    L’espace de travail Azure Log Analytics est un type de ressource Azure différent de celui de l’espace de travail Azure Machine Learning service. S’il n’existe aucune option dans cette liste, vous pouvez créer un espace de travail Log Analytics.

    Capture d’écran de la configuration de la notification par e-mail

  4. Dans l’onglet Journaux, ajoutez une nouvelle règle d’alerte.

    Capture d’écran de la nouvelle règle d’alerte.

  5. Découvrez comment créer et gérer les alertes de journal à l’aide d’Azure Monitor.

Exemples de notebooks

Les notebooks suivants illustrent les concepts de cet article :

Étapes suivantes