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. 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.

   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()

Python notebook

!pip install wandb

import wandb
wandb.login()

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

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

WandbCallback accepte les arguments suivants :

Args	Description
log	Indique s’il faut journaliser les gradients, les parameters, all ou None du modèle (par défaut). Les pertes et les métriques sont toujours journalisées.
log_preds	indique si vous souhaitez 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 seulement à la fin (par défaut : False)
log_model	indique si vous souhaitez journaliser votre modèle (par défaut : False). Cela nécessite également SaveModelCallback
model_name	Le nom du file à journaliser, remplace SaveModelCallback
log_dataset	False (par défaut) True journalise le dossier référencé par learn.dls.path. un chemin peut être défini explicitement pour indiquer quel dossier journaliser. Remarque : le sous-dossier “models” est toujours ignoré.
dataset_name	nom du jeu de données journalisé (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 journalisées (36 par défaut).
seed	utilisé pour définir les é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” sera 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.

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.

Python notebook

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 ci-dessus, wandb lance un run par processus. À la fin de l’entraînement, vous aurez donc deux runs. Cela peut parfois prêter à confusion, et vous pouvez vouloir journaliser uniquement depuis le processus principal. Pour ce faire, vous devez déterminer 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

Python 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():
    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

• 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.