Blog

# -*- coding: utf-8 -*-
"""과적합 실험용 합성 데이터와 다항 특성. 시드를 고정해 매 실행 같은 값이 나온다."""
import numpy as np

TRUE_F = lambda x: np.sin(2.2 * x) + 0.35 * x      # 정답 곡선(모델은 모른다)
NOISE = 0.22

def make(n_train=18, n_test=400, seed=7):
    rng = np.random.default_rng(seed)
    xtr = np.sort(rng.uniform(-2.5, 2.5, n_train))
    ytr = TRUE_F(xtr) + rng.normal(0, NOISE, n_train)
    xte = np.linspace(-2.5, 2.5, n_test)
    yte = TRUE_F(xte) + rng.normal(0, NOISE, n_test)
    return xtr, ytr, xte, yte

class Poly:
    """[1, x, x^2, ...]를 만들고 1열을 뺀 나머지를 학습 데이터 기준으로 표준화한다.

    x^15처럼 열마다 크기가 수십만 배 차이 나면 조건수가 커져 해가 불안정하고,
    L2 벌점이 열마다 다른 세기로 걸린다. 그래서 스케일을 먼저 맞춘다.
    """
    def __init__(self, degree): self.d = degree
    def fit(self, x):
        P = np.vander(x, self.d + 1, increasing=True)[:, 1:]
        self.mu, self.sd = P.mean(0), P.std(0)
        self.sd[self.sd == 0] = 1.0
        return self
    def transform(self, x):
        P = np.vander(x, self.d + 1, increasing=True)[:, 1:]
        return np.column_stack([np.ones(len(x)), (P - self.mu) / self.sd])
    def fit_transform(self, x): return self.fit(x).transform(x)

def rmse(a, b): return float(np.sqrt(np.mean((a - b) ** 2)))

# -*- coding: utf-8 -*-
"""차수를 올리면 학습 오차는 계속 내려가지만 평가 오차는 어느 지점부터 올라간다."""
import numpy as np
from over_data import make, Poly, rmse

xtr, ytr, xte, yte = make()
print(f"학습 {len(xtr)}개 / 평가 {len(xte)}개 / 잡음 표준편차 0.22")
print(f"{'차수':>4} {'파라미터':>8} {'학습RMSE':>10} {'평가RMSE':>10} {'|w|최대':>11}")
for d in [1, 2, 3, 5, 7, 9, 11, 13, 15, 17]:
    pf = Poly(d).fit(xtr)
    Xtr, Xte = pf.transform(xtr), pf.transform(xte)
    w, *_ = np.linalg.lstsq(Xtr, ytr, rcond=None)      # 정규화 없는 최소제곱
    print(f"{d:>4} {d+1:>8} {rmse(Xtr@w,ytr):>10.4f} {rmse(Xte@w,yte):>10.4f} {np.abs(w).max():>11.3e}")

# -*- coding: utf-8 -*-
"""같은 15차 모델에 L2 벌점만 붙여 lambda를 훑는다. 절편(w0)은 벌하지 않는다."""
import numpy as np
from over_data import make, Poly, rmse

xtr, ytr, xte, yte = make()
pf = Poly(15).fit(xtr)
Xtr, Xte = pf.transform(xtr), pf.transform(xte)

def ridge(X, y, lam):
    I = np.eye(X.shape[1]); I[0, 0] = 0.0          # 절편 제외
    return np.linalg.solve(X.T @ X + lam * I, X.T @ y)

print(f"15차 다항(파라미터 16개) / 학습 {len(xtr)}개")
print(f"{'lambda':>9} {'학습RMSE':>10} {'평가RMSE':>10} {'|w|최대':>11} {'||w||2':>11}")
best = (1e18, None)
for lam in [0.0, 1e-6, 1e-4, 1e-3, 1e-2, 1e-1, 1.0, 3.0, 10.0, 100.0]:
    w = ridge(Xtr, ytr, lam)
    te = rmse(Xte @ w, yte)
    print(f"{lam:>9.0e} {rmse(Xtr@w,ytr):>10.4f} {te:>10.4f} {np.abs(w).max():>11.3e} {np.linalg.norm(w):>11.3f}")
    if te < best[0]: best = (te, lam)
