Target Encoding과 고급 인코딩 기법: 범주형 변수의 정보를 극대화하는 법

원본 데이터:
  city      | churn
  ----------|------
  서울       |  1
  서울       |  0
  서울       |  1
  부산       |  0
  부산       |  0
  대구       |  1
  대구       |  1

Target Encoding 후:
  city      | city_encoded | churn
  ----------|-------------|------
  서울       |  0.667      |  1     (서울의 이탈률: 2/3)
  서울       |  0.667      |  0
  서울       |  0.667      |  1
  부산       |  0.000      |  0     (부산의 이탈률: 0/2)
  부산       |  0.000      |  0
  대구       |  1.000      |  1     (대구의 이탈률: 2/2)
  대구       |  1.000      |  1

import pandas as pd

def target_encode_naive(df, col, target):
    """가장 단순한 Target Encoding (실전에서 쓰면 안 됨)"""
    means = df.groupby(col)[target].mean()
    return df[col].map(means)

df['city_encoded'] = target_encode_naive(df, 'city', 'churn')

희귀 범주의 함정:
  범주    | 샘플 수 | 타겟 평균 | 신뢰도
  --------|---------|----------|-------
  서울     |  5,000  |  0.32    | 높음 (충분한 샘플)
  부산     |  2,000  |  0.28    | 높음
  속초     |     3   |  1.00    | 극히 낮음 (우연의 일치일 수 있음)
  태백     |     1   |  0.00    | 의미 없음

encoded(cᵢ) = (nᵢ × meanᵢ + m × global_mean) / (nᵢ + m)

def target_encode_smooth(df, col, target, m=100):
    """Smoothing이 적용된 Target Encoding"""
    global_mean = df[target].mean()
    agg = df.groupby(col)[target].agg(['mean', 'count'])

    smooth = (agg['count'] * agg['mean'] + m * global_mean) / (agg['count'] + m)
    return df[col].map(smooth)

5-Fold Target Encoding:

Fold 1의 샘플 인코딩 ← Fold 2+3+4+5의 타겟 평균 사용
Fold 2의 샘플 인코딩 ← Fold 1+3+4+5의 타겟 평균 사용
Fold 3의 샘플 인코딩 ← Fold 1+2+4+5의 타겟 평균 사용
Fold 4의 샘플 인코딩 ← Fold 1+2+3+5의 타겟 평균 사용
Fold 5의 샘플 인코딩 ← Fold 1+2+3+4의 타겟 평균 사용

→ 어떤 샘플도 자기 자신의 타겟을 보지 않음!

import numpy as np
from sklearn.model_selection import KFold

def target_encode_kfold(df, col, target, n_splits=5, m=100):
    """K-Fold Target Encoding (Smoothing 포함)"""
    global_mean = df[target].mean()
    encoded = pd.Series(index=df.index, dtype=float)

    kf = KFold(n_splits=n_splits, shuffle=True, random_state=42)

    for train_idx, val_idx in kf.split(df):
        # train_idx의 통계량으로 val_idx를 인코딩
        train_data = df.iloc[train_idx]
        agg = train_data.groupby(col)[target].agg(['mean', 'count'])
        smooth = (agg['count'] * agg['mean'] + m * global_mean) / (agg['count'] + m)

        encoded.iloc[val_idx] = df.iloc[val_idx][col].map(smooth)

    # 학습 데이터에 없는 범주는 전역 평균으로 채움
    encoded.fillna(global_mean, inplace=True)
    return encoded

encoded(xᵢ) = (Σⱼ≠ᵢ yⱼ · 1[xⱼ = xᵢ]) / (nᵢ - 1)

def loo_encode(df, col, target):
    """Leave-One-Out Encoding"""
    global_mean = df[target].mean()
    cat_sum = df.groupby(col)[target].transform('sum')
    cat_count = df.groupby(col)[target].transform('count')

    # 자기 자신을 빼고 평균 계산
    encoded = (cat_sum - df[target]) / (cat_count - 1)

    # 범주에 샘플이 1개뿐이면 전역 평균 사용
    encoded.fillna(global_mean, inplace=True)
    return encoded

