Journaliser des expériences d’entraînement distribué

• Suivre un seul processus : suivez avec W&B le processus de rank 0 (également appelé « leader » ou « coordinateur »). Il s’agit d’une solution courante pour journaliser des expériences d’entraînement distribué avec la classe PyTorch Distributed Data Parallel (DDP).
• Suivre plusieurs processus : pour plusieurs processus, vous pouvez :
  • Suivre chaque processus séparément, avec un run par processus. Vous pouvez éventuellement les regrouper dans l’interface de l’application W&B.
  • Suivre tous les processus dans un seul run.

​

Suivre un seul processus

1. Démarre plusieurs processus avec torch.distributed.launch.
2. Vérifie le rank à l’aide de l’argument de ligne de commande --local_rank.
3. Si le rank vaut 0, configure de manière conditionnelle la journalisation wandb dans la fonction train().

if __name__ == "__main__":
    # Obtenir les arguments
    args = parse_args()

    if args.local_rank == 0:  # uniquement dans le processus principal
        # Initialiser le run wandb
        run = wandb.init(
            entity=args.entity,
            project=args.project,
        )
        # Entraîner le modèle avec DDP
        train(args, run)
    else:
        train(args)

​

Suivre plusieurs processus

• Suivre chaque processus séparément en créant un run par processus.
• Suivre tous les processus dans un seul run.

​

Suivre chaque processus séparément

if __name__ == "__main__":
    # Récupérer les arguments
    args = parse_args()
    # Initialiser le run
    run = wandb.init(
        entity=args.entity,
        project=args.project,
        group="DDP",  # regrouper tous les runs de l’expérience dans un même groupe
    )
    # Entraîner le modèle avec DDP
    train(args, run)

    run.finish()  # marquer le run comme terminé

​

Organiser les runs distribués

   # Nœud de coordination principal
   with wandb.init(project="<project>", job_type="main", group="experiment_1") as run:
        # Code d’entraînement

   # Nœuds de calcul qui remontent les résultats
   with wandb.init(project="<project>", job_type="worker", group="experiment_1") as run:
        # Code d’entraînement

• Vue par défaut : exclure les nœuds de calcul pour réduire le bruit
  • Cliquez sur Filter, puis définissez Job Type sur worker.
  • Affiche uniquement vos nœuds de reporting
  • Vue Debug : cibler les nœuds de calcul pour le dépannage
    • Cliquez sur Filter, puis définissez Job Type == worker et State sur IN crashed.
    • Affiche uniquement les nœuds de calcul qui ont planté ou qui sont en état d’erreur
  • Vue de tous les nœuds : tout afficher en même temps
    • Aucun filtre
    • Utile pour une supervision globale

​

Suivre tous les processus dans un seul run

1. Le paramètre mode défini sur "shared" pour activer le mode partagé.
2. Un libellé unique pour x_label. La valeur que vous indiquez pour x_label vous permet d’identifier le nœud d’où proviennent les données dans les journaux et les métriques système de l’interface de l’application W&B. Si vous ne l’indiquez pas, W&B génère un libellé à partir du nom d’hôte et d’un hachage aléatoire.
3. Définissez le paramètre x_primary sur True pour indiquer qu’il s’agit du nœud principal.
4. Vous pouvez également fournir une liste d’index de GPU ([0,1,2]) à x_stats_gpu_device_ids pour indiquer les GPU dont W&B doit suivre les métriques. Si vous ne fournissez pas de liste, W&B suit les métriques de tous les GPU de la machine.

1. Un objet wandb.Settings passé au paramètre settings (wandb.init(settings=wandb.Settings()) comportant :
   • Le paramètre mode défini sur "shared" pour activer le mode partagé.
   • Un libellé unique pour x_label. La valeur que vous indiquez pour x_label vous permet d’identifier le nœud d’où proviennent les données dans les journaux et les métriques système de l’interface de l’application W&B. Si vous ne l’indiquez pas, W&B génère un libellé à partir du nom d’hôte et d’un hachage aléatoire.
   • Définissez le paramètre x_primary sur False pour indiquer qu’il s’agit d’un nœud de calcul.
2. Avant le démarrage du processus de calcul, définissez WANDB_RUN_ID sur l’ID de run généré utilisé par le nœud principal.
3. Vous pouvez également définir x_update_finish_state sur False. Cela empêche les nœuds secondaires de faire passer prématurément l’état du run à finished, de sorte que l’état du run reste cohérent et géré par le nœud principal.

import wandb

entity = "your-entity"
project = "your-project"

# Initialiser un run sur le nœud principal
with wandb.init(
    entity=entity,
    project=project,
    settings=wandb.Settings(
        x_label="rank_0",
        mode="shared",
        x_primary=True,
        x_stats_gpu_device_ids=[0, 1],  # (Facultatif) Suivre uniquement les métriques des GPU 0 et 1
    )
) as run:
    # Insérer ici la logique du nœud principal

import wandb

entity = "your-entity"
project = "your-project"
rank = 1

# Initialiser un run sur un nœud de calcul.
# W&B lit automatiquement WANDB_RUN_ID dans l’environnement du processus worker.
with wandb.init(
    entity=entity,  # Utiliser la même entity que le nœud principal
    project=project,  # Utiliser le même projet que le nœud principal
    settings=wandb.Settings(
        x_label=f"rank_{rank}",
        mode="shared",
        x_primary=False,
        x_update_finish_state=False,
    ),
) as run:
    # Logique du nœud de calcul

1. Accédez au projet qui contient le run.
2. Cliquez sur l’onglet Runs dans la barre latérale du projet.
3. Cliquez sur le run que vous souhaitez afficher.
4. Cliquez sur l’onglet Logs dans la barre latérale du projet.

​

Exemples de cas d’utilisation

​

Processus lancé avec spawn

import multiprocessing as mp

def do_work(n):
    with wandb.init(config=dict(n=n)) as run:
        run.log(dict(this=n * n))

def main():
    wandb.setup()
    pool = mp.Pool(processes=4)
    pool.map(do_work, range(4))


if __name__ == "__main__":
    main()

​

Partager un run

def do_work(run):
    with wandb.init() as run:
        run.log(dict(this=1))

def main():
    run = wandb.init()
    p = mp.Process(target=do_work, kwargs=dict(run=run))
    p.start()
    p.join()
    run.finish()  # marquer le run comme terminé


if __name__ == "__main__":
    main()

​

Dépannage

1. Blocage au début de l’entraînement - Un processus wandb peut se bloquer si le multiprocessing de wandb interfère avec celui de l’entraînement distribué.
2. Blocage à la fin de l’entraînement - Une tâche d’entraînement peut se bloquer si le processus wandb ne sait pas à quel moment se terminer. Appelez l’API wandb.Run.finish() à la fin de votre script Python pour indiquer à W&B que le run est terminé. L’API wandb.Run.finish() achève le téléversement des données et entraîne l’arrêt de W&B. W&B recommande d’utiliser la commande wandb service pour améliorer la fiabilité de vos jobs distribués. Ces deux problèmes d’entraînement se rencontrent fréquemment dans les versions du SDK W&B où wandb service n’est pas disponible.

​

Activer le service W&B

​

SDK W&B 0.13.0 et versions ultérieures

​

SDK W&B 0.12.5 et versions ultérieures

if __name__ == "__main__":
    main()


def main():
    wandb.require("service")
    # placez-ici-le-reste-de-votre-script