피처 선택(Feature Selection): 필터, 래퍼, 임베디드 방법 비교

피처 선택의 이점:
[1] 과적합 방지 → 분산 감소, 일반화 성능 향상
[2] 학습 속도  → 피처 수 감소 → 연산량 감소
[3] 해석력    → 핵심 피처만 남기면 모델 설명 가능

from sklearn.feature_selection import VarianceThreshold

# 분산이 0.01 미만인 피처 제거
selector = VarianceThreshold(threshold=0.01)
X_filtered = selector.fit_transform(X)

print(f"원래 피처 수: {X.shape[1]}")
print(f"필터 후 피처 수: {X_filtered.shape[1]}")

import pandas as pd
import numpy as np

# 상관 행렬 계산
corr_matrix = X.corr().abs()

# 상삼각 행렬 추출 (대각선 아래는 중복이므로)
upper = corr_matrix.where(
    np.triu(np.ones(corr_matrix.shape), k=1).astype(bool)
)

# 상관계수 0.95 이상인 피처 찾기
to_drop = [col for col in upper.columns if any(upper[col] > 0.95)]
X_filtered = X.drop(columns=to_drop)

print(f"제거된 피처: {to_drop}")

from sklearn.feature_selection import mutual_info_classif
from sklearn.feature_selection import SelectKBest

# 상호 정보량 기반으로 상위 10개 피처 선택
selector = SelectKBest(score_func=mutual_info_classif, k=10)
X_selected = selector.fit_transform(X, y)

# 각 피처의 MI 점수 확인
mi_scores = mutual_info_classif(X, y, random_state=42)
feature_ranking = pd.Series(mi_scores, index=X.columns).sort_values(ascending=False)
print(feature_ranking)

[시작] 피처 없음
[1단계] 피처 하나씩 넣어보고 가장 좋은 것 선택 → {A}
[2단계] 남은 피처를 하나씩 추가해보고 가장 좋은 것 선택 → {A, D}
[3단계] ... → {A, D, B}
[중단] 성능이 더 이상 개선되지 않으면 중단

[시작] 전체 피처 {A, B, C, D, E}
[1단계] 하나씩 빼보고 가장 영향 없는 것 제거 → {A, B, D, E}
[2단계] ... → {A, D, E}
[중단] 제거하면 성능이 크게 떨어지면 중단

from sklearn.feature_selection import RFE
from sklearn.ensemble import RandomForestClassifier

model = RandomForestClassifier(n_estimators=100, random_state=42)

# 상위 10개 피처 선택
rfe = RFE(estimator=model, n_features_to_select=10, step=1)
rfe.fit(X, y)

# 선택된 피처 확인
selected = X.columns[rfe.support_]
print(f"선택된 피처: {list(selected)}")
print(f"피처 순위: {rfe.ranking_}")

from sklearn.feature_selection import RFECV
from sklearn.model_selection import StratifiedKFold

rfecv = RFECV(
    estimator=model,
    step=1,
    cv=StratifiedKFold(5),
    scoring='accuracy',
    min_features_to_select=5
)
rfecv.fit(X, y)

print(f"최적 피처 수: {rfecv.n_features_}")
print(f"선택된 피처: {list(X.columns[rfecv.support_])}")

from sklearn.linear_model import LassoCV
import numpy as np

# 최적의 alpha를 자동 탐색
lasso = LassoCV(cv=5, random_state=42)
lasso.fit(X, y)

# 가중치가 0이 아닌 피처만 선택
selected_features = X.columns[lasso.coef_ != 0]
eliminated_features = X.columns[lasso.coef_ == 0]

print(f"선택된 피처 ({len(selected_features)}개): {list(selected_features)}")
print(f"제거된 피처 ({len(eliminated_features)}개): {list(eliminated_features)}")

from sklearn.linear_model import LogisticRegression
from sklearn.feature_selection import SelectFromModel

lr_l1 = LogisticRegression(penalty='l1', C=1.0, solver='liblinear', random_state=42)
lr_l1.fit(X, y)

# L1 정규화로 선택된 피처
selector = SelectFromModel(lr_l1, prefit=True)
X_selected = selector.transform(X)

selected_mask = selector.get_support()
print(f"선택된 피처: {list(X.columns[selected_mask])}")

from sklearn.ensemble import RandomForestClassifier
import matplotlib.pyplot as plt

rf = RandomForestClassifier(n_estimators=200, random_state=42)
rf.fit(X, y)

# 피처 중요도 추출
importances = pd.Series(rf.feature_importances_, index=X.columns)
importances = importances.sort_values(ascending=False)

# 상위 15개 피처 시각화
importances[:15].plot(kind='barh', figsize=(8, 6))
plt.title('Random Forest Feature Importance (Top 15)')
plt.xlabel('Importance')
plt.tight_layout()
plt.show()

# XGBoost도 동일한 인터페이스
from xgboost import XGBClassifier

xgb = XGBClassifier(n_estimators=200, random_state=42)
xgb.fit(X, y)

# 피처 중요도 (gain 기준)
importances_xgb = pd.Series(
    xgb.feature_importances_, index=X.columns
).sort_values(ascending=False)

from sklearn.inspection import permutation_importance
from sklearn.model_selection import train_test_split

X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=42)

model = RandomForestClassifier(n_estimators=200, random_state=42)
model.fit(X_train, y_train)

