[PyTorch] 공식 문서 Learn the Basics 요약 - 6. Optimization

목차

모델 매개변수 최적화(Optimizing the model parameters)

기본 코드(Prerequisite code)

하이퍼파라미터 설정(Setting hyperparameters)

최적화 루프 추가(Add an optimization loop)

손실 함수 추가(Add a loss function)

최적화 패스(Optimization pass)

전체 구현(Full implementation)

keyword:

학습률(learning rate), 최상의 가중치(best weights), 예측할 수 없는 동작(unpredictable behavior), 지역 최소값(local minima), 전역 최소값(global minima), 최적화 루프(optimization loop), 학습 루프(train loop), 검증 루프(validation loop), 테스트 루프(test loop), 손실 계산(loss calculation), 옵티마이저 단계(optimizer step), 평균 제곱 오차(Mean Square Error, MSE), 음의 로그 우도(Negative Log Likelihood, NLL), 크로스엔트로피 손실(Cross-Entropy Loss, CE), 로짓(logit), 최적화 알고리즘(optimization algorithms), 옵티마이저 객체(optimizer object), SGD(Stochastic Gradient Descent), ADAM, RMSProp, torch.save, 내부 상태 사전(internal state dictionary), state_dict()

---

모델 매개변수 최적화(Optimizing the model parameters)

• 모델: 훈련, 검증 및 테스트됨
• 데이터: 최적화에 사용
• 학습: 반복적인 과정 거침
• 반복(iteration): epoch(에폭)라고 함
• 각 반복에서의 모델의 학습:
  출력에 대해 추측
  오류(추측과 정답 사이의 차이(손실, loss)) 계산
  매개변수와 관련된 오류의 도함수(derivative) 수집
  경사하강법(Gradient Descent) 사용하여 매개변수 최적화(optimize)

keyword: model optimization

• 모델 최적화(model optimization):
  손실 함수와 같은 스칼라 값 함수를 최소화하기 위해 모델의 매개변수를 조정하는 프로세스
  손실 함수의 변화도를 기반으로 매개변수를 업데이트하는 알고리즘인 옵티마이저를 사용하여 수행됨
  목표는 최상의 모델 성능을 나타내는 가능한 최저 손실(lowest possible loss)을 초래하는 매개변수 집합을 찾는 것

 

기본 코드(Prerequisite code)

%matplotlib inline
import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision.transforms import ToTensor, Lambda

training_data = datasets.FashionMNIST(
    root="data",
    train=True,
    download=True,
    transform=ToTensor()
)

test_data = datasets.FashionMNIST(
    root="data",
    train=False,
    download=True,
    transform=ToTensor()
)

train_dataloader = DataLoader(training_data, batch_size=64)
test_dataloader = DataLoader(test_data, batch_size=64)

class NeuralNetwork(nn.Module):
    def __init__(self):
        super(NeuralNetwork, self).__init__()
        self.flatten = nn.Flatten()
        self.linear_relu_stack = nn.Sequential(
            nn.Linear(28*28, 512),
            nn.ReLU(),
            nn.Linear(512, 512),
            nn.ReLU(),
            nn.Linear(512, 10),
            nn.ReLU()
        )

    def forward(self, x):
        x = self.flatten(x)
        logits = self.linear_relu_stack(x)
        return logits

model = NeuralNetwork()

 

하이퍼파라미터 설정(Setting hyperparameters)

하이퍼파라미터

