편향-분산 트레이드오프(Bias-Variance Tradeoff): 과적합과 과소적합의 근본 원인

MSE = E[(y - ŷ)²]

y = f(x) + ε

E[(y - ŷ)²]
= E[(f + ε - ŷ)²]
= E[(f - ŷ)²] + 2·E[(f - ŷ)·ε] + E[ε²]

   ε가 ŷ와 독립이고 E[ε]=0이므로 2번째 항 = 0

= E[(f - ŷ)²] + σ²

   이제 첫 항을 E[ŷ]를 더하고 빼서 전개:

= E[(f - E[ŷ] + E[ŷ] - ŷ)²] + σ²
= (f - E[ŷ])² + E[(E[ŷ] - ŷ)²] + σ²
     ↑               ↑              ↑
   Bias²          Variance      Irreducible Noise

E[(y - ŷ)²] = Bias(ŷ)² + Var(ŷ) + σ²

Bias(ŷ) = E[ŷ] - f(x)

import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression
from sklearn.pipeline import Pipeline

np.random.seed(42)
n = 30
X = np.sort(np.random.uniform(0, 2*np.pi, n)).reshape(-1, 1)
y = np.sin(X.ravel()) + np.random.normal(0, 0.3, n)

# degree=1: 직선
pipe_d1 = Pipeline([
    ('poly', PolynomialFeatures(degree=1)),
    ('lr',   LinearRegression())
])
pipe_d1.fit(X, y)

train_mse = np.mean((pipe_d1.predict(X) - y)**2)
print(f"Degree 1 Train MSE: {train_mse:.4f}")

Degree 1 Train MSE: 0.3412

Variance = E[(ŷ - E[ŷ])²]

# degree=15: 15차 다항식
pipe_d15 = Pipeline([
    ('poly', PolynomialFeatures(degree=15)),
    ('lr',   LinearRegression())
])
pipe_d15.fit(X, y)

train_mse = np.mean((pipe_d15.predict(X) - y)**2)
print(f"Degree 15 Train MSE: {train_mse:.4f}")

# 다른 훈련 셋으로 실험
np.random.seed(99)
X2 = np.sort(np.random.uniform(0, 2*np.pi, n)).reshape(-1, 1)
y2 = np.sin(X2.ravel()) + np.random.normal(0, 0.3, n)

pipe_d15_v2 = Pipeline([
    ('poly', PolynomialFeatures(degree=15)),
    ('lr',   LinearRegression())
])
pipe_d15_v2.fit(X2, y2)

# 두 모델의 예측 차이 (같은 x 위치에서)
X_test = np.linspace(0, 2*np.pi, 100).reshape(-1, 1)
diff = np.mean((pipe_d15.predict(X_test) - pipe_d15_v2.predict(X_test))**2)
print(f"훈련셋이 달라졌을 때 예측 차이 (MSE): {diff:.4f}")

Degree 15 Train MSE: 0.0512

훈련셋이 달라졌을 때 예측 차이 (MSE): 1.8743

from sklearn.model_selection import cross_val_score
from sklearn.metrics import mean_squared_error

np.random.seed(42)
degrees = range(1, 16)
train_errors, val_errors = [], []

X_full = np.sort(np.random.uniform(0, 2*np.pi, 100)).reshape(-1, 1)
y_full = np.sin(X_full.ravel()) + np.random.normal(0, 0.3, 100)

for deg in degrees:
    pipe = Pipeline([
        ('poly', PolynomialFeatures(degree=deg)),
        ('lr',   LinearRegression())
    ])
    # 훈련 에러
    pipe.fit(X_full, y_full)
    tr_mse = mean_squared_error(y_full, pipe.predict(X_full))
    # 검증 에러 (5-fold CV)
    cv_scores = cross_val_score(pipe, X_full, y_full,
                                 cv=5, scoring='neg_mean_squared_error')
    train_errors.append(tr_mse)
    val_errors.append(-cv_scores.mean())

