fastai

Intégrez W&B à fastai à l’aide du WandbCallback pour suivre les expériences, journaliser des métriques et visualiser la performance du modèle.

Vous pouvez intégrer fastai à W&B à l’aide de la classe WandbCallback pour suivre les expériences, consigner des métriques et visualiser les performances du modèle pendant l’entraînement. Cette page explique comment configurer l’authentification, ajouter le callback à votre boucle d’entraînement et configurer la journalisation pour l’entraînement en processus unique comme pour l’entraînement distribué. Consultez cette documentation interactive avec exemples pour plus de détails.

Inscrivez-vous et créez une clé API

Une clé API sert à authentifier votre machine auprès de W&B. Vous pouvez générer une clé API à partir de votre profil utilisateur.

Pour une méthode plus directe, accédez aux Paramètres utilisateur et créez une clé API. Copiez immédiatement la clé API et conservez-la dans un endroit sûr, par exemple dans un gestionnaire de mots de passe.

1. Cliquez sur l’icône de votre profil utilisateur dans le coin supérieur droit.
2. Sélectionnez Paramètres utilisateur, puis faites défiler jusqu’à la section Clés API.

Installez la bibliothèque wandb et connectez-vous

Pour installer localement la bibliothèque wandb et vous connecter :

Ligne de commande

1. Définissez la variable d’environnement WANDB_API_KEY sur votre clé API. Remplacez les valeurs entre <> par les vôtres :

   export WANDB_API_KEY=<your_api_key>
   

2. Installez la bibliothèque wandb, puis connectez-vous.

   pip install wandb
   
   wandb login
   

Python

pip install wandb

import wandb
wandb.login()

notebook Python

!pip install wandb

import wandb
wandb.login()

Ajoutez le WandbCallback au learner ou à la méthode fit

Pour commencer à journaliser vos runs d’entraînement fastai dans W&B, joignez le WandbCallback soit à un seul appel à fit, soit au learner lui-même.

import wandb
from fastai.callback.wandb import *

# démarrer la journalisation d'un run wandb
wandb.init(project="my_project")

# Pour journaliser uniquement pendant une phase d'entraînement
learn.fit(..., cbs=WandbCallback())

# Pour journaliser en continu pour toutes les phases d'entraînement
learn = learner(..., cbs=WandbCallback())

Si vous utilisez la version 1 de fastai, consultez la documentation fastai v1.

Arguments de WandbCallback

Utilisez les arguments suivants pour contrôler ce que WandbCallback journalise pendant l’entraînement :

Arguments	Description
log	Indique s’il faut journaliser les gradients, les parameters, all ou None (par défaut) du modèle. Les pertes et les métriques sont toujours enregistrées.
log_preds	Indique s’il faut journaliser des échantillons de prédictions (par défaut, True).
log_preds_every_epoch	Indique s’il faut journaliser les prédictions à chaque époque ou uniquement à la fin (par défaut, False).
log_model	Indique s’il faut journaliser le modèle (par défaut, False). Cela nécessite également SaveModelCallback.
model_name	Le nom du file à enregistrer, remplace SaveModelCallback.
log_dataset	False (par défaut). True journalise le dossier référencé par learn.dls.path. Vous pouvez définir explicitement un chemin pour indiquer quel dossier journaliser. Remarque : le sous-dossier “models” est toujours ignoré.
dataset_name	Nom du jeu de données enregistré (par défaut, nom du dossier).
valid_dl	DataLoaders contenant les éléments utilisés pour les échantillons de prédictions (par défaut, des éléments aléatoires de learn.dls.valid).
n_preds	Nombre de prédictions enregistrées (par défaut, 36).
seed	Utilisé pour définir des échantillons aléatoires.

Pour les flux de travail personnalisés, vous pouvez journaliser manuellement vos jeux de données et modèles :

• log_dataset(path, name=None, metadata={})
• log_model(path, name=None, metadata={})

Remarque : tout sous-dossier “models” est ignoré.

Entraînement distribué

fastai prend en charge l’entraînement distribué à l’aide du gestionnaire de contexte distrib_ctx. W&B le prend automatiquement en charge et vous permet de suivre vos expériences multi-GPU sans configuration supplémentaire. Les sections suivantes décrivent comment intégrer W&B à l’entraînement distribué et comment limiter la journalisation au processus principal.

