분류 모델

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
import warnings
warnings.filterwarnings('ignore')
 
# 재현 가능한 결과를 위한 시드 설정
np.random.seed(42)
 
# 고객 이탈 예측용 샘플 데이터 생성
n_customers = 1000
 
customer_features = pd.DataFrame({
    'user_id': range(1, n_customers + 1),
    'total_orders': np.random.poisson(5, n_customers),
    'total_items': np.random.poisson(15, n_customers),
    'total_spent': np.random.exponential(500, n_customers),
    'avg_order_value': np.random.exponential(100, n_customers),
    'order_span_days': np.random.randint(1, 365, n_customers),
    'unique_categories': np.random.randint(1, 10, n_customers),
    'unique_brands': np.random.randint(1, 20, n_customers),
    'days_since_last_order': np.random.exponential(60, n_customers)
})
 
# 이탈 정의: 90일 이상 구매 없으면 이탈 (+ 랜덤 노이즈)
churn_prob = 1 / (1 + np.exp(-(customer_features['days_since_last_order'] - 90) / 30))
customer_features['churned'] = (np.random.random(n_customers) < churn_prob).astype(int)
 
print(f"전체 고객: {len(customer_features)}")
print(f"이탈 고객: {customer_features['churned'].sum()}")
print(f"이탈률: {customer_features['churned'].mean():.1%}")

# 피처와 타겟 분리
feature_cols = ['total_orders', 'total_items', 'total_spent', 'avg_order_value',
                'order_span_days', 'unique_categories', 'unique_brands']
X = customer_features[feature_cols]
y = customer_features['churned']
 
# 학습/테스트 분리 (80:20)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)
 
print(f"학습 세트: {len(X_train)}건")
print(f"테스트 세트: {len(X_test)}건")
print(f"학습 세트 이탈률: {y_train.mean():.1%}")
print(f"테스트 세트 이탈률: {y_test.mean():.1%}")

# 로지스틱 회귀, SVM 등은 스케일링 필요
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
 
# 트리 기반 모델은 스케일링 불필요
# RandomForest, XGBoost는 원본 사용 가능
print("스케일링 완료!")
print(f"X_train_scaled 평균: {X_train_scaled.mean():.4f}")
print(f"X_train_scaled 표준편차: {X_train_scaled.std():.4f}")

from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report, confusion_matrix
 
# 모델 학습
lr_model = LogisticRegression(random_state=42, max_iter=1000)
lr_model.fit(X_train_scaled, y_train)
 
# 예측
y_pred_lr = lr_model.predict(X_test_scaled)
y_prob_lr = lr_model.predict_proba(X_test_scaled)[:, 1]
 
# 평가
print("=== 로지스틱 회귀 결과 ===")
print(classification_report(y_test, y_pred_lr, target_names=['유지', '이탈']))

import matplotlib.pyplot as plt
 
# 피처별 계수 (영향력)
coef_df = pd.DataFrame({
    'feature': feature_cols,
    'coefficient': lr_model.coef_[0]
})
coef_df['abs_coef'] = coef_df['coefficient'].abs()
coef_df = coef_df.sort_values('abs_coef', ascending=False)
 
print("피처 중요도 (계수):")
print(coef_df.to_string(index=False))
 
# 시각화
plt.figure(figsize=(10, 6))
colors = ['green' if c > 0 else 'red' for c in coef_df['coefficient']]
plt.barh(coef_df['feature'], coef_df['coefficient'], color=colors)
plt.xlabel('계수 (양수: 이탈 증가, 음수: 이탈 감소)')
plt.title('로지스틱 회귀 피처 중요도', fontsize=14, fontweight='bold')
plt.axvline(x=0, color='black', linestyle='-', linewidth=0.5)
plt.tight_layout()
plt.show()

from sklearn.tree import DecisionTreeClassifier, plot_tree
 
# 모델 학습
dt_model = DecisionTreeClassifier(
    max_depth=5,           # 과적합 방지
    min_samples_split=20,  # 최소 분할 샘플 수
    random_state=42
)
dt_model.fit(X_train, y_train)
 
# 예측
y_pred_dt = dt_model.predict(X_test)
y_prob_dt = dt_model.predict_proba(X_test)[:, 1]
 
# 평가
print("=== 결정 트리 결과 ===")
print(classification_report(y_test, y_pred_dt, target_names=['유지', '이탈']))

# 결정 트리 시각화
plt.figure(figsize=(20, 10))
plot_tree(
    dt_model,
    feature_names=feature_cols,
    class_names=['유지', '이탈'],
    filled=True,
    rounded=True,
    fontsize=10,
    max_depth=3  # 시각화를 위해 깊이 제한
)
plt.title('결정 트리 시각화 (깊이 3까지)', fontsize=16, fontweight='bold')
plt.tight_layout()
plt.show()

from sklearn.ensemble import RandomForestClassifier
 
# 모델 학습
rf_model = RandomForestClassifier(
    n_estimators=100,      # 트리 개수
    max_depth=10,          # 최대 깊이
    min_samples_split=10,
    random_state=42,
    n_jobs=-1              # 병렬 처리
)
rf_model.fit(X_train, y_train)
 
