프로젝트 1 — 손글씨 숫자 분류하기

import numpy as np
import torch
from torch import nn
import matplotlib.pyplot as plt
from sklearn.datasets import load_digits

plt.rcParams["font.family"] = "Malgun Gothic"
plt.rcParams["axes.unicode_minus"] = False

digits = load_digits()
print(digits.data.shape, digits.target.shape)

# 앞의 그림 10장을 2줄 5칸으로 그린다. cmap="gray_r" 은 0 을 흰색, 큰 값을 검은색으로
fig, axes = plt.subplots(2, 5, figsize=(8, 3.6))
for ax, img, label in zip(axes.ravel(), digits.images, digits.target):
    ax.imshow(img, cmap="gray_r")
    ax.set_title(f"정답 {label}")
    ax.axis("off")
plt.tight_layout()
plt.show()

from sklearn.model_selection import train_test_split

X = digits.data / 16.0          # 진하기 0~16 을 0~1 로
y = digits.target

# 숫자마다의 비율을 맞춰 학습용 80%, 시험용 20% 로 나눈다
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)

# 특성은 float32, 분류 레이블은 정수(long) 텐서로
X_train_t = torch.tensor(X_train, dtype=torch.float32)
y_train_t = torch.tensor(y_train, dtype=torch.long)
X_test_t = torch.tensor(X_test, dtype=torch.float32)
print(X_train_t.shape, y_train_t.shape, X_test_t.shape)

from torch.utils.data import TensorDataset, DataLoader

torch.manual_seed(42)
model = nn.Sequential(
    nn.Linear(64, 64),   # 칸 64개 → 은닉층 뉴런 64개
    nn.ReLU(),
    nn.Linear(64, 10),   # → 숫자 10개의 점수. 활성화 없음(손실 함수가 확률로 바꿔 준다)
)
loss_fn = nn.CrossEntropyLoss()     # 분류 손실
opt = torch.optim.Adam(model.parameters(), lr=0.01)
loader = DataLoader(TensorDataset(X_train_t, y_train_t), batch_size=64, shuffle=True,
                    generator=torch.Generator().manual_seed(42))

for epoch in range(1, 31):
    for xb, yb in loader:
        opt.zero_grad()
        loss = loss_fn(model(xb), yb)
        loss.backward()
        opt.step()
    if epoch in (1, 10, 30):
        print(f"에포크 {epoch:2d}  마지막 배치 손실 {loss.item():.4f}")

from sklearn.metrics import accuracy_score, ConfusionMatrixDisplay

with torch.no_grad():
    # 출력 10칸 가운데 가장 큰 칸의 번호가 예측한 숫자다
    pred = model(X_test_t).argmax(dim=1).numpy()
print("시험용 정확도:", round(accuracy_score(y_test, pred), 3))

ConfusionMatrixDisplay.from_predictions(y_test, pred)
plt.title("손글씨 숫자 혼동행렬")
plt.show()

wrong = np.where(pred != y_test)[0]      # 틀린 그림의 위치(번호)
print("틀린 그림:", len(wrong), "장")

# 틀린 그림을 최대 8장 그린다. 제목에 정답과 예측을 적는다
fig, axes = plt.subplots(1, 8, figsize=(10, 1.9))
for ax, i in zip(axes, wrong[:8]):
    ax.imshow(X_test[i].reshape(8, 8), cmap="gray_r")
    ax.set_title(f"정답{y_test[i]}→{pred[i]}", fontsize=10)
    ax.axis("off")
for ax in axes[len(wrong):]:
    ax.axis("off")
plt.tight_layout()
plt.show()

from sklearn.metrics import confusion_matrix

with torch.no_grad():
    # 학습용도 예측해 본다. 학습용과 시험용의 차이로 과적합을 가늠한다
    train_pred = model(X_train_t).argmax(dim=1).numpy()
    # softmax 로 점수 10개를 확률로 바꾸고, 고른 숫자의 확률(가장 큰 값)만 남긴다
    prob = torch.softmax(model(X_test_t), dim=1).max(dim=1).values.numpy()
print("학습용 정확도:", round(accuracy_score(y_train, train_pred), 3))

# 혼동행렬의 대각선(맞힌 수) ÷ 줄의 합(그 숫자의 그림 수) = 숫자별 맞힌 비율
cm = confusion_matrix(y_test, pred)
print("숫자별 맞힌 비율(0~9):", (cm.diagonal() / cm.sum(axis=1)).round(3))

right = pred == y_test
print("고른 숫자의 확률 평균  맞힌 그림:", round(prob[right].mean(), 3), " 틀린 그림:", round(prob[~right].mean(), 3))
print("0.9 넘게 확신하고 틀린 그림:", (prob[~right] > 0.9).sum(), "장")