손실_함수와_최적화

1. 손실 함수 (Loss Function)

모델의 예측값과 실제값의 차이를 수치화하는 함수. 신경망이 최소화하려는 목표.

손실 함수의 역할

• 모델의 성능을 정량적으로 측정
• 학습의 방향을 제시
• 역전파의 시작점

---

2. 회귀 문제의 손실 함수

2.1 평균 제곱 오차 (MSE - Mean Squared Error)

$\text{MSE}=\frac{1}{n}{\sum }_{i=1}^n(y_i-{\hat{y}}_i{)}^2$

특징:

• 가장 많이 사용되는 회귀 손실
• 오차를 제곱하여 큰 오차에 더 큰 페널티
• 미분 가능

사용 시기:

• ✅ 일반적인 회귀 문제
• ✅ 이상치가 적을 때

코드:

# Keras
model.compile(loss='mse', optimizer='adam')
 
# PyTorch
import torch.nn as nn
criterion = nn.MSELoss()

2.2 평균 절대 오차 (MAE - Mean Absolute Error)

$\text{MAE}=\frac{1}{n}{\sum }_{i=1}^n|y_i-{\hat{y}}_i|$

특징:

• 이상치에 강건 (MSE보다)
• 모든 오차를 동등하게 취급

사용 시기:

• ✅ 이상치가 많을 때
• ✅ 모든 오차를 균등하게 다루고 싶을 때

코드:

# Keras
model.compile(loss='mae', optimizer='adam')
 
# PyTorch
criterion = nn.L1Loss()

2.3 Huber Loss

