fastai

Vous pouvez intégrer fastai à W&B à l’aide de la classe WandbCallback. Consultez cette documentation interactive avec exemples pour plus de détails. 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.

Cliquez sur l’icône de votre profil utilisateur dans le coin supérieur droit.
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
Python
Python notebook

Définissez la variable d’environnement WANDB_API_KEY sur votre clé API.
export WANDB_API_KEY=<your_api_key>
Installez la bibliothèque wandb, puis connectez-vous.
pip install wandb wandb login

pip install wandb

import wandb
wandb.login()

!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
Python notebook

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.

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
Python notebook

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

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.

Weights & Biases

Powered by CoreWeave

Platform Details

Resources

Installez la bibliothèque `wandb` et connectez-vous

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

Arguments de WandbCallback

Entraînement distribué

Journalisez uniquement depuis le processus principal

Exemples

​Inscrivez-vous et créez une clé API

​Installez la bibliothèque wandb et connectez-vous

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

​Arguments de WandbCallback

​Entraînement distribué

​Journalisez uniquement depuis le processus principal

​Exemples

Inscrivez-vous et créez une clé API

Installez la bibliothèque `wandb` et connectez-vous

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

Arguments de WandbCallback

Entraînement distribué

Journalisez uniquement depuis le processus principal

Exemples