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

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

`WandbCallback` 클래스를 사용해 **fastai**를 W\&B와 통합하여 트레이닝 중에 실험을 추적하고, 메트릭을 로깅하며, 모델 성능을 시각화할 수 있습니다. 이 페이지에서는 인증을 설정하고, 트레이닝 루프에 callback을 추가하며, 단일 프로세스 및 분산 트레이닝 모두에 대한 로깅을 구성하는 방법을 설명합니다. 자세한 내용은 예시가 포함된 [대화형 문서](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">
    ```python 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>

fastai 트레이닝 run을 W\&B에 로깅하기 시작하려면, 단일 `fit` 호출에 또는 `learner` 자체에 `WandbCallback`을 추가하세요.

```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`이 무엇을 로깅할지 제어하려면 다음 인수를 사용하세요.

| 인수                      | 설명                                                                                                                                                                                                   |
| ----------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `log`                   | 모델의 `gradients`, `parameters`, `all` 또는 `None`(기본값)을 로깅할지 여부입니다. loss와 메트릭은 항상 로깅됩니다.                                                                                                                |
| `log_preds`             | 예측 샘플을 로깅할지 여부입니다(기본값: `True`).                                                                                                                                                                      |
| `log_preds_every_epoch` | 예측을 매 에포크마다 로깅할지, 아니면 마지막에만 로깅할지 여부입니다(기본값: `False`).                                                                                                                                                |
| `log_model`             | 모델을 로깅할지 여부입니다(기본값: `False`). 이 옵션을 사용하려면 `SaveModelCallback`도 필요합니다.                                                                                                                                |
| `model_name`            | 저장할 `파일` 이름입니다. `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`          | 로깅되는 데이터셋의 이름입니다(기본값: `폴더 이름`).                                                                                                                                                                      |
| `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 실험을 추적할 수 있습니다. 다음 섹션에서는 W\&B를 분산 트레이닝과 통합하는 방법과 로깅을 메인 프로세스로만 제한하는 방법을 설명합니다.

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

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

이전 예시에서는 W\&B가 프로세스마다 하나의 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()
    ```

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

    ```shell theme={null}
    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 인테그레이션의 엔드 투 엔드 데모는 다음 레퍼런스를 참조하세요:

* [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): 이 인테그레이션의 사용 사례 예시입니다.