선형판별분석과 이차판별분석¶

import numpy as np

np.random.seed(42)

def generate_shared_cov(n_per_class=200):
    """공분산이 같은 두 범주.

    LDA 의 가정이 정확히 맞는 상황이다. 이때는 LDA 가 QDA 보다 낫다 —
    추정할 모수가 적어 분산이 작기 때문이다.
    """
    cov = [[1.0, 0.5], [0.5, 1.0]]
    X0 = np.random.multivariate_normal([0, 0], cov, n_per_class)
    X1 = np.random.multivariate_normal([2, 1.5], cov, n_per_class)
    X = np.vstack([X0, X1])
    y = np.array([0] * n_per_class + [1] * n_per_class)
    return X, y

def generate_diff_cov(n_per_class=200):
    """공분산이 다른 두 범주.

    LDA 의 가정이 깨진다. 경계가 직선이어야 할 까닭이 없으므로, 곡선
    경계를 그릴 수 있는 QDA 가 유리해진다.
    """
    cov0 = [[1.0, 0.0], [0.0, 0.3]]
    cov1 = [[0.3, 0.0], [0.0, 2.0]]
    X0 = np.random.multivariate_normal([0, 0], cov0, n_per_class)
    X1 = np.random.multivariate_normal([1.5, 1.5], cov1, n_per_class)
    X = np.vstack([X0, X1])
    y = np.array([0] * n_per_class + [1] * n_per_class)
    return X, y


from scipy import stats

# 시나리오 A: 닫힌 꼴.
S = np.array([[1.0, 0.5], [0.5, 1.0]])
d = np.array([2.0, 1.5])
delta2 = d @ np.linalg.inv(S) @ d
errA = stats.norm.cdf(-np.sqrt(delta2) / 2)
print(f"A: Delta^2 = {delta2:.5f}, Delta = {np.sqrt(delta2):.6f}")
print(f"A: 베이즈 오류율 = Phi(-{np.sqrt(delta2) / 2:.6f}) = {errA:.6f}"
      f"   정확도 = {1 - errA:.6f}")

# 시나리오 B: 격자 수치적분.  err = 0.5 * ∫ min(f0, f1)
g = np.linspace(-8, 10, 801)
XX, YY = np.meshgrid(g, g)
P = np.dstack([XX, YY])
h = g[1] - g[0]
f0 = stats.multivariate_normal([0, 0], [[1, 0], [0, 0.3]]).pdf(P)
f1 = stats.multivariate_normal([1.5, 1.5], [[0.3, 0], [0, 2.0]]).pdf(P)
errB = 0.5 * np.sum(np.minimum(f0, f1)) * h * h
print(f"B: 격자의 질량 합 = {0.5 * np.sum(f0 + f1) * h * h:.6f}  (1 이어야 한다)")
print(f"B: 베이즈 오류율 = {errB:.6f}   정확도 = {1 - errB:.6f}")

A: Delta^2 = 4.33333, Delta = 2.081666
A: 베이즈 오류율 = Phi(-1.040833) = 0.148977   정확도 = 0.851023
B: 격자의 질량 합 = 1.000000  (1 이어야 한다)
B: 베이즈 오류율 = 0.106328   정확도 = 0.893672

from sklearn.discriminant_analysis import (
    LinearDiscriminantAnalysis, QuadraticDiscriminantAnalysis,
)
from sklearn.naive_bayes import GaussianNB
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score

# 네 분류기를 같은 자료에 돌린다. 앞의 셋은 생성모형(각 범주의 분포를
# 모형화한 뒤 베이즈 정리로 뒤집는다)이고, 로지스틱 회귀만 판별모형
# (경계를 바로 추정한다)이다.
classifiers = {
    "LDA": LinearDiscriminantAnalysis(),
    "QDA": QuadraticDiscriminantAnalysis(),
    "Naive Bayes": GaussianNB(),
    "Logistic Reg": LogisticRegression(),
}

for scenario_name, (X, y) in [
    ("Shared Cov", generate_shared_cov()),
    ("Diff Cov", generate_diff_cov()),
]:
    print(f"\n--- {scenario_name} ---")
    for name, clf in classifiers.items():
        clf.fit(X, y)
        cv_acc = cross_val_score(clf, X, y, cv=10,
                                  scoring="accuracy").mean()
        print(f"  {name:15s}: 10-fold CV accuracy = {cv_acc:.4f}")

# LDA 와 QDA 가 정말 같은 예측을 하는가?
from sklearn.model_selection import cross_val_predict

np.random.seed(42)
for scenario_name, (X, y) in [
    ("Shared Cov", generate_shared_cov()),
    ("Diff Cov", generate_diff_cov()),
]:
    pl = cross_val_predict(LinearDiscriminantAnalysis(), X, y, cv=10)
    pq = cross_val_predict(QuadraticDiscriminantAnalysis(), X, y, cv=10)
    print(f"\n{scenario_name}: LDA 와 QDA 의 CV 예측이 엇갈린 관측 = "
          f"{int((pl != pq).sum())} / {len(y)}")
    print(f"  LDA 오류 {int((pl != y).sum())}건, "
          f"QDA 오류 {int((pq != y).sum())}건")

