로지스틱 회귀와 선형회귀의 시각적 비교¶

import numpy as np
from sklearn.linear_model import LinearRegression, LogisticRegression

# 카드 잔액이 커질수록 연체 확률이 오르는 자료. 참 관계가 S 자 곡선이다.
np.random.seed(42)
n_samples = 300
balance = np.random.uniform(0, 2500, n_samples)

true_prob = 1 / (1 + np.exp(-(balance - 1250) / 300))
default = np.random.binomial(1, true_prob)

X = balance.reshape(-1, 1)
y = default
X_test = np.linspace(balance.min(), balance.max(), 300).reshape(-1, 1)

print(f"참 계수   beta0 = {-1250 / 300:.5f},  beta1 = {1 / 300:.8f}")
print(f"표본 연체율            = {y.mean():.4f}   (이론 0.5)")
print(f"생성에 쓰인 참 확률의 평균 = {true_prob.mean():.4f}")
print(f"연체율의 표준오차        = {np.sqrt(0.25 / n_samples):.4f}")

참 계수   beta0 = -4.16667,  beta1 = 0.00333333
표본 연체율            = 0.5000   (이론 0.5)
생성에 쓰인 참 확률의 평균 = 0.4959
연체율의 표준오차        = 0.0289

# 0/1 반응에 선형회귀를 씌우면 예측값이 0 아래나 1 위로 나간다.
# 확률이라 부를 수 없는 값이 나오는 것이다.
linear_model = LinearRegression()
linear_model.fit(X, y)
y_pred_linear = linear_model.predict(X_test)

print(f"Linear predictions range: "
      f"[{y_pred_linear.min():.3f}, {y_pred_linear.max():.3f}]")

b0, b1 = linear_model.intercept_, linear_model.coef_[0]
print(f"적합        yhat = {b0:.6f} + {b1:.8f} * Balance")
print(f"yhat = 0 인 Balance = {-b0 / b1:.3f}")
print(f"yhat = 1 인 Balance = {(1 - b0) / b1:.3f}")

grid = X_test.ravel()
low = int(np.sum(grid < -b0 / b1))
high = int(np.sum(grid > (1 - b0) / b1))
print(f"격자 간격 h = {grid[1] - grid[0]:.5f}")
print(f"[0,1] 밖 격자점: 아래 {low} + 위 {high} = {low + high}개"
      f"  ({100 * (low + high) / len(grid):.2f}%)")

Linear predictions range: [-0.102, 1.107]
적합        yhat = -0.107902 + 0.00049103 * Balance
yhat = 0 인 Balance = 219.746
yhat = 1 인 Balance = 2256.277
격자 간격 h = 8.23572
[0,1] 밖 격자점: 아래 26 + 위 27 = 53개  (17.67%)

# 로지스틱은 시그모이드를 거치므로 예측값이 언제나 (0, 1) 안에 머문다.
logistic_model = LogisticRegression(solver='lbfgs')
logistic_model.fit(X, y)
y_pred_logistic = logistic_model.predict_proba(X_test)[:, 1]

print(f"Logistic predictions range: "
      f"[{y_pred_logistic.min():.3f}, {y_pred_logistic.max():.3f}]")

a0, a1 = logistic_model.intercept_[0], logistic_model.coef_[0][0]
print(f"적합 계수  b0 = {a0:.5f},  b1 = {a1:.8f}   (참값 -4.16667, 0.00333333)")

# 벌점이 얼마나 일하는가. 음의 로그가능도와 벌점의 크기를 나란히 본다.
def nll(p):
    return -np.sum(y * np.log(p) + (1 - y) * np.log(1 - p))

p_fit = logistic_model.predict_proba(X)[:, 1]
no_pen = LogisticRegression(penalty=None).fit(X, y)
print(f"벌점 0.5*b1^2 = {0.5 * a1**2:.3e}   자료항 NLL = {nll(p_fit):.4f}")
print(f"penalty=None  b1 = {no_pen.coef_[0][0]:.8f}, "
      f"NLL = {nll(no_pen.predict_proba(X)[:, 1]):.10f}")

# 같은 자료를 표준화하면 계수가 커져 벌점이 눈에 보인다.
Z = ((balance - balance.mean()) / balance.std()).reshape(-1, 1)
print(f"표준화  C=1.0        b1 = {LogisticRegression().fit(Z, y).coef_[0][0]:.6f}")
print(f"표준화  penalty=None b1 = "
      f"{LogisticRegression(penalty=None).fit(Z, y).coef_[0][0]:.6f}")

# 교차엔트로피의 세 층.
ent_sum = -np.sum(true_prob * np.log(true_prob)
                  + (1 - true_prob) * np.log(1 - true_prob))
print(f"절편만 (300 log2)     = {300 * np.log(2):.3f}")
print(f"참 확률의 엔트로피 합    = {ent_sum:.3f}")
print(f"참 확률을 그대로 쓴 손실  = {nll(true_prob):.3f}")
print(f"적합 모형의 손실        = {nll(p_fit):.3f}")

Logistic predictions range: [0.019, 0.981]
적합 계수  b0 = -3.97898,  b1 = 0.00321188   (참값 -4.16667, 0.00333333)
벌점 0.5*b1^2 = 5.158e-06   자료항 NLL = 111.4884
penalty=None  b1 = 0.00321188, NLL = 111.4883505231
표준화  C=1.0        b1 = 2.230632
표준화  penalty=None b1 = 2.359120
절편만 (300 log2)     = 207.944
참 확률의 엔트로피 합    = 108.126
참 확률을 그대로 쓴 손실  = 111.574
적합 모형의 손실        = 111.488