• 정의: 모델 최적화 과정을 제어하는 ​​조절 가능한 매개변수
• 영향(impact): 모델 학습 및 정확도 수준, 수렴율(convergence rate)
• 학습용으로 정의된 하이퍼파라미터:
  • Epoch 수: 전체 교육 데이터 세트가 네트워크를 통과하는 횟수
  • batch size: 매개변수가 갱신되기 전 신경망을 통해 전파된 데이터 샘플의 수
  • iterations(반복수): 한 에폭를 완료하는 데 필요한 배치 수(학습 데이터 수 / 배치 사이즈)
  • 학습률(learning rate):
    각 배치/에폭에서 모델의 매개변수를 조절하는 비율
    더 작은 학습률: 학습 속도 느려짐. 모델이 최상의 가중치를 찾는 데 더 오래 걸림. local minima에 빠질 수 있음
    더 큰 학습률: 모델이 건너뛰고 최상의 가중치를 놓칠 수 있으며 학습 중에 예측할 수 없는 동작이 발생할 수 있음

learning_rate = 1e-3
batch_size = 64
epochs = 5

keyword: learning rate, best weights, unpredictable behavior, local minima, global minima

• 학습률(learning rate):
  최적화 알고리즘의 단계 크기를 제어하는 ​​하이퍼파라미터
  각 반복에서 매개변수가 업데이트되는 양을 결정
  학습률이 높으면 업데이트가 커지고 수렴이 빨라지지만 모델이 최적의 솔루션을 초과할 수도 있음
  학습률이 낮으면 업데이트가 작아지고 수렴이 느려지지만 로컬 미니마에 갇힐 수 있음
• 최상의 가중치(best weights):
  최상의 모델 성능을 나타내는 가능한 최저 손실(lowest possible loss)을 초래하는 매개변수 집합
  옵티마이저의 목표는 손실 함수의 기울기에 따라 매개변수를 업데이트하여 모델에 가장 적합한 가중치를 찾는 것
• 예측할 수 없는 동작(unpredictable behavior):
  옵티마이저가 최상의 가중치를 찾을 수 없는 경우 모델 최적화 프로세스 중에 예측할 수 없는 동작이 발생할 수 있음
  이는 잘못된 하이퍼 매개변수 선택(poor choice of hyperparameter), 잘못 확장된 데이터(poorly scaled data) 또는 복잡하고 고차원적인 문제(complex, high-dimonsional problem)와 같은 여러 요인으로 인해 발생할 수 있음
  옵티마이저가 차선의 솔루션이 될 수 있는 로컬 미니멈 또는 안장점(saddle point)에 멈춘 경우에도 발생할 수 있음
• 지역 최소값(local minima):
  근처의 모든 지점보다 낮은 손실 함수 환경의 한 지점
  더 낮은 지점이 있을 수 있음
  로컬 최소값으로 수렴하도록 훈련된 모델은 전역 최소값으로 수렴하는 모델보다 성능이 좋지 않음
• 전역 최소값(global minima):
  전체적으로 가장 낮은 지점인 손실 함수 환경의 지점
  전역 최소값으로 수렴하도록 훈련된 모델이 최상의 성능을 발휘

 

최적화 단계 추가(Add an optimization loop)

• 최적화 단계: 모델 학습 및 최적화에 사용
• 각 에폭: 두 가지 주요 부분으로 구성
  • 훈련 루프: 훈련 데이터 세트를 반복하고 최적의 매개변수로 수렴하려고 시도
  • 검증/테스트 단계(validation/test loop): 테스트 데이터 세트를 반복하여 모델 성능이 개선되고 있는지 확인
• 교육 루프에서 사용되는 개념:
  • forward pass: 모델이 예측을 수행
  • loss calculation: 예측을 실제 출력과 비교
  • backward pass: 모델 매개변수에 대한 손실의 기울기를 계산
  • optimizer step: 계산된 그래디언트를 사용하여 모델 매개변수를 업데이트

 

키워드: optimization loop, train loop, validation loop, test loop, generalization performance, loss calculation, optimizer step

1. 최적화 루프(optimization loop):
   신경망 학습 과정의 주요 루프
   모델을 통해 입력 데이터를 반복적으로 전달하고, 손실을 계산하고, 옵티마이저를 사용하여 모델의 매개변수를 업데이트하는 것으로 구성됨
   지정된 반복 횟수 동안 또는 모델 성능이 특정 임계값에 도달할 때까지 반복됨
