NumPy만으로 2층 신경망을 짜 손글씨 숫자를 분류하는 실습(실행 확인, 테스트 정확도 0.9556)
먼저 알아야 할 것
다층 퍼셉트론역전파미니배치 SGDNumPy 배열 연산
다루는 내용
프레임워크 없이 NumPy로 64-64-10 신경망을 만들어 scikit-learn 내장 손글씨 숫자 데이터를 분류합니다. 순전파 · 소프트맥스 교차 엔트로피 · 역전파 · 수치 기울기 점검 · 미니배치 SGD · 검증 기반 모델 선택을 단계별 코드로 구현했고, 직접 실행한 출력(테스트 정확도 0.9556)과 해석, 바꿔 보기 과제, 흔한 오류를 함께 실었습니다.
해설
직접 해 보기: 넘파이로 신경망을 처음부터 만들기
프레임워크 없이 NumPy만으로 2층 신경망을 짜서 손글씨 숫자 10종을 분류합니다. 순전파 · 소프트맥스 교차 엔트로피 · 역전파 · 수치 기울기 점검 · 미니배치 SGD · 조기 종료식 모델 선택까지, 앞 수업들에서 손으로 계산한 것을 코드 100여 줄로 옮깁니다. 아래 코드는 실제로 실행했고, 출력도 그대로 붙였습니다.
미니배치 SGD로 30에포크 학습하고, 검증 정확도가 가장 좋았던 가중치로 테스트를 한 번만 잽니다.
어떤 숫자끼리 헷갈리는지 혼동 행렬로 봅니다.
준비물
bash
pip install numpy scikit-learn
데이터는 scikit-learn에 들어 있는 손글씨 숫자 데이터(load_digits)를 씁니다. 8×8 흑백 이미지 1,797장이고, 픽셀 값은 0~16 정수, 클래스는 0~9 열 개입니다. 내려받기가 필요 없습니다.
mermaid
12345678910flowchart LR
A[load_digits 1,797장] --> B[0~1 정규화 · 학습/검증/테스트 나누기]
B --> C[He 초기화]
C --> D[순전파: XW1+b1 → ReLU → hW2+b2]
D --> E[소프트맥스 교차 엔트로피]
E --> F[역전파: p-y → W2 · ReLU 문 → W1]
F --> G[수치 기울기 점검]
G --> H[미니배치 SGD 30에포크]
H --> I[검증 최고 시점 가중치 선택]
I --> J[테스트 한 번 · 혼동 행렬]
아래 코드 조각 1~8을 순서대로 한 파일(numpy_mlp.py)에 붙이면 실제로 실행한 스크립트와 같습니다.
1단계: 데이터 준비
python
123456789101112import numpy as np
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
# 1. 데이터 준비
X, y = load_digits(return_X_y=True) # (1797, 64), 값 0~16
X = X / 16.0 # 0~1로 맞추기
X_tr, X_te, y_tr, y_te = train_test_split(
X, y, test_size=0.2, random_state=0, stratify=y)
X_tr, X_va, y_tr, y_va = train_test_split(
X_tr, y_tr, test_size=0.2, random_state=0, stratify=y_tr)
print("학습", X_tr.shape, "검증", X_va.shape, "테스트", X_te.shape)
stratify는 나눈 묶음마다 숫자 0~9의 비율을 같게 유지합니다. 테스트 20%를 먼저 떼고, 남은 것에서 다시 20%를 검증으로 뗍니다(1,149 · 288 · 360장).
ReLU를 쓰므로 표준편차 2/nin의 He 초기화를 씁니다(초기화 수업 2절). 파라미터 수는 64×64+64+64×10+10=4,810개입니다. 여기서는 행이 예제인 X에 오른쪽으로 곱하도록 W1의 모양을 (입력, 출력)으로 잡았습니다.
3단계: 순전파와 손실
python
123456789101112131415161718# 3. 순전파와 손실
def forward(p, X):
z1 = X @ p["W1"] + p["b1"]
h = np.maximum(0, z1) # ReLU
o = h @ p["W2"] + p["b2"] # 로짓
return z1, h, o
def softmax(o):
o = o - o.max(axis=1, keepdims=True) # 넘침 방지
e = np.exp(o)
return e / e.sum(axis=1, keepdims=True)
def loss_fn(p, X, y, lam=0.0):
_, _, o = forward(p, X)
P = softmax(o)
n = len(y)
ce = -np.log(P[np.arange(n), y] + 1e-12).mean()
return ce + 0.5 * lam * ((p["W1"] ** 2).sum() + (p["W2"] ** 2).sum())
왜 최댓값을 빼나: 소프트맥스는 모든 로짓에 같은 수를 빼도 결과가 같습니다. 가장 큰 로짓을 빼 두면 exp가 넘치지 않습니다. 손실에는 L2 항 2λ(∥W1∥2+∥W2∥2)을 더했습니다(편향은 제외).
4단계: 역전파
python
123456789101112131415# 4. 역전파
def backward(p, X, y, lam=0.0):
z1, h, o = forward(p, X)
n = len(y)
dO = softmax(o)
dO[np.arange(n), y] -= 1 # p - y(원-핫)
dO /= n
g = {}
g["W2"] = h.T @ dO + lam * p["W2"]
g["b2"] = dO.sum(axis=0)
dH = dO @ p["W2"].T
dZ1 = dH * (z1 > 0) # ReLU 문
g["W1"] = X.T @ dZ1 + lam * p["W1"]
g["b1"] = dZ1.sum(axis=0)
return g
역전파 수업의 세 줄 규칙($\partial W = $ 입력ᵀ × δ, ∂b=∑δ, ∂입력 =δ×W⊤)이 층마다 반복됩니다. 소프트맥스 + 교차 엔트로피의 로짓 기울기가 p−y라는 것(다층 퍼셉트론 5절)을 그대로 씁니다. 배치 평균 손실이므로 n으로 나눕니다.
5단계: 수치 기울기 점검
python
123456789101112131415161718192021# 5. 수치 기울기 점검 (작은 배치, 몇 칸만)
def grad_check(p, X, y, lam=1e-3, eps=1e-5):
g = backward(p, X, y, lam)
worst = 0.0
for name in ["W1", "b1", "W2", "b2"]:
for _ in range(5):
idx = tuple(rng.integers(0, s) for s in p[name].shape)
old = p[name][idx]
p[name][idx] = old + eps; lp = loss_fn(p, X, y, lam)
p[name][idx] = old - eps; lm = loss_fn(p, X, y, lam)
p[name][idx] = old
num = (lp - lm) / (2 * eps)
rel = abs(num - g[name][idx]) / max(1e-12, abs(num) + abs(g[name][idx]))
worst = max(worst, rel)
return worst
print("초기 손실 %.4f (ln 10 = %.4f)" % (loss_fn(params, X_tr, y_tr), np.log(10)))
print("기울기 점검 최대 상대 오차 %.2e" % grad_check(params, X_tr[:20], y_tr[:20]))
def accuracy(p, X, y):
return (forward(p, X)[2].argmax(axis=1) == y).mean()
파라미터마다 무작위 칸 5개씩, 모두 20칸을 양쪽 차분으로 재서 역전파 값과 비교합니다. 학습을 시작하기 전에 반드시 통과시켜야 하는 관문입니다.
6단계: 미니배치 SGD 학습
python
12345678910111213141516# 6. 미니배치 SGD 학습
lr, lam, batch, epochs = 0.1, 1e-4, 32, 30
best = (0, None, -1)
for ep in range(1, epochs + 1):
perm = rng.permutation(len(y_tr))
for i in range(0, len(perm), batch):
idx = perm[i:i + batch]
g = backward(params, X_tr[idx], y_tr[idx], lam)
for k in params:
params[k] -= lr * g[k]
va = accuracy(params, X_va, y_va)
if va > best[0]:
best = (va, {k: v.copy() for k, v in params.items()}, ep)
if ep in (1, 5, 10, 20, 30):
print("에포크 %2d 학습 손실 %.4f 학습 정확도 %.4f 검증 정확도 %.4f"
% (ep, loss_fn(params, X_tr, y_tr), accuracy(params, X_tr, y_tr), va))
에포크마다 순서를 섞고, 32장씩 끊어 기울기를 구해 한 걸음씩 갑니다. 검증 정확도가 가장 좋았던 시점의 가중치를 복사해 둡니다(조기 종료와 같은 효과).
7~8단계: 테스트와 혼동 행렬
python
1234567891011# 7. 가장 좋았던 검증 시점의 가중치로 테스트 한 번
va, p_best, ep_best = best
print("검증 최고 %.4f (에포크 %d) → 테스트 정확도 %.4f" % (va, ep_best, accuracy(p_best, X_te, y_te)))
# 8. 혼동이 많은 숫자 쌍
pred = forward(p_best, X_te)[2].argmax(axis=1)
cm = np.zeros((10, 10), dtype=int)
for t, q in zip(y_te, pred):
cm[t, q] += 1
off = [(int(cm[i, j]), i, j) for i in range(10) for j in range(10) if i != j and cm[i, j] > 0]
print("틀린 예 (개수, 정답, 예측):", sorted(off, reverse=True)[:5])
이 글과 코드는 KAITABASE가 직접 작성했습니다(원문 번역 아님). 구성은 CS231n '신경망 사례 연구' 노트(MIT 라이선스)의 "넘파이로 작은 신경망 만들기" 흐름을 참고했습니다. 데이터는 scikit-learn에 포함된 UCI 손글씨 숫자 데이터의 사본입니다. 출력은 위 환경에서 직접 실행한 결과입니다.