Voici un exemple minimal :

Script

import wandb
from fastai.vision.all import *
from fastai.distributed import *
from fastai.callback.wandb import WandbCallback

wandb.require(experiment="service")
path = rank0_first(lambda: untar_data(URLs.PETS) / "images")

def train():
    dls = ImageDataLoaders.from_name_func(
        path,
        get_image_files(path),
        valid_pct=0.2,
        label_func=lambda x: x[0].isupper(),
        item_tfms=Resize(224),
    )
    wandb.init("fastai_ddp", entity="capecape")
    cb = WandbCallback()
    learn = vision_learner(dls, resnet34, metrics=error_rate, cbs=cb).to_fp16()
    with learn.distrib_ctx(sync_bn=False):
        learn.fit(1)

if __name__ == "__main__":
    train()

Ensuite, dans votre terminal, exécutez :

torchrun --nproc_per_node 2 train.py

Dans ce cas, la machine dispose de 2 GPU.

notebook Python

Vous pouvez désormais exécuter l’entraînement distribué directement dans un notebook.

import wandb
from fastai.vision.all import *

from accelerate import notebook_launcher
from fastai.distributed import *
from fastai.callback.wandb import WandbCallback

wandb.require(experiment="service")
path = untar_data(URLs.PETS) / "images"

def train():
    dls = ImageDataLoaders.from_name_func(
        path,
        get_image_files(path),
        valid_pct=0.2,
        label_func=lambda x: x[0].isupper(),
        item_tfms=Resize(224),
    )
    wandb.init("fastai_ddp", entity="capecape")
    cb = WandbCallback()
    learn = vision_learner(dls, resnet34, metrics=error_rate, cbs=cb).to_fp16()
    with learn.distrib_ctx(in_notebook=True, sync_bn=False):
        learn.fit(1)

notebook_launcher(train, num_processes=2)

Journalisez uniquement depuis le processus principal

Dans les exemples précédents, W&B lance un run par processus. À la fin de l’entraînement, vous avez deux runs. Cela peut parfois prêter à confusion, et vous pouvez vouloir journaliser uniquement depuis le processus principal. Pour ce faire, vous devez détecter manuellement dans quel processus vous vous trouvez et éviter de créer des runs (en appelant wandb.init() dans tous les autres processus).

Script

import wandb
from fastai.vision.all import *
from fastai.distributed import *
from fastai.callback.wandb import WandbCallback

wandb.require(experiment="service")
path = rank0_first(lambda: untar_data(URLs.PETS) / "images")

def train():
    cb = []
    dls = ImageDataLoaders.from_name_func(
        path,
        get_image_files(path),
        valid_pct=0.2,
        label_func=lambda x: x[0].isupper(),
        item_tfms=Resize(224),
    )
    if rank_distrib() == 0:
        run = wandb.init("fastai_ddp", entity="capecape")
        cb = WandbCallback()
    learn = vision_learner(dls, resnet34, metrics=error_rate, cbs=cb).to_fp16()
    with learn.distrib_ctx(sync_bn=False):
        learn.fit(1)

if __name__ == "__main__":
    train()

Dans votre terminal, exécutez :

torchrun --nproc_per_node 2 train.py

notebook Python

import wandb
from fastai.vision.all import *

from accelerate import notebook_launcher
from fastai.distributed import *
from fastai.callback.wandb import WandbCallback

wandb.require(experiment="service")
path = untar_data(URLs.PETS) / "images"

def train():
    cb = []
    dls = ImageDataLoaders.from_name_func(
        path,
        get_image_files(path),
        valid_pct=0.2,
        label_func=lambda x: x[0].isupper(),
        item_tfms=Resize(224),
    )
    if rank_distrib() == 0:
        run = wandb.init("fastai_ddp", entity="capecape")
        cb = WandbCallback()
    learn = vision_learner(dls, resnet34, metrics=error_rate, cbs=cb).to_fp16()
    with learn.distrib_ctx(in_notebook=True, sync_bn=False):
        learn.fit(1)

notebook_launcher(train, num_processes=2)

Exemples

Pour des démonstrations de bout en bout de l’intégration fastai, voir les références suivantes :

• Visualiser, suivre et comparer des modèles Fastai : Un guide pas à pas très détaillé.
• Segmentation d’images sur CamVid : Un exemple d’utilisation de l’intégration.