2. 학습 루프(train loop):
   훈련 데이터에서 모델을 훈련시키는 데 사용되는 특정 유형의 최적화 루프
   훈련 루프 동안 훈련 데이터에서 계산된 손실 함수의 기울기를 기반으로 모델의 매개변수가 업데이트됨
3. 검증 루프(validation loop):
   훈련 루프와 유사하지만 검증 데이터 세트에서 모델의 성능을 평가하는 데 사용됨
   훈련 중 모델의 성능을 모니터링하고 과적합을 감지하는 데 사용됨
4. 테스트 루프(test loop):
   학습이 완료된 후 테스트 데이터 세트에서 모델의 성능을 평가하는 데 사용됨
   모델의 일반화 성능에 대한 추정치를 제공
5. 일반화 성능(generalization performance):
   본 적이 없는 데이터에 대해 모델이 잘 수행할 수 있는 능력
6. 손실 계산(loss calculation):
   모델의 출력과 실제 출력에 대한 스칼라 값 함수를 계산하는 프로세스
   모델의 매개변수를 업데이트하는 데 필요한 정보를 제공하므로 최적화 루프에서 중요한 단계
7. 옵티마이저 단계(optimizer step):
   손실 함수의 기울기에 따라 모델의 매개변수를 업데이트하는 프로세스

 

손실 함수 추가(Add a loss function)

• 학습 데이터 제공 시 학습되지 않은 네트워크는 정답을 제공하지 않을 수 있음
• 손실 함수: 목표 값에 대한 얻은 결과의 비 유사성(degree of dissimilarity)을 측정, 학습 중 최소화
• 손실 계산:
  • 예측: 주어진 데이터 샘플을 모델에 입력
  • 비교: 실제 데이터 레이블 값과 비교
• 일반적인 손실 함수:
  • nn.MSELoss: 회귀 작업에 사용되는 Mean Square Error
  • nn.NLLLoss: 분류에 사용되는 음의 로그 우도
  • nn.CrossEntropyLoss:
    nn.LogSoftmax와 nn.NLLLoss를 합친 로스
•  예제에서는 nn.CrossEntropyLoss 사용, 모델의 출력 로짓을 전달하여 로짓을 정규화하고 예측 오류를 계산

# Initialize the loss function
loss_fn = nn.CrossEntropyLoss()

keyword: mean square error, negative log likelihood, cross-entropy loss, logits, normalization

1. 평균 제곱 오차(Mean Square Error, MSE):
   예측 출력과 실제 출력 간의 평균 제곱 차이를 측정하는 스칼라 값 함수
   연속 값을 예측하는 것이 목표인 회귀 문제의 손실 함수로 자주 사용됨
   이상치에 민감하며 작은 오류보다 큰 오류를 처벌(punish)함
2. 음의 로그 우도(Negative Log Likelihood, NLL):
   예측된 출력에서 ​​실제 출력의 우도를 측정하는 스칼라 값 함수
   이산 값을 예측하는 것이 목표인 분류 문제의 손실 함수로 자주 사용됨
   음의 로그는 함수를 미분 가능하게 만드는 데 사용됨
   음의 부호는 함수를 최소화해야 하는 손실 함수로 만드는 데 사용됨
3. 크로스엔트로피 손실(Cross-Entropy Loss, CE):
   예측된 출력과 실제 출력 간의 차이를 측정하는 스칼라 값 함수
   이산 값을 예측하는 것이 목표인 분류 문제의 손실 함수로 자주 사용됨
   NLL과 밀접한 관련이 있으며 출력의 확률을 얻기 위해 softmax activation function과 함께 자주 사용됨
4. 로짓(logit):
   활성화 함수가 적용되기 전 모델의 원시 출력
   신경망에서 로짓은 softmax 함수가 적용되기 전 마지막 선형 레이어의 출력
   로짓은 크로스 엔트로피 손실을 계산할 때 소프트맥스 함수가 ​​나중에 적용되기 때문에 유용

 

