> ## 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.
> W&B를 PyTorch Ignite와 통합하여 트레이닝 메트릭, 모델 매개변수 및 실험 설정을 자동으로 로깅합니다.
# PyTorch Ignite
이 페이지는 PyTorch Ignite와 함께 W\&B 핸들러를 사용하여 트레이닝 및 검증 메트릭, 모델 및 옵티마이저 매개변수, 그라디언트, 그리고 모델 체크포인트를 실험 중에 자동으로 로깅하는 방법을 보여줍니다.
Ignite는 W\&B 핸들러를 지원하여 트레이닝 및 검증 중에 메트릭, 모델 및 옵티마이저 매개변수, 그라디언트를 로깅합니다. 또한 W\&B 클라우드에 모델 체크포인트를 로깅하는 데 사용할 수 있습니다. 이 클래스는 W\&B Python SDK(`wandb`)를 래핑하므로 이 래퍼를 사용하여 모든 `wandb` 함수를 호출할 수 있습니다. 모델 매개변수와 그라디언트를 저장하는 방법에 대한 예시는 예시를 참조하세요.
추가 컨텍스트는 다음 리소스를 참조하세요:
* 이 [예시 W\&B Report](https://forge.coreweave.com/wandb/example-team/pytorch-ignite-example/reports/PyTorch-Ignite-with-W%26B--Vmlldzo0NzkwMg)에서 결과 시각화를 확인하세요.
* 이 [예시 호스티드 노트북](https://colab.research.google.com/drive/15e-yGOvboTzXU4pe91Jg-Yr7sae3zBOJ#scrollTo=ztVifsYAmnRr)에서 코드를 직접 실행해 보세요.
기본 설정
다음 예시에서는 단순한 컨볼루션 모델과 MNIST용 데이터 로더를 정의합니다. 이어지는 로깅 예시에서는 이 구성 요소들을 사용합니다.
```python theme={"system"}
from argparse import ArgumentParser
import wandb
import torch
from torch import nn
from torch.optim import SGD
from torch.utils.data import DataLoader
import torch.nn.functional as F
from torchvision.transforms import Compose, ToTensor, Normalize
from torchvision.datasets import MNIST
from ignite.engine import Events, create_supervised_trainer, create_supervised_evaluator
from ignite.metrics import Accuracy, Loss
from tqdm import tqdm
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
self.conv2_drop = nn.Dropout2d()
self.fc1 = nn.Linear(320, 50)
self.fc2 = nn.Linear(50, 10)
def forward(self, x):
x = F.relu(F.max_pool2d(self.conv1(x), 2))
x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))
x = x.view(-1, 320)
x = F.relu(self.fc1(x))
x = F.dropout(x, training=self.training)
x = self.fc2(x)
return F.log_softmax(x, dim=-1)
def get_data_loaders(train_batch_size, val_batch_size):
data_transform = Compose([ToTensor(), Normalize((0.1307,), (0.3081,))])
train_loader = DataLoader(MNIST(download=True, root=".", transform=data_transform, train=True),
batch_size=train_batch_size, shuffle=True)
val_loader = DataLoader(MNIST(download=False, root=".", transform=data_transform, train=False),
batch_size=val_batch_size, shuffle=False)
return train_loader, val_loader
```
Ignite에서 `WandBLogger`를 사용하는 과정은 모듈식으로 구성됩니다. 먼저 `WandBLogger` 객체를 생성하세요. 그런 다음 트레이너나 평가기에 연결하여 메트릭을 자동으로 로깅하세요. 이 예제는 다음을 보여줍니다:
* 트레이너 객체에 연결하여 트레이닝 손실을 로깅합니다.
* 평가기에 연결하여 검증 손실을 로깅합니다.
* 학습률과 같은 선택 매개변수를 로깅합니다.
* 모델을 모니터링합니다.
```python theme={"system"}
from ignite.contrib.handlers.wandb_logger import *
def run(train_batch_size, val_batch_size, epochs, lr, momentum, log_interval):
train_loader, val_loader = get_data_loaders(train_batch_size, val_batch_size)
model = Net()
device = 'cpu'
if torch.cuda.is_available():
device = 'cuda'
optimizer = SGD(model.parameters(), lr=lr, momentum=momentum)
trainer = create_supervised_trainer(model, optimizer, F.nll_loss, device=device)
evaluator = create_supervised_evaluator(model,
metrics={'accuracy': Accuracy(),
'nll': Loss(F.nll_loss)},
device=device)
desc = "ITERATION - loss: {:.2f}"
pbar = tqdm(
initial=0, leave=False, total=len(train_loader),
desc=desc.format(0)
)
#WandBlogger 객체 생성
wandb_logger = WandBLogger(
project="pytorch-ignite-integration",
name="cnn-mnist",
config={"max_epochs": epochs,"batch_size":train_batch_size},
tags=["pytorch-ignite", "mninst"]
)
wandb_logger.attach_output_handler(
trainer,
event_name=Events.ITERATION_COMPLETED,
tag="training",
output_transform=lambda loss: {"loss": loss}
)
wandb_logger.attach_output_handler(
evaluator,
event_name=Events.EPOCH_COMPLETED,
tag="training",
metric_names=["nll", "accuracy"],
global_step_transform=lambda *_: trainer.state.iteration,
)
wandb_logger.attach_opt_params_handler(
trainer,
event_name=Events.ITERATION_STARTED,
optimizer=optimizer,
param_name='lr' # 선택
)
wandb_logger.watch(model)
```
로거를 연결하면 Ignite가 트레이닝 및 검증 메트릭, 옵티마이저 매개변수, 모델 그라디언트를 W\&B 프로젝트로 자동 스트리밍합니다.
선택적으로 Ignite `EVENTS`를 사용하여 메트릭을 터미널에 직접 로깅할 수 있습니다.
```python theme={"system"}
@trainer.on(Events.ITERATION_COMPLETED(every=log_interval))
def log_training_loss(engine):
pbar.desc = desc.format(engine.state.output)
pbar.update(log_interval)
@trainer.on(Events.EPOCH_COMPLETED)
def log_training_results(engine):
pbar.refresh()
evaluator.run(train_loader)
metrics = evaluator.state.metrics
avg_accuracy = metrics['accuracy']
avg_nll = metrics['nll']
tqdm.write(
"Training Results - Epoch: {} Avg accuracy: {:.2f} Avg loss: {:.2f}"
.format(engine.state.epoch, avg_accuracy, avg_nll)
)
@trainer.on(Events.EPOCH_COMPLETED)
def log_validation_results(engine):
evaluator.run(val_loader)
metrics = evaluator.state.metrics
avg_accuracy = metrics['accuracy']
avg_nll = metrics['nll']
tqdm.write(
"Validation Results - Epoch: {} Avg accuracy: {:.2f} Avg loss: {:.2f}"
.format(engine.state.epoch, avg_accuracy, avg_nll))
pbar.n = pbar.last_print_n = 0
trainer.run(train_loader, max_epochs=epochs)
pbar.close()
if __name__ == "__main__":
parser = ArgumentParser()
parser.add_argument('--batch_size', type=int, default=64,
help='input batch size for training (default: 64)')
parser.add_argument('--val_batch_size', type=int, default=1000,
help='input batch size for validation (default: 1000)')
parser.add_argument('--epochs', type=int, default=10,
help='number of epochs to train (default: 10)')
parser.add_argument('--lr', type=float, default=0.01,
help='learning rate (default: 0.01)')
parser.add_argument('--momentum', type=float, default=0.5,
help='SGD momentum (default: 0.5)')
parser.add_argument('--log_interval', type=int, default=10,
help='how many batches to wait before logging training status')
args = parser.parse_args()
run(args.batch_size, args.val_batch_size, args.epochs, args.lr, args.momentum, args.log_interval)
```
이 코드는 다음 시각화를 생성합니다:
자세한 내용은 [Ignite 문서](https://pytorch.org/ignite/contrib/handlers.html#module-ignite.contrib.handlers.wandb_logger)를 참고하세요.