옵티마이저(Optimizers): SGD에서 Adam까지, 경사하강법의 진화

# Batch GD: 전체 데이터 m개로 기울기 계산
∂J/∂w = (1/m) × Σᵢ₌₁ᵐ (ŷᵢ - yᵢ) × xᵢ
w := w - α × ∂J/∂w

# SGD: 데이터 1개로 기울기 계산
∂J/∂w = (ŷᵢ - yᵢ) × xᵢ    ← 샘플 하나
w := w - α × ∂J/∂w

# Mini-batch GD: B개(보통 32~256)로 기울기 계산
∂J/∂w = (1/B) × Σᵢ₌₁ᴮ (ŷᵢ - yᵢ) × xᵢ
w := w - α × ∂J/∂w

v = β × v + (1 - β) × ∇J(w)     ← 속도 업데이트 (지수 가중 이동 평균)
w = w - α × v                    ← 파라미터 업데이트

import numpy as np

def sgd_momentum(params, grads, velocities, lr=0.01, beta=0.9):
    """Momentum SGD 업데이트"""
    updated_params = []
    updated_velocities = []

    for param, grad, v in zip(params, grads, velocities):
        v_new = beta * v + (1 - beta) * grad   # 속도 업데이트
        param_new = param - lr * v_new          # 파라미터 업데이트
        updated_params.append(param_new)
        updated_velocities.append(v_new)

    return updated_params, updated_velocities


# 사용 예시
np.random.seed(42)
w = np.random.randn(3)
b = 0.0
v_w = np.zeros_like(w)
v_b = 0.0

for step in range(1000):
    # (실제로는 미니배치에서 기울기를 구한다)
    grad_w = np.random.randn(3) * 0.5 + 0.1  # 노이즈 있는 기울기
    grad_b = np.random.randn() * 0.5 + 0.1

    v_w = 0.9 * v_w + 0.1 * grad_w
    v_b = 0.9 * v_b + 0.1 * grad_b
    w = w - 0.01 * v_w
    b = b - 0.01 * v_b

print(f"최종 w: {w}")
print(f"최종 b: {b:.4f}")

v = β × v + (1 - β) × ∇J(w - α × β × v)    ← "미리 가본 곳"의 기울기
w = w - α × v

s = β × s + (1 - β) × (∇J)²     ← 기울기 제곱의 이동 평균
w = w - α × ∇J / √(s + ε)       ← 적응적 업데이트

def rmsprop(params, grads, cache, lr=0.001, beta=0.9, eps=1e-8):
    """RMSprop 업데이트"""
    updated_params = []
    updated_cache = []

    for param, grad, s in zip(params, grads, cache):
        s_new = beta * s + (1 - beta) * grad ** 2        # 제곱 기울기 이동 평균
        param_new = param - lr * grad / np.sqrt(s_new + eps)  # 적응적 업데이트
        updated_params.append(param_new)
        updated_cache.append(s_new)

    return updated_params, updated_cache

# 1차 모멘트 (기울기의 평균 → Momentum 역할)
m = β₁ × m + (1 - β₁) × ∇J

# 2차 모멘트 (기울기 제곱의 평균 → RMSprop 역할)
v = β₂ × v + (1 - β₂) × (∇J)²

m̂ = m / (1 - β₁ᵗ)    ← t는 현재 스텝 번호
v̂ = v / (1 - β₂ᵗ)

초기화: m = 0, v = 0, t = 0

매 스텝:
  t = t + 1
  g = ∇J(w)                               ← 기울기 계산

  m = β₁ × m + (1 - β₁) × g              ← 1차 모멘트 업데이트
  v = β₂ × v + (1 - β₂) × g²             ← 2차 모멘트 업데이트

  m̂ = m / (1 - β₁ᵗ)                      ← 편향 보정
  v̂ = v / (1 - β₂ᵗ)                      ← 편향 보정

  w = w - α × m̂ / (√v̂ + ε)              ← 파라미터 업데이트

import numpy as np

class Adam:
    def __init__(self, lr=0.001, beta1=0.9, beta2=0.999, eps=1e-8):
        self.lr = lr
        self.beta1 = beta1
        self.beta2 = beta2
        self.eps = eps
        self.m = None  # 1차 모멘트
        self.v = None  # 2차 모멘트
        self.t = 0     # 스텝 카운터

    def update(self, params, grads):
        if self.m is None:
            self.m = [np.zeros_like(p) for p in params]
            self.v = [np.zeros_like(p) for p in params]

        self.t += 1
        updated = []

        for i, (param, grad) in enumerate(zip(params, grads)):
            # 1차, 2차 모멘트 업데이트
            self.m[i] = self.beta1 * self.m[i] + (1 - self.beta1) * grad
            self.v[i] = self.beta2 * self.v[i] + (1 - self.beta2) * grad ** 2

            # 편향 보정
            m_hat = self.m[i] / (1 - self.beta1 ** self.t)
            v_hat = self.v[i] / (1 - self.beta2 ** self.t)

            # 파라미터 업데이트
            param_new = param - self.lr * m_hat / (np.sqrt(v_hat) + self.eps)
            updated.append(param_new)

        return updated