최적화 패스(Optimization pass)

• 최적화: 각 학습 단계에서 모델 오류를 줄이기 위해 모델 매개변수를 조정하는 프로세스
• 최적화 알고리즘: 최적화 프로세스 수행 방법 정의(이 예에서는 Stochastic Gradient Descent가 사용됨)
• 옵티마이저 객체: 모든 최적화 로직을 캡슐화
• SGD 옵티마이저: 이 예에서 사용되며 다른 옵션에는 ADAM 및 RMSProp 등이 있음
• 옵티마이저 초기화: 학습할 모델의 매개변수 및 학습률을 하이퍼파라미터로 전달하여 시행
• 학습 단계(loop)에서의 최적화: 3단계
  1. optimizer.zero_grad(): 모델 매개변수의 그래디언트를 재설정. 그래디언트는 기본적으로 합산(accumulate)되기에 명시적으로 0으로 초기화 필요
  2. loss.backwards(): 예측 손실(prediction loss)을 역전파. PyTorch는 각 매개변수에 대해 손실 변화도를 저장
  3. optimizer.step(): 역전파 패스에서 수집된 그래디언트로 매개변수를 조정

optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)

 

keyword: optimization algorithms, optimizer object, SGD, ADAM, RMSProp

1. 최적화 알고리즘(optimization algorithms):
   손실 함수와 같은 스칼라 값 함수를 최소화하기 위해 모델의 매개변수를 조정하는 데 사용되는 방법
   일반적인 최적화 알고리즘에는 SGD(Stochastic Gradient Descent), Adam 및 RMSProp이 포함됨
   각 알고리즘에는 학습 프로세스를 제어하는 ​​학습 속도와 같은 고유한 하이퍼 매개변수 세트가 있음
2. 옵티마이저 객체(optimizer object):
   모델의 매개변수를 업데이트하는 데 사용되는 PyTorch의 SGD, Adam 또는 RMSProp과 같은 최적화 알고리즘의 인스턴스
   모델의 매개변수를 원하는 하이퍼 매개변수와 함께 알고리즘의 생성자(constructor)에 전달하여 옵티마이저 객체를 생성할 수 있음
3. SGD(Stochastic Gradient Descent):
   손실 함수의 음의 기울기 방향으로 단계를 진행하여 모델의 매개변수를 업데이트하는 간단한 최적화 알고리즘
   계산적으로 효율적이며 광범위한 최적화 문제에 사용할 수 있지만 학습률 선택에 민감
4. ADAM:
   과거 그래디언트 정보를 기반으로 각 매개변수의 학습률을 조정하는 최적화 알고리즘
   이전 단계의 그래디언트 정보를 사용하여 단계 크기를 조정하므로 학습률 선택에 더욱 강건해짐
5. RMSProp:
    과거 그래디언트 정보를 기반으로 각 매개변수의 학습률을 조정하는 최적화 알고리즘
   그래디언트의 제곱의 이동 평균을 사용하여 단계 크기를 조정하므로 학습률 선택에 더 강건해짐

 

전체 구현(Full implementation)

• train_loop: 최적화 코드를 반복하여 수행
• test_loop: 테스트 데이터로 모델의 성능 측정
• 모델 학습 단계
  • 손실 함수 정의
  • 옵티마이저 초기화(모델의 매개변수 및 러닝레이트 전달)
  • 에폭 수 정의 후 train_loop, test_loop 실행

• 성능 좋지 않을 시 epoch, learning_rate 등 조정 가능. 또는 모델이 적합하지 않을 수 있음. 이후 비전 문제에 대해 다룰 것

def train_loop(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)
    for batch, (X, y) in enumerate(dataloader):        
        # Compute prediction and loss
        pred = model(X)
        loss = loss_fn(pred, y)
        
        # Backpropagation
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        if batch % 100 == 0:
            loss, current = loss.item(), batch * len(X)
            print(f"loss: {loss:>7f}  [{current:>5d}/{size:>5d}]")


