19강 / 20강

실습 종합 — 신경망 하나를 처음부터 끝까지

numpy 로 짜고, 학습시키고, 정직하게 채점한다

스무 강의 것을 한 줄기로 이어 붙입니다. /ml 19강의 네 단계를 그대로 따라가되, 모형만 신경망으로 바꿉니다.

고등학생신경망 하나를 처음부터 끝까지

1~18강을 한 흐름으로 잇습니다.

numpy 로 짜 보면 신비가 사라진다 — 1강의 약속

필요한 부품

부품	줄 수	강
순전파	약 5줄	2·3
역전파	약 10줄	4
갱신	2줄	5
미니배치 루프	5줄	7

전부 합쳐 스무 줄 남짓이다

직접 짜면 알게 되는 것

깨달음	—
수학이 어렵지 않다	연쇄법칙 하나
차원 맞추기가 일의 절반	행렬 모양 오류
학습률이 정말 중요하다	5강을 몸으로
초기화가 정말 중요하다	6강을 몸으로

읽어서 아는 것과 돌려 봐서 아는 것은 다르다

디버깅 요령

확인	방법
기울기가 맞나	수치 미분과 비교 ⭐
학습이 되나	표본 몇 개만 외우게 해 본다
차원이 맞나	매 단계 `.shape`

"작은 자료를 외우지 못하면" 코드가 틀린 것이다 — 가장 좋은 첫 시험

가장 먼저 나눕니다. 표준화조차 그 다음이에요.

Python 브라우저에서 실행

# 1. 자료를 만들고 - 먼저 나눈다
import numpy as np
rng = np.random.default_rng(211)

N, D = 1200, 8
X = rng.normal(0, 1, (N, D))
# 정답은 굽어 있다 - 직선으로는 못 가른다
z = (X[:,0]**2 + X[:,1]**2) - 1.5 + 0.8*X[:,2]*X[:,3]
y = (rng.random(N) < 1/(1+np.exp(-z))).astype(float)

perm = np.random.default_rng(0).permutation(N)
tr, va, te = perm[:700], perm[700:950], perm[950:]
print(f"전체 {N} · 훈련 {len(tr)} · 검증 {len(va)} · 시험 {len(te)}")
print(f"양성 비율 {y.mean():.3f}")
print()
print("시험자료는 마지막 셀까지 손대지 않는다 (/ml 4강).")
print("표준화의 평균·분산도 훈련자료에서만 구한다 (/ml 16강).")

고등학생왜 작은 자료를 외우게 해 보나

딥러닝 디버깅의 첫 번째 시험입니다.

표본 10개를 훈련 정확도 100% 로 못 만들면 — 버그다

왜 이게 좋은 시험인가

8강에서 봤듯 딥러닝은 외우는 게 특기입니다. 그런데 못 외운다면?

가능성	확인할 곳
기울기 계산이 틀렸다	역전파
학습률이 이상하다	5강
라벨이 어긋났다	자료 준비 ⭐
활성화가 죽었다	6강

과적합이 안 되는 것이 신호다 — 보통은 반대를 걱정하는데

순서를 정리하면

단계	확인
1	표본 10개를 외우는가
2	훈련 손실이 내려가는가
3	검증 손실이 따라오는가
4	기준선보다 나은가

앞 단계를 통과하지 못한 채 다음으로 가지 않는다

비유 — 악기 조율

순서	—
1. 소리가 나나	기본 확인
2. 음이 맞나	조율
3. 연주	—

소리도 안 나는데 연주법을 고민하지 않는다

조기종료 지점을 검증자료로 고릅니다 — 그러니 검증 점수는 성능이 아닙니다.

Python 브라우저에서 실행

# 2. 신경망을 손으로 짜고, 검증자료로 멈출 시점을 고른다
import numpy as np
rng = np.random.default_rng(211)
N, D = 1200, 8
X = rng.normal(0, 1, (N, D))
z = (X[:,0]**2 + X[:,1]**2) - 1.5 + 0.8*X[:,2]*X[:,3]
y = (rng.random(N) < 1/(1+np.exp(-z))).astype(float)
perm = np.random.default_rng(0).permutation(N)
tr, va, te = perm[:700], perm[700:950], perm[950:]

