Personnaliser les axes de journalisation

Utilisez define_metric() pour définir un axe x personnalisé pour les métriques enregistrées au lieu du compteur d’étapes W&B par défaut.

Définissez un axe x personnalisé lorsque vous consignez des métriques dans W&B. Par défaut, W&B consigne les métriques sous forme d’étapes. Chaque étape correspond à un appel à l’API wandb.Run.log().

Par exemple, le script suivant contient une boucle for qui s’exécute 10 fois. À chaque itération, le script enregistre une métrique appelée validation_loss et incrémente le numéro d’étape de 1.

import wandb

with wandb.init() as run:
  # la fonction range crée une séquence de nombres de 0 à 9
  for i in range(10):
    log_dict = {
        "validation_loss": 1/(i+1)   
    }
    run.log(log_dict)

Dans le Workspace du projet, la métrique validation_loss est tracée en fonction de l’axe des x step, qui s’incrémente de 1 à chaque appel de wandb.Run.log(). Dans le code précédent, l’axe des x affiche les numéros d’étape 0, 1, 2, …, 9.

Dans certaines situations, il est plus pertinent de consigner des métriques en fonction d’un autre axe des x, par exemple un axe des x logarithmique. Utilisez la méthode define_metric() pour définir comme axe des x personnalisé n’importe quelle métrique que vous consignez.

Indiquez la métrique que vous souhaitez faire apparaître sur l’axe des y avec le paramètre name. Le paramètre step_metric indique la métrique que vous souhaitez utiliser comme axe des x. Lorsque vous consignez une métrique personnalisée, indiquez une valeur pour l’axe des x et pour l’axe des y sous forme de paires clé-valeur dans un dictionnaire.

Copiez-collez l’extrait de code suivant pour définir une métrique personnalisée comme axe des x. Remplacez les valeurs entre <> par vos propres valeurs :

import wandb

custom_step = "<custom_step>"  # Nom de l'axe x personnalisé
metric_name = "<metric>"  # Nom de la métrique de l'axe y

with wandb.init() as run:
    # Spécifier la métrique d'étape (axe x) et la métrique à journaliser en regard (axe y)
    run.define_metric(step_metric = custom_step, name = metric_name)

    for i in range(10):
        log_dict = {
            custom_step : int,  # Valeur de l'axe x
            metric_name : int,  # Valeur de l'axe y
        }
        run.log(log_dict)

À titre d’exemple, l’extrait de code suivant crée un axe des x personnalisé appelé x_axis_squared. La valeur de l’axe des x personnalisé correspond au carré de l’indice i de la boucle for (i**2). Le y-axis est constitué de valeurs fictives pour la perte de validation ("validation_loss"), générées à l’aide du module intégré random de Python :

import wandb
import random

with wandb.init() as run:
    run.define_metric(step_metric = "x_axis_squared", name = "validation_loss")

    for i in range(10):
        log_dict = {
            "x_axis_squared": i**2,
            "validation_loss": random.random(),
        }
        run.log(log_dict)

L’image suivante montre le graphique obtenu dans l’UI de l’application W&B. La métrique validation_loss est tracée en fonction de l’axe x personnalisé x_axis_squared, qui correspond au carré de l’indice i dans la boucle for. Notez que les valeurs de l’axe x sont 0, 1, 4, 9, 16, 25, 36, 49, 64, 81, ce qui correspond respectivement aux carrés de 0, 1, 2, ..., 9.

Vous pouvez définir un axe x personnalisé pour plusieurs métriques à l’aide de globs avec des préfixes de chaîne de caractères. Par exemple, l’extrait de code suivant trace les métriques enregistrées avec le préfixe train/* sur l’axe x train/step : ”

import wandb

with wandb.init() as run:

    # définir toutes les autres métriques train/ pour utiliser cette étape
    run.define_metric("train/*", step_metric="train/step")

    for i in range(10):
        log_dict = {
            "train/step": 2**i,  # croissance exponentielle avec l'étape W&B interne
            "train/loss": 1 / (i + 1),  # l'axe des x est train/step
            "train/accuracy": 1 - (1 / (1 + i)),  # l'axe des x est train/step
            "val/loss": 1 / (1 + i),  # l'axe des x est l'étape wandb interne
        }
        run.log(log_dict)