--- Shared Cov ---
  LDA            : 10-fold CV accuracy = 0.8825
  QDA            : 10-fold CV accuracy = 0.8825
  Naive Bayes    : 10-fold CV accuracy = 0.8800
  Logistic Reg   : 10-fold CV accuracy = 0.8850

--- Diff Cov ---
  LDA            : 10-fold CV accuracy = 0.8575
  QDA            : 10-fold CV accuracy = 0.8575
  Naive Bayes    : 10-fold CV accuracy = 0.8475
  Logistic Reg   : 10-fold CV accuracy = 0.8600

Shared Cov: LDA 와 QDA 의 CV 예측이 엇갈린 관측 = 0 / 400
  LDA 오류 47건, QDA 오류 47건

Diff Cov: LDA 와 QDA 의 CV 예측이 엇갈린 관측 = 18 / 400
  LDA 오류 57건, QDA 오류 57건

import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap

def plot_decision_boundary(ax, clf, X, y, title):
    """결정경계를 격자로 칠하고 그 위에 자료를 흩뿌린다.

    LDA 는 직선, QDA 는 곡선 경계를 그린다. 나이브 베이즈는 변수 사이의
    상관을 아예 없다고 보므로 축에 나란한 모양이 나온다.
    """
    h = 0.05
    x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
    y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
    xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                          np.arange(y_min, y_max, h))
    Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
    Z = Z.reshape(xx.shape)
    cmap_light = ListedColormap(["#FFAAAA", "#AAAAFF"])
    ax.contourf(xx, yy, Z, alpha=0.3, cmap=cmap_light)
    ax.scatter(X[y == 0, 0], X[y == 0, 1], c="red", s=10,
               edgecolors="none", alpha=0.6, label="Class 0")
    ax.scatter(X[y == 1, 0], X[y == 1, 1], c="blue", s=10,
               edgecolors="none", alpha=0.6, label="Class 1")
    ax.set_title(title, fontsize=10)
    ax.legend(fontsize=7, loc="upper left")

fig, axes = plt.subplots(2, 4, figsize=(18, 9))
scenarios = {
    "Shared Covariance": generate_shared_cov(),
    "Different Covariances": generate_diff_cov(),
}
for row, (scenario_name, (X, y)) in enumerate(scenarios.items()):
    for col, (name, clf) in enumerate(classifiers.items()):
        clf.fit(X, y)
        cv_acc = cross_val_score(clf, X, y, cv=10,
                                  scoring="accuracy").mean()
        plot_decision_boundary(
            axes[row, col], clf, X, y,
            f"{name}\nCV acc = {cv_acc:.3f}")
        if col == 0:
            axes[row, col].set_ylabel(scenario_name, fontsize=11)

plt.suptitle("Generative Classifiers: Decision Boundaries", fontsize=13)
plt.tight_layout()
plt.show()

# 아랫줄 QDA 의 오른쪽 붉은 섬을 수로 확인한다.
X, y = scenarios["Different Covariances"]
qda = QuadraticDiscriminantAnalysis().fit(X, y)
lda = LinearDiscriminantAnalysis().fit(X, y)
xs = np.linspace(1, 6, 2001)
line = np.c_[xs, np.zeros_like(xs)]
for nm, clf in [("LDA", lda), ("QDA", qda)]:
    pr = clf.predict(line)
    flips = np.where(np.diff(pr) != 0)[0]
    print(f"{nm}: y = 0 선을 따라가며 예측이 바뀌는 x = "
          f"{np.round(xs[flips], 3)}")
print(f"자료 중 x1 > 3 인 점 = {int((X[:, 0] > 3).sum())}개,  "
      f"x1 > 2.5 인 점 = {int((X[:, 0] > 2.5).sum())}개")

LDA: y = 0 선을 따라가며 예측이 바뀌는 x = [1.088]
QDA: y = 0 선을 따라가며 예측이 바뀌는 x = [1.358 3.38 ]
자료 중 x1 > 3 인 점 = 1개,  x1 > 2.5 인 점 = 9개

import numpy as np
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis

np.random.seed(42)
cov = [[1.0, 0.5], [0.5, 1.0]]
X0 = np.random.multivariate_normal([0, 0], cov, 200)
X1 = np.random.multivariate_normal([2, 1.5], cov, 200)
X = np.vstack([X0, X1])
y = np.array([0]*200 + [1]*200)

mu0, mu1 = X[y == 0].mean(axis=0), X[y == 1].mean(axis=0)
S0 = np.cov(X[y == 0].T)
S1 = np.cov(X[y == 1].T)
S_pooled = 0.5 * (S0 + S1)
S_inv = np.linalg.inv(S_pooled)

def predict_lda(x):
    d0 = x @ S_inv @ mu0 - 0.5 * mu0 @ S_inv @ mu0
    d1 = x @ S_inv @ mu1 - 0.5 * mu1 @ S_inv @ mu1
    return (d1 > d0).astype(int)

y_manual = predict_lda(X)
lda = LinearDiscriminantAnalysis().fit(X, y)
y_sklearn = lda.predict(X)
agreement = np.mean(y_manual == y_sklearn)
print(f"Agreement with sklearn: {agreement:.4f}")

Agreement with sklearn: 1.0000