데이터를 랜덤하게 셔플한 뒤:

샘플 1 (서울, y=1): encoded = prior (아직 앞선 데이터 없음)
샘플 2 (서울, y=0): encoded = (1 + prior) / (1 + 1)      ← 샘플 1의 타겟만 참조
샘플 3 (부산, y=1): encoded = prior                        ← 부산 첫 등장
샘플 4 (서울, y=1): encoded = (1+0 + prior) / (2 + 1)     ← 샘플 1,2의 타겟 참조
샘플 5 (부산, y=0): encoded = (1 + prior) / (1 + 1)       ← 샘플 3의 타겟만 참조

encoded(xₖ) = (Σⱼ<ₖ yⱼ · 1[xⱼ = xₖ] + a · prior) / (Σⱼ<ₖ 1[xⱼ = xₖ] + a)

# CatBoost는 범주형 특성을 직접 처리한다
from catboost import CatBoostClassifier

model = CatBoostClassifier(
    iterations=1000,
    learning_rate=0.05,
    cat_features=['city', 'region', 'product_type'],  # 범주형 열 지정
    random_state=42
)

# 인코딩 필요 없이 원본 범주형 데이터 그대로 학습
model.fit(X_train, y_train, verbose=100)

WoE(cᵢ) = ln(Event Rate / Non-Event Rate)
         = ln(%Events_in_cᵢ / %Non-Events_in_cᵢ)

%Events_in_cᵢ    = (범주 i에서 타겟=1인 수) / (전체 타겟=1인 수)
%Non-Events_in_cᵢ = (범주 i에서 타겟=0인 수) / (전체 타겟=0인 수)

전체: 타겟=1: 300명, 타겟=0: 700명

범주 A: 타겟=1: 60명, 타겟=0: 40명
  %Events = 60/300 = 0.200
  %Non    = 40/700 = 0.057
  WoE = ln(0.200/0.057) = 1.253 (강한 양의 지표)

범주 B: 타겟=1: 10명, 타겟=0: 90명
  %Events = 10/300 = 0.033
  %Non    = 90/700 = 0.129
  WoE = ln(0.033/0.129) = -1.350 (강한 음의 지표)

IV = Σᵢ (%Eventsᵢ - %Non-Eventsᵢ) × WoE(cᵢ)

def woe_encode(df, col, target):
    """Weight of Evidence Encoding"""
    total_events = df[target].sum()
    total_non = len(df) - total_events

    agg = df.groupby(col)[target].agg(['sum', 'count'])
    agg['non_events'] = agg['count'] - agg['sum']

    agg['pct_events'] = agg['sum'] / total_events
    agg['pct_non'] = agg['non_events'] / total_non

    # 0 방지를 위한 작은 값 추가
    eps = 1e-6
    agg['woe'] = np.log((agg['pct_events'] + eps) / (agg['pct_non'] + eps))

    return df[col].map(agg['woe'])

encoded(cᵢ) = (1 - Bᵢ) × meanᵢ + Bᵢ × global_mean

Bᵢ = Var(yᵢ) / (Var(yᵢ) + nᵢ × Var(mean_across_categories))

def james_stein_encode(df, col, target):
    """James-Stein Encoding"""
    global_mean = df[target].mean()
    global_var = df[target].var()

    agg = df.groupby(col)[target].agg(['mean', 'count', 'var'])

    # 범주 간 평균의 분산
    between_var = agg['mean'].var()

    # 수축 계수
    B = agg['var'] / (agg['var'] + agg['count'] * between_var + 1e-10)

    shrunk = (1 - B) * agg['mean'] + B * global_mean
    return df[col].map(shrunk)

pip install category_encoders

import category_encoders as ce

# Target Encoding (smoothing 포함)
encoder = ce.TargetEncoder(cols=['city'], smoothing=1.0)
X_train_enc = encoder.fit_transform(X_train, y_train)
X_test_enc = encoder.transform(X_test)

# Leave-One-Out Encoding
encoder = ce.LeaveOneOutEncoder(cols=['city'])
X_train_enc = encoder.fit_transform(X_train, y_train)
X_test_enc = encoder.transform(X_test)

