신경망 학습 안정화: Dropout, Batch Normalization, 가중치 초기화

# 모든 가중치를 0으로
W1 = np.zeros((input_dim, hidden_dim))
W2 = np.zeros((hidden_dim, output_dim))

너무 큰 초기값 (예: W ~ N(0, 1), 뉴런 수가 많을 때)
→ 순전파: 활성값이 층마다 기하급수적으로 커짐
→ 역전파: 그래디언트도 기하급수적으로 커짐
→ 가중치 폭발 (Exploding Gradients) → Loss = NaN

너무 작은 초기값 (예: W ~ N(0, 0.001))
→ 순전파: 활성값이 층마다 0에 수렴
→ 역전파: 그래디언트도 0에 수렴
→ 가중치 소실 (Vanishing Gradients) → 학습 정지

Xavier 초기화:

W ~ N(0, 1/n_in)         ← 순전파 기준
W ~ N(0, 1/n_out)        ← 역전파 기준
W ~ N(0, 2/(n_in + n_out))  ← 절충안 (가장 많이 사용)

n_in  = 이전 층의 뉴런 수
n_out = 현재 층의 뉴런 수

Var(z) = n_in * sigma^2

Var(z) = 1이 되려면 sigma^2 = 1/n_in

He 초기화:

W ~ N(0, 2/n_in)

Xavier 대비 분산이 2배

Xavier: Var(W) = 2 / (n_in + n_out)  ← Sigmoid, Tanh
He:     Var(W) = 2 / n_in            ← ReLU, Leaky ReLU

import numpy as np

def simulate_forward(init_std, layers=10, neurons=256, activation='relu'):
    """각 층의 활성값 분산을 추적"""
    x = np.random.randn(1000, neurons)  # 입력: 평균 0, 분산 1
    variances = []

    for _ in range(layers):
        W = np.random.randn(neurons, neurons) * init_std
        z = x @ W

        if activation == 'relu':
            x = np.maximum(0, z)
        elif activation == 'tanh':
            x = np.tanh(z)
        else:
            x = z  # 선형

        variances.append(np.var(x))

    return variances

n = 256

# 나쁜 초기화: 고정 표준편차
bad = simulate_forward(init_std=0.01, neurons=n)
# → [3.3e-05, 2.6e-09, ...] 분산 급감 → 신호 소실

# Xavier 초기화 + ReLU (불일치)
xavier_relu = simulate_forward(init_std=np.sqrt(1/n), neurons=n)
# → 분산이 층마다 서서히 줄어듦

# He 초기화 + ReLU (올바른 조합)
he_relu = simulate_forward(init_std=np.sqrt(2/n), neurons=n)
# → [1.01, 0.98, 1.03, ...] 분산 안정 유지!

Epoch 1: 2번째 층 입력 분포 → 평균 0.5, 분산 2.0
Epoch 2: 2번째 층 입력 분포 → 평균 -1.2, 분산 0.3
Epoch 3: 2번째 층 입력 분포 → 평균 3.7, 분산 8.1

1. 배치 평균:   mu_B = (1/m) * SUM(x_i)

2. 배치 분산:   sigma_B^2 = (1/m) * SUM((x_i - mu_B)^2)

3. 정규화:      x_hat_i = (x_i - mu_B) / sqrt(sigma_B^2 + epsilon)

4. 스케일·시프트: y_i = gamma * x_hat_i + beta

선형 변환 → BatchNorm → 활성화 함수

z = W * x + b
z_norm = BatchNorm(z)
a = ReLU(z_norm)

# 학습 시: 배치 통계 사용 + 이동 평균 업데이트
running_mean = momentum * running_mean + (1 - momentum) * batch_mean
running_var  = momentum * running_var  + (1 - momentum) * batch_var

# 추론 시: 저장된 이동 평균 사용
x_hat = (x - running_mean) / sqrt(running_var + epsilon)
y = gamma * x_hat + beta

BatchNorm: 같은 뉴런, 여러 샘플 → 배치 의존
LayerNorm: 같은 샘플, 여러 뉴런 → 배치 독립

일반 순전파:      [o] [o] [o] [o] [o]   ← 5개 뉴런 모두 활성
Dropout (p=0.4):  [o] [x] [o] [x] [o]   ← 2개 랜덤 비활성화
다음 순전파:      [x] [o] [o] [o] [x]   ← 다른 2개 비활성화

def dropout_forward(x, p=0.5, training=True):
    if not training:
        return x  # 추론 시: 변경 없음

    # 학습 시: 마스크 생성 + 스케일 보정
    mask = (np.random.rand(*x.shape) > p).astype(float)
    return x * mask / (1 - p)  # 살아남은 뉴런을 1/(1-p)로 스케일링

# 예시: p=0.5
# 학습 시: 절반 꺼지고, 살아남은 것은 2배로 → 기대값 유지
# 추론 시: 전부 켜지고, 스케일 조정 없음 → 기대값 동일

에폭 1~20:   훈련 Loss ↓, 검증 Loss ↓  → 학습 중
에폭 20~50:  훈련 Loss ↓, 검증 Loss ↑  → 과적합 시작
에폭 50~100: 훈련 Loss ↓↓, 검증 Loss ↑↑ → 심각한 과적합

