🐹 경사 하강법

💡 1. 경사 하강법의 종류

1-1. 배치 경사 하강법

• 가장 기본적인 경사 하강법(Vanilla Gradient Descent)
• 데이터셋 전체를 고려하여 손실함수를 계산
• 한 번의 Epoch에 모든 파라미터 업데이트를 단 한 번만 수행
• 파라미터 업데이트힐 때 한 번의 전체 데이터셋을 고려하기 때문에 모델 학습 시 많은 시간과 메모리가 필요하다는 단점이 있음

1-2. 확률적 경사 하강법

• 확률적 경사 하강법(Stochastoc Gradient Descent)은 배치 경사 하강법이 모델 학습 시 많은 시간과 메모리가 필요하다는 단점을 보완하기 위해 제안된 기법
• batch size를 1로 설정하여 파라미터를 업데이트 하기 때문에 배치 경사 하강법보다 훨씬 빠르고 적은 메모리로 학습을 진행
• 파라미터 값의 업데이트 폭이 불안정하기 때문에 정확도가 낮은 경우가 생길 수 있음

1-3. 미니 배치 경사 하강법

• 미니 배치 경사 하강법(Mini-Batch Gradient Descent)은 Batch Size를 설정한 size로 사용
• 배치 경사 하강법보다 모델 속도가 빠르고, 확률적 경사 하강법보다 안정적인 장점이 있음
• 딥러닝 분야에서 가장 많이 활용되는 경사 하강법
• 일반적으로 Batch Size를 4, 8, 16, 32, 64, 128과 같이 2의 n제곱에 해당하는 값으로 사용하는게 관례적

💡 2. 경사 하강법의 여러가지 알고리즘

2-1. SGD(확률적 경사 하강법)

• 매개변수 값을 조정 시 전체 데이터가 아니라 랜덤으로 선택한 하나의 데이터에 대해서만 계산하는 방법

2-2. 모멘텀(Momentum)

• 경사 하강법의 단점을 보완하기 위해 도입된 알고리즘
• 관성이라는 물리학 법칙을 응용한 방법
• 접선의 기울기에 한 시점 이전의 접선의 기울기 값을 일정한 비율만큼 반영
• 이전 기울기의 이동 평균을 사용하여 현재 기울기를 업데이트
• 가속도를 제공하여, 경사 하강법보다 빠르게 최소값에 도달할 수 있음

2-3. 아다그라드(Adagrad)

• 모든 매개변수에 동일한 학습률(lr)을 적용하는 것은 비효율적이다라는 생각에서 만들어진 학습 방법
• 처음에는 크게 학습하다가 조금씩 작게 학습시킴
• 각 파라미터에 맞춤형 학습률을 적용하는 방법
• 희소한 데이터에서 유리함
• 시간이 지남에 따라 학습률이 계속 감소하여 학습을 멈출 수 있음

2-4. 아담(Adam)

• 모멘텀 + 아다그라드
• 각 매개변수에 대해 적응형 학습률을 적용하며, 과거의 기울기 정보를 활용해 현재의 학습률을 조절
• AdamW: Adam의 변형으로 L2정규화(가중치 감쇠)를 별도로 처리하여 더 나은 일반화 성능을 제공, L2 정규화가 학습률 조정과 섞여 불안정한 학습을 초래할 수 있는 문제를 해결

💡 3. 와인 품종 예측하기

• sklearn.datasets.load_wine: 이탈리아의 같은 지역에서 재배된 세가지 다른 품종으로 만든 와인을 화학적으로 분석한 결과에 대한 데이터셋
• 13개의 성분을 분석하여 어떤 와인인지 구별하는 모델을 구축
• 데이터를 섞은 후 train 데이터를 80%, test 데이터를 20%로 하여 사용
• Adam을 사용
  • optimizer = optim.Adam(model.parameters(), lr=0.01)