import matplotlib.pyplot as plt

fig, axes = plt.subplots(1, 2, figsize=(14, 5))

# 왼쪽: 선형회귀. 직선이 0 과 1 을 그은 점선을 넘어가는 것을 본다.
axes[0].scatter(X[y == 0], y[y == 0], alpha=0.6, s=30,
                color='steelblue', label='No Default (y=0)')
axes[0].scatter(X[y == 1], y[y == 1], alpha=0.6, s=30,
                color='coral', label='Default (y=1)')
axes[0].plot(X_test, y_pred_linear, 'g-', linewidth=2.5,
             label='Linear Fit')
axes[0].axhline(y=0, color='black', linestyle='--', linewidth=0.8)
axes[0].axhline(y=1, color='black', linestyle='--', linewidth=0.8)
axes[0].set_xlabel('Credit Card Balance')
axes[0].set_ylabel('Predicted Probability')
axes[0].set_title('Linear Regression on Binary Data')
axes[0].legend(); axes[0].set_ylim(-0.5, 1.5)

# 오른쪽: 로지스틱. 곡선이 0 과 1 사이에 갇혀 있고, 자료가 만들어진
# 참 관계와도 모양이 맞는다.
axes[1].scatter(X[y == 0], y[y == 0], alpha=0.6, s=30,
                color='steelblue', label='No Default (y=0)')
axes[1].scatter(X[y == 1], y[y == 1], alpha=0.6, s=30,
                color='coral', label='Default (y=1)')
axes[1].plot(X_test, y_pred_logistic, 'purple', linewidth=2.5,
             label='Logistic Fit')
axes[1].axhline(y=0.5, color='red', linestyle=':', linewidth=1.5,
                alpha=0.7, label='Decision boundary (0.5)')
axes[1].set_xlabel('Credit Card Balance')
axes[1].set_ylabel('Predicted Probability')
axes[1].set_title('Logistic Regression on Binary Data')
axes[1].legend(); axes[1].set_ylim(-0.05, 1.05)

plt.tight_layout()
plt.show()

# 그림이 보여 주지 않는 것 — 0.5 문턱으로 자른 뒤의 분류 결과.
cut_lin = (0.5 - linear_model.intercept_) / linear_model.coef_[0]
cut_log = -logistic_model.intercept_[0] / logistic_model.coef_[0][0]
print(f"0.5 를 지나는 Balance   선형 {cut_lin:.4f}   로지스틱 {cut_log:.4f}")
print(f"잔액의 표본평균        {balance.mean():.4f}")

pred_lin = (linear_model.predict(X) > 0.5).astype(int)
pred_log = (logistic_model.predict_proba(X)[:, 1] > 0.5).astype(int)
print(f"두 분류가 엇갈린 관측 수 = {(pred_lin != pred_log).sum()}")
print(f"정확도   선형 {(pred_lin == y).mean():.4f}   "
      f"로지스틱 {(pred_log == y).mean():.4f}")

p_lin = linear_model.predict(X)
p_log = logistic_model.predict_proba(X)[:, 1]
print(f"브라이어 점수  선형 {np.mean((p_lin - y) ** 2):.5f}   "
      f"로지스틱 {np.mean((p_log - y) ** 2):.5f}")
print(f"선형 예측이 [0,1] 밖인 관측 수 = {int(((p_lin < 0) | (p_lin > 1)).sum())}")

0.5 를 지나는 Balance   선형 1238.0115   로지스틱 1238.8332
잔액의 표본평균        1238.0115
두 분류가 엇갈린 관측 수 = 0
정확도   선형 0.8367   로지스틱 0.8367
브라이어 점수  선형 0.11988   로지스틱 0.11446
선형 예측이 [0,1] 밖인 관측 수 = 55

# 계수가 아주 작으므로 1 달러당 오즈비는 1 에 가깝다. 이럴 때는 단위를
# 바꿔 100 달러당으로 읽는 편이 뜻이 잘 통한다.
odds_ratio = np.exp(logistic_model.coef_[0][0])
print(f"Odds ratio per $1 increase: {odds_ratio:.4f}")
print(f"Percentage increase in odds per $100: "
      f"{(np.exp(100 * logistic_model.coef_[0][0]) - 1) * 100:.2f}%")

b0_hat = logistic_model.intercept_[0]
b1_hat = logistic_model.coef_[0][0]
sigmoid = lambda z: 1 / (1 + np.exp(-z))

print(f"\n최대 기울기 beta/4 = {b1_hat / 4:.8f} (/$1)"
      f"  ->  {100 * b1_hat / 4:.4f} (/$100)")
print("\nBalance    p(b)    오즈비($100)   확률 변화(+$100)")
for b in [400, 900, 1238.83, 1600, 2100]:
    p_here = sigmoid(b0_hat + b1_hat * b)
    p_next = sigmoid(b0_hat + b1_hat * (b + 100))
    odds_here = p_here / (1 - p_here)
    odds_next = p_next / (1 - p_next)
    print(f"{b:8.1f}  {p_here:.4f}      {odds_next / odds_here:.5f}"
          f"         {p_next - p_here:.4f}")

Odds ratio per $1 increase: 1.0032
Percentage increase in odds per $100: 37.88%

최대 기울기 beta/4 = 0.00080297 (/$1)  ->  0.0803 (/$100)

Balance    p(b)    오즈비($100)   확률 변화(+$100)
   400.0  0.0633      1.37876         0.0219
   900.0  0.2519      1.37876         0.0652
  1238.8  0.5000      1.37876         0.0796
  1600.0  0.7613      1.37876         0.0534
  2100.0  0.9408      1.37876         0.0156