피처 선택(Feature Selection)

특성(feature)이 많다고 더 좋은 것은 아닙니다. 올바른 특성이 더 좋은 것입니다.

유형: Build 언어: Python 선수 지식: Phase 2, Lessons 01-09, 08 (특성 엔지니어링(feature engineering)) 소요 시간: 약 75분

학습 목표

• 필터 방법(filter methods: 분산 임계값(variance threshold), 상호정보량(mutual information), 카이제곱(chi-squared))과 래퍼 방법(wrapper methods: 재귀적 특성 제거(RFE), 전진 선택(forward selection))을 처음부터 구현합니다.
• 상호정보량(mutual information)이 상관관계(correlation)가 놓치는 비선형 특성-타깃 관계(nonlinear feature-target relationship)를 포착하는 이유를 설명합니다.
• L1 정규화(L1 regularization, 내장 선택(embedded selection))와 재귀적 특성 제거(RFE, 래퍼 선택(wrapper selection))를 비교하고 계산 비용의 절충(computational tradeoff)을 평가합니다.
• 여러 방법을 결합한 피처 선택 파이프라인(feature selection pipeline)을 만들고 홀드아웃 데이터(held-out data)에서 일반화(generalization) 성능이 좋아지는지 보입니다.

문제

특성(feature)이 500개 있습니다. 모델(model)은 느리게 학습되고, 계속 과적합(overfit)하며, 무엇을 배웠는지 설명하기 어렵습니다. 성능을 올리려고 특성을 더 추가했는데 오히려 더 나빠졌습니다.

이것이 차원의 저주(curse of dimensionality)입니다. 특성 수가 늘어나면 특성 공간(feature space)의 부피(volume)가 폭발적으로 커집니다. 데이터 포인트(data point)는 희소(sparse)해지고, 포인트 사이 거리(distance)는 서로 비슷해지며, 모델은 실제 패턴(real pattern)을 찾기 위해 훨씬 더 많은 데이터를 필요로 합니다. 잡음 특성(noise feature)이 신호 특성(signal feature)을 덮어버리고, 과적합(overfitting)이 기본값이 됩니다.

피처 선택(feature selection)은 해독제입니다. 잡음을 걷어내고, 중복성(redundancy)을 줄이고, 타깃(target)에 대한 실제 정보를 가진 특성만 남깁니다. 그 결과 학습(training)이 더 빨라지고, 일반화(generalization) 성능이 좋아지며, 설명 가능한 모델을 얻을 수 있습니다.

목표는 가능한 모든 정보를 쓰는 것이 아닙니다. 올바른 정보를 쓰는 것입니다.

개념

피처 선택의 세 범주

모든 피처 선택 방법은 다음 세 범주 중 하나에 속합니다.

flowchart TD
    A[피처 선택 방법] --> B[필터 방법(Filter Methods)]
    A --> C[래퍼 방법(Wrapper Methods)]
    A --> D[내장 방법(Embedded Methods)]

    B --> B1["분산 임계값(Variance Threshold)"]
    B --> B2["상호정보량(Mutual Information)"]
    B --> B3["카이제곱 검정(Chi-squared Test)"]
    B --> B4["상관관계 필터링(Correlation Filtering)"]

    C --> C1["재귀적 특성 제거(RFE)"]
    C --> C2["전진 선택(Forward Selection)"]
    C --> C3["후진 제거(Backward Elimination)"]

    D --> D1["L1 / Lasso 정규화"]
    D --> D2["트리 기반 중요도(Tree-based Importance)"]
    D --> D3["엘라스틱넷(Elastic Net)"]

필터 방법(filter method)은 통계적 척도(statistical measure)로 각 특성을 독립적으로 점수화(score)합니다. 모델을 사용하지 않으므로 빠르지만 특성 상호작용(feature interaction)을 놓칩니다.

래퍼 방법(wrapper method)은 특성 부분집합(feature subset)을 평가하기 위해 모델을 학습합니다. 모델 성능(model performance)을 점수로 사용합니다. 결과는 좋을 수 있지만 모델을 여러 번 다시 학습하므로 비용이 큽니다.

