PyTorch 실전: 텐서부터 학습 루프까지

텐서의 모양과 자료형, 브로드캐스팅을 익히고, 자동 미분이 기울기를 쌓아 두는 성질 때문에 zero_grad가 꼭 필요한 이유를 직접 확인해요. nn.Module로 모델을 정의하고, DataLoader로 미니배치를 만들고, 학습 모드와 평가 모드를 구분하는 표준 학습 루프로 손글씨 숫자를 98.2%까지 분류한 뒤, 모델을 저장하고 다시 불러와 예측까지 해요.

중급강의 3 / 6약 10분

지난 강의에서 numpy로 손수 쓴 순전파, 역전파, 가중치 갱신을 PyTorch는 몇 줄로 줄여 줘요. 연구실과 회사에서 가장 널리 쓰는 딥러닝 라이브러리이고, 요즘 공개되는 대부분의 AI 모델 코드가 PyTorch로 되어 있어요. 이번 강의를 마치면 그런 코드를 읽고 고칠 수 있는 기본기가 생겨요.

설치는 공식 사이트(pytorch.org)의 안내대로 하세요. GPU가 없어도 CPU 버전으로 이 강의의 모든 예제가 1분 안에 돌아가요.

텐서: PyTorch의 배열

텐서는 numpy 배열과 거의 같아요. 다른 점은 두 가지예요. GPU에 올릴 수 있고, 자동 미분을 지원해요.

import numpy as np
import torch

a = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
print(a.shape, a.dtype, a.device)          # torch.Size([2, 3]) torch.float32 cpu
print(a + torch.tensor([10.0, 20.0, 30.0]))   # 브로드캐스팅: 행마다 더해져요
print(a @ a.T)                             # 행렬 곱: [[14, 32], [32, 77]]
print(torch.from_numpy(np.arange(3)).dtype)   # torch.int64

자주 부딪히는 세 가지만 기억하세요.

  • 모양(shape): 오류의 절반은 모양이 안 맞아서 나요. 막히면 일단 .shape를 출력해 보세요.
  • 자료형(dtype): 신경망은 보통 float32를 써요. numpy는 기본이 float64라서, numpy에서 넘어온 데이터는 float32로 바꿔 주세요. 분류의 정답은 정수(int64)여야 해요.
  • 장치(device): 모델과 데이터가 같은 장치(CPU 또는 GPU)에 있어야 계산돼요. x.to("cuda")로 옮겨요.

자동 미분과 zero_grad

requires_grad=True를 붙인 텐서는 계산 과정을 기억했다가 .backward()로 기울기를 구해요. 지난 강의의 Value와 같아요. 같은 성질, 기울기를 더해 쌓는 성질도 그대로예요.

w = torch.tensor(2.0, requires_grad=True)
for i in range(3):
    loss = (w * 3 - 1) ** 2      # d(loss)/dw = 6(3w - 1) = 30
    loss.backward()
    print(i, w.grad.item())      # 30.0, 60.0, 90.0  쌓여요!
w.grad.zero_()
((w * 3 - 1) ** 2).backward()
print(w.grad.item())             # 30.0

기울기는 30이어야 하는데, 지우지 않으면 60, 90으로 쌓여요. 그래서 학습 루프에서는 매번 optimizer.zero_grad()로 기울기를 지워요. 이걸 빼먹는 게 PyTorch 초보의 가장 흔한 버그예요. 에러도 안 나고 학습이 이상하게만 돼서 찾기 어려워요.

데이터 준비: Dataset과 DataLoader

손글씨 숫자를 다시 쓸게요. 데이터를 텐서로 바꾸고, DataLoader로 미니배치를 만들어요. DataLoader는 에포크마다 섞어서 64개씩 잘라 건네주는 일을 해요.

from torch.utils.data import TensorDataset, DataLoader
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

X, y = load_digits(return_X_y=True)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.25, random_state=0)
sc = StandardScaler().fit(X_tr)
Xtr = torch.tensor(sc.transform(X_tr), dtype=torch.float32)   # 입력은 float32
Xte = torch.tensor(sc.transform(X_te), dtype=torch.float32)
ytr, yte = torch.tensor(y_tr), torch.tensor(y_te)              # 정답은 int64

train_dl = DataLoader(TensorDataset(Xtr, ytr), batch_size=64, shuffle=True,
                      generator=torch.Generator().manual_seed(0))

