Journaliser des métriques de synthèse

Outre les valeurs qui évoluent au fil de l’entraînement, il est souvent important de suivre des valeurs qui résument un modèle ou une étape de prétraitement. Stockez ces informations dans l’attribut summary d’un run. L’attribut summary d’un run prend en charge les tableaux NumPy, les tenseurs PyTorch et les tenseurs TensorFlow. W&B enregistre les tableaux NumPy, les tenseurs PyTorch et les tenseurs TensorFlow dans un fichier binaire. La dernière valeur journalisée avec wandb.Run.log() est automatiquement définie comme dictionnaire de synthèse du run. Toute modification d’un dictionnaire de métriques de synthèse entraîne la perte de la valeur précédente. Vous pouvez journaliser une métrique de synthèse pendant qu’un run est actif ou une fois qu’il est terminé.

Pendant un run
Après un run

L’extrait de code suivant montre comment fournir une métrique de synthèse personnalisée à W&B :

import wandb
import random

# Projet dans lequel le run est enregistré
project = "summary-demo"
entity = "<your-entity>" # Remplacez par le nom de votre entity W&B

# Dictionnaire des hyperparamètres
config = {
    'epochs' : 10,
    'lr' : 0.01
}

with wandb.init(entity=entity, project=project, config=config) as run:
    offset = random.random() / 5
    print(f"lr: {config['lr']}")

    # Simuler un run d’entraînement
    for epoch in range(2, config['epochs']):
        acc = 1 - 2**-config['epochs'] - random.random() / config['epochs'] - offset
        loss = 2**-config['epochs'] + random.random() / config['epochs'] + offset
        print(f"epoch={config['epochs']}, accuracy={acc}, loss={loss}")
        run.log({"accuracy": acc, "loss": loss})

        if epoch % 5 == 0:
            run.summary["best_accuracy"] = acc
            run.summary["best_loss"] = loss

Une fois l’entraînement terminé, vous pouvez mettre à jour l’attribut summary d’un run W&B existant. Pour ce faire, utilisez l’API publique de W&B :

api = wandb.Api()
run = api.run("entity/project/run_id")
run.summary["tensor"] = np.random.random(1000)
run.summary.update()

L’image suivante montre à quoi pourraient ressembler les métriques de synthèse si vous copiez et exécutez l’extrait de code ci-dessus :

Personnaliser les métriques de synthèse

Les métriques de synthèse personnalisées permettent de capturer dans votre run.summary les performances du modèle à la meilleure étape de l’entraînement. Par exemple, vous pouvez capturer la précision maximale ou la perte minimale plutôt que la valeur finale. Par défaut, la synthèse utilise la valeur finale de l’historique. Pour personnaliser les métriques de synthèse, passez l’argument summary à define_metric. Il accepte les valeurs suivantes :

"min"
"max"
"mean"
"best"
"last"
"none"

Vous ne pouvez utiliser "best" que si vous définissez également l’argument facultatif objective sur "minimize" ou "maximize". L’exemple suivant ajoute à la synthèse les valeurs minimale et maximale de la perte et de la précision :

import wandb
import random

random.seed(1)

with wandb.init() as run:
    # Valeurs min et max de la perte dans la synthèse
    run.define_metric("loss", summary="min")
    run.define_metric("loss", summary="max")

    # Valeurs min et max de la précision dans la synthèse
    run.define_metric("acc", summary="min")
    run.define_metric("acc", summary="max")

    for i in range(10):
        log_dict = {
            "loss": random.uniform(0, 1 / (i + 1)),
            "acc": random.uniform(1 / (i + 1), 1),
        }
        run.log(log_dict)

Afficher les métriques de synthèse

Accédez à la synthèse d’un run dans la W&B App, pendant l’exécution d’un run, à partir d’un run existant ou depuis le système de fichiers local.

Aperçu du run
Tableau des runs
Pendant un run
Runs existants
Système de fichiers local

Accédez à la W&B App.
Sélectionnez l’onglet Workspace dans la barre latérale du projet.
Cliquez sur le run qui a journalisé les valeurs de synthèse. La page du run s’ouvre sur l’onglet Overview, affiché par défaut.
Consultez les valeurs de synthèse dans la section Summary.

L’image suivante montre à quoi peuvent ressembler les métriques de synthèse dans l’onglet Overview si vous copiez et exécutez l’extrait de code ci-dessus :

Utilisez wandb.Run.summary pour accéder aux valeurs de synthèse d’un run pendant son exécution. Cet attribut renvoie un dictionnaire de paires clé-valeur.L’exemple suivant accède à la synthèse d’un run. Remplacez "<my-project>" par le nom de votre projet W&B :

import wandb

with wandb.init(project="<my-project>", config=config) as run:
  run.log({"accuracy": 0.9, "loss": 0.1})

  print(run.summary)  # affiche le dictionnaire de synthèse

Utilisez l’API publique de W&B pour accéder aux métriques de synthèse via la propriété wandb.Api.Run.summary.L’exemple de code suivant montre une façon de récupérer les valeurs de synthèse journalisées dans un run donné à l’aide de l’API publique de W&B et de pandas :

import wandb
import pandas

entity = "<your-entity>"
project = "<your-project>"
run_name = "<your-run-name>" # Nom du run contenant les valeurs de synthèse

all_runs = []

for run in api.runs(f"{entity}/{project_name}"):
    print("Fetching details for run: ", run.id, run.name)
    run_data = {
              "id": run.id,
              "name": run.name,
              "url": run.url,
              "state": run.state,
              "tags": run.tags,
              "config": run.config,
              "created_at": run.created_at,
              "system_metrics": run.system_metrics,
              "summary": run.summary,
              "project": run.project,
              "entity": run.entity,
              "user": run.user,
              "path": run.path,
              "notes": run.notes,
              "read_only": run.read_only,
              "history_keys": run.history_keys,
              "metadata": run.metadata,
          }
    all_runs.append(run_data)
  
# Convertir en DataFrame  
df = pd.DataFrame(all_runs)

# Récupérer la ligne en fonction du nom de colonne (run) et la convertir en dictionnaire
df[df['name']==run_name].summary.reset_index(drop=True).to_dict()

Pour accéder aux métriques de synthèse de plusieurs runs d’un projet, itérez sur les runs renvoyés par api.runs() :

import wandb

api = wandb.Api()
runs = api.runs("<entity>/<project>")

for run in runs:
    print(f"Run name: {run.name}")
    print(f"Run ID: {run.id}")
    print(f"Run summary: {dict(run.summary)}")
    print("----------")

L’objet JSON suivant présente un exemple de synthèse de run :

Run name: clean-oath-11
Run ID: mt2dasoz
Run summary: {'_runtime': 3, '_step': 1000, '_timestamp': 1778541534.834642, '_wandb.runtime': 3, 'train/epoch_ndx': 1000, 'train/train_loss': 0.25498124957084656}

Run name: zesty-snowball-7
Run ID: qne08r7u
Run summary: {'_runtime': 3, '_step': 1000, '_timestamp': 1776714833.636171, '_wandb.runtime': 3, 'train/epoch_ndx': 1000, 'train/train_loss': 0.24914199113845825}

W&B stocke les valeurs de synthèse du run dans le fichier wandb-summary.json du répertoire du run. Pour lire les valeurs de synthèse en local, ouvrez le fichier wandb-summary.json.Par défaut, W&B stocke les répertoires des runs à l’emplacement suivant : ./wandb/run-<timestamp>-<run_id>.

​Personnaliser les métriques de synthèse

​Afficher les métriques de synthèse

Personnaliser les métriques de synthèse

Afficher les métriques de synthèse