best_deg = degrees[int(np.argmin(val_errors))]
print(f"최적 Degree: {best_deg}")
print(f"  Train MSE: {train_errors[best_deg-1]:.4f}")
print(f"  Val MSE:   {val_errors[best_deg-1]:.4f}")

최적 Degree: 4
  Train MSE: 0.0731
  Val MSE:   0.1023

from sklearn.model_selection import learning_curve

np.random.seed(42)
n = 200
X_lc = np.sort(np.random.uniform(0, 2*np.pi, n)).reshape(-1, 1)
y_lc = np.sin(X_lc.ravel()) + np.random.normal(0, 0.3, n)

# 과소적합 모델 (degree=1)
pipe_under = Pipeline([
    ('poly', PolynomialFeatures(degree=1)),
    ('lr',   LinearRegression())
])

train_sizes, train_scores, val_scores = learning_curve(
    pipe_under, X_lc, y_lc,
    train_sizes=np.linspace(0.1, 1.0, 10),
    cv=5,
    scoring='neg_mean_squared_error'
)

print("== 과소적합 모델 (Degree=1) ==")
print(f"{'데이터 수':>8} | {'훈련 MSE':>10} | {'검증 MSE':>10}")
for sz, tr, val in zip(train_sizes,
                        -train_scores.mean(axis=1),
                        -val_scores.mean(axis=1)):
    print(f"{int(sz):>8} | {tr:>10.4f} | {val:>10.4f}")

== 과소적합 모델 (Degree=1) ==
 데이터 수 |   훈련 MSE |   검증 MSE
       20 |     0.3289 |     0.3892
       40 |     0.3351 |     0.3614
       60 |     0.3398 |     0.3541
       80 |     0.3412 |     0.3498
      100 |     0.3423 |     0.3471
      120 |     0.3431 |     0.3455
      140 |     0.3436 |     0.3447
      160 |     0.3440 |     0.3443
      180 |     0.3443 |     0.3441
      200 |     0.3445 |     0.3440

# 과적합 모델 (degree=15)
pipe_over = Pipeline([
    ('poly', PolynomialFeatures(degree=15)),
    ('lr',   LinearRegression())
])

train_sizes, train_scores_o, val_scores_o = learning_curve(
    pipe_over, X_lc, y_lc,
    train_sizes=np.linspace(0.1, 1.0, 10),
    cv=5,
    scoring='neg_mean_squared_error'
)

print("\n== 과적합 모델 (Degree=15) ==")
print(f"{'데이터 수':>8} | {'훈련 MSE':>10} | {'검증 MSE':>10}")
for sz, tr, val in zip(train_sizes,
                        -train_scores_o.mean(axis=1),
                        -val_scores_o.mean(axis=1)):
    print(f"{int(sz):>8} | {tr:>10.4f} | {val:>10.4f}")

== 과적합 모델 (Degree=15) ==
 데이터 수 |   훈련 MSE |   검증 MSE
       20 |     0.0000 |    12.4521
       40 |     0.0001 |     3.8745
       60 |     0.0023 |     2.1033
       80 |     0.0198 |     1.4872
      100 |     0.0312 |     1.1047
      120 |     0.0428 |     0.8934
      140 |     0.0487 |     0.7612
      160 |     0.0511 |     0.6841
      180 |     0.0523 |     0.6243
      200 |     0.0531 |     0.5812

from sklearn.model_selection import train_test_split