# 사용 예시: 간단한 2차 함수 최적화
# f(x, y) = x² + 10y²  (타원형 등고선)
optimizer = Adam(lr=0.1)
params = [np.array([5.0, 5.0])]   # 시작점

for step in range(200):
    x, y = params[0]
    grads = [np.array([2 * x, 20 * y])]  # ∂f/∂x = 2x, ∂f/∂y = 20y
    params = optimizer.update(params, grads)

    if step % 50 == 0:
        print(f"Step {step:3d} | x={params[0][0]:.4f}, y={params[0][1]:.4f} | f={params[0][0]**2 + 10*params[0][1]**2:.4f}")

Step   0 | x=4.9000, y=4.9000 | f=264.0100
Step  50 | x=0.5765, y=0.0098 | f=0.3324
Step 100 | x=0.0077, y=0.0001 | f=0.0001
Step 150 | x=0.0000, y=0.0000 | f=0.0000

# SGD에서의 L2 규제 = Weight Decay와 동일
w = w - α × (∇J + λ × w)
w = w - α × ∇J - α × λ × w     ← 두 번째 항이 weight decay

# Adam: L2 규제 (기울기에 포함 → 모멘트로 나눠짐)
g = ∇J + λ × w                    ← 규제 항이 기울기에 섞임
m, v 업데이트 (g 사용)
w = w - α × m̂ / √v̂               ← 규제가 적응적 스케일링에 의해 왜곡됨

# AdamW: Decoupled Weight Decay (기울기와 분리)
g = ∇J                             ← 순수 기울기만
m, v 업데이트 (g 사용)
w = w - α × m̂ / √v̂ - α × λ × w  ← weight decay를 별도로 적용

# 매 30 에폭마다 학습률을 1/10로 줄임
def step_decay(epoch, initial_lr=0.1, drop_rate=0.1, drop_every=30):
    return initial_lr * (drop_rate ** (epoch // drop_every))

# epoch  0~29: lr = 0.1
# epoch 30~59: lr = 0.01
# epoch 60~89: lr = 0.001

import math

def cosine_annealing(epoch, total_epochs, initial_lr=0.1, min_lr=0.0):
    return min_lr + 0.5 * (initial_lr - min_lr) * (1 + math.cos(math.pi * epoch / total_epochs))

def warmup_cosine(step, total_steps, warmup_steps, max_lr=0.001):
    if step < warmup_steps:
        # Warmup: 선형으로 증가
        return max_lr * step / warmup_steps
    else:
        # Cosine annealing: 부드럽게 감소
        progress = (step - warmup_steps) / (total_steps - warmup_steps)
        return max_lr * 0.5 * (1 + math.cos(math.pi * progress))

# PyTorch 예시
optimizer = torch.optim.AdamW(
    model.parameters(),
    lr=5e-5,         # 사전학습 모델 fine-tuning 시
    betas=(0.9, 0.999),
    weight_decay=0.01
)

# Warmup + Cosine 스케줄러
scheduler = torch.optim.lr_scheduler.OneCycleLR(
    optimizer,
    max_lr=5e-5,
    total_steps=total_steps,
    pct_start=0.1,   # 10% warmup
    anneal_strategy='cos'
)

import torch
import torch.nn as nn
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split

# 데이터 생성
X, y = make_moons(n_samples=1000, noise=0.2, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

X_train = torch.FloatTensor(X_train)
y_train = torch.FloatTensor(y_train).unsqueeze(1)
X_test = torch.FloatTensor(X_test)
y_test = torch.FloatTensor(y_test).unsqueeze(1)

# 간단한 신경망
def create_model():
    return nn.Sequential(
        nn.Linear(2, 32),
        nn.ReLU(),
        nn.Linear(32, 16),
        nn.ReLU(),
        nn.Linear(16, 1),
        nn.Sigmoid()
    )

# 옵티마이저별 학습
optimizers_config = {
    'SGD (lr=0.1)': lambda m: torch.optim.SGD(m.parameters(), lr=0.1),
    'SGD+Momentum': lambda m: torch.optim.SGD(m.parameters(), lr=0.1, momentum=0.9),
    'Adam (lr=0.001)': lambda m: torch.optim.Adam(m.parameters(), lr=0.001),
}

results = {}

for name, opt_fn in optimizers_config.items():
    torch.manual_seed(42)
    model = create_model()
    optimizer = opt_fn(model)
    criterion = nn.BCELoss()
    losses = []

    for epoch in range(200):
        optimizer.zero_grad()
        output = model(X_train)
        loss = criterion(output, y_train)
        loss.backward()
        optimizer.step()
        losses.append(loss.item())

    # 테스트 정확도
    with torch.no_grad():
        preds = (model(X_test) > 0.5).float()
        acc = (preds == y_test).float().mean().item()

    results[name] = {'losses': losses, 'accuracy': acc}
    print(f"{name:20s} | 최종 loss: {losses[-1]:.4f} | 테스트 정확도: {acc:.2%}")

SGD (lr=0.1)         | 최종 loss: 0.2981 | 테스트 정확도: 87.50%
SGD+Momentum         | 최종 loss: 0.1842 | 테스트 정확도: 93.00%
Adam (lr=0.001)      | 최종 loss: 0.1553 | 테스트 정확도: 95.50%