def test_loop(dataloader, model, loss_fn):
    size = len(dataloader.dataset)
    test_loss, correct = 0, 0

    with torch.no_grad():
        for X, y in dataloader:
            pred = model(X)
            test_loss += loss_fn(pred, y).item()
            correct += (pred.argmax(1) == y).type(torch.float).sum().item()
            
    test_loss /= size
    correct /= size
    print(f"Test Error: \n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \n")
    
    loss_fn = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)

epochs = 10
for t in range(epochs):
    print(f"Epoch {t+1}\n-------------------------------")
    train_loop(train_dataloader, model, loss_fn, optimizer)
    test_loop(test_dataloader, model, loss_fn)
print("Done!")


Epoch 1
-------------------------------
loss: 2.307260  [    0/60000]
loss: 2.305284  [ 6400/60000]
loss: 2.293966  [12800/60000]
loss: 2.291592  [19200/60000]
loss: 2.288022  [25600/60000]
loss: 2.259277  [32000/60000]
loss: 2.277950  [38400/60000]
loss: 2.252569  [44800/60000]
loss: 2.238333  [51200/60000]
loss: 2.239141  [57600/60000]
Test Error: 
 Accuracy: 27.5%, Avg loss: 0.035050 

Epoch 2
-------------------------------
loss: 2.222609  [    0/60000]
loss: 2.244805  [ 6400/60000]
loss: 2.209550  [12800/60000]
loss: 2.227453  [19200/60000]
loss: 2.217051  [25600/60000]
loss: 2.162092  [32000/60000]
loss: 2.206926  [38400/60000]
loss: 2.151579  [44800/60000]
loss: 2.117667  [51200/60000]
loss: 2.143689  [57600/60000]
Test Error: 
 Accuracy: 38.9%, Avg loss: 0.033368 

Epoch 3
-------------------------------
loss: 2.102783  [    0/60000]
loss: 2.154025  [ 6400/60000]
loss: 2.076486  [12800/60000]
loss: 2.124048  [19200/60000]
loss: 2.107713  [25600/60000]
loss: 2.014179  [32000/60000]
loss: 2.090220  [38400/60000]
loss: 1.989485  [44800/60000]
loss: 1.933911  [51200/60000]
loss: 2.002917  [57600/60000]
Test Error: 
 Accuracy: 41.2%, Avg loss: 0.030885 

Epoch 4
-------------------------------
loss: 1.926293  [    0/60000]
loss: 2.019496  [ 6400/60000]
loss: 1.888668  [12800/60000]
loss: 1.987653  [19200/60000]
loss: 1.968171  [25600/60000]
loss: 1.838344  [32000/60000]
loss: 1.951870  [38400/60000]
loss: 1.808960  [44800/60000]
loss: 1.749038  [51200/60000]
loss: 1.868777  [57600/60000]
Test Error: 
 Accuracy: 44.4%, Avg loss: 0.028537 

Epoch 5
-------------------------------
loss: 1.754023  [    0/60000]
loss: 1.889865  [ 6400/60000]
loss: 1.724985  [12800/60000]
loss: 1.880932  [19200/60000]
loss: 1.852289  [25600/60000]
loss: 1.703095  [32000/60000]
loss: 1.850078  [38400/60000]
loss: 1.679640  [44800/60000]
loss: 1.618462  [51200/60000]
loss: 1.781099  [57600/60000]
Test Error: 
 Accuracy: 46.4%, Avg loss: 0.026904 

