분류: 통계 기초 정리 5장

import numpy as np
import pandas as pd
from sklearn.naive_bayes import GaussianNB, MultinomialNB
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, accuracy_score
from sklearn.datasets import load_iris

# 예시 1: 가우시안 나이브 베이즈 (연속형 특징)
iris = load_iris()
X, y = iris.data, iris.target

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

gnb = GaussianNB()
gnb.fit(X_train, y_train)
y_pred = gnb.predict(X_test)

print("=== 가우시안 나이브 베이즈 (붓꽃 분류) ===")
print(f"정확도: {accuracy_score(y_test, y_pred):.4f}")
print("\n클래스별 사전확률 (P(C)):")
for cls, prior in zip(iris.target_names, gnb.class_prior_):
    print(f"  {cls}: {prior:.3f}")

# 예시 2: 스팸 분류 (나이브 베이즈 직접 구현)
print("\n=== 나이브 베이즈 직접 구현 (스팸 분류) ===")
# 단어 빈도 데이터 (단순화)
np.random.seed(42)
spam_words = np.random.poisson([5, 2, 8, 1], size=(200, 4))   # 스팸에 자주 나오는 단어
ham_words  = np.random.poisson([1, 5, 1, 6], size=(200, 4))   # 정상 메일

X_spam = np.vstack([spam_words, ham_words])
y_spam = np.array([1] * 200 + [0] * 200)

X_tr, X_te, y_tr, y_te = train_test_split(X_spam, y_spam, test_size=0.3, random_state=42)

mnb = MultinomialNB()
mnb.fit(X_tr, y_tr)
print(f"정확도: {mnb.score(X_te, y_te):.4f}")
print("\n로그 우도 (단어별 클래스 연관성):")
words = ['무료', '안녕', '당첨', '회의']
for w, log_ham, log_spam in zip(words, mnb.feature_log_prob_[0], mnb.feature_log_prob_[1]):
    print(f"  '{w}': 정상={np.exp(log_ham):.3f}, 스팸={np.exp(log_spam):.3f}")

import numpy as np
import matplotlib.pyplot as plt
import matplotlib
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis, QuadraticDiscriminantAnalysis
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

matplotlib.rcParams['font.family'] = 'AppleGothic'
matplotlib.rcParams['axes.unicode_minus'] = False

iris = load_iris()
X, y = iris.data, iris.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# LDA
lda = LinearDiscriminantAnalysis()
lda.fit(X_train, y_train)
print(f"LDA 정확도: {accuracy_score(y_test, lda.predict(X_test)):.4f}")

# QDA (클래스마다 공분산 행렬이 다를 때)
qda = QuadraticDiscriminantAnalysis()
qda.fit(X_train, y_train)
print(f"QDA 정확도: {accuracy_score(y_test, qda.predict(X_test)):.4f}")

# LDA로 차원 축소 후 시각화 (4차원 → 2차원)
lda_2d = LinearDiscriminantAnalysis(n_components=2)
X_lda = lda_2d.fit_transform(X, y)

plt.figure(figsize=(8, 5))
colors = ['red', 'green', 'blue']
for cls, color, name in zip([0, 1, 2], colors, iris.target_names):
    mask = y == cls
    plt.scatter(X_lda[mask, 0], X_lda[mask, 1], c=color, label=name, alpha=0.7)

plt.xlabel('LD1 (판별축 1)')
plt.ylabel('LD2 (판별축 2)')
plt.title('LDA 판별 공간 시각화 (4차원 → 2차원)')
plt.legend()
plt.grid(alpha=0.3)
plt.show()

print("\n=== LDA vs QDA 비교 ===")
print("LDA: 클래스 간 공분산 동일 가정 → 선형 결정 경계")
print("QDA: 클래스마다 공분산 다름 허용 → 이차 결정 경계 (더 유연, 과대적합 위험)")

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib
import statsmodels.api as sm
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report

matplotlib.rcParams['font.family'] = 'AppleGothic'
matplotlib.rcParams['axes.unicode_minus'] = False
np.random.seed(42)

# 예시: 신용 위험 분류 (대출 상환 여부)
n = 500
income = np.random.normal(4000, 1500, n)       # 월소득 (만원)
debt_ratio = np.random.uniform(0.1, 0.9, n)    # 부채비율
credit_score = np.random.normal(700, 80, n)    # 신용점수