# 전형적인 진단 코드
def diagnose_model(model, X, y, cv=5):
    """모델의 편향-분산 상태를 진단한다."""
    from sklearn.model_selection import cross_val_score

    # 훈련/검증 분리
    X_tr, X_val, y_tr, y_val = train_test_split(X, y, test_size=0.2, random_state=42)
    model.fit(X_tr, y_tr)

    train_mse = mean_squared_error(y_tr, model.predict(X_tr))
    val_mse   = mean_squared_error(y_val, model.predict(X_val))
    gap       = val_mse - train_mse

    print(f"훈련 MSE:  {train_mse:.4f}")
    print(f"검증 MSE:  {val_mse:.4f}")
    print(f"갭(Gap):   {gap:.4f}")
    print()

    # 임계값 (데이터마다 다를 수 있음)
    baseline_mse = 0.15   # 허용 가능한 에러 수준

    if train_mse > baseline_mse:
        print("⚠️  높은 편향 (과소적합)")
        print("   → 더 복잡한 모델 사용")
        print("   → 더 많은 특성 추가")
        print("   → 규제 강도 줄이기")
    elif gap > baseline_mse:
        print("⚠️  높은 분산 (과적합)")
        print("   → 더 많은 훈련 데이터 수집")
        print("   → 규제(L1/L2) 적용")
        print("   → 앙상블 방법 (배깅, 랜덤 포레스트)")
        print("   → 특성 수 줄이기 (PCA 등)")
    else:
        print("✅ 균형 잡힌 모델")

# 예시
pipe_d1  = Pipeline([('poly', PolynomialFeatures(1)),  ('lr', LinearRegression())])
pipe_d4  = Pipeline([('poly', PolynomialFeatures(4)),  ('lr', LinearRegression())])
pipe_d15 = Pipeline([('poly', PolynomialFeatures(15)), ('lr', LinearRegression())])

for name, pipe in [("Degree 1", pipe_d1), ("Degree 4", pipe_d4), ("Degree 15", pipe_d15)]:
    print(f"=== {name} ===")
    diagnose_model(pipe, X_full, y_full)

=== Degree 1 ===
훈련 MSE:  0.3401
검증 MSE:  0.3582
갭(Gap):   0.0181

⚠️  높은 편향 (과소적합)
   → 더 복잡한 모델 사용
   → 더 많은 특성 추가
   → 규제 강도 줄이기

=== Degree 4 ===
훈련 MSE:  0.0731
검증 MSE:  0.1023
갭(Gap):   0.0292

✅ 균형 잡힌 모델

=== Degree 15 ===
훈련 MSE:  0.0189
검증 MSE:  0.5847
갭(Gap):   0.5658

⚠️  높은 분산 (과적합)
   → 더 많은 훈련 데이터 수집
   → 규제(L1/L2) 적용
   → 앙상블 방법 (배깅, 랜덤 포레스트)
   → 특성 수 줄이기 (PCA 등)

from sklearn.linear_model import Ridge

# Degree를 올려서 편향 해결
for deg in [1, 2, 4, 6]:
    pipe = Pipeline([
        ('poly', PolynomialFeatures(degree=deg)),
        ('ridge', Ridge(alpha=1.0))
    ])
    cv_mse = -cross_val_score(pipe, X_full, y_full,
                               cv=5, scoring='neg_mean_squared_error').mean()
    print(f"Degree {deg:2d} | CV MSE: {cv_mse:.4f}")

Degree  1 | CV MSE: 0.3541
Degree  2 | CV MSE: 0.1893
Degree  4 | CV MSE: 0.0987
Degree  6 | CV MSE: 0.1102

# 규제를 적용해서 분산 감소
pipe_overfit = Pipeline([
    ('poly', PolynomialFeatures(degree=15)),
    ('ridge', Ridge(alpha=100.0))   # 강한 규제
])

cv_mse = -cross_val_score(pipe_overfit, X_full, y_full,
                            cv=5, scoring='neg_mean_squared_error').mean()
print(f"Degree 15 + Ridge(alpha=100) | CV MSE: {cv_mse:.4f}")

# 규제 없는 경우와 비교
pipe_no_reg = Pipeline([
    ('poly', PolynomialFeatures(degree=15)),
    ('lr',   LinearRegression())
])
cv_mse_no_reg = -cross_val_score(pipe_no_reg, X_full, y_full,
                                   cv=5, scoring='neg_mean_squared_error').mean()
