> ## Documentation Index
> Fetch the complete documentation index at: https://docs.wandb.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# fastai

> WandbCallback을 사용해 fastai를 W&B와 통합하여 실험를 추적하고, 메트릭을 기록하며, 모델 성능을 시각화합니다.

`WandbCallback` 클래스를 사용해 **fastai**를 W\&B와 통합할 수 있습니다. 자세한 내용은 예제가 포함된 [대화형 문서](https://app.wandb.ai/borisd13/demo_config/reports/Visualize-track-compare-Fastai-models--Vmlldzo4MzAyNA)를 확인하세요.

<div id="sign-up-and-create-an-api-key">
  ## 가입하고 API 키 만들기
</div>

API 키는 사용 중인 머신을 W\&B에 인증하는 데 사용됩니다. 사용자 프로필에서 API 키를 생성할 수 있습니다.

<Note>
  더 간편하게 하려면 [User Settings](https://wandb.ai/settings)로 이동해 API 키를 생성하세요. API 키는 즉시 복사해 비밀번호 관리자와 같은 안전한 위치에 저장하세요.
</Note>

1. 오른쪽 상단에 있는 사용자 프로필 아이콘을 클릭합니다.
2. **User Settings**를 선택한 다음 **API Keys** 섹션으로 스크롤합니다.

<div id="install-the-wandb-library-and-log-in">
  ## `wandb` 라이브러리 설치 및 로그인
</div>

로컬에 `wandb` 라이브러리를 설치하고 로그인하려면 다음 단계를 따르세요.

<Tabs>
  <Tab title="명령줄">
    1. `WANDB_API_KEY` [환경 변수](/ko/models/track/environment-variables/)를 API 키로 설정합니다.

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

    2. `wandb` 라이브러리를 설치하고 로그인합니다.

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

<div id="add-the-wandbcallback-to-the-learner-or-fit-method">
  ## `learner` 또는 `fit` 방법에 `WandbCallback` 추가하기
</div>

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

# wandb run 로깅 시작
wandb.init(project="my_project")

# 하나의 트레이닝 단계에서만 로깅하려면
learn.fit(..., cbs=WandbCallback())

# 모든 트레이닝 단계에서 지속적으로 로깅하려면
learn = learner(..., cbs=WandbCallback())
```

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

<div id="wandbcallback-arguments">
  ## WandbCallback 매개변수
</div>

`WandbCallback`은 다음 매개변수를 받습니다:

| Args                     | Description                                                                                                                                                                                     |
| ------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| log                      | 모델의 `gradients`, `parameters`, `all` 또는 `None`(기본값)을 로깅할지 여부입니다. loss 및 메트릭은 항상 로깅됩니다.                                                                                                          |
| log\_preds               | 예측 샘플을 로깅할지 여부입니다(기본값은 `True`).                                                                                                                                                                 |
| log\_preds\_every\_epoch | 매 에포크마다 예측을 로깅할지, 아니면 마지막에 로깅할지 여부입니다(기본값은 `False`).                                                                                                                                            |
| log\_model               | 모델을 로깅할지 여부입니다(기본값은 `False`). 이 옵션을 사용하려면 `SaveModelCallback`도 필요합니다.                                                                                                                           |
| model\_name              | 저장할 `file` 이름입니다. `SaveModelCallback`을 재정의합니다.                                                                                                                                                  |
| log\_dataset             | <ul><li><code>False</code> (기본값)</li><li><code>True</code>이면 learn.dls.path가 가리키는 폴더를 로깅합니다.</li><li>로깅할 폴더를 가리키도록 경로를 명시적으로 지정할 수 있습니다.</li></ul><p><em>참고: "models" 하위 폴더는 항상 무시됩니다.</em></p> |
| dataset\_name            | 로깅되는 데이터셋의 이름입니다(기본값은 `folder name`).                                                                                                                                                           |
| valid\_dl                | 예측 샘플에 사용할 항목이 들어 있는 `DataLoaders`입니다(기본값은 `learn.dls.valid`에서 무작위로 선택한 항목).                                                                                                                    |
| n\_preds                 | 로깅할 예측 수입니다(기본값은 36).                                                                                                                                                                           |
| seed                     | 무작위 샘플을 정하는 데 사용됩니다.                                                                                                                                                                            |

맞춤형 워크플로의 경우 데이터셋과 모델을 수동으로 로깅할 수 있습니다:

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

*참고: "models" 하위 폴더는 모두 무시됩니다.*

<div id="distributed-training">
  ## 분산 트레이닝
</div>

`fastai`는 컨텍스트 매니저 `distrib_ctx`를 사용해 분산 트레이닝을 지원합니다. W\&B는 이를 자동으로 지원하므로, 별도 설정 없이 멀티 GPU 실험을 추적할 수 있습니다.

다음의 최소 예제를 살펴보세요:

<Tabs>
  <Tab title="스크립트">
    ```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()
    ```

    그런 다음 터미널에서 다음 명령을 실행합니다:

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

    이 경우 이 머신에는 GPU가 2개 있습니다.
  </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():
        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">
  ### 메인 프로세스에서만 로깅하기
</div>

위 예시에서는 `wandb`가 프로세스마다 하나의 run을 생성합니다. 트레이닝이 끝나면 run이 두 개 생깁니다. 이 때문에 혼란스러울 수 있으므로, 메인 프로세스에서만 로깅하고 싶을 수 있습니다. 이렇게 하려면 현재 어떤 프로세스에서 실행 중인지 직접 확인하고, 다른 모든 프로세스에서는 run을 생성하지 않도록(`wandb.init()`를 호출하지 않도록) 해야 합니다.

<Tabs>
  <Tab title="스크립트">
    ```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()

    ```

    터미널에서 다음을 실행합니다:

    ```

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

<div id="examples">
  ## 예제
</div>

* [Fastai 모델을 시각화하고 추적하며 비교하기](https://app.wandb.ai/borisd13/demo_config/reports/Visualize-track-compare-Fastai-models--Vmlldzo4MzAyNA): 문서화가 충실한 워크스루입니다.
* [CamVid 이미지 분할](https://colab.research.google.com/drive/1IWrhwcJoncCKHm6VXsNwOr9Yukhz3B49?usp=sharing): 이 인테그레이션의 사용 사례 예시입니다.