데이터가 메모리에 다 안 들어갈 만큼 크면(사진 수백만 장처럼) Dataset을 직접 만들어, 필요할 때 파일에서 하나씩 읽게 해요. DataLoader는 여러 프로세스로 미리 읽어 두는 일까지 해 줘요.

모델 정의: nn.Module

모델은 nn.Module을 상속한 클래스로 만들어요. __init__에 층을 만들고, forward에 계산 순서를 적어요. 역전파는 적을 필요가 없어요. 자동이니까요.

from torch import nn

class MLP(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(64, 128),   # 입력 64 → 은닉 128
            nn.ReLU(),
            nn.Linear(128, 10),   # 은닉 128 → 숫자 10개의 점수(로짓)
        )

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

torch.manual_seed(0)                                     # 가중치 초기값을 고정해요
model = MLP()
print(sum(p.numel() for p in model.parameters()))       # 9610

마지막 층 뒤에 소프트맥스를 넣지 않은 것에 주의하세요. nn.CrossEntropyLoss가 안에서 소프트맥스와 로그를 한꺼번에 계산해요. 정보 이론 강의에서 본 것처럼, 그래야 수치적으로 안정적이에요. 소프트맥스를 두 번 거치면 학습이 이상해져요.

학습 루프: 다섯 줄의 의식

PyTorch 학습 루프는 거의 언제나 이 다섯 줄이에요.

loss_fn = nn.CrossEntropyLoss()
opt = torch.optim.Adam(model.parameters(), lr=1e-3)

def evaluate(model, X, y):
    model.eval()                                  # 평가 모드
    with torch.no_grad():                         # 기울기 계산을 꺼서 빠르고 가볍게
        logits = model(X)
        return loss_fn(logits, y).item(), (logits.argmax(1) == y).float().mean().item()

for epoch in range(1, 31):
    model.train()                                 # 학습 모드
    for xb, yb in train_dl:
        opt.zero_grad()                           # 1. 지난 기울기 지우기
        loss = loss_fn(model(xb), yb)             # 2. 순전파와 손실
        loss.backward()                           # 3. 역전파
        opt.step()                                # 4. 가중치 갱신
    if epoch in (1, 5, 10, 20, 30):
        tl, ta = evaluate(model, Xtr, ytr)
        vl, va = evaluate(model, Xte, yte)
        print(epoch, round(tl, 4), round(ta, 3), round(vl, 4), round(va, 3))
에포크학습 손실학습 정확도시험 손실시험 정확도
11.5930.7771.6600.711
50.3210.9430.3820.931
100.1270.9810.1840.964
200.0460.9960.1160.982
300.0220.9990.1020.982

30에포크 만에 시험 정확도 98.2%예요. scikit-learn의 신경망(97.3%)보다 조금 나은 건 은닉층이 더 넓고(128) 옵티마이저가 Adam이기 때문이에요. 최적화 강의에서 Adam이 경사 하강법보다 빨리 수렴하는 걸 봤죠.

학습 손실(0.022)과 시험 손실(0.102)의 차이가 점점 벌어지는 게 보이나요? 학습 데이터는 거의 외웠고(99.9%), 시험 성적은 20에포크 이후로 제자리예요. 과적합이 시작된 신호예요. 다음 강의에서 이걸 다루는 기술들을 배워요.

model.train()과 model.eval()

두 모드를 왜 구분할까요? 지금 모델에는 차이가 없지만, 다음 강의에서 배울 드롭아웃(학습 중에만 뉴런을 무작위로 끄는 기술)과 배치 정규화(학습 중에는 배치 통계, 평가 때는 누적 통계를 쓰는 기술)는 두 모드에서 다르게 동작해요. 평가할 때 model.eval()을 빼먹으면 예측이 매번 달라지거나 성능이 이상하게 나와요. 습관처럼 써 두세요.

torch.no_grad()는 평가할 때 계산 과정을 기억하지 않게 해서 메모리를 아끼고 빨라지게 해요.

저장하고 불러오기

모델은 가중치 묶음(state_dict)만 저장하는 게 표준이에요. 불러올 때는 같은 클래스로 모델을 만든 뒤 가중치를 넣어요.

torch.save(model.state_dict(), "digits_mlp.pt")       # 약 39KB

loaded = MLP()
loaded.load_state_dict(torch.load("digits_mlp.pt"))
loaded.eval()
with torch.no_grad():
    probs = torch.softmax(loaded(Xte[:3]), dim=1)      # 예측할 때는 확률로 바꿔서
