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

# fastai

> Integrate W&B with fastai using the WandbCallback to track experiments, log metrics, and visualize model performance.

You can integrate **fastai** with W\&B using the `WandbCallback` class. Check out these [interactive docs with examples](https://app.wandb.ai/borisd13/demo_config/reports/Visualize-track-compare-Fastai-models--Vmlldzo4MzAyNA) for more details.

## Sign up and create an API key

An API key authenticates your machine to W\&B. You can generate an API key from your user profile.

<Note>
  For a more streamlined approach, go to [User Settings](https://wandb.ai/settings) and create an API key. Copy the API key immediately and save it in a secure location such as a password manager.
</Note>

1. Click your user profile icon in the upper right corner.
2. Select **User Settings**, then scroll to the **API Keys** section.

## Install the `wandb` library and log in

To install the `wandb` library locally and log in:

<Tabs>
  <Tab title="Command Line">
    1. Set the `WANDB_API_KEY` [environment variable](/models/track/environment-variables/) to your API key.

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

    2. Install the `wandb` library and log in.

       ```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="Python notebook">
    ```notebook theme={null}
    !pip install wandb

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

## Add the `WandbCallback` to the `learner` or `fit` method

```python theme={null}
import wandb
from fastai.callback.wandb import *

# start logging a wandb run
wandb.init(project="my_project")

# To log only during one training phase
learn.fit(..., cbs=WandbCallback())

# To log continuously for all training phases
learn = learner(..., cbs=WandbCallback())
```

<Note>
  If you use version 1 of Fastai, refer to the [Fastai v1 docs](/models/integrations/fastai/v1/).
</Note>

## WandbCallback Arguments

`WandbCallback` accepts the following arguments:

| Args                     | Description                                                                                                                                                                                                                                                  |
| ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| log                      | Whether to log the model's: `gradients` , `parameters`, `all` or `None` (default). Losses & metrics are always logged.                                                                                                                                       |
| log\_preds               | whether we want to log prediction samples (default to `True`).                                                                                                                                                                                               |
| log\_preds\_every\_epoch | whether to log predictions every epoch or at the end (default to `False`)                                                                                                                                                                                    |
| log\_model               | whether we want to log our model (default to False). This also requires `SaveModelCallback`                                                                                                                                                                  |
| model\_name              | The name of the `file` to save, overrides `SaveModelCallback`                                                                                                                                                                                                |
| log\_dataset             | <ul><li><code>False</code> (default)</li><li><code>True</code> will log folder referenced by learn.dls.path.</li><li>a path can be defined explicitly to reference which folder to log.</li></ul><p><em>Note: subfolder "models" is always ignored.</em></p> |
| dataset\_name            | name of logged dataset (default to `folder name`).                                                                                                                                                                                                           |
| valid\_dl                | `DataLoaders` containing items used for prediction samples (default to random items from `learn.dls.valid`.                                                                                                                                                  |
| n\_preds                 | number of logged predictions (default to 36).                                                                                                                                                                                                                |
| seed                     | used for defining random samples.                                                                                                                                                                                                                            |

For custom workflows, you can manually log your datasets and models:

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

*Note: any subfolder "models" will be ignored.*

## Distributed training

`fastai` supports distributed training by using the context manager `distrib_ctx`. W\&B supports this automatically and enables you to track your Multi-GPU experiments out of the box.

Review this minimal example:

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

    Then, in your terminal you will execute:

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

    in this case, the machine has 2 GPUs.
  </Tab>

  <Tab title="Python notebook">
    You can now run distributed training directly inside a 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>

### Log only on the main process

In the examples above, `wandb` launches one run per process. At the end of the training, you will end up with two runs. This can sometimes be confusing, and you may want to log only on the main process. To do so, you will have to detect in which process you are manually and avoid creating runs (calling `wandb.init()` in all other processes)

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

    in your terminal call:

    ```
    $ torchrun --nproc_per_node 2 train.py
    ```
  </Tab>

  <Tab title="Python 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():
        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>

## Examples

* [Visualize, track, and compare Fastai models](https://app.wandb.ai/borisd13/demo_config/reports/Visualize-track-compare-Fastai-models--Vmlldzo4MzAyNA): A thoroughly documented walkthrough.
* [Image Segmentation on CamVid](https://colab.research.google.com/drive/1IWrhwcJoncCKHm6VXsNwOr9Yukhz3B49?usp=sharing): A sample use case of the integration.