03_backprop.py - Examples

  1"""
  203. 역전파 (Backpropagation) - PyTorch 버전
  3
  4PyTorch의 autograd가 역전파를 자동으로 처리합니다.
  5NumPy 버전(examples/numpy/03_backprop_scratch.py)과 비교해 보세요.
  6
  7핵심: loss.backward() 한 줄이 모든 기울기를 자동 계산!
  8"""
  9
 10import torch
 11import torch.nn as nn
 12import torch.nn.functional as F
 13import matplotlib.pyplot as plt
 14
 15print("=" * 60)
 16print("PyTorch 역전파 (Backpropagation)")
 17print("=" * 60)
 18
 19
 20# ============================================
 21# 1. 자동 미분 복습
 22# ============================================
 23print("\n[1] 자동 미분 복습")
 24print("-" * 40)
 25
 26# requires_grad=True로 기울기 추적
 27x = torch.tensor(2.0, requires_grad=True)
 28w = torch.tensor(3.0, requires_grad=True)
 29b = torch.tensor(1.0, requires_grad=True)
 30
 31# 순전파
 32y = w * x + b
 33print(f"y = w*x + b = {w.item()}*{x.item()} + {b.item()} = {y.item()}")
 34
 35# 역전파
 36y.backward()
 37
 38print(f"dy/dw = x = {w.grad.item()}")
 39print(f"dy/dx = w = {x.grad.item()}")
 40print(f"dy/db = 1 = {b.grad.item()}")
 41
 42
 43# ============================================
 44# 2. 단일 뉴런 역전파
 45# ============================================
 46print("\n[2] 단일 뉴런 역전파")
 47print("-" * 40)
 48
 49# 입력과 목표
 50x = torch.tensor([2.0], requires_grad=True)
 51target = torch.tensor([1.0])
 52
 53# 가중치와 편향
 54w = torch.tensor([0.5], requires_grad=True)
 55b = torch.tensor([0.1], requires_grad=True)
 56
 57# 순전파
 58z = w * x + b
 59a = torch.sigmoid(z)
 60loss = (a - target) ** 2
 61
 62print(f"입력: x={x.item()}, target={target.item()}")
 63print(f"가중치: w={w.item()}, b={b.item()}")
 64print(f"예측: a={a.item():.4f}")
 65print(f"손실: {loss.item():.4f}")
 66
 67# 역전파 (자동!)
 68loss.backward()
 69
 70print(f"\n자동 계산된 기울기:")
 71print(f"  dL/dw = {w.grad.item():.4f}")
 72print(f"  dL/db = {b.grad.item():.4f}")
 73
 74
 75# ============================================
 76# 3. 2층 MLP 역전파
 77# ============================================
 78print("\n[3] 2층 MLP 역전파")
 79print("-" * 40)
 80
 81class SimpleMLP(nn.Module):
 82    def __init__(self, input_dim, hidden_dim, output_dim):
 83        super().__init__()
 84        self.fc1 = nn.Linear(input_dim, hidden_dim)
 85        self.fc2 = nn.Linear(hidden_dim, output_dim)
 86
 87    def forward(self, x):
 88        x = F.relu(self.fc1(x))
 89        x = torch.sigmoid(self.fc2(x))
 90        return x
 91
 92# 모델 생성
 93torch.manual_seed(42)
 94model = SimpleMLP(2, 8, 1)
 95print(model)
 96
 97# 파라미터 확인
 98total_params = sum(p.numel() for p in model.parameters())
 99print(f"\n총 파라미터 수: {total_params}")