$L_{\delta }(y,\hat{y})=\{\begin{array}{ll}\frac{1}{2}(y-\hat{y}{)}^2& \text{if }|y-\hat{y}|\le \delta \\ \delta |y-\hat{y}|-\frac{1}{2}{\delta }^2& \text{otherwise}\end{array}$

특징:

• MSE와 MAE의 조합
• 작은 오차에는 MSE, 큰 오차에는 MAE
• 이상치에 강건하면서 미분 가능

사용 시기:

• ✅ 이상치가 있지만 정확한 예측도 중요할 때

---

3. 분류 문제의 손실 함수

3.1 이진 크로스 엔트로피 (Binary Cross-Entropy)

$\text{BCE}=-\frac{1}{n}{\sum }_{i=1}^n[y_i\log ({\hat{y}}_i)+(1-y_i)\log (1-{\hat{y}}_i)]$

사용:

• ✅ 이진 분류 (0 또는 1)
• 출력층: Sigmoid

예시:

실제값 y = 1, 예측 ŷ = 0.9
BCE = -[1×log(0.9) + 0×log(0.1)] = 0.105 (낮음 = 좋음)

실제값 y = 1, 예측 ŷ = 0.1
BCE = -[1×log(0.1) + 0×log(0.9)] = 2.303 (높음 = 나쁨)

코드:

# Keras
model.compile(loss='binary_crossentropy', optimizer='adam')
 
# PyTorch
criterion = nn.BCELoss()  # Sigmoid 포함 안 됨
# 또는
criterion = nn.BCEWithLogitsLoss()  # Sigmoid 포함

3.2 범주형 크로스 엔트로피 (Categorical Cross-Entropy)

$\text{CCE}=-{\sum }_{i=1}^n{\sum }_{c=1}^C{y}_{i,c}\log ({\hat{y}}_{i,c})$

사용:

• ✅ 다중 클래스 분류 (K개 클래스 중 하나)
• 출력층: Softmax
• 레이블: One-hot encoding

예시:

3개 클래스, 실제 클래스 = 1 (원-핫: [0, 1, 0])
예측 확률 ŷ = [0.1, 0.8, 0.1]
CCE = -[0×log(0.1) + 1×log(0.8) + 0×log(0.1)] = 0.223

코드:

# Keras
model.compile(loss='categorical_crossentropy', optimizer='adam')
 
# PyTorch
criterion = nn.CrossEntropyLoss()  # Softmax 포함

3.3 Sparse Categorical Cross-Entropy

범주형 크로스 엔트로피와 동일하지만 레이블이 정수 형태

사용:

• ✅ 다중 클래스 분류
• 레이블: 정수 (0, 1, 2, …, K-1)
• One-hot encoding 불필요

예시:

레이블: 1 (정수)
예측: [0.1, 0.8, 0.1]
동일한 손실 계산

코드:

# Keras
model.compile(loss='sparse_categorical_crossentropy', optimizer='adam')

---

4. 손실 함수 선택 가이드

문제 유형	손실 함수	출력 활성화
회귀 (일반)	MSE	None (선형)
회귀 (이상치 많음)	MAE, Huber	None
이진 분류	Binary Cross-Entropy	Sigmoid
다중 분류 (one-hot)	Categorical Cross-Entropy	Softmax
다중 분류 (정수)	Sparse Categorical Cross-Entropy	Softmax

---

5. 역전파 (Backpropagation)

출력층에서 입력층 방향으로 기울기를 계산하여 가중치를 업데이트하는 알고리즘

핵심 아이디어

연쇄 법칙 (Chain Rule) 사용:

$\frac{\partial L}{\partial w}=\frac{\partial L}{\partial \hat{y}}\cdot \frac{\partial \hat{y}}{\partial z}\cdot \frac{\partial z}{\partial w}$

역전파 과정

1단계: 순전파

• 입력 → 은닉층 → 출력층
• 예측값 $\hat{y}$ 계산

2단계: 손실 계산 $L=\text{Loss}(y,\hat{y})$

3단계: 출력층 기울기 $\frac{\partial L}{\partial {\mathbf{a}}^{[L]}}$

4단계: 역방향 전파

각 층 $l$에서:

$\frac{\partial L}{\partial {\mathbf{W}}^{[l]}}=\frac{\partial L}{\partial {\mathbf{z}}^{[l]}}\cdot ({\mathbf{a}}^{[l-1]}{)}^T$

$\frac{\partial L}{\partial {\mathbf{b}}^{[l]}}=\frac{\partial L}{\partial {\mathbf{z}}^{[l]}}$

$\frac{\partial L}{\partial {\mathbf{a}}^{[l-1]}}=({\mathbf{W}}^{[l]}{)}^T\cdot \frac{\partial L}{\partial {\mathbf{z}}^{[l]}}$

5단계: 가중치 업데이트 ${\mathbf{W}}^{[l]}:={\mathbf{W}}^{[l]}-\alpha \frac{\partial L}{\partial {\mathbf{W}}^{[l]}}$

역전파 예시

# PyTorch에서 자동으로 처리
loss = criterion(outputs, labels)
loss.backward()  # 자동으로 모든 기울기 계산
optimizer.step()  # 가중치 업데이트

---

6. 기울기 문제

6.1 기울기 소실 (Vanishing Gradient)

문제:

• 깊은 신경망에서 초기 층으로 갈수록 기울기가 0에 가까워짐
• 학습이 매우 느려지거나 멈춤

원인:

• Sigmoid, Tanh의 기울기가 최대 1보다 작음
• 여러 층을 거치며 기울기가 곱해져 소실

해결책:

• ✅ ReLU 활성화 함수 사용
• ✅ 배치 정규화 (Batch Normalization)
• ✅ 잔차 연결 (Residual Connection, ResNet)
• ✅ 적절한 가중치 초기화 (He, Xavier)

6.2 기울기 폭발 (Exploding Gradient)

문제:

• 기울기가 너무 커져 가중치가 불안정하게 업데이트
• NaN 값 발생

해결책:

• ✅ 기울기 클리핑 (Gradient Clipping)
• ✅ 적절한 가중치 초기화
• ✅ 낮은 학습률
• ✅ 배치 정규화

기울기 클리핑 예시:

# PyTorch
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
 
# Keras (optimizer에 내장)
optimizer = keras.optimizers.Adam(clipnorm=1.0)

---

7. 최적화 알고리즘 (Optimizers)

7.1 경사 하강법 (Gradient Descent)

배치 경사 하강법 (Batch GD)

$\theta =\theta -\alpha {\nabla }_{\theta }L(\theta )$

특징:

• 전체 데이터셋 사용
• 느리지만 안정적
• 메모리 많이 필요

확률적 경사 하강법 (SGD)

$\theta =\theta -\alpha {\nabla }_{\theta }L(\theta ;x^{(i)},y^{(i)})$

특징:

• 한 번에 하나의 샘플 사용
• 빠르지만 불안정
• 메모리 효율적

미니배치 경사 하강법 (Mini-batch GD) ⭐

$\theta =\theta -\alpha {\nabla }_{\theta }L(\theta ;x^{(i:i+b)},y^{(i:i+b)})$

특징:

• 작은 배치 단위로 학습
• 가장 많이 사용 (보통 32, 64, 128, 256)
• 속도와 안정성의 균형

코드:

# PyTorch
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
 
# Keras
model.compile(optimizer='sgd', loss='mse')

---

7.2 모멘텀 (Momentum)

$v_t=\beta v_{t-1}+(1-\beta ){\nabla }_{\theta }L$ $\theta =\theta -\alpha v_t$

특징:

• 이전 기울기의 방향을 일부 유지
• 진동을 줄이고 수렴 속도 향상
• 관성 효과
• 보통 $\beta =0.9$

비유: 공을 언덕 아래로 굴리면 관성으로 계속 굴러감

코드:

# PyTorch
optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9)