# 예측
y_pred_rf = rf_model.predict(X_test)
y_prob_rf = rf_model.predict_proba(X_test)[:, 1]
 
# 평가
print("=== 랜덤 포레스트 결과 ===")
print(classification_report(y_test, y_pred_rf, target_names=['유지', '이탈']))

# 피처 중요도
importance_df = pd.DataFrame({
    'feature': feature_cols,
    'importance': rf_model.feature_importances_
}).sort_values('importance', ascending=False)
 
print("피처 중요도:")
print(importance_df.to_string(index=False))
 
# 시각화
plt.figure(figsize=(10, 6))
plt.barh(importance_df['feature'], importance_df['importance'], color='steelblue')
plt.xlabel('중요도')
plt.title('랜덤 포레스트 피처 중요도', fontsize=14, fontweight='bold')
plt.tight_layout()
plt.show()

from xgboost import XGBClassifier
 
# 모델 학습
xgb_model = XGBClassifier(
    n_estimators=100,
    max_depth=6,
    learning_rate=0.1,
    subsample=0.8,         # 행 샘플링
    colsample_bytree=0.8,  # 열 샘플링
    random_state=42,
    eval_metric='logloss'
)
xgb_model.fit(X_train, y_train)
 
# 예측
y_pred_xgb = xgb_model.predict(X_test)
y_prob_xgb = xgb_model.predict_proba(X_test)[:, 1]
 
# 평가
print("=== XGBoost 결과 ===")
print(classification_report(y_test, y_pred_xgb, target_names=['유지', '이탈']))

from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay
 
# 혼동 행렬 시각화
fig, axes = plt.subplots(1, 3, figsize=(15, 4))
models = [
    ('Logistic Regression', y_pred_lr),
    ('Random Forest', y_pred_rf),
    ('XGBoost', y_pred_xgb)
]
 
for ax, (name, y_pred) in zip(axes, models):
    cm = confusion_matrix(y_test, y_pred)
    disp = ConfusionMatrixDisplay(cm, display_labels=['유지', '이탈'])
    disp.plot(ax=ax, cmap='Blues', values_format='d')
    ax.set_title(name)
 
plt.tight_layout()
plt.show()

from sklearn.metrics import roc_curve, roc_auc_score
 
plt.figure(figsize=(10, 8))
 
# 각 모델의 ROC 곡선
for name, y_prob in [('Logistic Regression', y_prob_lr),
                      ('Random Forest', y_prob_rf),
                      ('XGBoost', y_prob_xgb)]:
    fpr, tpr, _ = roc_curve(y_test, y_prob)
    auc = roc_auc_score(y_test, y_prob)
    plt.plot(fpr, tpr, linewidth=2, label=f'{name} (AUC={auc:.3f})')
 
# 기준선 (랜덤 예측)
plt.plot([0, 1], [0, 1], 'k--', linewidth=1, label='Random (AUC=0.500)')
 
plt.xlabel('False Positive Rate (위양성률)', fontsize=12)
plt.ylabel('True Positive Rate (재현율)', fontsize=12)
plt.title('ROC 곡선 비교', fontsize=14, fontweight='bold')
plt.legend(loc='lower right')
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
 
# 모델별 성능 비교
results = []
for name, y_pred, y_prob in [('Logistic Regression', y_pred_lr, y_prob_lr),
                               ('Random Forest', y_pred_rf, y_prob_rf),
                               ('XGBoost', y_pred_xgb, y_prob_xgb)]:
    results.append({
        '모델': name,
        '정확도': accuracy_score(y_test, y_pred),
        '정밀도': precision_score(y_test, y_pred),
        '재현율': recall_score(y_test, y_pred),
        'F1': f1_score(y_test, y_pred),
        'AUC': roc_auc_score(y_test, y_prob)
    })
 
results_df = pd.DataFrame(results).round(3)
print("=== 모델 성능 비교 ===")
print(results_df.to_string(index=False))

# 방법 1: class_weight 조정
rf_balanced = RandomForestClassifier(
    n_estimators=100,
    class_weight='balanced',  # 소수 클래스에 가중치
    random_state=42
)
rf_balanced.fit(X_train, y_train)
y_pred_balanced = rf_balanced.predict(X_test)
 
print("=== class_weight='balanced' 적용 결과 ===")
print(f"기존 재현율: {recall_score(y_test, y_pred_rf):.3f}")
print(f"균형 재현율: {recall_score(y_test, y_pred_balanced):.3f}")
 
# 방법 2: 임계값 조정
threshold = 0.3  # 기본 0.5에서 낮춤
y_pred_adjusted = (y_prob_xgb >= threshold).astype(int)
 
print(f"\n=== 임계값 조정 (0.5 → 0.3) ===")
print(f"기존 재현율: {recall_score(y_test, y_pred_xgb):.3f}")
print(f"조정 재현율: {recall_score(y_test, y_pred_adjusted):.3f}")
print(f"기존 정밀도: {precision_score(y_test, y_pred_xgb):.3f}")
print(f"조정 정밀도: {precision_score(y_test, y_pred_adjusted):.3f}")