내장 방법(embedded method)은 모델 학습 과정 안에서 특성을 선택합니다. L1 정규화(L1 regularization)는 가중치(weight)를 0으로 밀어냅니다. 의사결정 트리(decision tree)는 가장 유용한 특성으로 분할(split)합니다.

분산 임계값(Variance Threshold)

가장 단순한 필터입니다. 샘플(sample) 사이에서 거의 변하지 않는 특성은 정보가 거의 없습니다. 1000개 샘플 중 999개가 0.0인 특성은 분산(variance)이 거의 0이고, 어떤 모델도 그것으로 클래스(class)를 잘 구분하기 어렵기 때문에 제거합니다.

variance(x) = mean((x - mean(x))^2)

임계값(threshold)을 정하고, 예를 들어 분산이 0.01보다 낮은 특성을 제거합니다. 타깃 변수(target variable)를 보지 않고도 상수(constant) 또는 거의 상수인 특성(near-constant feature)을 거의 비용 없이 제거할 수 있습니다.

사용 시점은 다른 방법 전에 전처리(preprocessing) 단계로 적용하는 것입니다. 거의 0의 비용으로 명백히 쓸모없는 특성을 잡아냅니다. 제한도 있습니다. 분산이 높아도 순수 잡음(noise)일 수 있습니다. 분산 임계값은 필요하지만 충분하지는 않습니다.

상호정보량(Mutual Information)

상호정보량은 특성 X의 값을 알면 타깃 Y에 대한 불확실성(uncertainty)이 얼마나 줄어드는지 측정합니다.

I(X; Y) = sum_x sum_y p(x, y) * log(p(x, y) / (p(x) * p(y)))

X와 Y가 독립(independent)이라면 p(x, y) = p(x) * p(y)이므로 로그 항(log term)이 0이고 I(X; Y)=0이 됩니다. X가 Y에 대해 더 많이 알려줄수록 상호정보량은 커집니다.

상관관계(correlation)보다 중요한 장점은 비선형 관계(nonlinear relationship)를 잡아낸다는 점입니다. 타깃과의 상관관계가 0이라도 2차(quadratic) 또는 주기적(periodic) 관계 때문에 상호정보량은 높을 수 있습니다.