---

7.3 RMSprop

$s_t=\beta s_{t-1}+(1-\beta )({\nabla }_{\theta }L{)}^2$ $\theta =\theta -\alpha \frac{{\nabla }_{\theta }L}{\sqrt{s_t+ϵ}}$

특징:

• 각 파라미터마다 적응적 학습률
• 기울기가 큰 방향은 학습률 감소
• RNN에서 효과적
• 보통 $\beta =0.999$, $ϵ=10^{-8}$

코드:

# PyTorch
optimizer = torch.optim.RMSprop(model.parameters(), lr=0.001)

---

7.4 Adam (Adaptive Moment Estimation) ⭐

Momentum + RMSprop의 조합. 가장 많이 사용되는 옵티마이저

$m_t={\beta }_1{m}_{t-1}+(1-{\beta }_1){\nabla }_{\theta }L$ $v_t={\beta }_2{v}_{t-1}+(1-{\beta }_2)({\nabla }_{\theta }L{)}^2$

편향 보정 (Bias Correction): ${\hat{m}}_t=\frac{m_t}{1-{\beta }_1^t}$ ${\hat{v}}_t=\frac{v_t}{1-{\beta }_2^t}$

가중치 업데이트: $\theta =\theta -\alpha \frac{{\hat{m}}_t}{\sqrt{{\hat{v}}_t}+ϵ}$

하이퍼파라미터:

• ${\beta }_1=0.9$ (1차 모멘텀)
• ${\beta }_2=0.999$ (2차 모멘텀)
• $\alpha =0.001$ (학습률)
• $ϵ=10^{-8}$

특징:

• ✅ 가장 많이 사용
• ✅ 대부분의 경우 잘 작동
• ✅ 하이퍼파라미터 튜닝이 덜 필요
• ✅ 적응적 학습률

코드:

# PyTorch
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
 
# Keras
model.compile(optimizer='adam', loss='mse')
# 또는 커스텀
from tensorflow.keras.optimizers import Adam
optimizer = Adam(learning_rate=0.001)

---

7.5 AdamW

Adam에 가중치 감쇠(Weight Decay)를 올바르게 적용한 버전

$\theta =\theta -\alpha \left(\frac{{\hat{m}}_t}{\sqrt{{\hat{v}}_t}+ϵ}+\lambda \theta \right)$

특징:

• Adam보다 일반화 성능 향상
• Transformer 모델에서 많이 사용
• L2 정규화와 Weight Decay의 차이 수정