100
101for name, param in model.named_parameters():
102    print(f"  {name}: shape={param.shape}")
103
104
105# ============================================
106# 4. XOR 문제로 역전파 확인
107# ============================================
108print("\n[4] XOR 문제 학습")
109print("-" * 40)
110
111# 데이터
112X = torch.tensor([[0, 0], [0, 1], [1, 0], [1, 1]], dtype=torch.float32)
113y = torch.tensor([[0], [1], [1], [0]], dtype=torch.float32)
114
115# 모델, 손실 함수, 옵티마이저
116torch.manual_seed(42)
117mlp = SimpleMLP(2, 8, 1)
118criterion = nn.MSELoss()
119optimizer = torch.optim.SGD(mlp.parameters(), lr=1.0)
120
121# 학습
122losses = []
123for epoch in range(2000):
124    # 순전파
125    y_pred = mlp(X)
126    loss = criterion(y_pred, y)
127    losses.append(loss.item())
128
129    # 역전파 (핵심 3줄!)
130    optimizer.zero_grad()  # 기울기 초기화
131    loss.backward()        # 역전파 (자동 기울기 계산)
132    optimizer.step()       # 가중치 업데이트
133
134    if (epoch + 1) % 400 == 0:
135        print(f"Epoch {epoch+1}: Loss = {loss.item():.6f}")
136
137# 결과 확인
138print("\n학습 결과:")
139mlp.eval()
140with torch.no_grad():
141    y_final = mlp(X)
142    for i in range(4):
143        print(f"  {X[i].tolist()} → {y_final[i, 0]:.4f} (정답: {y[i, 0]})")
144
145# 손실 그래프
146plt.figure(figsize=(10, 5))
147plt.plot(losses)
148plt.xlabel('Epoch')
149plt.ylabel('Loss')
150plt.title('XOR Training Loss (PyTorch Backprop)')
151plt.yscale('log')
152plt.grid(True, alpha=0.3)
153plt.savefig('pytorch_xor_loss.png', dpi=100)
154plt.close()
155print("\n손실 그래프 저장: pytorch_xor_loss.png")
156
157
158# ============================================
159# 5. 기울기 흐름 시각화
160# ============================================
161print("\n[5] 기울기 흐름 확인")
162print("-" * 40)
163
164# 새 모델로 기울기 확인
165torch.manual_seed(0)
166test_model = SimpleMLP(2, 4, 1)
167
168# 순전파
169x_test = torch.tensor([[1.0, 0.0]])
170y_test = torch.tensor([[1.0]])
171
172y_pred = test_model(x_test)
173loss = criterion(y_pred, y_test)
174
175# 역전파 전 기울기 확인
176print("역전파 전:")
177for name, param in test_model.named_parameters():
178    print(f"  {name}.grad: {param.grad}")
179
180# 역전파
181loss.backward()
182
183# 역전파 후 기울기 확인
184print("\n역전파 후:")
185for name, param in test_model.named_parameters():
186    grad_norm = param.grad.norm().item()
187    print(f"  {name}.grad norm: {grad_norm:.6f}")
188
189
190# ============================================
191# 6. 계산 그래프 확인
192# ============================================
193print("\n[6] 계산 그래프")
194print("-" * 40)
195
196# 간단한 계산
197a = torch.tensor(2.0, requires_grad=True)
198b = torch.tensor(3.0, requires_grad=True)
199
200c = a + b
201d = a * b
202e = c * d
203
204print(f"a = {a.item()}, b = {b.item()}")
205print(f"c = a + b = {c.item()}")
206print(f"d = a * b = {d.item()}")
207print(f"e = c * d = {e.item()}")
208
209# 역전파
210e.backward()
211
212print(f"\nde/da = {a.grad.item()}")  # d(c*d)/da = d + c*b = 6 + 5*3 = 21
213print(f"de/db = {b.grad.item()}")  # d(c*d)/db = d + c*a = 6 + 5*2 = 16
214
215# 수동 검증
216print("\n수동 검증:")
217print("e = (a+b) * (a*b)")
218print("de/da = (a*b) + (a+b)*b = d + c*b")
219print(f"     = {d.item()} + {c.item()}*{b.item()} = {d.item() + c.item()*b.item()}")
220
221
222# ============================================
223# 7. retain_graph와 기울기 누적
224# ============================================
225print("\n[7] 기울기 누적")
226print("-" * 40)
227
228x = torch.tensor(2.0, requires_grad=True)
229y = x ** 2
230
231# 첫 번째 backward
232y.backward(retain_graph=True)
233print(f"첫 번째 backward: dy/dx = {x.grad.item()}")
234
235# 두 번째 backward (기울기 누적!)
236y.backward(retain_graph=True)
237print(f"두 번째 backward: dy/dx = {x.grad.item()} (누적됨!)")
238
239# 기울기 초기화 후 다시
240x.grad.zero_()
241y.backward()
242print(f"zero_grad() 후: dy/dx = {x.grad.item()}")
243
244
245# ============================================
246# 8. NumPy vs PyTorch 비교
247# ============================================
248print("\n" + "=" * 60)
249print("NumPy vs PyTorch 역전파 비교")
250print("=" * 60)
251
252comparison = """
253| 단계        | NumPy (수동)                    | PyTorch (자동)              |
254|-------------|--------------------------------|----------------------------|
255| 순전파      | z1 = X @ W1 + b1               | y = model(X)              |
256|             | a1 = relu(z1)                  |                            |
257|             | z2 = a1 @ W2 + b2              |                            |
258|             | a2 = sigmoid(z2)               |                            |
259| 손실        | loss = mean((a2 - y)**2)       | loss = criterion(y, target)|
260| 역전파      | dL_da2 = 2*(a2-y)/m            | loss.backward()           |
261|             | dL_dz2 = dL_da2 * σ'(z2)       | (자동!)                    |
262|             | dW2 = a1.T @ dL_dz2            |                            |
263|             | dL_da1 = dL_dz2 @ W2.T         |                            |
264|             | dL_dz1 = dL_da1 * relu'(z1)    |                            |
265|             | dW1 = X.T @ dL_dz1             |                            |
266| 업데이트    | W1 -= lr * dW1                 | optimizer.step()          |
267|             | W2 -= lr * dW2                 |                            |
268
269NumPy 구현의 가치:
2701. 체인 룰의 동작 원리 직접 체험
2712. 행렬 전치(T)가 왜 필요한지 이해
2723. 활성화 함수 미분의 역할 파악
2734. 배치 처리의 수학적 의미 이해
274
275PyTorch의 장점:
2761. 코드 간결성 (3줄로 역전파 완료)
2772. 계산 오류 없음 (자동 미분)
2783. 복잡한 모델도 동일한 방식
2794. GPU 가속 자동 지원
280"""
281print(comparison)
282
283
284# ============================================
285# 정리
286# ============================================
287print("=" * 60)
288print("역전파 핵심 정리")
289print("=" * 60)
290
291summary = """
292PyTorch 역전파 3줄:
293    optimizer.zero_grad()  # 기울기 초기화 (필수!)
294    loss.backward()        # 역전파 (모든 기울기 자동 계산)
295    optimizer.step()       # W = W - lr * grad
296
297주의사항:
2981. zero_grad() 없으면 기울기가 누적됨
2992. backward()는 기본적으로 그래프 삭제 (retain_graph=True로 유지)
3003. torch.no_grad()로 추론 시 기울기 계산 비활성화
301
302NumPy로 구현해보면:
303- 체인 룰이 실제로 어떻게 적용되는지 이해
304- backward()가 내부적으로 하는 일을 알게 됨
305- 더 깊은 디버깅 능력 획득
306"""
307print(summary)
308print("=" * 60)