지도학습¶

import numpy as np
from scipy.optimize import minimize
from scipy.special import expit  # logistic function

np.random.seed(42)
n = 1000

# === 자료 생성: 대출 연체를 맞히는 이진 분류 문제 ===
# 설명변수 둘을 만든다.
#   income  연소득(천 달러). clip(10)으로 하한을 둔다
#   dti     소득 대비 부채 비율(debt-to-income). 0.01~1.0으로 자른다
income = np.random.normal(60, 20, n).clip(10)
dti = np.random.normal(0.3, 0.15, n).clip(0.01, 1.0)

# 참 구조를 로그오즈로 적는다.
#   소득이 낮을수록(50 - income이 클수록) 연체 확률이 오르고
#   부채비율이 높을수록(dti - 0.3이 클수록) 크게 오른다
log_odds = -3 + 0.01 * (50 - income) + 5 * (dti - 0.3)

# expit(z) = 1/(1+e^{-z}). 로그오즈를 0~1 사이 확률로 바꾼다.
prob = expit(log_odds)

# 각자 자기 확률로 동전을 던져 실제 연체 여부(정답 레이블)를 정한다
default = np.random.binomial(1, prob)

# === 훈련/시험 분할 ===
# 앞 700개로 배우고 뒤 300개로 평가한다.
# 지도학습의 성적은 반드시 **보지 않은 자료**에서 재야 한다.
train, test = np.arange(700), np.arange(700, n)
X = np.column_stack([np.ones(n), income, dti])   # 절편 열을 앞에 붙인다

# === 적합: 음의 로그가능도를 최소화한다 ===
def neg_log_lik(beta):
    """로지스틱 회귀의 음의 로그가능도.

    한 관측의 로그가능도는  y*z - log(1 + e^z)  이다 (z는 로그오즈).
    log1p(exp(z))는 log(1+exp(z))를 수치적으로 안정하게 계산한다.
    최소제곱과 달리 닫힌 해가 없어 수치 최적화가 필요하다.
    """
    z = X[train] @ beta
    return -np.sum(default[train] * z - np.log1p(np.exp(z)))

# BFGS: 기울기를 근사해 내려가는 준뉴턴법
result = minimize(neg_log_lik, np.zeros(3), method="BFGS")
beta_hat = result.x

# === 평가: 시험자료에서의 정확도 ===
probs_test = expit(X[test] @ beta_hat)   # 예측 확률
preds = (probs_test > 0.5).astype(int)   # 0.5를 문턱으로 0/1 판정
accuracy = np.mean(preds == default[test])
print(f"Test accuracy:        {accuracy:.3f}")
print(f"Default rate (test):  {default[test].mean():.3f}")
print(f"Coefficients:         {beta_hat.round(4)}")

# --- (1)(2) 의 이론값과 맞추어 본다 ---
beta_true = np.array([-4.0, -0.01, 5.0])
p_hat = expit(X[train] @ beta_hat)
info = X[train].T @ (X[train] * (p_hat * (1 - p_hat))[:, None])
se = np.sqrt(np.diag(np.linalg.inv(info)))
print(f"참 계수:              {beta_true}")
print(f"SE:                   {se.round(4)}")
print(f"z (추정 - 참)/SE:     {((beta_hat - beta_true) / se).round(2)}")
print(f"훈련 연체 수 {default[train].sum()} / 700,  시험 연체 수 {default[test].sum()} / 300")
print(f"모형이 '연체'로 판정한 시험 건수: {preds.sum()}")
print(f"'연체 없음'만 답하는 모형의 정확도: {1 - default[test].mean():.3f}")

Test accuracy:        0.957
Default rate (test):  0.043
Coefficients:         [-3.6561 -0.0273  6.0932]
참 계수:              [-4.   -0.01  5.  ]
SE:                   [0.7291 0.0094 1.2631]
z (추정 - 참)/SE:     [ 0.47 -1.84  0.87]
훈련 연체 수 37 / 700,  시험 연체 수 13 / 300
모형이 '연체'로 판정한 시험 건수: 0
'연체 없음'만 답하는 모형의 정확도: 0.957

import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.tree import DecisionTreeRegressor

rng = np.random.default_rng(0)
f = lambda z: np.sin(1.5 * z)
x0 = np.linspace(-2, 2, 50)
sigma, B, n = 0.5, 800, 40

models = [("선형회귀", lambda: LinearRegression()),
          ("깊이 3 트리", lambda: DecisionTreeRegressor(max_depth=3, random_state=0)),
          ("완전 성장 트리", lambda: DecisionTreeRegressor(random_state=0))]

