MNIST 사례연구¶

import torch
import torchvision
from torchvision import transforms
import matplotlib.pyplot as plt

# ToTensor 는 PIL 이미지를 텐서로 바꾸면서 화소값을 0~255 에서 0~1 로
# 나눠 준다. 이 눈금 맞추기를 빠뜨리면 학습이 잘 되지 않는다.
transform = transforms.ToTensor()
train_dataset = torchvision.datasets.MNIST(
    root='./data', train=True, download=True, transform=transform)
test_dataset = torchvision.datasets.MNIST(
    root='./data', train=False, download=True, transform=transform)

# DataLoader 가 자료를 묶음으로 잘라 넘겨준다. shuffle=True 는 세대마다
# 순서를 섞는다는 뜻이고, 이래야 묶음 사이의 기울기가 서로 닮지 않는다.
train_loader = torch.utils.data.DataLoader(
    train_dataset, batch_size=64, shuffle=True)
test_loader = torch.utils.data.DataLoader(
    test_dataset, batch_size=64, shuffle=True)

print(f"train {len(train_dataset)}, test {len(test_dataset)}")

images, labels = next(iter(test_loader))
img_grid = torchvision.utils.make_grid(images, nrow=8, padding=2)

plt.figure(figsize=(8, 8))
plt.imshow(img_grid.permute(1, 2, 0), cmap='gray')
plt.axis('off')
plt.show()

# (1) 과 자료의 성질을 수로 확인한다.
print(f"묶음 수  train {len(train_loader)}  test {len(test_loader)}")
print(f"마지막 묶음 크기  train {60000 % 64}  test {10000 % 64}")
print(f"한 장의 모양 {tuple(train_dataset[0][0].shape)},"
      f"  값 범위 {float(train_dataset[0][0].min())}"
      f" ~ {float(train_dataset[0][0].max())}")

X = train_dataset.data.float() / 255.0
idx = torch.arange(28.0)
rows, cols = X.sum(dim=2), X.sum(dim=1)
cy = (rows * idx).sum(1) / rows.sum(1)
cx = (cols * idx).sum(1) / cols.sum(1)
print(f"화소 평균 {float(X.mean()):.4f},"
      f"  정확히 0 인 화소 비율 {float((X == 0).float().mean()):.4f}")
print(f"질량중심  세로 {cy.mean():.3f} +- {cy.std():.3f},"
      f"  가로 {cx.mean():.3f} +- {cx.std():.3f}   (한가운데는 13.5)")

train 60000, test 10000
묶음 수  train 938  test 157
마지막 묶음 크기  train 32  test 16
한 장의 모양 (1, 28, 28),  값 범위 0.0 ~ 1.0
화소 평균 0.1307,  정확히 0 인 화소 비율 0.8088
질량중심  세로 13.996 +- 0.289,  가로 14.007 +- 0.291   (한가운데는 13.5)

for images, labels in train_loader:
    ...
    loss = criterion(model(images), labels)
    ...
print(f"Epoch {epoch}, Loss: {loss.item():.4f}")

import torch.nn as nn
import torch.optim as optim

class SimpleMNIST(nn.Module):
    """28x28 화소를 곧바로 열 범주로 보내는 선형층 하나짜리 모형.

    사실상 소프트맥스 회귀다. 신경망이라 부르기도 민망한 구조인데도
    MNIST 에서 92% 가까이 나온다 — 자료가 그만큼 쉽다는 뜻이기도 하다.
    """

    def __init__(self):
        super().__init__()
        self.fc = nn.Linear(28 * 28, 10)

    def forward(self, x):
        return self.fc(x.view(x.size(0), -1))

torch.manual_seed(0)
model = SimpleMNIST()
# CrossEntropyLoss 는 소프트맥스와 교차엔트로피를 한꺼번에 한다. 그래서
# 모형의 마지막에 소프트맥스를 또 씌우면 안 된다. 흔한 실수다.
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.1)
print(f"모수 {sum(p.numel() for p in model.parameters())}개,"
      f"  갱신 {5 * len(train_loader)}번")

# 학습 전후를 비교하기 위해 고정된 묶음과 학습 전 모형을 따로 보관해 둔다
import copy
fixed_images, fixed_labels = next(iter(test_loader))
model_untrained = copy.deepcopy(model)