print(f"\n평가 RMSE 최소: lambda={best[1]:.0e} 에서 {best[0]:.4f}")
print(f"(정규화 없는 5차 모델의 평가 RMSE는 0.3080 이었다)")

# -*- coding: utf-8 -*-
"""같은 lambda에서 L2는 계수를 줄이고 L1은 0으로 만든다. L1은 근접 경사(ISTA)로 푼다."""
import numpy as np
from over_data import make, Poly, rmse

xtr, ytr, xte, yte = make()
pf = Poly(15).fit(xtr)
Xtr, Xte = pf.transform(xtr), pf.transform(xte)
n, k = Xtr.shape

def ridge(lam):
    I = np.eye(k); I[0, 0] = 0.0
    return np.linalg.solve(Xtr.T @ Xtr + lam * I, Xtr.T @ ytr)

def lasso(lam, steps=200000, lr=None):
    """L1은 미분 불가라 soft-threshold를 쓴다: w <- sign(w) * max(|w|-lr*lam/n, 0)"""
    L = np.linalg.eigvalsh(Xtr.T @ Xtr).max() / n
    lr = lr or 1.0 / L
    w = np.zeros(k)
    for _ in range(steps):
        g = Xtr.T @ (Xtr @ w - ytr) / n
        w = w - lr * g
        thr = lr * lam / n
        w[1:] = np.sign(w[1:]) * np.maximum(np.abs(w[1:]) - thr, 0.0)   # 절편 제외
    return w

for lam in [1e-2, 1e-1, 1.0]:
    w2, w1 = ridge(lam), lasso(lam)
    print(f"--- lambda = {lam:g} ---")
    print(f"  L2: 평가RMSE={rmse(Xte@w2,yte):7.4f}  0인 계수={int((np.abs(w2[1:])<1e-8).sum()):2d}/15  ||w||1={np.abs(w2[1:]).sum():8.3f}")
    print(f"  L1: 평가RMSE={rmse(Xte@w1,yte):7.4f}  0인 계수={int((np.abs(w1[1:])<1e-8).sum()):2d}/15  ||w||1={np.abs(w1[1:]).sum():8.3f}")

w1 = lasso(1e-1)
nz = [i for i in range(1, k) if abs(w1[i]) >= 1e-8]
print(f"\nlambda=0.1 L1이 남긴 항의 차수: {nz}")
print("계수:", np.array2string(w1[nz], precision=3, suppress_small=True))

# -*- coding: utf-8 -*-
"""정규화 없이도 데이터가 늘어나면 같은 모델의 과적합이 줄어든다."""
import numpy as np
from over_data import make, Poly, rmse

print(f"{'학습개수':>8} {'15차 학습':>10} {'15차 평가':>12} {'5차 평가':>10}")
for n in [18, 30, 60, 120, 400, 2000]:
    xtr, ytr, xte, yte = make(n_train=n)
    row = []
    for d in (15, 5):
        pf = Poly(d).fit(xtr)
        Xtr, Xte = pf.transform(xtr), pf.transform(xte)
        w, *_ = np.linalg.lstsq(Xtr, ytr, rcond=None)
        row.append((rmse(Xtr@w, ytr), rmse(Xte@w, yte)))
    print(f"{n:>8} {row[0][0]:>10.4f} {row[0][1]:>12.4f} {row[1][1]:>10.4f}")
print("\n(평가 데이터의 잡음 표준편차 0.22가 도달 가능한 하한이다)")

# -*- coding: utf-8 -*-
"""경사하강으로 15차 모델을 학습하며 검증 손실이 다시 올라가는 지점을 찾는다."""
import numpy as np
from over_data import make, Poly, rmse