• 테스트 데이터의 0번 인덱스가 어떤 와인인지 알아보자. 정확도를 출력

import torch
import torch.nn as nn
import torch.optim as optim
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split

x_data, y_data = load_wine(return_X_y=True, as_frame=True)

x_data = torch.FloatTensor(x_data.values)
y_data = torch.LongTensor(y_data.values)

print(x_data.shape)
print(y_data.shape)

> torch.Size([178, 13])
> torch.Size([178])

x_train, x_test, y_train, y_test = train_test_split(x_data, y_data, test_size=0.2, random_state=2024)

print(x_train.shape, y_train.shape)
print(x_test.shape, y_test.shape)

torch.Size([142, 13]) torch.Size([142])
torch.Size([36, 13]) torch.Size([36])

model = nn.Sequential(
    nn.Linear(13, 3)
)

optimizer = optim.Adam(model.parameters(), lr=0.01)

epochs = 1000

for epoch in range(epochs + 1):
  y_pred = model(x_train)
  loss = nn.CrossEntropyLoss()(y_pred, y_train)
  optimizer.zero_grad()
  loss.backward()
  optimizer.step()

  if epoch % 100 == 0:
    y_prob = nn.Softmax(1)(y_pred)
    y_pred_index = torch.argmax(y_prob, axis=1)
    y_train_index = y_train
    accuracy = (y_pred_index == y_train_index).float().sum() / len(y_train) * 100
    print(f'Epoch {epoch:4d}/{epochs} Loss:{loss: .6f} Accuracy: {accuracy: .2f}%')

Epoch    0/1000 Loss: 100.665215 Accuracy:  25.35%
Epoch  100/1000 Loss: 0.302390 Accuracy:  89.44%
Epoch  200/1000 Loss: 0.197123 Accuracy:  92.25%
Epoch  300/1000 Loss: 0.158662 Accuracy:  94.37%
Epoch  400/1000 Loss: 0.137645 Accuracy:  95.77%
Epoch  500/1000 Loss: 0.123086 Accuracy:  97.18%
Epoch  600/1000 Loss: 0.111958 Accuracy:  98.59%
Epoch  700/1000 Loss: 0.102981 Accuracy:  98.59%
Epoch  800/1000 Loss: 0.095471 Accuracy:  98.59%
Epoch  900/1000 Loss: 0.089016 Accuracy:  98.59%
Epoch 1000/1000 Loss: 0.083348 Accuracy:  98.59%

y_pred = model(x_test)
y_pred[:5]

> tensor([[-28.7244, -30.6228, -22.7633],
        [-51.6261, -58.9351, -60.1704],
        [-17.1980, -12.4382, -12.0121],
        [-54.0891, -59.6118, -59.6391],
        [-30.0164, -31.9313, -35.4247]], grad_fn=<SliceBackward0>)

y_prob = nn.Softmax(1)(y_pred)
y_prob[:5]

> tensor([[2.5695e-03, 3.8493e-04, 9.9705e-01],
        [9.9914e-01, 6.6892e-04, 1.9448e-04],
        [3.3733e-03, 3.9373e-01, 6.0290e-01],
        [9.9218e-01, 3.9641e-03, 3.8571e-03],
        [8.6818e-01, 1.2793e-01, 3.8885e-03]], grad_fn=<SliceBackward0>)

print(f'0번 품종일 확률: {y_prob[0][0]:.2f}')
print(f'1번 품종일 확률: {y_prob[0][1]:.2f}')
print(f'2번 품종일 확률: {y_prob[0][2]:.2f}')

> 0번 품종일 확률: 0.00
> 1번 품종일 확률: 0.00
> 2번 품종일 확률: 1.00

y_pred_index = torch.argmax(y_prob, axis=1)
accuracy = (y_test == y_pred_index).float().sum() / len(y_test) * 100
print(f'테스트 정확도는 {accuracy: .2f}% 입니다!')

> 테스트 정확도는  94.44% 입니다!