for epoch in range(1, 6):
    model.train()
    for images, labels in train_loader:
        # 기울기를 0 으로 되돌린다. 파이토치는 기울기를 누적하므로
        # 이 줄을 빠뜨리면 앞 묶음의 기울기가 계속 더해진다.
        optimizer.zero_grad()
        loss = criterion(model(images), labels)
        loss.backward()          # 역전파로 기울기 계산
        optimizer.step()         # 계산된 기울기로 모수 갱신
    print(f"Epoch {epoch}, Loss: {loss.item():.4f}")

model_trained = model

# eval() 과 no_grad() 는 다른 일을 한다. 앞은 드롭아웃·배치정규화 같은
# 층을 평가 모드로 바꾸고, 뒤는 기울기 계산을 꺼 메모리와 시간을 아낀다.
# 평가할 때는 둘 다 필요하다.
model.eval()
correct = total = 0
with torch.no_grad():
    for images, labels in test_loader:
        _, pred = torch.max(model(images), 1)
        correct += (pred == labels).sum().item()
        total += labels.size(0)
print(f"Test accuracy: {100 * correct / total:.2f}%")

# 왜 들쭉날쭉한지 — 묶음 하나의 손실이 얼마나 흔들리는지 재어 본다.
with torch.no_grad():
    X_all = train_dataset.data.float().reshape(-1, 1, 28, 28) / 255.0
    per = nn.functional.cross_entropy(model(X_all), train_dataset.targets,
                                      reduction='none')
print(f"표본당 손실  평균 {per.mean():.4f}  표준편차 {per.std():.4f}")
print(f"64개 평균의 표준오차 = sd/8 = {per.std() / 8:.4f}")

모수 7850개,  갱신 4690번
Epoch 1, Loss: 0.2995
Epoch 2, Loss: 0.3877
Epoch 3, Loss: 0.3358
Epoch 4, Loss: 0.2993
Epoch 5, Loss: 0.3032
Test accuracy: 92.03%
표본당 손실  평균 0.2879  표준편차 0.8233
64개 평균의 표준오차 = sd/8 = 0.1029

def show_images(images, true_labels, pred_labels, title):
    plt.figure(figsize=(10, 10))
    for i in range(64):
        plt.subplot(8, 8, i + 1)
        plt.imshow(images[i][0], cmap='binary')
        plt.axis("off")
        plt.title(f"T:{true_labels[i]} P:{pred_labels[i]}", fontsize=6)
    plt.suptitle(title, fontsize=16)
    plt.tight_layout()
    plt.show()

# 학습 전
with torch.no_grad():
    _, preds = torch.max(model_untrained(fixed_images), 1)
show_images(fixed_images, fixed_labels, preds, "Before Training")

# 학습 뒤
with torch.no_grad():
    _, preds_after = torch.max(model_trained(fixed_images), 1)
show_images(fixed_images, fixed_labels, preds_after, "After Training")

# 그림에서 읽을 것을 수로도 찍어 둔다.
with torch.no_grad():
    _, preds = torch.max(model_untrained(fixed_images), 1)
    p0 = torch.softmax(model_untrained(fixed_images), 1)
print(f"학습 전 맞힌 수 {(preds == fixed_labels).sum().item()}/64")
print(f"학습 전 예측 분포 {torch.bincount(preds, minlength=10).tolist()}")
print(f"참 이름표 분포   {torch.bincount(fixed_labels, minlength=10).tolist()}")
print(f"학습 전 최대확률의 평균 {p0.max(1).values.mean():.4f}  (균등이면 0.1)")

with torch.no_grad():
    p1 = torch.softmax(model_trained(fixed_images), 1)
print(f"학습 뒤 맞힌 수 {(preds_after == fixed_labels).sum().item()}/64")
bad = (preds_after != fixed_labels).nonzero().flatten()
print(f"틀린 자리 {bad.tolist()},  참 {fixed_labels[bad].tolist()},"
      f"  예측 {preds_after[bad].tolist()}")
print(f"학습 뒤 최대확률의 평균 {p1.max(1).values.mean():.4f}")

학습 전 맞힌 수 2/64
학습 전 예측 분포 [7, 10, 5, 0, 6, 6, 0, 7, 21, 2]
참 이름표 분포   [6, 7, 8, 4, 9, 3, 7, 8, 9, 3]
학습 전 최대확률의 평균 0.1308  (균등이면 0.1)
학습 뒤 맞힌 수 63/64
틀린 자리 [58],  참 [9],  예측 [5]
학습 뒤 최대확률의 평균 0.8997

import torch.nn.functional as F