log_odds = (-5 + 0.001 * income - 2 * debt_ratio + 0.005 * credit_score
            + np.random.normal(0, 0.5, n))
prob = 1 / (1 + np.exp(-log_odds))
default = (np.random.random(n) < (1 - prob)).astype(int)  # 1=상환 실패

df = pd.DataFrame({'부도': default, '소득': income, '부채비율': debt_ratio, '신용점수': credit_score})

# statsmodels로 로지스틱 회귀
X = sm.add_constant(df[['소득', '부채비율', '신용점수']])
logit_model = sm.Logit(df['부도'], X).fit(disp=False)

print("=== 로지스틱 회귀 계수 ===")
print(logit_model.params.round(4))

print("\n=== 오즈비 (Odds Ratio) 해석 ===")
odds_ratios = np.exp(logit_model.params)
for name, OR in odds_ratios.items():
    print(f"  {name}: OR={OR:.4f} → 1단위 증가 시 부도 오즈 {(OR-1)*100:+.1f}%")

# sigmoid 함수 시각화
z = np.linspace(-6, 6, 300)
sigma = 1 / (1 + np.exp(-z))

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))

ax1.plot(z, sigma, 'b-', linewidth=2)
ax1.axhline(0.5, color='red', linestyle='--', alpha=0.7, label='p=0.5 (결정 경계)')
ax1.axvline(0, color='gray', linestyle='--', alpha=0.7)
ax1.set_xlabel('선형 예측값 z')
ax1.set_ylabel('확률 p')
ax1.set_title('Sigmoid 함수 (로지스틱 반응 함수)')
ax1.legend()
ax1.grid(alpha=0.3)

# 예측 확률 분포
from sklearn.linear_model import LogisticRegression
lr = LogisticRegression(max_iter=1000, random_state=42)
lr.fit(df[['소득', '부채비율', '신용점수']], df['부도'])
probs = lr.predict_proba(df[['소득', '부채비율', '신용점수']])[:, 1]

ax2.hist(probs[df['부도'] == 0], bins=30, alpha=0.6, label='정상 상환', color='blue')
ax2.hist(probs[df['부도'] == 1], bins=30, alpha=0.6, label='부도', color='red')
ax2.axvline(0.5, color='black', linestyle='--', label='임계값 0.5')
ax2.set_xlabel('예측 부도 확률')
ax2.set_ylabel('빈도')
ax2.set_title('클래스별 예측 확률 분포')
ax2.legend()

plt.tight_layout()
plt.show()

import numpy as np
import matplotlib.pyplot as plt
import matplotlib
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import (confusion_matrix, classification_report,
                              roc_curve, auc, ConfusionMatrixDisplay)

matplotlib.rcParams['font.family'] = 'AppleGothic'
matplotlib.rcParams['axes.unicode_minus'] = False
np.random.seed(42)