print(f"Degree 15 (규제 없음)         | CV MSE: {cv_mse_no_reg:.4f}")

Degree 15 + Ridge(alpha=100) | CV MSE: 0.1147
Degree 15 (규제 없음)         | CV MSE: 1.2384

import numpy as np

# 10개의 서로 다른 훈련셋으로 학습한 모델들의 예측 시뮬레이션
np.random.seed(42)
n_models = 10
x_test = 2.0

individual_preds = []
for i in range(n_models):
    # 각기 다른 훈련셋
    X_i = np.sort(np.random.uniform(0, 2*np.pi, 50)).reshape(-1, 1)
    y_i = np.sin(X_i.ravel()) + np.random.normal(0, 0.3, 50)

    pipe = Pipeline([
        ('poly', PolynomialFeatures(degree=15)),
        ('ridge', Ridge(alpha=0.1))
    ])
    pipe.fit(X_i, y_i)
    pred = pipe.predict([[x_test]])[0]
    individual_preds.append(pred)

true_val = np.sin(x_test)
ensemble_pred = np.mean(individual_preds)

print(f"실제 값:           {true_val:.4f}")
print(f"개별 예측 분산:    {np.var(individual_preds):.4f}")
print(f"앙상블 예측:       {ensemble_pred:.4f}")
print(f"앙상블 에러:       {(ensemble_pred - true_val)**2:.4f}")
print(f"평균 개별 에러:    {np.mean([(p - true_val)**2 for p in individual_preds]):.4f}")

실제 값:           0.9093
개별 예측 분산:    0.1823
앙상블 예측:       0.9218
앙상블 에러:       0.0016
평균 개별 에러:    0.1840

# ❌ 잘못된 접근
model.fit(X_train, y_train)
test_mse = mean_squared_error(y_test, model.predict(X_test))
print(f"테스트 MSE: {test_mse:.4f}")   # 이것만으로는 원인을 모른다

# ✅ 올바른 접근: 훈련/검증 에러 모두 확인
train_mse = mean_squared_error(y_train, model.predict(X_train))
val_mse   = mean_squared_error(y_val,   model.predict(X_val))
print(f"훈련 MSE: {train_mse:.4f}")
print(f"검증 MSE: {val_mse:.4f}")
print(f"갭:       {val_mse - train_mse:.4f}")

# ❌ 편향 문제에 데이터를 더 넣어봤자
pipe_under = Pipeline([('poly', PolynomialFeatures(1)), ('lr', LinearRegression())])

for n_data in [50, 200, 1000, 5000]:
    X_n = np.sort(np.random.uniform(0, 2*np.pi, n_data)).reshape(-1, 1)
    y_n = np.sin(X_n.ravel()) + np.random.normal(0, 0.3, n_data)
    pipe_under.fit(X_n, y_n)
    mse = mean_squared_error(y_n, pipe_under.predict(X_n))
    print(f"n={n_data:5d} | Train MSE: {mse:.4f}")

n=   50 | Train MSE: 0.3298
n=  200 | Train MSE: 0.3401
n= 1000 | Train MSE: 0.3445
n= 5000 | Train MSE: 0.3451

from sklearn.linear_model import Ridge

# ❌ 규제가 너무 강하면 편향이 생긴다
for alpha in [0.001, 1, 100, 10000]:
    pipe = Pipeline([
        ('poly', PolynomialFeatures(degree=4)),
        ('ridge', Ridge(alpha=alpha))
    ])
    cv_mse = -cross_val_score(pipe, X_full, y_full,
                               cv=5, scoring='neg_mean_squared_error').mean()
    print(f"alpha={alpha:7.3f} | CV MSE: {cv_mse:.4f}")

alpha=  0.001 | CV MSE: 0.1124
alpha=  1.000 | CV MSE: 0.0987
alpha=100.000 | CV MSE: 0.1253
alpha=10000.000 | CV MSE: 0.3318