# 순열 중요도 계산 (검증 세트 기준)
perm_imp = permutation_importance(
    model, X_val, y_val,
    n_repeats=10,
    random_state=42,
    scoring='accuracy'
)

# 결과 정리
perm_imp_df = pd.DataFrame({
    'feature': X.columns,
    'importance_mean': perm_imp.importances_mean,
    'importance_std': perm_imp.importances_std
}).sort_values('importance_mean', ascending=False)

print(perm_imp_df.head(15))

[1단계] Filter로 빠르게 걸러내기
   └→ 분산 0 피처 제거, 상관 0.95 이상 중복 제거
   └→ 1000개 → 200개

[2단계] Embedded로 중요도 기반 선택
   └→ 트리 모델의 feature_importances_ 기준
   └→ 200개 → 50개

[3단계] 필요하면 Wrapper로 미세 조정
   └→ RFECV로 최적 피처 수 탐색
   └→ 50개 → 25개

import shap

model = XGBClassifier(n_estimators=200, random_state=42)
model.fit(X_train, y_train)

# SHAP 값 계산
explainer = shap.TreeExplainer(model)
shap_values = explainer.shap_values(X_val)

# 전체 피처 중요도 (요약 플롯)
shap.summary_plot(shap_values, X_val)

# 글로벌: 전체 데이터에서 각 피처의 평균 SHAP 값
shap.summary_plot(shap_values, X_val, plot_type="bar")

# 로컬: 개별 예측 하나에 대한 설명
shap.force_plot(
    explainer.expected_value,
    shap_values[0],      # 첫 번째 샘플
    X_val.iloc[0]
)

# 평균 |SHAP| 값으로 피처 순위 매기기
shap_importance = np.abs(shap_values).mean(axis=0)
shap_ranking = pd.Series(shap_importance, index=X.columns).sort_values(ascending=False)

# 상위 N개 피처 선택
top_n = 20
selected_features = shap_ranking.head(top_n).index.tolist()

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.feature_selection import (
    VarianceThreshold, SelectKBest, mutual_info_classif, RFECV
)
from sklearn.ensemble import RandomForestClassifier
from sklearn.pipeline import Pipeline
from sklearn.metrics import classification_report

# --- 데이터 준비 ---
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

print(f"원본 피처 수: {X_train.shape[1]}")

# --- 1단계: Filter — 분산 0인 피처 제거 ---
var_selector = VarianceThreshold(threshold=0.0)
X_train_v = var_selector.fit_transform(X_train)
print(f"분산 필터 후: {X_train_v.shape[1]}")

# --- 2단계: Filter — 상관관계 높은 피처 제거 ---
X_train_df = pd.DataFrame(
    X_train_v, columns=X_train.columns[var_selector.get_support()]
)
corr_matrix = X_train_df.corr().abs()
upper = corr_matrix.where(np.triu(np.ones(corr_matrix.shape), k=1).astype(bool))
to_drop = [col for col in upper.columns if any(upper[col] > 0.95)]
X_train_df = X_train_df.drop(columns=to_drop)
print(f"상관관계 필터 후: {X_train_df.shape[1]}")

# --- 3단계: Embedded — RFECV로 최적 피처 수 탐색 ---
rf = RandomForestClassifier(n_estimators=100, random_state=42)
rfecv = RFECV(
    estimator=rf,
    step=1,
    cv=5,
    scoring='accuracy',
    min_features_to_select=5
)
rfecv.fit(X_train_df, y_train)

selected_features = X_train_df.columns[rfecv.support_]
print(f"RFECV 선택 피처 수: {len(selected_features)}")
print(f"선택된 피처: {list(selected_features)}")

# --- 4단계: 최종 모델 학습 및 평가 ---
X_train_final = X_train_df[selected_features]

# 테스트 세트에도 동일한 변환 적용
X_test_v = var_selector.transform(X_test)
X_test_df = pd.DataFrame(
    X_test_v, columns=X_train.columns[var_selector.get_support()]
)
X_test_df = X_test_df.drop(columns=to_drop)
X_test_final = X_test_df[selected_features]

# 최종 모델 학습
final_model = RandomForestClassifier(n_estimators=200, random_state=42)
final_model.fit(X_train_final, y_train)

# 평가
y_pred = final_model.predict(X_test_final)
print(classification_report(y_test, y_pred))

# Pipeline으로 깔끔하게 묶기
pipeline = Pipeline([
    ('variance', VarianceThreshold(threshold=0.0)),
    ('scaler', StandardScaler()),
    ('selector', SelectKBest(score_func=mutual_info_classif, k=20)),
    ('classifier', RandomForestClassifier(n_estimators=200, random_state=42))
])

# 교차 검증 (피처 선택이 각 fold 안에서 수행됨)
scores = cross_val_score(pipeline, X, y, cv=5, scoring='accuracy')
print(f"CV 정확도: {scores.mean():.4f} (+/- {scores.std():.4f})")

피처 선택 의사결정:

피처 수가 100개 이상?
├── Yes → 피처 선택 권장 (Filter + Embedded)
└── No
    ├── 데이터가 충분한가?
    │   ├── Yes → 선택 안 해도 됨 (트리 모델이면 특히)
    │   └── No → Filter 또는 L1 정규화만 적용
    └── 해석력이 중요한가?
        ├── Yes → 피처 선택 권장 (SHAP 활용)
        └── No → 모델에 맡기기