mu, sd = X[tr].mean(0), X[tr].std(0) + 1e-9        # 훈련에서만
Xs = (X - mu) / sd
def sigmoid(t): return 1/(1+np.exp(-np.clip(t, -30, 30)))

def make(h, seed):
    r = np.random.default_rng(seed)
    return [r.normal(0, np.sqrt(2/D), (D, h)), np.zeros(h),
            r.normal(0, np.sqrt(2/h), (h, 1)), np.zeros(1)]

def fwd(P, Xb):
    Z1 = Xb @ P[0] + P[1]; A1 = np.maximum(Z1, 0)
    return Z1, A1, np.clip(sigmoid(A1 @ P[2] + P[3]).ravel(), 1e-9, 1-1e-9)

def loss(P, idx):
    p = fwd(P, Xs[idx])[2]
    return -np.mean(y[idx]*np.log(p) + (1-y[idx])*np.log(1-p))

H, LR, BATCH = 32, 0.25, 64
P = make(H, 3)
best, best_P, best_ep, hist = 9e9, None, 0, []
for ep in range(1, 61):
    order = np.random.default_rng(100+ep).permutation(tr)
    for s in range(0, len(order), BATCH):
        b = order[s:s+BATCH]; m = len(b)
        Z1, A1, p = fwd(P, Xs[b])
        d2 = ((p - y[b])/m)[:, None]
        d1 = (d2 @ P[2].T) * (Z1 > 0)
        P[2] -= LR*(A1.T @ d2); P[3] -= LR*d2.sum(0)
        P[0] -= LR*(Xs[b].T @ d1); P[1] -= LR*d1.sum(0)
    ltr, lva = loss(P, tr), loss(P, va)
    hist.append((ep, ltr, lva))
    if lva < best:
        best, best_ep = lva, ep
        best_P = [a.copy() for a in P]

print("  에폭   훈련 손실   검증 손실")
for ep, a, b in hist[::6]:
    mark = "  <- 가장 낮다" if ep == best_ep else ""
    print(f"  {ep:4d}   {a:9.4f}   {b:9.4f}{mark}")
print()
print(f"조기종료 지점: {best_ep} 에폭 (/dl 8강)")
print("이 지점은 **검증자료**로 골랐다 - 그러니 검증 점수는 성능이 아니다.")

로지스틱 회귀와 견줍니다. 못 이기면 신경망을 쓸 이유가 없어요.

Python 브라우저에서 실행

# 3. 봉인을 풀고 딱 한 번 채점한다
import numpy as np
rng = np.random.default_rng(211)
N, D = 1200, 8
X = rng.normal(0, 1, (N, D))
z = (X[:,0]**2 + X[:,1]**2) - 1.5 + 0.8*X[:,2]*X[:,3]
y = (rng.random(N) < 1/(1+np.exp(-z))).astype(float)
perm = np.random.default_rng(0).permutation(N)
tr, va, te = perm[:700], perm[700:950], perm[950:]
mu, sd = X[tr].mean(0), X[tr].std(0) + 1e-9
Xs = (X - mu) / sd
def sigmoid(t): return 1/(1+np.exp(-np.clip(t, -30, 30)))

def train(h, lr, epochs, seed):
    r = np.random.default_rng(seed)
    P = [r.normal(0, np.sqrt(2/D), (D, h)), np.zeros(h),
         r.normal(0, np.sqrt(2/h), (h, 1)), np.zeros(1)]
    for ep in range(epochs):
        order = np.random.default_rng(100+ep).permutation(tr)
        for s in range(0, len(order), 64):
            b = order[s:s+64]; m = len(b)
            Z1 = Xs[b] @ P[0] + P[1]; A1 = np.maximum(Z1, 0)
            p = np.clip(sigmoid(A1 @ P[2] + P[3]).ravel(), 1e-9, 1-1e-9)
            d2 = ((p - y[b])/m)[:, None]; d1 = (d2 @ P[2].T) * (Z1 > 0)
            P[2] -= lr*(A1.T @ d2); P[3] -= lr*d2.sum(0)
            P[0] -= lr*(Xs[b].T @ d1); P[1] -= lr*d1.sum(0)
    return P