Epoch 6
-------------------------------
loss: 1.629323  [    0/60000]
loss: 1.794621  [ 6400/60000]
loss: 1.609603  [12800/60000]
loss: 1.806047  [19200/60000]
loss: 1.771073  [25600/60000]
loss: 1.610854  [32000/60000]
loss: 1.782800  [38400/60000]
loss: 1.593032  [44800/60000]
loss: 1.530435  [51200/60000]
loss: 1.721836  [57600/60000]
Test Error: 
 Accuracy: 47.5%, Avg loss: 0.025738 

Epoch 7
-------------------------------
loss: 1.541017  [    0/60000]
loss: 1.723998  [ 6400/60000]
loss: 1.525540  [12800/60000]
loss: 1.745950  [19200/60000]
loss: 1.714844  [25600/60000]
loss: 1.542636  [32000/60000]
loss: 1.735072  [38400/60000]
loss: 1.529822  [44800/60000]
loss: 1.467118  [51200/60000]
loss: 1.675812  [57600/60000]
Test Error: 
 Accuracy: 48.3%, Avg loss: 0.024844 

Epoch 8
-------------------------------
loss: 1.474333  [    0/60000]
loss: 1.669000  [ 6400/60000]
loss: 1.460421  [12800/60000]
loss: 1.694097  [19200/60000]
loss: 1.674764  [25600/60000]
loss: 1.487773  [32000/60000]
loss: 1.699166  [38400/60000]
loss: 1.481064  [44800/60000]
loss: 1.419311  [51200/60000]
loss: 1.638599  [57600/60000]
Test Error: 
 Accuracy: 48.7%, Avg loss: 0.024137 

Epoch 9
-------------------------------
loss: 1.420322  [    0/60000]
loss: 1.625176  [ 6400/60000]
loss: 1.408073  [12800/60000]
loss: 1.649715  [19200/60000]
loss: 1.644693  [25600/60000]
loss: 1.443653  [32000/60000]
loss: 1.671596  [38400/60000]
loss: 1.443777  [44800/60000]
loss: 1.382555  [51200/60000]
loss: 1.608089  [57600/60000]
Test Error: 
 Accuracy: 49.1%, Avg loss: 0.023570 

Epoch 10
-------------------------------
loss: 1.375013  [    0/60000]
loss: 1.588062  [ 6400/60000]
loss: 1.364595  [12800/60000]
loss: 1.612044  [19200/60000]
loss: 1.621220  [25600/60000]
loss: 1.407904  [32000/60000]
loss: 1.649211  [38400/60000]
loss: 1.415225  [44800/60000]
loss: 1.353849  [51200/60000]
loss: 1.582835  [57600/60000]
Test Error: 
 Accuracy: 49.5%, Avg loss: 0.023104 

Done!

모델 저장(Saving Models)

모델 성능 만족 시 torch.save 사용하여 저장 가능

pytorch 모델은 state_dict라는 internal state dictionary에 매개변수 저장

These can be persisted(유지) with the torch.save method:

torch.save(model.state_dict(), "data/model.pth")

print("Saved PyTorch Model State to model.pth")

 

keyword: torch.save, internal state dictionary, state_dict

1. torch.save:
   모델의 매개변수와 옵티마이저의 상태를 포함하여 PyTorch 모델의 상태를 저장하는 데 사용되는 함수
   나중에 torch.load 기능을 사용하여 로드할 수 있는 파일에 모델을 저장
2. 내부 상태 사전(internal state dictionary):
   모델의 매개변수 및 옵티마이저의 상태를 포함하여 PyTorch 모델의 현재 상태를 포함하는 Python 사전
   이 사전은 모델이나 옵티마이저의 state_dict() 함수를 사용하여 액세스할 수 있음
3. state_dict():
   모델 또는 옵티마이저의 학습 가능한 모든 매개변수를 포함하는 정렬된 사전을 반환하는 함수
   torch.save 함수를 사용하여 모델의 현재 상태를 저장하거나 torch.load 함수를 사용하여 사전 훈련된 모델을 로드하는 데 사용할 수 있음
   키는 매개변수의 이름
   값은 해당 매개변수 값을 포함하는 텐서