X, y = make_classification(n_samples=1000, n_features=10, n_informative=5,
                            weights=[0.7, 0.3], random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

lr = LogisticRegression(max_iter=500, random_state=42)
lr.fit(X_train, y_train)
y_pred = lr.predict(X_test)
y_prob = lr.predict_proba(X_test)[:, 1]

print("=== 분류 성능 지표 ===")
print(classification_report(y_test, y_pred, target_names=['음성', '양성']))

# 혼동행렬 시각화
fig, axes = plt.subplots(1, 3, figsize=(15, 4))

# 1. 혼동행렬
cm = confusion_matrix(y_test, y_pred)
disp = ConfusionMatrixDisplay(cm, display_labels=['음성', '양성'])
disp.plot(ax=axes[0], colorbar=False, cmap='Blues')
axes[0].set_title('혼동행렬')

# 2. ROC 곡선
fpr, tpr, thresholds = roc_curve(y_test, y_prob)
roc_auc = auc(fpr, tpr)
axes[1].plot(fpr, tpr, 'b-', linewidth=2, label=f'AUC = {roc_auc:.4f}')
axes[1].plot([0, 1], [0, 1], 'k--', label='랜덤 분류기')
axes[1].set_xlabel('1 - 특이도 (FPR)')
axes[1].set_ylabel('민감도 (TPR)')
axes[1].set_title('ROC 곡선')
axes[1].legend()
axes[1].grid(alpha=0.3)

# 3. 리프트 차트
sorted_idx = np.argsort(-y_prob)
y_sorted = y_test[sorted_idx]
n_pos = y_test.sum()

lifts = []
proportions = np.linspace(0.01, 1, 100)
for p in proportions:
    n = int(p * len(y_test))
    pos_in_top_n = y_sorted[:n].sum()
    lift = (pos_in_top_n / n) / (n_pos / len(y_test))
    lifts.append(lift)

axes[2].plot(proportions * 100, lifts, 'b-', linewidth=2)
axes[2].axhline(1, color='red', linestyle='--', label='랜덤 기준선 (Lift=1)')
axes[2].set_xlabel('상위 예측 비율 (%)')
axes[2].set_ylabel('Lift')
axes[2].set_title('리프트 차트')
axes[2].legend()
axes[2].grid(alpha=0.3)

plt.tight_layout()
plt.show()

print(f"\nAUC = {roc_auc:.4f}")
print(f"상위 10% 대상 Lift = {lifts[9]:.2f}배 (랜덤 대비)")

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib
from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, roc_auc_score
from sklearn.preprocessing import StandardScaler
from imblearn.over_sampling import SMOTE
from imblearn.under_sampling import RandomUnderSampler

matplotlib.rcParams['font.family'] = 'AppleGothic'
matplotlib.rcParams['axes.unicode_minus'] = False
np.random.seed(42)

# 불균형 데이터 생성 (95% 음성, 5% 양성)
X, y = make_classification(n_samples=2000, n_features=10, n_informative=5,
                            weights=[0.95, 0.05], random_state=42)
print(f"클래스 분포: 음성={sum(y==0)}, 양성={sum(y==1)} ({sum(y==1)/len(y)*100:.1f}%)")

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3,
                                                     stratify=y, random_state=42)

scaler = StandardScaler()
X_train_sc = scaler.fit_transform(X_train)
X_test_sc = scaler.transform(X_test)

def evaluate(name, X_tr, y_tr, X_te=X_test_sc, y_te=y_test, **kwargs):
    lr = LogisticRegression(max_iter=1000, random_state=42, **kwargs)
    lr.fit(X_tr, y_tr)
    y_pred = lr.predict(X_te)
    y_prob = lr.predict_proba(X_te)[:, 1]
    report = classification_report(y_te, y_pred, output_dict=True)
    auc = roc_auc_score(y_te, y_prob)
    print(f"\n[{name}]")
    print(f"  양성 재현율: {report['1']['recall']:.3f} | 정밀도: {report['1']['precision']:.3f} | AUC: {auc:.3f}")

# 1. 기준: 불균형 그대로
evaluate("기준 (불균형)", X_train_sc, y_train)

# 2. 클래스 가중치 조정
evaluate("클래스 가중치", X_train_sc, y_train, class_weight='balanced')

# 3. 과소표본
rus = RandomUnderSampler(random_state=42)
X_under, y_under = rus.fit_resample(X_train_sc, y_train)
print(f"\n과소표본 후: 음성={sum(y_under==0)}, 양성={sum(y_under==1)}")
evaluate("과소표본", X_under, y_under)

# 4. SMOTE (과잉표본)
smote = SMOTE(random_state=42)
X_smote, y_smote = smote.fit_resample(X_train_sc, y_train)
print(f"SMOTE 후: 음성={sum(y_smote==0)}, 양성={sum(y_smote==1)}")
evaluate("SMOTE", X_smote, y_smote)

# 5. 임계값 조정 (0.5 → 0.3)
lr_base = LogisticRegression(max_iter=1000, random_state=42)
lr_base.fit(X_train_sc, y_train)
y_prob = lr_base.predict_proba(X_test_sc)[:, 1]
y_pred_low_thresh = (y_prob >= 0.3).astype(int)

report = classification_report(y_test, y_pred_low_thresh, output_dict=True)
print(f"\n[임계값 0.3 조정]")
print(f"  양성 재현율: {report['1']['recall']:.3f} | 정밀도: {report['1']['precision']:.3f}")

# 임계값에 따른 정밀도-재현율 트레이드오프
from sklearn.metrics import precision_recall_curve
precision, recall, thresh = precision_recall_curve(y_test, y_prob)

plt.figure(figsize=(8, 4))
plt.plot(recall, precision, 'b-', linewidth=2)
plt.xlabel('재현율 (Recall)')
plt.ylabel('정밀도 (Precision)')
plt.title('정밀도-재현율 트레이드오프 (임계값 조정 효과)')
plt.grid(alpha=0.3)
plt.show()