코드:

# PyTorch
optimizer = torch.optim.AdamW(model.parameters(), lr=0.001, weight_decay=0.01)

---

8. 옵티마이저 선택 가이드

상황	추천 옵티마이저
일반적인 경우	Adam
빠른 수렴 필요	Adam, AdamW
일반화 성능 중요	SGD + Momentum, AdamW
RNN, LSTM	Adam, RMSprop
Transformer	AdamW
대규모 데이터	SGD + Momentum
처음 시작	Adam (기본 선택)

---

9. 학습률 스케줄링 (Learning Rate Scheduling)

9.1 고정 학습률

$\alpha (t)={\alpha }_0$

장점: 간단 단점: 최적이 아닐 수 있음

---

9.2 스텝 감쇠 (Step Decay)

$\alpha (t)={\alpha }_0\times {\text{drop}}^{\lfloor \frac{\text{epoch}}{\text{epochs\_drop}}\rfloor }$

예: 매 10 에포크마다 학습률을 절반으로

# PyTorch
from torch.optim.lr_scheduler import StepLR
scheduler = StepLR(optimizer, step_size=10, gamma=0.5)

---

9.3 지수 감쇠 (Exponential Decay)

$\alpha (t)={\alpha }_0{e}^{-kt}$

# PyTorch
from torch.optim.lr_scheduler import ExponentialLR
scheduler = ExponentialLR(optimizer, gamma=0.95)

---

9.4 코사인 어닐링 (Cosine Annealing)

$\alpha (t)={\alpha }_{min}+\frac{1}{2}({\alpha }_{max}-{\alpha }_{min})(1+\cos (\frac{t\pi }{T}))$

특징:

• 부드럽게 감소
• 주기적 재시작 가능 (Warm Restarts)

# PyTorch
from torch.optim.lr_scheduler import CosineAnnealingLR
scheduler = CosineAnnealingLR(optimizer, T_max=50)

---

9.5 워밍업 (Warmup)

처음 몇 에포크 동안 학습률을 서서히 증가

$\alpha (t)={\alpha }_0\times \frac{t}{\text{warmup\_steps}}$

사용:

• Transformer 모델
• 대규모 배치 학습

---

9.6 ReduceLROnPlateau ⭐

검증 손실이 개선되지 않으면 학습률 감소

# PyTorch
from torch.optim.lr_scheduler import ReduceLROnPlateau
scheduler = ReduceLROnPlateau(
    optimizer, mode='min', factor=0.5, patience=5, min_lr=1e-7
)
 
# 학습 루프에서
val_loss = validate(...)
scheduler.step(val_loss)  # 검증 손실 전달

# Keras
from tensorflow.keras.callbacks import ReduceLROnPlateau
reduce_lr = ReduceLROnPlateau(
    monitor='val_loss', factor=0.5, patience=5, min_lr=1e-7
)
model.fit(X, y, callbacks=[reduce_lr])

---

핵심 요약

손실 함수 선택

• 회귀: MSE (일반), MAE (이상치 많음)
• 이진 분류: Binary Cross-Entropy
• 다중 분류: Categorical Cross-Entropy

옵티마이저 선택

• 🥇 1순위: Adam (기본 선택)
• 🥈 2순위: AdamW (Transformer, 일반화 중요)
• 🥉 3순위: SGD + Momentum (대규모 데이터)

학습률

• 기본값: Adam (0.001), SGD (0.01)
• ReduceLROnPlateau로 자동 조정 추천

기억할 것

• ✅ 손실 함수는 문제 유형에 따라 선택
• ✅ Adam이 대부분의 경우 잘 작동
• ✅ 학습률 스케줄링으로 성능 향상
• ✅ 기울기 소실/폭발 문제 주의

---

다음 학습

1. 정규화_기법 (Regularization) - 과적합 방지와 안정적인 학습
2. 딥러닝_실전_가이드 - 하이퍼파라미터 튜닝과 문제 해결

---

← 딥러닝 기초