class SimpleCNN(nn.Module):
    """합성곱 두 층짜리 신경망.

    선형층은 화소를 한 줄로 펴 버려 "이웃한 화소끼리 관계가 있다"는 것을
    모른다. 합성곱은 작은 창을 이미지 위로 미끄러뜨리므로 그 구조를 살린다.
    같은 가중값을 온 이미지에 되쓰기 때문에 모수도 훨씬 적다.
    """

    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(1, 16, 3, padding=1)  # → 16×28×28
        self.conv2 = nn.Conv2d(16, 32, 3, padding=1)  # → 32×14×14
        self.fc = nn.Linear(32 * 7 * 7, 10)

    def forward(self, x):
        # 최대풀링이 크기를 절반으로 줄인다. 자잘한 위치 차이에 덜 흔들리게
        # 만들면서 계산량도 줄이는 두 가지 일을 함께 한다.
        x = F.max_pool2d(F.relu(self.conv1(x)), 2)   # 28→14
        x = F.max_pool2d(F.relu(self.conv2(x)), 2)   # 14→7
        return self.fc(x.view(x.size(0), -1))

model = SimpleCNN()

# (1) 모양을 따라가 본다.
with torch.no_grad():
    z = fixed_images
    print(f"입력        {tuple(z.shape)}")
    z = F.max_pool2d(F.relu(model.conv1(z)), 2)
    print(f"conv1+풀링  {tuple(z.shape)}")
    z = F.max_pool2d(F.relu(model.conv2(z)), 2)
    print(f"conv2+풀링  {tuple(z.shape)}")

# (2) 층별 모수를 센다.
total = 0
for name, p in model.named_parameters():
    print(f"  {name:13s} {str(tuple(p.shape)):16s} {p.numel():6d}")
    total += p.numel()
fc_n = model.fc.weight.numel() + model.fc.bias.numel()
print(f"합계 {total},  마지막 선형층이 {fc_n}개로 {fc_n / total:.1%}")

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.1)

for epoch in range(1, 6):
    for images, labels in train_loader:
        optimizer.zero_grad()
        loss = criterion(model(images), labels)
        loss.backward()
        optimizer.step()
    print(f"Epoch {epoch}, Loss: {loss.item():.4f}")

입력        (64, 1, 28, 28)
conv1+풀링  (64, 16, 14, 14)
conv2+풀링  (64, 32, 7, 7)
  conv1.weight  (16, 1, 3, 3)       144
  conv1.bias    (16,)                16
  conv2.weight  (32, 16, 3, 3)     4608
  conv2.bias    (32,)                32
  fc.weight     (10, 1568)        15680
  fc.bias       (10,)                10
합계 20490,  마지막 선형층이 15690개로 76.6%
Epoch 1, Loss: 0.0546
Epoch 2, Loss: 0.0084
Epoch 3, Loss: 0.1543
Epoch 4, Loss: 0.1759
Epoch 5, Loss: 0.0320

class Net(nn.Module):
    """입력 크기와 범주 수를 인자로 받는 선형 모형. 되쓰기 좋게 일반화했다."""

    def __init__(self, input_size=784, num_classes=10):
        super().__init__()
        self.layer = nn.Linear(input_size, num_classes)

    def forward(self, x):
        return self.layer(torch.flatten(x, 1))

net = Net()
print(f"layer.weight {tuple(net.layer.weight.shape)},"
      f"  bias {tuple(net.layer.bias.shape)},"
      f"  모수 {sum(p.numel() for p in net.parameters())}")

t = torch.randn(4, 1, 28, 28)                 # 연속 텐서
print(f"연속:    flatten {tuple(torch.flatten(t, 1).shape)},"
      f"  view {tuple(t.view(t.size(0), -1).shape)}")

tt = t.transpose(2, 3)                        # 보폭이 뒤섞인다
print(f"비연속:  flatten {tuple(torch.flatten(tt, 1).shape)}", end=",  ")
try:
    tt.view(tt.size(0), -1)
    print("view 성공")
except RuntimeError:
    print("view RuntimeError")

layer.weight (10, 784),  bias (10,),  모수 7850
연속:    flatten (4, 784),  view (4, 784)
비연속:  flatten (4, 784),  view RuntimeError

