PyTorch에서 에포크마다 정확도 계산하기
import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
# 데이터 로드
train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transforms.ToTensor())
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)
test_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transforms.ToTensor())
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=64, shuffle=False)
# 모델 정의
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.fc1 = nn.Linear(784, 100)
self.fc2 = nn.Linear(100, 10)
def forward(self, x):
x = x.view(-1, 784)
x = F.relu(self.fc1(x))
x = self.fc2(x)
return x
# 모델 생성 및 최적화 설정
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model = Net().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters())
# 학습 루프
for epoch in range(10):
# 에포크마다 정확도 초기화
total = 0
correct = 0
for images, labels in train_loader:
images = images.to(device)
labels = labels.to(device)
# 모델 예측
outputs = model(images)
_, predicted = torch.max(outputs.data, 1)
# 정확도 계산
total += labels.size(0)
correct += (predicted == labels).sum().item()
# 에포크마다 정확도 출력
print('Epoch [{}/{}], Accuracy: {:.2f}%'.format(epoch + 1, 10, 100 * correct / total))
# 모델 학습
loss = criterion(outputs, labels)
optimizer.zero_grad()
loss.backward()
optimizer.step()
# 모델 저장
torch.save(model.state_dict(), 'model.pth')
설명:
- 데이터 로드: MNIST 데이터 세트를 로드하고 훈련 및 테스트 데이터 로더를 만듭니다.
- 모델 정의:
Net
클래스는 두 개의 완전 연결 레이어로 구성된 간단한 신경망 모델을 정의합니다. - 모델 생성 및 최적화 설정: 모델을 생성하고 장치에 할당하고 손실 함수와 최적화 알고리즘을 설정합니다.
- 학습 루프:
- 모델 저장: 학습된 모델을 파일에 저장합니다.
핵심 내용:
torch.autograd
를 사용하여 모델 예측에 대한 기울기를 계산하고 역방향 전파를 통해 모델 매개변수를 업데이트합니다.train_loader
및test_loader
를 사용하여 데이터를 미니 배치로 효율적으로 처리합니다.
import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
# 데이터 로드
train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transforms.ToTensor())
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)
test_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transforms.ToTensor())
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=64, shuffle=False)
# 모델 정의
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.fc1 = nn.Linear(784, 100)
self.fc2 = nn.Linear(100, 10)
def forward(self, x):
x = x.view(-1, 784)
x = F.relu(self.fc1(x))
x = self.fc2(x)
return x
# 모델 생성 및 최적화 설정
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model = Net().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters())
# 학습 루프
for epoch in range(10):
# 에포크마다 정확도 초기화
total = 0
correct = 0
for images, labels in train_loader:
images = images.to(device)
labels = labels.to(device)
# 모델 예측
outputs = model(images)
_, predicted = torch.max(outputs.data, 1)
# 정확도 계산
total += labels.size(0)
correct += (predicted == labels).sum().item()
# 에포크마다 정확도 출력
print('Epoch [{}/{}], Accuracy: {:.2f}%'.format(epoch + 1, 10, 100 * correct / total))
# 모델 학습
loss = criterion(outputs, labels)
optimizer.zero_grad()
loss.backward()
optimizer.step()
# 모델 저장
torch.save(model.state_dict(), 'model.pth')
추가 정보:
- PyTorch 공식 문서:
PyTorch에서 에포크마다 정확도 계산하기: 대체 방법
다음은 대체 방법 몇 가지입니다.
tqdm 라이브러리 사용:
import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
import tqdm
# 데이터 로드
train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transforms.ToTensor())
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)
test_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transforms.ToTensor())
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=64, shuffle=False)
# 모델 정의
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.fc1 = nn.Linear(784, 100)
self.fc2 = nn.Linear(100, 10)
def forward(self, x):
x = x.view(-1, 784)
x = F.relu(self.fc1(x))
x = self.fc2(x)
return x
# 모델 생성 및 최적화 설정
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model = Net().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters())
# 학습 루프
for epoch in range(10):
# 정확도 초기화
running_loss = 0.0
correct = 0
total = 0
# tqdm 사용하여 진행률 표시
with tqdm.tqdm(total=len(train_loader)) as pbar:
for images, labels in train_loader:
images = images.to(device)
labels = labels.to(device)
# 모델 예측
outputs = model(images)
_, predicted = torch.max(outputs.data, 1)
# 정확도 계산
total += labels.size(0)
correct += (predicted == labels).sum().item()
# 손실 계산
loss = criterion(outputs, labels)
running_loss += loss.item()
# 모델 학습
optimizer.zero_grad()
loss.backward()
optimizer.step()
# 진행률 업데이트
pbar.update(1)
# 에포크마다 평균 손실 및 정확도 출력
average_loss = running_loss / len(train_loader)
print(f'Epoch [{epoch + 1}/{10}], Average Loss: {average_loss:.4f}, Accuracy: {100 * correct / total:.2f}%')
# 모델 저장
torch.save(model.state_dict(), 'model.pth')
tqdm
라이브러리를 사용하여 학습 과정의 진행률을 표시합니다.pbar.update(1)
를 사용하여 각 배치 처리 후 진행률 표시줄을 업데이트합니다.
Early Stopping 구현:
import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.tensorboard import SummaryWriter
# 데이터 로드
train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transforms.ToTensor())
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)
test_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transforms.ToTensor())
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=64, shuffle=False)
# 모델 정의
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.fc1 = nn.Linear(784, 100)
python neural-network pytorch