def auc(yy, s):
    o = np.argsort(-s); yy = yy[o]
    tp = np.cumsum(yy); fp = np.cumsum(1-yy)
    a = np.concatenate([[0], fp/max((1-yy).sum(),1)])
    b = np.concatenate([[0], tp/max(yy.sum(),1)])
    return float(np.sum(np.diff(a)*(b[:-1]+b[1:])/2))

def score(P, idx):
    return sigmoid(np.maximum(Xs[idx] @ P[0] + P[1], 0) @ P[2] + P[3]).ravel()

P = train(32, 0.25, 33, 3)
print(f"훈련 AUC {auc(y[tr], score(P, tr)):.3f}")
print(f"검증 AUC {auc(y[va], score(P, va)):.3f}   (여기서 멈출 시점을 골랐다)")
print(f"시험 AUC {auc(y[te], score(P, te)):.3f}   <- 보고할 값")
print()
# 로지스틱 회귀와 견준다 - 이겨야 쓸 이유가 있다
A = np.column_stack([np.ones(len(tr)), Xs[tr]])
w = np.zeros(D+1)
for _ in range(4000):
    w -= 0.5 * (A.T @ (sigmoid(A @ w) - y[tr])) / len(tr)
lin = sigmoid(np.column_stack([np.ones(len(te)), Xs[te]]) @ w)
print(f"로지스틱 회귀의 시험 AUC {auc(y[te], lin):.3f}   <- 기준선 (/ml 11강)")
print()
print("정답이 굽어 있어(x²항, 곱셈항) 신경망이 이긴다.")
print("만약 못 이겼다면 - 그냥 로지스틱을 쓰면 된다.")

씨앗의 폭과 이름표 섞기 검사. 둘 다 통과해야 앞의 숫자를 믿습니다.

Python 브라우저에서 실행

# 4. 의심한다 - 씨앗을 바꿔 여러 번 돌린다
import numpy as np
rng = np.random.default_rng(211)
N, D = 1200, 8
X = rng.normal(0, 1, (N, D))
z = (X[:,0]**2 + X[:,1]**2) - 1.5 + 0.8*X[:,2]*X[:,3]
y = (rng.random(N) < 1/(1+np.exp(-z))).astype(float)
perm = np.random.default_rng(0).permutation(N)
tr, te = perm[:700], perm[950:]
mu, sd = X[tr].mean(0), X[tr].std(0) + 1e-9
Xs = (X - mu) / sd
def sigmoid(t): return 1/(1+np.exp(-np.clip(t, -30, 30)))

def run(seed, yy):
    r = np.random.default_rng(seed); h = 32
    P = [r.normal(0, np.sqrt(2/D), (D, h)), np.zeros(h),
         r.normal(0, np.sqrt(2/h), (h, 1)), np.zeros(1)]
    for ep in range(33):
        order = np.random.default_rng(100+ep+seed).permutation(tr)
        for s in range(0, len(order), 64):
            b = order[s:s+64]; m = len(b)
            Z1 = Xs[b] @ P[0] + P[1]; A1 = np.maximum(Z1, 0)
            p = np.clip(sigmoid(A1 @ P[2] + P[3]).ravel(), 1e-9, 1-1e-9)
            d2 = ((p - yy[b])/m)[:, None]; d1 = (d2 @ P[2].T) * (Z1 > 0)
            P[2] -= .25*(A1.T @ d2); P[3] -= .25*d2.sum(0)
            P[0] -= .25*(Xs[b].T @ d1); P[1] -= .25*d1.sum(0)
    s = sigmoid(np.maximum(Xs[te] @ P[0] + P[1], 0) @ P[2] + P[3]).ravel()
    o = np.argsort(-s); q = yy[te][o]
    tp = np.cumsum(q); fp = np.cumsum(1-q)
    a = np.concatenate([[0], fp/max((1-q).sum(),1)])
    b2 = np.concatenate([[0], tp/max(q.sum(),1)])
    return float(np.sum(np.diff(a)*(b2[:-1]+b2[1:])/2))

