> ## Documentation Index
> Fetch the complete documentation index at: https://docs.coreweave.com/llms.txt
> Use this file to discover all available pages before exploring further.
# PyTorch Lightning
> 내장된 WandbLogger를 통해 PyTorch Lightning과 함께 W&B를 사용하여 실험 추적 및 모델 체크포인트 저장을 하세요.
export const ColabLink = ({url}) =>
Try in Colab
;
PyTorch Lightning는 PyTorch 코드를 정리하고 분산 트레이닝 및 16비트 정밀도와 같은 고급 기능을 추가하기 위한 경량 래퍼를 제공합니다. W\&B는 ML 실험을 로깅하는 경량 래퍼를 제공합니다. 두 가지를 직접 결합할 필요가 없습니다. PyTorch Lightning 라이브러리는 [`WandbLogger`](https://lightning.ai/docs/pytorch/stable/api/lightning.pytorch.loggers.wandb.html#module-lightning.pytorch.loggers.wandb)를 통해 W\&B를 직접 포함합니다.
이 페이지는 `WandbLogger`를 사용하여 메트릭을 추적하고, 하이퍼파라미터를 로깅하고, 모델 체크포인트를 아티팩트로 저장하고, 미디어를 로깅하고, PyTorch Lightning 및 W\&B와 함께 multi-GPU 트레이닝을 실행하는 방법을 보여줍니다.
Lightning과 통합하기
다음 섹션에서는 W\&B로 인증하는 방법, `wandb` 라이브러리를 설치하는 방법, Lightning의 `Trainer` 또는 `Fabric` 인스턴스에 `WandbLogger`를 연결하는 방법을 보여줍니다.
```python theme={"system"}
from lightning.pytorch.loggers import WandbLogger
from lightning.pytorch import Trainer
wandb_logger = WandbLogger(log_model="all")
trainer = Trainer(logger=wandb_logger)
```
**`wandb.log()` 사용:** `WandbLogger`는 Trainer의 `global_step`을 사용하여 W\&B에 로깅합니다. 코드에서 직접 `wandb.log()`를 추가로 호출하는 경우 `wandb.log()`에서 `step` 인수를 사용하지 마십시오.
대신 다른 메트릭과 마찬가지로 Trainer의 `global_step`을 로깅하세요:
```python theme={"system"}
wandb.log({"accuracy":0.99, "trainer/global_step": step})
```
```python theme={"system"}
import lightning as L
from wandb.integration.lightning.fabric import WandbLogger
wandb_logger = WandbLogger(log_model="all")
fabric = L.Fabric(loggers=[wandb_logger])
fabric.launch()
fabric.log_dict({"important_metric": important_metric})
```
가입하고 API 키 생성하기
API 키는 W\&B에 머신을 인증합니다. 사용자 프로필에서 API 키를 생성할 수 있습니다.
더 간단한 방법으로 [User Settings](https://forge.coreweave.com/settings)로 이동해 API 키를 생성하세요. API 키를 즉시 복사한 후 비밀번호 관리자와 같은 안전한 위치에 저장하세요.
사용자 프로필에서 API 키를 생성하려면:
1. 오른쪽 상단의 사용자 프로필 아이콘을 클릭하세요.
2. **User Settings**를 선택한 다음 **API Keys** 섹션으로 스크롤하세요.
`wandb` 라이브러리 설치 및 로그인
`wandb` 라이브러리를 로컬에 설치하고 로그인하려면 다음 단계를 따르세요.
1. `WANDB_API_KEY` [환경 변수](/ko/products/wandb/track/environment-variables)에 API 키를 설정하세요. `<>`로 묶인 값은 사용자 값으로 바꾸세요.
```bash theme={"system"}
export WANDB_API_KEY=
```
2. `wandb` 라이브러리를 설치하고 로그인하세요.
```shell theme={"system"}
pip install wandb
wandb login
```
```bash theme={"system"}
pip install wandb
```
```python theme={"system"}
import wandb
wandb.login()
```
```notebook theme={"system"}
!pip install wandb
import wandb
wandb.login()
```
PyTorch Lightning의 `WandbLogger` 사용하기
PyTorch Lightning에는 메트릭, model 가중치, 미디어를 로깅할 수 있는 여러 `WandbLogger` 클래스가 있습니다. 사용 중인 트레이닝 설정에 맞는 클래스를 선택하세요.
* [`PyTorch`](https://lightning.ai/docs/pytorch/stable/api/lightning.pytorch.loggers.wandb.html#module-lightning.pytorch.loggers.wandb)
* [`Fabric`](https://lightning.ai/docs/pytorch/stable/api/lightning.pytorch.loggers.wandb.html#module-lightning.pytorch.loggers.wandb)
Lightning과 통합하려면 `WandbLogger`를 인스턴스화한 후 Lightning의 `Trainer` 또는 `Fabric`에 전달하세요.
```python theme={"system"}
trainer = Trainer(logger=wandb_logger)
```
```python theme={"system"}
fabric = L.Fabric(loggers=[wandb_logger])
fabric.launch()
fabric.log_dict({
"important_metric": important_metric
})
```
공통 logger 인수
다음 table은 `WandbLogger`에 대한 공통 매개변수를 나열합니다. 모든 logger 인수에 대한 자세한 내용은 PyTorch Lightning 문서를 참조하세요.
* [`PyTorch`](https://lightning.ai/docs/pytorch/stable/api/lightning.pytorch.loggers.wandb.html#module-lightning.pytorch.loggers.wandb)
* [`Fabric`](https://lightning.ai/docs/pytorch/stable/api/lightning.pytorch.loggers.wandb.html#module-lightning.pytorch.loggers.wandb)
| 매개변수 | 설명 |
| - | - |
| `project` | 로깅할 W\&B 프로젝트를 정의합니다 |
| `name` | W\&B run의 이름을 지정합니다 |
| `log_model` | `log_model="all"`이면 모든 모델을 로깅하거나, `log_model=True`이면 트레이닝 종료 시 로깅합니다 |
| `save_dir` | 데이터가 저장되는 경로 |
하이퍼파라미터 로깅하기
W\&B로 하이퍼파라미터를 로깅하면 run을 비교하고 결과를 재현할 수 있습니다. 사용하는 Logger에 맞는 방법을 선택하세요.
```python theme={"system"}
class LitModule(LightningModule):
def __init__(self, *args, **kwarg):
self.save_hyperparameters()
```
```python theme={"system"}
wandb_logger.log_hyperparams(
{
"hyperparameter_1": hyperparameter_1,
"hyperparameter_2": hyperparameter_2,
}
)
```
추가 설정 매개변수 로깅하기
하이퍼파라미터와 함께 추가 설정 값을 캡처하려면 run 설정을 직접 업데이트하세요:
```python theme={"system"}
# 하나의 매개변수 추가
wandb_logger.experiment.config["key"] = value
# 여러 매개변수 추가
wandb_logger.experiment.config.update({key1: val1, key2: val2})
# wandb 모듈을 직접 사용
wandb.config["key"] = value
wandb.config.update()
```
그라디언트, 매개변수 히스토그램 및 모델 토폴로지 로깅하기
모델 객체를 `wandb_logger.watch()`에 전달하여 훈련하는 동안 모델의 그라디언트와 매개변수를 모니터링하세요. PyTorch Lightning `WandbLogger` 문서를 참조하세요.
메트릭 로깅
`WandbLogger`를 사용할 때 메트릭을 W\&B에 로깅하려면 `LightningModule` 내에서, 예를 들어 `training_step` 또는 `validation_step` 메서드 안에서 `self.log('my_metric_name', metric_value)`를 호출하세요.
다음 코드 스니펫은 메트릭과 `LightningModule` 하이퍼파라미터를 로깅하도록 `LightningModule`을 정의하는 방법을 보여줍니다. 이 예제에서는 [`torchmetrics`](https://github.com/Lightning-AI/torchmetrics) 라이브러리를 사용하여 메트릭을 계산합니다.
```python theme={"system"}
import torch
from torch.nn import Linear, CrossEntropyLoss, functional as F
from torch.optim import Adam
from torchmetrics.functional import accuracy
from lightning.pytorch import LightningModule
class My_LitModule(LightningModule):
def __init__(self, n_classes=10, n_layer_1=128, n_layer_2=256, lr=1e-3):
"""모델 매개변수를 정의하는 메서드"""
super().__init__()
# mnist 이미지는 (1, 28, 28) (channels, width, height)입니다
self.layer_1 = Linear(28 * 28, n_layer_1)
self.layer_2 = Linear(n_layer_1, n_layer_2)
self.layer_3 = Linear(n_layer_2, n_classes)
self.loss = CrossEntropyLoss()
self.lr = lr
# 하이퍼파라미터를 self.hparams에 저장합니다 (W&B가 자동으로 로깅)
self.save_hyperparameters()
def forward(self, x):
"""추론에 사용하는 메서드: 입력 -> 출력"""
# (b, 1, 28, 28) -> (b, 1*28*28)
batch_size, channels, width, height = x.size()
x = x.view(batch_size, -1)
# 3 x (linear + relu) 적용
x = F.relu(self.layer_1(x))
x = F.relu(self.layer_2(x))
x = self.layer_3(x)
return x
def training_step(self, batch, batch_idx):
"""단일 배치의 loss를 반환해야 합니다"""
_, loss, acc = self._get_preds_loss_accuracy(batch)
# loss와 메트릭 로깅
self.log("train_loss", loss)
self.log("train_accuracy", acc)
return loss
def validation_step(self, batch, batch_idx):
"""메트릭 로깅에 사용합니다"""
preds, loss, acc = self._get_preds_loss_accuracy(batch)
# loss와 메트릭 로깅
self.log("val_loss", loss)
self.log("val_accuracy", acc)
return preds
def configure_optimizers(self):
"""모델 옵티마이저를 정의합니다"""
return Adam(self.parameters(), lr=self.lr)
def _get_preds_loss_accuracy(self, batch):
"""train/valid/test 단계가 비슷하므로 공통으로 사용하는 편의 함수"""
x, y = batch
logits = self(x)
preds = torch.argmax(logits, dim=1)
loss = self.loss(logits, y)
acc = accuracy(preds, y)
return preds, loss, acc
```
```python theme={"system"}
import lightning as L
import torch
import torchvision as tv
from wandb.integration.lightning.fabric import WandbLogger
import wandb
fabric = L.Fabric(loggers=[wandb_logger])
fabric.launch()
model = tv.models.resnet18()
optimizer = torch.optim.SGD(model.parameters(), lr=lr)
model, optimizer = fabric.setup(model, optimizer)
train_dataloader = fabric.setup_dataloaders(
torch.utils.data.DataLoader(train_dataset, batch_size=batch_size)
)
model.train()
for epoch in range(num_epochs):
for batch in train_dataloader:
optimizer.zero_grad()
loss = model(batch)
loss.backward()
optimizer.step()
fabric.log_dict({"loss": loss})
```
메트릭의 최소/최대값 로깅
W\&B의 [`define_metric`](/ko/products/wandb/ref/python/experiments/run#define_metric) 함수를 사용하면 W\&B summary 메트릭이 해당 메트릭의 최소, 최대, 평균 또는 최적값을 표시할지 정의할 수 있습니다. `define_metric`을 사용하지 않으면 summary 메트릭에 마지막으로 로깅한 값이 표시됩니다. 자세한 내용은 [로깅 축 사용자 지정 가이드](/ko/products/wandb/track/log/customize-logging-axes)를 참조하세요.
W\&B summary 메트릭에서 최대 검증 정확도를 추적하려면 트레이닝 시작 시 `wandb.define_metric()`을 한 번만 호출하세요.
```python theme={"system"}
class My_LitModule(LightningModule):
...
def validation_step(self, batch, batch_idx):
if trainer.global_step == 0:
wandb.define_metric("val_accuracy", summary="max")
preds, loss, acc = self._get_preds_loss_accuracy(batch)
# loss와 메트릭 로깅
self.log("val_loss", loss)
self.log("val_accuracy", acc)
return preds
```
```python theme={"system"}
wandb.define_metric("val_accuracy", summary="max")
fabric = L.Fabric(loggers=[wandb_logger])
fabric.launch()
fabric.log_dict({"val_accuracy": val_accuracy})
```
모델 체크포인트
W\&B 아티팩트로 체크포인트를 저장하면 run, 별칭 또는 버전으로 나중에 검색할 수 있는 버전 관리된 모델 파일을 얻을 수 있습니다.
W\&B [아티팩트](/ko/products/wandb/artifacts)로 모델 체크포인트를 저장하려면
Lightning [`ModelCheckpoint`](https://lightning.ai/docs/pytorch/stable/api/lightning.pytorch.callbacks.ModelCheckpoint.html) callback을 사용하고 `WandbLogger`에서 `log_model` 인수를 설정하세요.
```python theme={"system"}
trainer = Trainer(logger=wandb_logger, callbacks=[checkpoint_callback])
```
```python theme={"system"}
fabric = L.Fabric(loggers=[wandb_logger], callbacks=[checkpoint_callback])
```
`latest`와 `best` 별칭은 W\&B 아티팩트에서 모델 체크포인트를 더 쉽게 검색할 수 있도록 자동으로 설정됩니다:
```python theme={"system"}
# 레퍼런스는 아티팩트 패널에서 확인할 수 있습니다
# 은 버전(예: "v2") 또는 별칭("latest" 또는 "best")일 수 있습니다
checkpoint_reference = "//:"
```
```python theme={"system"}
# 로컬에 체크포인트 다운로드(아직 캐시되지 않은 경우)
wandb_logger.download_artifact(checkpoint_reference, artifact_type="model")
```
```python theme={"system"}
# 로컬에 체크포인트 다운로드(아직 캐시되지 않은 경우)
run = wandb.init(project="MNIST")
artifact = run.use_artifact(checkpoint_reference, type="model")
artifact_dir = artifact.download()
```
```python theme={"system"}
# 체크포인트 로드
model = LitModule.load_from_checkpoint(Path(artifact_dir) / "model.ckpt")
```
```python theme={"system"}
# 원시 체크포인트 요청
full_checkpoint = fabric.load(Path(artifact_dir) / "model.ckpt")
model.load_state_dict(full_checkpoint["model"])
optimizer.load_state_dict(full_checkpoint["optimizer"])
```
로깅한 모델 체크포인트는 [W\&B 아티팩트](/ko/products/wandb/artifacts) UI에서 조회할 수 있으며, 전체 모델 리니지도 함께 확인할 수 있습니다(UI의 [예시 모델 체크포인트](https://forge.coreweave.com/wandb/wandb/arttest/artifacts/model/iv3_trained/5334ab69740f9dda4fed/lineage?_gl=1*yyql5q*_ga*MTQxOTYyNzExOS4xNjg0NDYyNzk1*_ga_JH1SJHJQXJ*MTY5MjMwNzI2Mi4yNjkuMS4xNjkyMzA5NjM2LjM3LjAuMA..) 참조).
최고 성능 모델 체크포인트를 북마크하고 팀 전체에서 한곳에 모아 관리하려면 [W\&B 모델 레지스트리](/ko/products/wandb)에 연결하세요.
레지스트리에서는 최고 성능 모델을 작업별로 정리하고, 모델 라이프사이클을 관리하고, ML 라이프사이클 전반에 걸쳐 추적 및 감사할 수 있으며, 웹훅이나 작업으로 다운스트림 액션을 [자동화](/ko/products/wandb/automations)할 수도 있습니다.
이미지, 텍스트 등 로깅하기
`WandbLogger`에는 미디어를 로깅하기 위한 `log_image`, `log_text`, `log_table` 메서드가 있습니다.
또한 `wandb.log()` 또는 `trainer.logger.experiment.log()`를 직접 호출하여 오디오, Molecule, point cloud, 3D 객체와 같은 다른 미디어 유형을 로깅할 수 있습니다.
```python theme={"system"}
# 텐서, numpy 배열 또는 PIL 이미지 사용
wandb_logger.log_image(key="samples", images=[img1, img2])
# 캡션 추가
wandb_logger.log_image(key="samples", images=[img1, img2], caption=["tree", "person"])
# 파일 경로 사용
wandb_logger.log_image(key="samples", images=["img_1.jpg", "img_2.jpg"])
# trainer에서 .log 사용
trainer.logger.experiment.log(
{"samples": [wandb.Image(img, caption=caption) for (img, caption) in my_images]},
step=current_trainer_global_step,
)
```
```python theme={"system"}
# 데이터는 목록의 목록이어야 합니다
columns = ["input", "label", "prediction"]
my_data = [["cheese", "english", "english"], ["fromage", "french", "spanish"]]
# 열과 데이터 사용
wandb_logger.log_text(key="my_samples", columns=columns, data=my_data)
# pandas 데이터프레임 사용
wandb_logger.log_text(key="my_samples", dataframe=my_dataframe)
```
```python theme={"system"}
# 텍스트 캡션, 이미지 및 오디오가 있는 W&B Table 로깅하기
columns = ["caption", "image", "sound"]
# 데이터는 목록의 목록이어야 합니다
my_data = [
["cheese", wandb.Image(img_1), wandb.Audio(snd_1)],
["wine", wandb.Image(img_2), wandb.Audio(snd_2)],
]
# table 로깅하기
wandb_logger.log_table(key="my_samples", columns=columns, data=my_data)
```
Lightning의 callback 시스템을 사용하여 `WandbLogger`를 통해 W\&B에 로깅하는 시점을 제어하세요. 다음 예시는 검증 이미지 및 예측 샘플을 로깅합니다:
```python theme={"system"}
import torch
import wandb
import lightning.pytorch as pl
from lightning.pytorch.loggers import WandbLogger
# or
# from wandb.integration.lightning.fabric import WandbLogger
class LogPredictionSamplesCallback(Callback):
def on_validation_batch_end(
self, trainer, pl_module, outputs, batch, batch_idx, dataloader_idx
):
"""Called when the validation batch ends."""
# `outputs`는 `LightningModule.validation_step`에서 오며
# 이 경우 모델 예측에 해당합니다
# 첫 번째 batch에서 20개의 샘플 이미지 예측을 로깅합니다
if batch_idx == 0:
n = 20
x, y = batch
images = [img for img in x[:n]]
captions = [
f"Ground Truth: {y_i} - Prediction: {y_pred}"
for y_i, y_pred in zip(y[:n], outputs[:n])
]
# 옵션 1: `WandbLogger.log_image`로 이미지 로깅
wandb_logger.log_image(key="sample_images", images=images, caption=captions)
# 옵션 2: 이미지와 예측을 W&B Table로 로깅
columns = ["image", "ground truth", "prediction"]
data = [
[wandb.Image(x_i), y_i, y_pred] or x_i,
y_i,
y_pred in list(zip(x[:n], y[:n], outputs[:n])),
]
wandb_logger.log_table(key="sample_table", columns=columns, data=data)
trainer = pl.Trainer(callbacks=[LogPredictionSamplesCallback()])
```
Lightning 및 W\&B와 함께 여러 GPU 사용
분산 트레이닝을 실행할 때, rank 간에 `wandb.run`을 참조하는 방식이 트레이닝이 계속 진행될지 아니면 교착 상태에 빠질지에 영향을 줄 수 있습니다. 이 섹션에서는 요구 사항을 설명하고 권장 패턴을 보여줍니다.
PyTorch Lightning은 DDP 인터페이스를 통해 multi-GPU를 지원합니다. 그러나 PyTorch Lightning의 설계상 GPU를 인스턴스화하는 방식에 주의해야 합니다.
Lightning은 트레이닝 루프의 각 GPU(또는 rank)를 정확히 동일한 방식으로, 동일한 초기 조건으로 인스턴스화해야 합니다. 그러나 rank 0 프로세스만 `wandb.run` 객체에 액세스할 수 있습니다. 0이 아닌 rank 프로세스의 경우 `wandb.run = None`입니다. 이로 인해 0이 아닌 rank 프로세스가 실패할 수 있습니다. 이 경우 rank 0 프로세스는 이미 크래시된 0이 아닌 rank 프로세스가 join하기를 계속 기다리게 되므로 교착 상태에 빠질 수 있습니다.
따라서 트레이닝 코드를 설정하는 방식에 주의해야 합니다. 권장하는 방법은 코드가 `wandb.run` 객체에 의존하지 않도록 작성하는 것입니다.
```python theme={"system"}
class MNISTClassifier(pl.LightningModule):
def __init__(self):
super(MNISTClassifier, self).__init__()
self.model = nn.Sequential(
nn.Flatten(),
nn.Linear(28 * 28, 128),
nn.ReLU(),
nn.Linear(128, 10),
)
self.loss = nn.CrossEntropyLoss()
def forward(self, x):
return self.model(x)
def training_step(self, batch, batch_idx):
x, y = batch
y_hat = self.forward(x)
loss = self.loss(y_hat, y)
self.log("train/loss", loss)
return {"train_loss": loss}
def validation_step(self, batch, batch_idx):
x, y = batch
y_hat = self.forward(x)
loss = self.loss(y_hat, y)
self.log("val/loss", loss)
return {"val_loss": loss}
def configure_optimizers(self):
return torch.optim.Adam(self.parameters(), lr=0.001)
def main():
# 모든 랜덤 시드를 동일한 값으로 설정합니다.
# 이는 분산 트레이닝 설정에서 중요합니다.
# 각 rank는 고유한 초기 가중치 세트를 받습니다.
# 일치하지 않으면 그라디언트도 일치하지 않습니다,
# 트레이닝이 수렴하지 않을 수 있습니다.
pl.seed_everything(1)
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True, num_workers=4)
val_loader = DataLoader(val_dataset, batch_size=64, shuffle=False, num_workers=4)
model = MNISTClassifier()
wandb_logger = WandbLogger(project="")
callbacks = [
ModelCheckpoint(
dirpath="checkpoints",
every_n_train_steps=100,
),
]
trainer = pl.Trainer(
max_epochs=3, gpus=2, logger=wandb_logger, strategy="ddp", callbacks=callbacks
)
trainer.fit(model, train_loader, val_loader)
```
예시
엔드투엔드 워크스루를 따라 하려면 [Colab 노트북이 포함된 비디오 튜토리얼](https://wandb.me/lit-colab)을 참고하세요.
자주 묻는 질문
W\&B는 Lightning과 어떻게 통합되나요?
핵심 인테그레이션은 [Lightning `loggers` API](https://lightning.ai/docs/pytorch/stable/extensions/logging.html)를 기반으로 합니다. 이 API를 사용하면 로깅 코드의 상당 부분을 프레임워크에 구애받지 않는 방식으로 작성할 수 있습니다. `Logger` 인스턴스는 [Lightning `Trainer`](https://lightning.ai/docs/pytorch/stable/common/trainer.html)에 전달되며, 이 API가 제공하는 풍부한 [훅 및 callback 시스템](https://lightning.ai/docs/pytorch/stable/extensions/callbacks.html)에 따라 트리거됩니다. 덕분에 연구 코드를 엔지니어링 코드 및 로깅 코드와 깔끔하게 분리할 수 있습니다.
추가 코드 없이 인테그레이션은 무엇을 로깅하나요?
W\&B는 모델 체크포인트를 저장하므로, 이를 확인하거나 향후 run에서 사용하기 위해 다운로드할 수 있습니다. W\&B는 또한 GPU 사용량 및 네트워크 I/O와 같은 [시스템 메트릭](/ko/products/wandb/ref/python/experiments/system-metrics)을 캡처합니다. 하드웨어 및 OS 정보와 같은 환경 정보를 캡처합니다. Git 커밋 및 diff 패치, 노트북 콘텐츠, 세션 이력을 포함한 [코드 상태](/ko/products/wandb/app/features/panels/code)를 캡처합니다. 또한 표준 출력으로 출력된 모든 것을 캡처합니다.
`wandb.run`을 트레이닝 설정에서 사용해야 하는 경우에는 어떻게 하나요?
액세스해야 하는 변수의 범위를 직접 확장해야 합니다. 즉, 모든 프로세스에서 초기 조건이 동일하도록 하십시오.
```python theme={"system"}
if os.environ.get("LOCAL_RANK", None) is None:
os.environ["WANDB_DIR"] = wandb.run.dir
```
그렇다면 `os.environ["WANDB_DIR"]`을 사용하여 모델 체크포인트 디렉터리를 설정할 수 있습니다. 이렇게 하면 0이 아닌 rank 프로세스가 `wandb.run.dir`에 액세스할 수 있습니다.
