백프로파게이션

# PyTorch에서 백프로파게이션 이해하기
import torch
import torch.nn as nn

# 간단한 신경망 정의
class SimpleNetwork(nn.Module):
    def __init__(self):
        super().__init__()
        self.layer1 = nn.Linear(10, 20)
        self.relu = nn.ReLU()
        self.layer2 = nn.Linear(20, 1)

    def forward(self, x):
        x = self.layer1(x)
        x = self.relu(x)
        x = self.layer2(x)
        return x

# 모델, 손실 함수, 옵티마이저 설정
model = SimpleNetwork()
criterion = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

# 데이터 준비
x = torch.randn(32, 10)  # 배치 크기 32, 특성 10개
y_true = torch.randn(32, 1)

# === Forward Pass ===
# 입력이 네트워크를 통과하며 예측값 생성
y_pred = model(x)
loss = criterion(y_pred, y_true)
print(f"Loss: {loss.item():.4f}")

# === Backward Pass (역전파) ===
# 손실로부터 각 파라미터의 기울기 계산
optimizer.zero_grad()  # 기존 기울기 초기화 (필수!)
loss.backward()        # 역전파 수행 - 모든 .grad 속성 업데이트

# 기울기 확인
print(f"layer1 weight gradient shape: {model.layer1.weight.grad.shape}")
print(f"layer1 weight gradient mean: {model.layer1.weight.grad.mean():.6f}")

# === 가중치 업데이트 ===
optimizer.step()  # w = w - lr * gradient

# 수동으로 역전파 이해하기 (교육용)
def manual_backprop_demo():
    """
    연쇄 법칙 시각화: dL/dw = dL/dy * dy/dz * dz/dw
    """
    w = torch.tensor([2.0], requires_grad=True)
    x = torch.tensor([3.0])

    # Forward: z = w*x, y = z^2, L = y
    z = w * x           # z = 6
    y = z ** 2          # y = 36
    L = y               # L = 36

    # Backward (연쇄 법칙)
    L.backward()

    # dL/dw = dL/dy * dy/dz * dz/dw
    #       = 1 * 2z * x = 2 * 6 * 3 = 36
    print(f"자동 기울기: {w.grad.item()}")
    print(f"수동 계산: {2 * (w.item() * x.item()) * x.item()}")

manual_backprop_demo()