print(f"{'모형':>16}{'편향^2':>10}{'분산':>10}{'잡음':>9}{'합':>10}{'실제 MSE':>11}")
for label, make in models:
    preds = np.empty((B, len(x0)))
    mse = 0.0
    for b in range(B):
        X = rng.uniform(-2, 2, (n, 1))
        y = f(X[:, 0]) + rng.normal(0, sigma, n)
        preds[b] = make().fit(X, y).predict(x0.reshape(-1, 1))
        y0 = f(x0) + rng.normal(0, sigma, len(x0))       # 새 시험 관측
        mse += np.mean((preds[b] - y0) ** 2)
    bias2 = np.mean((preds.mean(0) - f(x0)) ** 2)
    var = np.mean(preds.var(0))
    print(f"{label:>16}{bias2:>10.4f}{var:>10.4f}{sigma ** 2:>9.4f}"
          f"{bias2 + var + sigma ** 2:>10.4f}{mse / B:>11.4f}")

              모형      편향^2        분산       잡음         합     실제 MSE
            선형회귀    0.1795    0.0232   0.2500    0.4527     0.4512
         깊이 3 트리    0.0020    0.1314   0.2500    0.3834     0.3840
        완전 성장 트리    0.0010    0.2553   0.2500    0.5063     0.5089

import numpy as np
from sklearn.svm import SVC
from sklearn.model_selection import GridSearchCV, cross_val_score

rng = np.random.default_rng(1)
grid = {"C": [0.01, 0.1, 1, 10, 100], "gamma": [0.001, 0.01, 0.1]}

naive, nested = [], []
for _ in range(60):
    X = rng.normal(0, 1, (120, 20))
    y = rng.integers(0, 2, 120)                  # 특성과 아무 관계가 없다

    gs = GridSearchCV(SVC(), grid, cv=5).fit(X, y)
    naive.append(gs.best_score_)                 # 선택에 쓴 점수를 그대로 보고
    nested.append(cross_val_score(
        GridSearchCV(SVC(), grid, cv=5), X, y, cv=5).mean())   # 중첩 교차검증

print("신호가 전혀 없는 자료 (참 정확도 0.50)")
print(f"  선택에 쓴 CV 점수를 그대로 보고: {np.mean(naive):.4f}")
print(f"  중첩 교차검증:                   {np.mean(nested):.4f}")

신호가 전혀 없는 자료 (참 정확도 0.50)
  선택에 쓴 CV 점수를 그대로 보고: 0.5681
  중첩 교차검증:                   0.5214

import numpy as np
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import (accuracy_score, precision_score, recall_score,
                             roc_auc_score, average_precision_score)

rng = np.random.default_rng(0)
n = 50_000
y = (rng.random(n) < 0.01).astype(int)               # 양성 1%
x = (rng.normal(0, 1, n) + 1.5 * y).reshape(-1, 1)
tr, te = np.arange(35_000), np.arange(35_000, n)

proba = LogisticRegression().fit(x[tr], y[tr]).predict_proba(x[te])[:, 1]
pred = (proba > 0.5).astype(int)

print(f"항상 '음성'이라 답하는 모형의 정확도 {1 - y[te].mean():.4f}")
print(f"학습된 모형의 정확도                 {accuracy_score(y[te], pred):.4f}")
print(f"  정밀도 {precision_score(y[te], pred, zero_division=0):.4f}"
      f"   재현율 {recall_score(y[te], pred):.4f}")
print(f"  ROC-AUC {roc_auc_score(y[te], proba):.4f}"
      f"   PR-AUC {average_precision_score(y[te], proba):.4f}"
      f"  (무작위 기준 {y[te].mean():.4f})")

print("\n임계값을 낮추면")
for th in (0.5, 0.1, 0.05, 0.02):
    p = (proba > th).astype(int)
    print(f"  {th:>4}: 정밀도 {precision_score(y[te], p, zero_division=0):.4f}"
          f"   재현율 {recall_score(y[te], p):.4f}")

항상 '음성'이라 답하는 모형의 정확도 0.9895
학습된 모형의 정확도                 0.9896
  정밀도 0.6667   재현율 0.0127
  ROC-AUC 0.8779   PR-AUC 0.1714  (무작위 기준 0.0105)

임계값을 낮추면
   0.5: 정밀도 0.6667   재현율 0.0127
   0.1: 정밀도 0.2564   재현율 0.2548
  0.05: 정밀도 0.1184   재현율 0.4013
  0.02: 정밀도 0.0613   재현율 0.6943

import numpy as np

rng = np.random.default_rng(1)
y = rng.lognormal(0, 1, 200_000)              # 오른쪽으로 크게 치우친 분포
print(f"평균 {y.mean():.4f}   중앙값 {np.median(y):.4f}"
      f"   90% 분위수 {np.quantile(y, 0.9):.4f}")

grid = np.linspace(0.1, 4, 400)
losses = {
    "제곱오차": [np.mean((y - c) ** 2) for c in grid],
    "절대오차": [np.mean(np.abs(y - c)) for c in grid],
    "핀볼 (tau=0.9)": [np.mean(np.maximum(0.9 * (y - c), -0.1 * (y - c)))
                       for c in grid],
}
targets = {"제곱오차": y.mean(), "절대오차": np.median(y),
           "핀볼 (tau=0.9)": np.quantile(y, 0.9)}
print()
for name, vals in losses.items():
    print(f"  {name:>15} 최소화 상수 {grid[int(np.argmin(vals))]:.4f}"
          f"   이론값 {targets[name]:.4f}")

평균 1.6438   중앙값 0.9979   90% 분위수 3.5769

             제곱오차 최소화 상수 1.6444   이론값 1.6438
             절대오차 최소화 상수 0.9992   이론값 0.9979
     핀볼 (tau=0.9) 최소화 상수 3.5797   이론값 3.5769