[PyTorch] 6주차: 모델 훈련 및 평가

강의 목표

• PyTorch에서 모델 훈련 및 평가 방법 이해
• 손실 함수와 옵티마이저 설정 및 사용법 습득
• 훈련 루프 작성 및 모델 평가 지표 이해

강의 내용

1. 모델 훈련 기본 개념

• 모델 훈련 과정
  • 순전파(forward pass): 입력 데이터를 모델에 통과시켜 예측값 계산
  • 손실 계산: 예측값과 실제값의 차이 계산
  • 역전파(backward pass): 기울기 계산
  • 가중치 업데이트: 옵티마이저를 통해 가중치 조정
• 손실 함수(Loss Function)
  • 손실 함수는 모델의 예측값과 실제값의 차이를 측정하는 함수
  • 예시: nn.MSELoss(), nn.CrossEntropyLoss()
   

import torch
import torch.nn as nn

# MSELoss 예시
criterion = nn.MSELoss()

•  옵티마이저(Optimizer)
  • 옵티마이저는 손실을 줄이기 위해 가중치를 업데이트하는 알고리즘
  • 예시: optim.SGD, optim.Adam
   

import torch.optim as optim

# SGD 옵티마이저 예시
optimizer = optim.SGD(model.parameters(), lr=0.01)

 

2. 모델 훈련 루프

• 훈련 루프 작성
  • 모델 훈련 과정의 각 단계 구현
   

# 모델 정의 (이전 주차의 예제 사용)
class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(10, 50)
        self.fc2 = nn.Linear(50, 1)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

model = SimpleNN()

# 손실 함수와 옵티마이저 설정
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 데이터 로더 설정 (이전 주차의 데이터 사용)
from torch.utils.data import DataLoader, TensorDataset

data = torch.randn(100, 10)
labels = torch.randn(100, 1)
dataset = TensorDataset(data, labels)
dataloader = DataLoader(dataset, batch_size=16, shuffle=True)

# 훈련 루프
num_epochs = 100

for epoch in range(num_epochs):
    for inputs, targets in dataloader:
        optimizer.zero_grad()  # 옵티마이저 초기화
        outputs = model(inputs)  # 순전파
        loss = criterion(outputs, targets)  # 손실 계산
        loss.backward()  # 역전파
        optimizer.step()  # 가중치 업데이트

    print(f'Epoch {epoch+1}/{num_epochs}, Loss: {loss.item()}')

 

3. 모델 평가

• 검증 데이터셋을 사용한 평가
  • 훈련 중간 및 끝에 모델 성능을 평가하기 위해 검증 데이터셋 사용
  • 모델의 일반화 성능을 평가
   

# 검증 데이터 로더 설정
val_data = torch.randn(20, 10)
val_labels = torch.randn(20, 1)
val_dataset = TensorDataset(val_data, val_labels)
val_loader = DataLoader(val_dataset, batch_size=16, shuffle=False)

# 모델 평가 함수
def evaluate_model(model, val_loader):
    model.eval()  # 평가 모드
    val_loss = 0
    with torch.no_grad():  # 평가 시 기울기 계산 안함
        for inputs, targets in val_loader:
            outputs = model(inputs)
            loss = criterion(outputs, targets)
            val_loss += loss.item()

    return val_loss / len(val_loader)

# 훈련 후 평가
val_loss = evaluate_model(model, val_loader)
print(f'Validation Loss: {val_loss}')

• 모델 성능 지표
  • 정확도(Accuracy), 정밀도(Precision), 재현율(Recall), F1-score 등
  • 회귀 문제에서는 MSE, RMSE, MAE 등
   

from sklearn.metrics import accuracy_score

# 예시: 분류 문제에서 정확도 계산
def calculate_accuracy(model, val_loader):
    model.eval()
    all_preds = []
    all_labels = []
    with torch.no_grad():
        for inputs, labels in val_loader:
            outputs = model(inputs)
            preds = torch.argmax(outputs, dim=1)
            all_preds.extend(preds.tolist())
            all_labels.extend(labels.tolist())

    accuracy = accuracy_score(all_labels, all_preds)
    return accuracy

 

4. 실습 및 과제

• 실습 과제
  • 주어진 데이터셋을 사용하여 신경망 모델을 구축하고, 훈련 및 평가
  • 손실 함수와 옵티마이저를 설정하고, 훈련 루프 작성
  • 검증 데이터셋을 사용하여 모델 성능 평가
   

# 실습 과제 예시
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
from sklearn.metrics import mean_squared_error

# 데이터 생성
data = torch.randn(100, 10)  # 100개의 샘플, 각 샘플은 10개의 특징
labels = torch.randn(100, 1)  # 100개의 샘플에 대한 타겟 값

# 데이터셋 및 데이터로더 설정
dataset = TensorDataset(data, labels)
dataloader = DataLoader(dataset, batch_size=16, shuffle=True)

# 모델 정의
class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(10, 50)
        self.fc2 = nn.Linear(50, 1)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

model = SimpleNN()

# 손실 함수와 옵티마이저 설정
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 훈련 루프
num_epochs = 100
for epoch in range(num_epochs):
    model.train()  # 훈련 모드
    for inputs, targets in dataloader:
        optimizer.zero_grad()  # 옵티마이저 초기화
        outputs = model(inputs)  # 순전파
        loss = criterion(outputs, targets)  # 손실 계산
        loss.backward()  # 역전파
        optimizer.step()  # 가중치 업데이트

    print(f'Epoch {epoch+1}/{num_epochs}, Loss: {loss.item()}')

# 모델 평가
val_data = torch.randn(20, 10)
val_labels = torch.randn(20, 1)
val_dataset = TensorDataset(val_data, val_labels)
val_loader = DataLoader(val_dataset, batch_size=16, shuffle=False)

def evaluate_model(model, val_loader):
    model.eval()  # 평가 모드
    val_loss = 0
    all_preds = []
    all_labels = []
    with torch.no_grad():
        for inputs, labels in val_loader:
            outputs = model(inputs)
            loss = criterion(outputs, labels)
            val_loss += loss.item()
            all_preds.extend(outputs.tolist())
            all_labels.extend(labels.tolist())

    val_loss /= len(val_loader)
    mse = mean_squared_error(all_labels, all_preds)
    return val_loss, mse

val_loss, mse = evaluate_model(model, val_loader)
print(f'Validation Loss: {val_loss}, MSE: {mse}')

 

• 과제 제출
  • Jupyter Notebook 파일로 제출
  • 제출 기한: 다음 강의 시작 전까지