N = 30
xtr, ytr, xte, yte = make(n_train=N)
rng = np.random.default_rng(1)
idx = rng.permutation(N); tr, va = idx[:20], idx[20:]      # 학습 20 / 검증 10
pf = Poly(15).fit(xtr[tr])
Xtr, Xva, Xte = pf.transform(xtr[tr]), pf.transform(xtr[va]), pf.transform(xte)
ytr_, yva = ytr[tr], ytr[va]

w = np.zeros(Xtr.shape[1]); lr = 0.05
best = (1e18, 0, None)
print(f"15차 / 학습 {len(tr)}개 / 검증 {len(va)}개 / lr={lr}")
print(f"{'step':>8} {'학습RMSE':>10} {'검증RMSE':>10} {'평가RMSE':>10}")
for step in range(1, 100001):
    w -= lr * (Xtr.T @ (Xtr @ w - ytr_) / len(ytr_))
    v = rmse(Xva @ w, yva)
    if v < best[0]: best = (v, step, w.copy())
    if step in (100, 1000, 5000, 20000, 50000, 100000):
        print(f"{step:>8} {rmse(Xtr@w,ytr_):>10.4f} {v:>10.4f} {rmse(Xte@w,yte):>10.4f}")
print(f"\n검증 최소: step={best[1]} (검증RMSE={best[0]:.4f}) -> 그때 평가RMSE={rmse(Xte@best[2],yte):.4f}")
print(f"끝까지(100000 step): 검증RMSE={rmse(Xva@w,yva):.4f}, 평가RMSE={rmse(Xte@w,yte):.4f}")
print(f"즉 조기 종료로 평가 RMSE가 {rmse(Xte@w,yte)/rmse(Xte@best[2],yte):.2f}배 나빠지는 것을 막았다")

# -*- coding: utf-8 -*-
"""평가 세트를 보지 않고 lambda를 고르는 방법: K-겹 교차검증. 데이터 양에 따라 신뢰도가 다르다."""
import numpy as np
from over_data import make, Poly, rmse

D, K = 15, 6
LAMS = [1e-6, 1e-4, 1e-3, 1e-2, 1e-1, 1.0, 10.0]

def ridge(X, y, lam):
    I = np.eye(X.shape[1]); I[0, 0] = 0.0
    return np.linalg.solve(X.T @ X + lam * I, X.T @ y)

def run(n_train):
    xtr, ytr, xte, yte = make(n_train=n_train)
    rng = np.random.default_rng(0)
    folds = np.array_split(rng.permutation(len(xtr)), K)
    print(f"\n=== 학습 {n_train}개 / {K}-겹 교차검증 / {D}차 ===")
    print(f"{'lambda':>9} {'CV RMSE':>10} {'평가RMSE':>10}")
    cv, te = {}, {}
    for lam in LAMS:
        errs = []
        for i in range(K):
            va = folds[i]; tr = np.concatenate([folds[j] for j in range(K) if j != i])
            pf = Poly(D).fit(xtr[tr])                 # 스케일링도 폴드 안에서만 학습
            w = ridge(pf.transform(xtr[tr]), ytr[tr], lam)
            errs.append(rmse(pf.transform(xtr[va]) @ w, ytr[va]))
        cv[lam] = float(np.mean(errs))
        pf = Poly(D).fit(xtr); w = ridge(pf.transform(xtr), ytr, lam)
        te[lam] = rmse(pf.transform(xte) @ w, yte)
        print(f"{lam:>9.0e} {cv[lam]:>10.4f} {te[lam]:>10.4f}")
    pick, oracle = min(cv, key=cv.get), min(te, key=te.get)
    print(f"CV 선택: lambda={pick:.0e} -> 평가RMSE {te[pick]:.4f}")
    print(f"평가 세트를 훔쳐본 최적: lambda={oracle:.0e} -> 평가RMSE {te[oracle]:.4f}")

run(18)
run(60)