# WoE Encoding
encoder = ce.WOEEncoder(cols=['city'])
X_train_enc = encoder.fit_transform(X_train, y_train)
X_test_enc = encoder.transform(X_test)

# James-Stein Encoding
encoder = ce.JamesSteinEncoder(cols=['city'])
X_train_enc = encoder.fit_transform(X_train, y_train)
X_test_enc = encoder.transform(X_test)

from sklearn.pipeline import Pipeline
from sklearn.ensemble import GradientBoostingClassifier

pipeline = Pipeline([
    ('encoder', ce.TargetEncoder(cols=['city', 'region', 'product'])),
    ('model', GradientBoostingClassifier(n_estimators=200))
])

# 교차 검증도 자연스럽게 동작
from sklearn.model_selection import cross_val_score
scores = cross_val_score(pipeline, X, y, cv=5, scoring='roc_auc')
print(f"AUC: {scores.mean():.4f} (+/- {scores.std():.4f})")

import pandas as pd
import numpy as np
from sklearn.model_selection import cross_val_score, StratifiedKFold
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.preprocessing import OneHotEncoder
import category_encoders as ce
import warnings
warnings.filterwarnings('ignore')

# 고카디널리티 데이터 생성 (실제로는 Kaggle 등에서 가져옴)
np.random.seed(42)
n_samples = 10000
n_cities = 200

cities = [f'city_{i}' for i in range(n_cities)]
city_probs = np.random.dirichlet(np.ones(n_cities) * 0.5)  # 불균형한 분포

df = pd.DataFrame({
    'city': np.random.choice(cities, size=n_samples, p=city_probs),
    'age': np.random.normal(35, 10, n_samples),
    'income': np.random.normal(50000, 15000, n_samples),
})

# 도시별로 다른 이탈률 설정 (city가 타겟과 실제로 관련 있게)
city_effects = {c: np.random.normal(0, 0.5) for c in cities}
logit = df['city'].map(city_effects) + 0.01 * df['age'] - 0.00001 * df['income']
df['churn'] = (np.random.random(n_samples) < 1 / (1 + np.exp(-logit))).astype(int)

X = df[['city', 'age', 'income']]
y = df['churn']

# 각 인코딩 전략 비교
encoders = {
    'One-Hot': ce.OneHotEncoder(cols=['city'], use_cat_names=True),
    'Target (smoothing=1)': ce.TargetEncoder(cols=['city'], smoothing=1.0),
    'Target (smoothing=100)': ce.TargetEncoder(cols=['city'], smoothing=100.0),
    'LOO': ce.LeaveOneOutEncoder(cols=['city']),
    'WoE': ce.WOEEncoder(cols=['city']),
    'James-Stein': ce.JamesSteinEncoder(cols=['city']),
}

cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
model = GradientBoostingClassifier(n_estimators=100, random_state=42)

print(f"{'인코딩 방식':<25} {'AUC (mean ± std)':<20} {'특성 수'}")
print('-' * 65)

for name, encoder in encoders.items():
    pipe = Pipeline([
        ('encoder', encoder),
        ('model', model)
    ])
    scores = cross_val_score(pipe, X, y, cv=cv, scoring='roc_auc')

    # 특성 수 확인 (One-Hot과 나머지 비교)
    pipe.fit(X, y)
    n_features = pipe.named_steps['encoder'].transform(X.head(1)).shape[1]

    print(f"{name:<25} {scores.mean():.4f} ± {scores.std():.4f}    {n_features}")

인코딩 방식                AUC (mean ± std)     특성 수
-----------------------------------------------------------------
One-Hot                  0.6823 ± 0.0112    202     ← 차원 폭발
Target (smoothing=1)     0.7156 ± 0.0098      3     ← 약한 smoothing
Target (smoothing=100)   0.7089 ± 0.0087      3     ← 과도한 smoothing
LOO                      0.7134 ± 0.0103      3
WoE                      0.7121 ± 0.0095      3
James-Stein              0.7148 ± 0.0091      3