print(probs.argmax(1).tolist(), yte[:3].tolist())     # [2, 8, 2] [2, 8, 2]
print([round(float(p), 3) for p in probs.max(1).values])   # [1.0, 0.975, 1.0]

가중치 9,610개가 39KB 파일 하나에 들어 있어요. 서비스에서는 이 파일을 불러와 eval() 모드로 예측만 해요. 두 번째 숫자는 97.5%로 확신이 조금 낮은데, 이런 확률을 보고 "확신이 낮은 예측은 사람이 다시 보기" 같은 규칙을 만들 수 있어요.

GPU 쓰기

GPU가 있으면 모델과 데이터를 GPU로 옮기기만 하면 돼요.

device = "cuda" if torch.cuda.is_available() else "cpu"
model = model.to(device)
# 학습 루프 안에서: xb, yb = xb.to(device), yb.to(device)

이 정도 작은 모델은 CPU로도 충분하지만, 이미지나 언어 모델은 GPU가 수십 배 빨라요. 개인 컴퓨터에 GPU가 없으면 구글 코랩 같은 무료 노트북 서비스에서 GPU를 빌려 쓸 수 있어요.

재현성

같은 코드를 다시 돌렸을 때 같은 결과가 나오게 하려면, 난수를 쓰는 곳마다 씨앗을 고정해요. 이 강의에서는 가중치 초기화(torch.manual_seed)와 데이터 섞기(DataLoader의 generator)를 고정했어요. GPU에서는 일부 연산이 미세하게 달라질 수 있어서 완전한 재현은 추가 설정이 필요해요. 실험 결과를 비교할 때는 씨앗을 여러 개로 바꿔 돌려 평균을 보는 게 더 믿을 만해요. 평가 강의의 "흔들림과 함께 보기"와 같은 이야기예요.

실습

  1. 옵티마이저를 torch.optim.SGD(model.parameters(), lr=0.1)로 바꿔 같은 에포크 동안 시험 정확도를 비교해 보세요.
  2. 은닉층을 두 개(128, 64)로 늘려 보세요. 파라미터 수와 시험 정확도가 어떻게 변하나요?
  3. 학습 루프에서 opt.zero_grad()를 일부러 빼고 돌려 보세요. 손실이 어떻게 변하나요?
  4. 배치 크기를 8, 64, 512로 바꿔 에포크당 걸리는 시간과 최종 정확도를 비교해 보세요.

자주 하는 실수

  • zero_grad() 빼먹기. 기울기가 쌓여서 학습이 이상해져요.
  • 마지막 층에 소프트맥스를 넣고 CrossEntropyLoss 쓰기. 소프트맥스가 두 번 들어가요.
  • 평가할 때 model.eval()과 torch.no_grad() 빼먹기. 드롭아웃이 켜진 채로 평가하거나 메모리를 낭비해요.
  • float64 입력, float 정답. 입력은 float32, 분류 정답은 int64로 맞추세요.
  • 모델과 데이터의 장치가 다름. "Expected all tensors to be on the same device" 오류의 원인이에요.

점검 문제

  1. requires_grad=True인 텐서로 같은 손실을 세 번 backward()하면 기울기는 어떻게 되나요?
  2. nn.Linear(64, 128)의 파라미터는 몇 개인가요?
  3. PyTorch 학습 루프의 네 단계를 순서대로 말해 보세요.
  4. CrossEntropyLoss에 넣는 모델 출력은 확률이어야 하나요, 로짓이어야 하나요?
  5. 평가할 때 model.eval()이 필요한 이유는?

정답

  1. 세 번의 기울기가 더해져 세 배가 돼요. 그래서 매번 지워야 해요.
  2. 가중치 64×128=8,19264 \times 128 = 8{,}192개와 편향 128개를 합쳐 8,320개예요.
  3. 기울기 지우기(zero_grad), 순전파와 손실 계산, 역전파(backward), 가중치 갱신(step)이에요.
  4. 로짓이에요. 소프트맥스는 손실 함수 안에서 계산돼요.
  5. 드롭아웃이나 배치 정규화처럼 학습과 평가에서 다르게 동작하는 층을 평가 방식으로 바꾸기 위해서예요.

다음 강의

학습 루프를 손에 익혔으니, 이제 잘 학습시키는 기술을 배워요. 다음 강의에서는 가중치 초기화, 드롭아웃과 가중치 감쇠, 배치 정규화, 학습률 스케줄과 옵티마이저 선택을 실험으로 비교하며, 과적합을 다스리고 깊은 신경망을 안정적으로 학습시키는 법을 익혀요.