def train(model, loader, criterion, optimizer, epochs=2, device='cpu'):
    """학습 반복문을 함수로 묶는다. 모형을 바꿔 가며 되쓸 수 있다."""
    model.train()
    for epoch in range(epochs):
        running_loss = 0.0
        for i, (inputs, labels) in enumerate(loader):
            inputs, labels = inputs.to(device), labels.to(device)
            optimizer.zero_grad()
            loss = criterion(model(inputs), labels)
            loss.backward()
            optimizer.step()
            running_loss += loss.item()
            if i % 2000 == 1999:
                print(f'[{epoch+1}, {i+1:5d}] '
                      f'loss: {running_loss/2000:.3f}')
                running_loss = 0.0

# 돌리지 않고도 몇 번 찍힐지 셀 수 있다.
for n, bs, name in ((60000, 64, "MNIST"), (60000, 32, "MNIST"),
                    (50000, 4, "CIFAR-10 튜토리얼")):
    n_batch = -(-n // bs)
    hits = sum(1 for i in range(n_batch) if i % 2000 == 1999)
    print(f"{name:18s} n={n}, batch={bs} -> 묶음 {n_batch:6d}개,"
          f" 세대마다 {hits}줄 출력")

MNIST              n=60000, batch=64 -> 묶음    938개, 세대마다 0줄 출력
MNIST              n=60000, batch=32 -> 묶음   1875개, 세대마다 0줄 출력
CIFAR-10 튜토리얼      n=50000, batch=4 -> 묶음  12500개, 세대마다 6줄 출력

import numpy as np

n_c = np.array([980, 1135, 1032, 1010, 982, 892, 958, 1028, 974, 1009])
a_c = np.array([97.8, 97.6, 89.1, 92.4, 93.3, 84.0, 95.8, 91.1, 89.0, 90.2])

print(f"검정 범주별 개수 합 {n_c.sum()},"
      f"  가장 큰 범주 {n_c.max()}  가장 작은 범주 {n_c.min()}")
print(f"가중평균(= 전체 정확도) {np.sum(n_c * a_c) / n_c.sum():.4f}%")
print(f"단순평균(= 거시평균)    {a_c.mean():.4f}%")
print(f"차이 {np.sum(n_c * a_c) / n_c.sum() - a_c.mean():.4f}%p")

검정 범주별 개수 합 10000,  가장 큰 범주 1135  가장 작은 범주 892
가중평균(= 전체 정확도) 92.1569%
단순평균(= 거시평균)    92.0300%
차이 0.1269%p

from pathlib import Path

Path('./model').mkdir(exist_ok=True)
torch.save(model.state_dict(), './model/model.pth')

# 적재할 때는 저장할 때와 같은 구조의 모형을 먼저 만들어야 한다
reloaded = SimpleCNN()   # 이 시점의 model은 CNN이다
reloaded.load_state_dict(torch.load('./model/model.pth', weights_only=True))
reloaded.eval()

# 같은 입력에 같은 출력을 내는지 확인한다
with torch.no_grad():
    same = torch.allclose(model(fixed_images), reloaded(fixed_images))
print("적재한 모형이 원본과 동일한가:", same)

sd = torch.load('./model/model.pth', weights_only=True)
n_param = sum(v.numel() for v in sd.values())
print("키:", list(sd.keys()))
print(f"모수 {n_param}개 x 4바이트 = {4 * n_param}바이트,"
      f"  실제 파일 {Path('./model/model.pth').stat().st_size}바이트")

try:
    SimpleMNIST().load_state_dict(sd)
except RuntimeError:
    print("구조가 다른 모형에 적재하면: RuntimeError")

적재한 모형이 원본과 동일한가: True
키: ['conv1.weight', 'conv1.bias', 'conv2.weight', 'conv2.bias', 'fc.weight', 'fc.bias']
모수 20490개 x 4바이트 = 81960바이트,  실제 파일 84212바이트
구조가 다른 모형에 적재하면: RuntimeError

# 어떤 범주가 검정자료에 하나도 없으면 class_total[c] == 0이 된다
classes = ['0', '1', '2']
class_correct = {'0': 8, '1': 5, '2': 0}
class_total = {'0': 10, '1': 7, '2': 0}

c = '2'
try:
    print(f'  {c}: {100 * class_correct[c] / class_total[c]:.1f}%')
except ZeroDivisionError as e:
    print("ZeroDivisionError:", e)

ZeroDivisionError: division by zero

for c in classes:
    if class_total[c] == 0:
        print(f'  {c}: n/a (no test examples)')
    else:
        print(f'  {c}: {100 * class_correct[c] / class_total[c]:.1f}%')

0: 80.0%
  1: 71.4%
  2: n/a (no test examples)