real = np.array([run(s, y) for s in range(8)])
print("같은 설정. 씨앗만 8가지:")
print("  ", " ".join(f"{a:.3f}" for a in real))
print(f"  평균 {real.mean():.3f}  표준편차 {real.std():.4f}  폭 {real.max()-real.min():.3f}")
print()
shuf = np.array([run(100+s, np.random.default_rng(s).permutation(y)) for s in range(6)])
print("이름표를 섞었을 때 (/ml 16강의 검사):")
print("  ", " ".join(f"{a:.3f}" for a in shuf))
print(f"  평균 {shuf.mean():.3f}")
print()
print("섞으면 0.5 근처로 내려간다 - 파이프라인이 새지 않는다.")
print("그리고 위의 '폭' 보다 작은 차이로는 모형을 견줄 수 없다(10강).")

고등학생정직하게 채점한다

부제의 마지막 단어가 이 강의 핵심입니다.

딥러닝에서 정직한 채점은 더 어렵다

추가로 보고할 것들

항목	왜
seed 개수와 편차	10강 — 한 번의 결과는 운이다 ⭐
시도한 설정 수	10강 — 다중 비교
멈춘 기준	8강 — 조기 종료
기준선	1강 — 로지스틱 회귀와 비교 ⭐
사전학습 자료	15강 — 누출 확인

네 번째가 가장 자주 빠진다 — 그런데 가장 중요하다

왜 기준선이 그렇게 중요한가

딥러닝 논문의 상당수가 단순한 방법과 비교하면 이점이 사라집니다.

비교	흔한 결과
딥러닝 vs 없음	좋아 보인다
딥러닝 vs 로지스틱 회귀	비슷하다 ⚠

표 형태 자료에서는 부스팅이 딥러닝을 이기는 경우가 흔하다

그리고 정직한 표현

과한 표현	정확한 표현
"딥러닝으로 예측에 성공"	"이 코호트에서 AUC 0.78 (5 seed, ±0.04)"
"모형이 발견했다"	"모형이 이 특징에 기댄다"

/ml 20강의 그 이야기 — 맞히는 것과 아는 것은 다르다

고등학생다섯 단계로 정리하면

note 의 정리를 각 단계가 막는 실패와 함께.

단계	막는 실패	강
나눈다	누출 · 외운 것을 실력으로	15·17·18
기준선을 만든다	"딥러닝이 필요한가" 를 못 답함	1·20
학습시킨다	기울기 문제 · 학습률	5·6
규제한다	과적합	8
의심한다	지름길 · 확신에 찬 오답	18

2번이 /ml 에 없던 단계다 — 딥러닝에서 새로 추가된다

왜 새로 추가되나

딥러닝은 비용이 큽니다. 얻는 게 없으면 쓰지 말아야 해요.

비용	설명
계산	GPU · 시간 · 전기
불투명	설명하기 어렵다
취약	분포가 바뀌면 무너진다
유지보수	—

"조금 더 좋다" 로는 이 비용을 정당화하지 못한다

그래서 결정 기준

차이	판단
기준선과 비슷	기준선을 쓴다 ✔
조금 낫다	비용을 따져 본다
크게 낫다	딥러닝 ✔

20강의 결론이 여기서 이미 나온다

🤔 확인 문제

신경망이 시험 AUC 0.84, 로지스틱 회귀가 0.83 을 냈습니다. 어느 것을 쓸까요?