> ## Documentation Index
> Fetch the complete documentation index at: https://wb-21fd5541-docs-2751.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# 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](https://app.wandb.ai/borisd13/demo_config/reports/Visualize-track-compare-Fastai-models--Vmlldzo4MzAyNA) pour plus de détails.

<div id="sign-up-and-create-an-api-key">
  ## Inscrivez-vous et créez une clé API
</div>

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.

<Note>
  Pour une méthode plus directe, accédez aux [Paramètres utilisateur](https://wandb.ai/settings) 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.
</Note>

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

<div id="install-the-wandb-library-and-log-in">
  ## Installez la bibliothèque `wandb` et connectez-vous
</div>

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

<Tabs>
  <Tab title="Ligne de commande">
    1. Définissez la [variable d'environnement](/fr/models/track/environment-variables/) `WANDB_API_KEY` sur votre clé API. Remplacez les valeurs entre `<>` par les vôtres :

       ```bash theme={null}
       export WANDB_API_KEY=<your_api_key>
       ```

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

       ```shell theme={null}
       pip install wandb

       wandb login
       ```
  </Tab>

  <Tab title="Python">
    ```bash theme={null}
    pip install wandb
    ```

    ```python theme={null}
    import wandb
    wandb.login()
    ```
  </Tab>

  <Tab title="notebook Python">
    ```python theme={null}
    !pip install wandb

    import wandb
    wandb.login()
    ```
  </Tab>
</Tabs>

<div id="add-the-wandbcallback-to-the-learner-or-fit-method">
  ## Ajoutez le `WandbCallback` au `learner` ou à la méthode `fit`
</div>

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.

```python theme={null}
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())
```

<Note>
  Si vous utilisez la version 1 de fastai, consultez la [documentation fastai v1](/fr/models/integrations/fastai/v1/).
</Note>

<div id="wandbcallback-arguments">
  ## Arguments de WandbCallback
</div>

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`           | <ul><li><code>False</code> (par défaut).</li><li><code>True</code> journalise le dossier référencé par `learn.dls.path`.</li><li>Vous pouvez définir explicitement un chemin pour indiquer quel dossier journaliser.</li></ul><p><em>Remarque : le sous-dossier "models" est toujours ignoré.</em></p> |
| `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é.*

<div id="distributed-training">
  ## Entraînement distribué
</div>

`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 :

<Tabs>
  <Tab title="Script">
    ```python theme={null}
    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 :

    ```shell theme={null}
    torchrun --nproc_per_node 2 train.py
    ```

    Dans ce cas, la machine dispose de 2 GPU.
  </Tab>

  <Tab title="notebook Python">
    Vous pouvez désormais exécuter l'entraînement distribué directement dans un notebook.

    ```python theme={null}
    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)
    ```
  </Tab>
</Tabs>

<div id="log-only-on-the-main-process">
  ### Journalisez uniquement depuis le processus principal
</div>

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

<Tabs>
  <Tab title="Script">
    ```python theme={null}
    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 :

    ```shell theme={null}
    torchrun --nproc_per_node 2 train.py
    ```
  </Tab>

  <Tab title="notebook Python">
    ```python theme={null}
    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)
    ```
  </Tab>
</Tabs>

<div id="examples">
  ## Exemples
</div>

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](https://app.wandb.ai/borisd13/demo_config/reports/Visualize-track-compare-Fastai-models--Vmlldzo4MzAyNA) : Un guide pas à pas très détaillé.
* [Segmentation d’images sur CamVid](https://colab.research.google.com/drive/1IWrhwcJoncCKHm6VXsNwOr9Yukhz3B49?usp=sharing) : Un exemple d’utilisation de l’intégration.