연속형 특성(continuous feature)에서는 먼저 구간(bin)으로 이산화(discretize)합니다. 구간 수는 추정값(estimate)에 영향을 줍니다. 너무 적으면 정보를 잃고, 너무 많으면 잡음이 늘어납니다. 흔한 선택은 sqrt(n) 구간이나 스터지스 규칙(Sturges' rule; 1 + log2(n))입니다.

재귀적 특성 제거(Recursive Feature Elimination; RFE)

재귀적 특성 제거는 래퍼 방법입니다. 모델의 특성 중요도(feature importance)를 사용해 반복적으로 제거(prune)합니다.

1. 모든 특성으로 모델을 학습합니다.
2. 특성 중요도를 순위화(rank)합니다. 선형 모델(linear model)에서는 계수(coefficient), 트리(tree)에서는 불순도 감소(impurity reduction)를 사용합니다.
3. 가장 덜 중요한 특성을 제거합니다.
4. 원하는 특성 수가 남을 때까지 반복합니다.

flowchart TD
    A["시작: 모든 N개 특성"] --> B["모델 학습"]
    B --> C["특성 중요도 순위화"]
    C --> D["가장 덜 중요한 특성 제거"]
    D --> E{"특성 수 == 목표 개수?"}
    E -->|아니오| B
    E -->|예| F["선택된 특성 반환"]

재귀적 특성 제거는 모델이 남은 특성들을 함께 보기 때문에 특성 상호작용을 고려합니다. 어떤 특성을 제거하면 다른 특성의 중요도가 바뀔 수 있습니다. 대신 비용이 큽니다. 특성 500개에서 10개만 남기려면 490번을 학습해야 할 수도 있습니다.

L1(Lasso) 정규화

L1 정규화는 손실 함수(loss function)에 가중치 절댓값(absolute value)의 합을 더합니다.

loss = prediction_error + alpha * sum(|w_i|)

alpha가 클수록 더 많은 가중치가 정확히 0이 됩니다. L1 벌점(penalty)의 제약 영역(constraint region)이 다이아몬드 모양(diamond shape)이기 때문에 최적해가 모서리(corner), 즉 가중치가 0인 지점에 놓이기 쉽습니다. L2 능형(ridge)은 원형(circular) 제약이라 가중치가 작아지긴 하지만 정확히 0이 되기는 어렵습니다.

이것은 내장(embedded) 피처 선택입니다. 모델이 학습 중에 무시(ignore)할 특성을 학습합니다. 가중치가 0인 특성은 사실상 제거된 것과 같습니다.

장점은 한 번의 학습으로 끝나고, 상관된 특성(correlated feature) 중 하나를 고르고 나머지를 0으로 만들 수 있다는 점입니다. 제한은 선형 모델 중심이며 비선형 특성 중요도를 잡지 못한다는 점입니다.

트리 기반 특성 중요도(Tree-based Feature Importance)

의사결정 트리(decision tree)와 그 앙상블(ensemble; 랜덤 포레스트(random forest), 그래디언트 부스팅(gradient boosting))은 특성을 자연스럽게 순위화합니다. 모든 분할(split)은 불순도(impurity)를 줄이며, 더 큰 불순도 감소를 만든 특성이 더 중요합니다.

importance(feature_j) = (1/T) * sum over all trees of
    sum over all nodes splitting on feature_j of
        (n_samples * impurity_decrease)

비선형 관계와 특성 상호작용을 자동으로 다룹니다. 다만 고유값(unique value)이 많은 고-카디널리티 특성(high-cardinality feature)에 편향될 수 있습니다. 무작위 ID 컬럼(random ID column)도 샘플을 잘게 나누기 때문에 중요해 보일 수 있습니다. 순열 중요도(permutation importance)로 정합성 검사(sanity check)를 합니다.

순열 중요도(Permutation Importance)

모델 무관(model-agnostic) 방법입니다.

1. 모델을 학습하고 검증 데이터(validation data)에서 기준 성능(baseline performance)을 기록합니다.
2. 특성 하나씩 값을 무작위로 섞고(shuffle) 성능 저하(performance drop)를 측정합니다.
3. 저하가 클수록 중요한 특성입니다.

특성을 섞어도 성능이 줄지 않으면 모델은 그 특성에 의존하지 않습니다. 성능이 크게 무너지면 그 특성은 핵심적인(critical) 특성입니다. 트리 중요도의 카디널리티 편향(cardinality bias)을 피할 수 있지만, 특성마다 전체 평가(full evaluation)를 반복해야 하므로 느립니다.

비교

의사결정 흐름도(Decision Flowchart)

flowchart TD
    A[시작: 피처 선택] --> B{특성 수는?}
    B -->|"< 50"| C["분산 임계값 + 상호정보량부터"]
    B -->|"50-500"| D["분산 임계값 후 L1 또는 트리 중요도"]
    B -->|"> 500"| E["분산 임계값 -> 상호정보량 필터 -> 남은 특성에 RFE"]

    C --> F{선형 모델 사용?}
    D --> F
    E --> F

    F -->|예| G["최종 선택에 L1 정규화"]
    F -->|아니오 - 트리| H["트리 중요도 + 순열 중요도"]
    F -->|아니오 - 그 외| I["사용 모델로 RFE"]

    G --> J[선택된 특성 대 전체 특성 비교]
    H --> J
    I --> J

    J --> K{성능 개선?}
    K -->|예| L["선택된 특성으로 배포"]
    K -->|아니오| M["다른 방법 시도 또는 모든 특성 유지"]

만들어보기

Step 1: 알려진 특성 구조를 가진 합성 데이터(synthetic data) 생성

import numpy as np


def make_feature_selection_data(n_samples=500, seed=42):
    rng = np.random.RandomState(seed)

    x1 = rng.randn(n_samples)
    x2 = rng.randn(n_samples)
    x3 = rng.randn(n_samples)
    x4 = x1 + 0.1 * rng.randn(n_samples)
    x5 = x2 + 0.1 * rng.randn(n_samples)

    informative = np.column_stack([x1, x2, x3, x4, x5])

    correlated = np.column_stack([
        x1 * 0.9 + 0.1 * rng.randn(n_samples),
        x2 * 0.8 + 0.2 * rng.randn(n_samples),
        x3 * 0.7 + 0.3 * rng.randn(n_samples),
        x1 * 0.5 + x2 * 0.5 + 0.1 * rng.randn(n_samples),
        x2 * 0.6 + x3 * 0.4 + 0.1 * rng.randn(n_samples),
    ])

    noise = rng.randn(n_samples, 10) * 0.5

    X = np.hstack([informative, correlated, noise])
    y = (2 * x1 - 1.5 * x2 + x3 + 0.5 * rng.randn(n_samples) > 0).astype(int)

    feature_names = (
        [f"info_{i}" for i in range(5)]
        + [f"corr_{i}" for i in range(5)]
        + [f"noise_{i}" for i in range(10)]
    )

    return X, y, feature_names

우리는 정답(ground truth)을 알고 있습니다. 특성 0-4는 정보가 있는(informative) 특성입니다. 그중 3과 4는 0과 1의 상관 복사본(correlated copy)입니다. 특성 5-9는 정보 특성과 상관되어 있고, 특성 10-19는 순수 잡음(pure noise)입니다. 좋은 선택 방법은 0-4를 높게, 10-19를 낮게 순위화해야 합니다.

Step 2: 분산 임계값(Variance threshold)

def variance_threshold(X, threshold=0.01):
    variances = np.var(X, axis=0)
    mask = variances > threshold
    return mask, variances

Step 3: 상호정보량(Mutual information)

def discretize(x, n_bins=10):
    min_val, max_val = x.min(), x.max()
    if max_val == min_val:
        return np.zeros_like(x, dtype=int)
    bin_edges = np.linspace(min_val, max_val, n_bins + 1)
    binned = np.digitize(x, bin_edges[1:-1])
    return binned


def mutual_information(X, y, n_bins=10):
    n_samples, n_features = X.shape
    mi_scores = np.zeros(n_features)

    y_vals, y_counts = np.unique(y, return_counts=True)
    p_y = y_counts / n_samples

    for f in range(n_features):
        x_binned = discretize(X[:, f], n_bins)
        x_vals, x_counts = np.unique(x_binned, return_counts=True)
        p_x = dict(zip(x_vals, x_counts / n_samples))

        mi = 0.0
        for xv in x_vals:
            for yi, yv in enumerate(y_vals):
                joint_mask = (x_binned == xv) & (y == yv)
                p_xy = np.sum(joint_mask) / n_samples
                if p_xy > 0:
                    mi += p_xy * np.log(p_xy / (p_x[xv] * p_y[yi]))
        mi_scores[f] = mi

    return mi_scores

Step 4: 재귀적 특성 제거(Recursive Feature Elimination)

def rfe(X, y, n_features_to_select=5, lr=0.1, epochs=100):
    remaining = list(range(X.shape[1]))
    rankings = np.ones(X.shape[1], dtype=int)
    while len(remaining) > n_features_to_select:
        X_subset = X[:, remaining]
        w, _ = simple_logistic_importance(X_subset, y, lr, epochs)
        least_idx = np.argmin(np.abs(w))
        remaining.pop(least_idx)
    selected_mask = rankings == 1
    return selected_mask, rankings

Step 5: L1 피처 선택

def soft_threshold(w, alpha):
    return np.sign(w) * np.maximum(np.abs(w) - alpha, 0)

L1 구현은 경사 단계(gradient step) 이후 소프트 임계화(soft-thresholding)를 적용해 작은 가중치를 0으로 보냅니다.

Step 6: 트리 기반 중요도(Tree-based importance)

def gini_impurity(y):
    if len(y) == 0:
        return 0.0
    classes, counts = np.unique(y, return_counts=True)
    probs = counts / len(y)
    return 1.0 - np.sum(probs ** 2)


def best_split(X, y, feature_idx):
    values = np.unique(X[:, feature_idx])
    if len(values) <= 1:
        return None, -1.0

    best_threshold = None
    best_gain = -1.0
    parent_gini = gini_impurity(y)
    n = len(y)

    for i in range(len(values) - 1):
        threshold = (values[i] + values[i + 1]) / 2.0
        left_mask = X[:, feature_idx] <= threshold
        right_mask = ~left_mask

        n_left = np.sum(left_mask)
        n_right = np.sum(right_mask)

        if n_left == 0 or n_right == 0:
            continue

        gain = parent_gini - (n_left / n) * gini_impurity(y[left_mask]) - (n_right / n) * gini_impurity(y[right_mask])

        if gain > best_gain:
            best_gain = gain
            best_threshold = threshold

    return best_threshold, best_gain


def tree_importance(X, y, n_trees=50, max_depth=5, seed=42):
    rng = np.random.RandomState(seed)
    n_samples, n_features = X.shape
    importances = np.zeros(n_features)

    for _ in range(n_trees):
        sample_idx = rng.choice(n_samples, size=n_samples, replace=True)
        feature_subset = rng.choice(n_features, size=max(1, int(np.sqrt(n_features))), replace=False)

        X_boot = X[sample_idx]
        y_boot = y[sample_idx]

        tree_imp = _build_tree_importance(X_boot, y_boot, feature_subset, max_depth)
        importances += tree_imp

    total = importances.sum()
    if total > 0:
        importances /= total

    return importances

코드는 단순한 의사결정 트리 분할(simple decision tree split)에서 지니 불순도 감소(gini impurity reduction)를 누적해 특성 중요도를 계산합니다. 여러 부트스트랩 트리(bootstrap tree)의 중요도를 평균내면 랜덤 포레스트식 중요도가 됩니다.

Step 7: 모든 방법 비교

코드 파일은 같은 합성 데이터셋(synthetic dataset)에서 분산 임계값, 상호정보량, RFE, L1, 트리 중요도를 실행하고 어떤 특성을 선택했는지 비교 표(comparison table)로 출력합니다.

사용하기

사이킷런(scikit-learn)에서는 피처 선택을 파이프라인(pipeline)에 넣을 수 있습니다.

from sklearn.feature_selection import (
    VarianceThreshold,
    mutual_info_classif,
    RFE,
    SelectFromModel,
)
from sklearn.linear_model import Lasso, LogisticRegression
from sklearn.ensemble import RandomForestClassifier

vt = VarianceThreshold(threshold=0.01)
X_filtered = vt.fit_transform(X)

mi_scores = mutual_info_classif(X, y)
top_k = np.argsort(mi_scores)[-10:]

rfe_selector = RFE(LogisticRegression(), n_features_to_select=10)
rfe_selector.fit(X, y)
X_rfe = rfe_selector.transform(X)

lasso_selector = SelectFromModel(Lasso(alpha=0.01))
lasso_selector.fit(X, y)
X_lasso = lasso_selector.transform(X)

rf = RandomForestClassifier(n_estimators=100)
rf.fit(X, y)
importances = rf.feature_importances_

처음부터 구현(from-scratch)한 버전은 각 방법 안에서 어떤 일이 일어나는지 보여줍니다. 분산 임계값은 var(X, axis=0)와 마스크(mask)이고, 상호정보량은 분할표(contingency table)의 결합/주변 빈도 수(joint/marginal frequency count)입니다. 재귀적 특성 제거는 학습-순위화-제거(train, rank, prune) 반복문이며, L1은 소프트 임계화(soft-thresholding)가 들어간 경사 하강법(gradient descent)입니다. 트리 중요도는 분할 전반의 불순도 감소(impurity reduction)를 누적합니다. 마법은 없습니다. 통계와 반복문일 뿐입니다.

사이킷런 버전은 강건성(robustness), 속도, 파이프라인 통합(pipeline integration)을 더합니다. 예를 들어 mutual_info_classif는 단순 구간 분할(binning) 대신 k-NN 밀도 추정(k-NN density estimation)을 사용하고, 많은 구현이 C 기반으로 빠르게 동작합니다.

산출물 만들기

이 lesson의 최종 산출물은 outputs/skill-feature-selector.md입니다. 특성 수, 모델 유형, 해석 가능성(interpretability) 필요 여부, 비선형/상호작용 여부에 따라 적절한 피처 선택 방법을 고르는 빠른 참고용 의사결정 트리(quick reference decision tree)입니다.

연습문제

1. 전진 선택(Forward selection): 재귀적 특성 제거의 반대 방향을 구현합니다. 특성 0개에서 시작해 각 단계마다 모델 성능을 가장 많이 개선하는 특성을 하나씩 추가합니다. 특성을 더해도 더 이상 도움이 되지 않으면 멈춥니다. 선택된 특성을 재귀적 특성 제거 결과와 비교합니다. 어느 쪽이 더 빠른가요? 어느 쪽이 더 좋은 결과를 내나요?

2. 안정성 선택(Stability selection): L1 피처 선택을 50번 반복합니다. 매번 데이터의 무작위 80% 부분표본(subsample)과 조금 다른 alpha를 사용합니다. 각 특성이 선택된 횟수를 세고 80% 이상 선택된 특성을 안정(stable)하다고 봅니다. 안정 특성을 단일 실행(single-run) L1 선택과 비교합니다. 어느 쪽이 더 신뢰할 만한가요?

3. 다중공선성 탐지(Multicollinearity detection): 모든 특성의 상관 행렬(correlation matrix)을 계산합니다. 상관 임계값, 예를 들어 0.9를 받으면 강하게 상관된 쌍(highly-correlated pair)마다 하나의 특성을 제거하는 함수를 구현합니다. 타깃과의 상호정보량이 더 높은 특성을 남깁니다. 합성 데이터셋에서 중복된 상관 특성(redundant correlated feature)이 제거되는지 확인합니다.

4. 피처 선택 파이프라인(Feature selection pipeline): 분산 임계값, 상호정보량 필터, 재귀적 특성 제거를 하나의 파이프라인으로 연결합니다. 먼저 분산이 거의 0인 특성(near-zero-variance feature)을 제거하고, 상호정보량 기준 상위 50%만 남긴 뒤, 남은 특성에 재귀적 특성 제거를 실행합니다. 재귀적 특성 제거만 전체 특성에 적용하는 경우와 비교합니다. 파이프라인이 더 빠른가요? 정확도(accuracy)는 비슷한가요?

5. 순열 중요도 직접 구현(Permutation importance from scratch): 순열 중요도를 구현합니다. 각 특성의 값을 10번 섞고 F1 점수(F1 score) 저하 평균을 계산합니다. 트리 기반 중요도와 순위를 비교합니다. 두 방법의 결과가 어긋나는(disagree) 경우를 찾고 이유를 설명합니다. 힌트: 상관된 특성을 살펴보세요.

핵심 용어

더 읽을거리

• An Introduction to Variable and Feature Selection (Guyon & Elisseeff, 2003) - 피처 선택의 토대가 된 개관(survey) 논문
• scikit-learn Feature Selection Guide - 필터, 래퍼, 내장 방법에 대한 실무 참고 자료
• Stability Selection (Meinshausen & Buhlmann, 2010) - 부분표본화(subsampling)와 피처 선택을 결합해 강건한(robust) 결과를 얻는 방법
• Beware Default Random Forest Importances (Strobl et al., 2007) - 트리 기반 중요도의 카디널리티 편향을 다룬 논문