import copy

best_val_loss = float('inf')
patience = 10       # 개선이 없어도 기다리는 에폭 수
patience_counter = 0
best_weights = None

for epoch in range(max_epochs):
    train_loss = train_one_epoch(model, train_loader)
    val_loss = evaluate(model, val_loader)

    if val_loss < best_val_loss:
        best_val_loss = val_loss
        patience_counter = 0
        best_weights = copy.deepcopy(model.state_dict())  # 최적 가중치 저장
    else:
        patience_counter += 1

    if patience_counter >= patience:
        print(f"Early stopping at epoch {epoch}")
        model.load_state_dict(best_weights)  # 최적 가중치로 복원
        break

원본 이미지 → 좌우 반전 (Horizontal Flip)
           → 회전 (Rotation, ±15도)
           → 랜덤 자르기 (Random Crop)
           → 색상 변형 (Color Jitter: 밝기, 대비, 채도)
           → 스케일 변환 (Random Resize)

from torchvision import transforms

train_transform = transforms.Compose([
    transforms.RandomHorizontalFlip(p=0.5),
    transforms.RandomRotation(15),
    transforms.RandomCrop(224, padding=16),
    transforms.ColorJitter(brightness=0.2, contrast=0.2),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406],
                         std=[0.229, 0.224, 0.225]),
])

가중치 초기화: He 초기화
     ↓
각 은닉층:    Linear → BatchNorm → ReLU → Dropout(0.3)
     ↓
옵티마이저:   Adam (lr=0.001)
     ↓
학습 전략:    Early Stopping (patience=10) + Data Augmentation

import torch
import torch.nn as nn

class StableNet(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim, dropout_rate=0.3):
        super().__init__()
        self.net = nn.Sequential(
            # 은닉층 1
            nn.Linear(input_dim, hidden_dim),
            nn.BatchNorm1d(hidden_dim),
            nn.ReLU(),
            nn.Dropout(dropout_rate),

            # 은닉층 2
            nn.Linear(hidden_dim, hidden_dim),
            nn.BatchNorm1d(hidden_dim),
            nn.ReLU(),
            nn.Dropout(dropout_rate),

            # 은닉층 3
            nn.Linear(hidden_dim, hidden_dim // 2),
            nn.BatchNorm1d(hidden_dim // 2),
            nn.ReLU(),
            nn.Dropout(dropout_rate),

            # 출력층 (Dropout, BatchNorm 없음)
            nn.Linear(hidden_dim // 2, output_dim),
        )
        self._init_weights()

    def _init_weights(self):
        for m in self.modules():
            if isinstance(m, nn.Linear):
                nn.init.kaiming_normal_(m.weight, nonlinearity='relu')  # He 초기화
                nn.init.zeros_(m.bias)

    def forward(self, x):
        return self.net(x)

# 사용
model = StableNet(input_dim=784, hidden_dim=256, output_dim=10)
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
criterion = nn.CrossEntropyLoss()

from sklearn.neural_network import MLPClassifier

mlp = MLPClassifier(
    hidden_layer_sizes=(256, 256, 128),
    activation='relu',           # → He 초기화 자동 적용
    solver='adam',               # Adam 옵티마이저
    alpha=0.001,                 # L2 규제 (Dropout 대신)
    batch_size=64,
    learning_rate_init=0.001,
    early_stopping=True,         # Early Stopping
    validation_fraction=0.1,
    n_iter_no_change=10,         # patience
    max_iter=500,
)

가능한 원인                해결법
-----------------------------------------------------------
학습률이 너무 작다        → lr을 10배 키워본다 (0.001 → 0.01)
학습률이 너무 크다        → lr을 10배 줄여본다 (0.001 → 0.0001)
가중치 초기화 실패        → He 초기화 확인
데이터 전처리 누락        → 입력을 정규화했는지 확인 (평균 0, 분산 1)
배치 크기가 너무 크다     → 32 또는 64로 줄여본다

원인: 그래디언트 폭발
-----------------------------------------------------------
→ 학습률 줄이기
→ Gradient Clipping 적용
→ BatchNorm 추가
→ He 초기화 확인

# Gradient Clipping 예시
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

→ Dropout 비율 높이기 (0.3 → 0.5)
→ 데이터 증강 적용
→ L2 규제 강화 (weight_decay 증가)
→ 모델 크기 줄이기 (뉴런 수, 층 수 감소)
→ Early Stopping 적용

→ 모델 크기 키우기 (뉴런 수, 층 수 증가)
→ 학습 에폭 늘리기
→ Dropout 비율 줄이기 또는 제거
→ 학습률 올리기
→ 더 좋은 특성(feature) 찾기

#19  퍼셉트론과 MLP       → 신경망의 구조를 만들었다
#20  순전파               → 입력에서 출력까지 예측하는 법을 배웠다
#21  역전파               → 오차를 되돌려 보내 학습하는 원리를 이해했다
#22  활성화 함수           → 비선형성을 부여해 표현력을 확보했다
#23  옵티마이저            → SGD부터 Adam까지, 효율적으로 최적화하는 법을 배웠다
#24  학습 안정화 (이번 글)  → 실전에서 학습을 망치는 문제들과 해결법을 정리했다