범주형 데이터 인코딩: One-Hot, Label, Ordinal Encoding 총정리

# 이건 계산이 안 된다
y = w1 * "서울" + w2 * 25 + w3 * "남성"

# 이건 된다
y = w1 * 0 + w2 * 25 + w3 * 1

서울 → 0
부산 → 1
대구 → 2
인천 → 3

from sklearn.preprocessing import LabelEncoder

le = LabelEncoder()
df['city_encoded'] = le.fit_transform(df['city'])

print(le.classes_)
# ['대구', '부산', '서울', '인천']

print(le.transform(['서울', '부산']))
# [2, 1]

대구(0) < 부산(1) < 서울(2) < 인천(3)

모델이 학습하는 것:
- "인천은 대구보다 3배 크다"
- "서울 - 부산 = 부산 - 대구" (등간격)

S → 0,  M → 1,  L → 2,  XL → 3
# 실제로 S < M < L < XL 순서가 성립

from sklearn.preprocessing import OrdinalEncoder

# 순서를 명시적으로 지정
size_order = [['S', 'M', 'L', 'XL']]

oe = OrdinalEncoder(categories=size_order)
df['size_encoded'] = oe.fit_transform(df[['size']])

print(df[['size', 'size_encoded']].drop_duplicates())
#   size  size_encoded
#      S           0.0
#      M           1.0
#      L           2.0
#     XL           3.0

edu_order = [['고졸', '학사', '석사', '박사']]
oe = OrdinalEncoder(categories=edu_order)
df['edu_encoded'] = oe.fit_transform(df[['education']])

원본:          One-Hot:
city           city_서울  city_부산  city_대구  city_인천
서울     →       1         0         0         0
부산     →       0         1         0         0
대구     →       0         0         1         0
인천     →       0         0         0         1
서울     →       1         0         0         0

import pandas as pd

df = pd.DataFrame({'city': ['서울', '부산', '대구', '인천', '서울']})

encoded = pd.get_dummies(df, columns=['city'], dtype=int)
print(encoded)
#    city_대구  city_부산  city_서울  city_인천
# 0       0       0       1       0
# 1       0       1       0       0
# 2       1       0       0       0
# 3       0       0       0       1
# 4       0       0       1       0

from sklearn.preprocessing import OneHotEncoder

ohe = OneHotEncoder(sparse_output=False)
encoded = ohe.fit_transform(df[['city']])

print(ohe.get_feature_names_out())
# ['city_대구', 'city_부산', 'city_서울', 'city_인천']

# 카테고리 수 = 생성되는 컬럼 수
도시 (4개)     → 4 컬럼    ✓ 괜찮다
우편번호 (500개) → 500 컬럼  ✗ 위험하다
상품 ID (10만개) → 10만 컬럼  ✗✗ 재앙이다

city_서울 + city_부산 + city_대구 + city_인천 = 1 (모든 행에서)

# 즉, city_인천 = 1 - city_서울 - city_부산 - city_대구
# city_인천은 나머지 3개로 완벽히 예측 가능 → 정보 중복

# pandas
encoded = pd.get_dummies(df, columns=['city'], drop_first=True, dtype=int)
# city_부산, city_서울, city_인천 (3개만 생성, 대구가 기준)

# sklearn
ohe = OneHotEncoder(drop='first', sparse_output=False)
encoded = ohe.fit_transform(df[['city']])

카테고리   정수    이진    bit_2  bit_1  bit_0
서울       1     001      0      0      1
부산       2     010      0      1      0
대구       3     011      0      1      1
인천       4     100      1      0      0
광주       5     101      1      0      1
대전       6     110      1      1      0
울산       7     111      1      1      1

# category_encoders 라이브러리 사용
# pip install category_encoders
import category_encoders as ce

encoder = ce.BinaryEncoder(cols=['city'])
df_encoded = encoder.fit_transform(df)

# Count Encoding: 등장 횟수
freq_map = df['city'].value_counts()
df['city_count'] = df['city'].map(freq_map)

# Frequency Encoding: 등장 비율
freq_map_ratio = df['city'].value_counts(normalize=True)
df['city_freq'] = df['city'].map(freq_map_ratio)

city    count   freq
서울     1500    0.30
부산      800    0.16
대구      600    0.12
인천      500    0.10
...

import lightgbm as lgb

# 범주형 컬럼을 category 타입으로 지정
df['city'] = df['city'].astype('category')

model = lgb.LGBMClassifier()
model.fit(X_train, y_train, categorical_feature=['city'])

from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder, OrdinalEncoder, StandardScaler
from sklearn.linear_model import LogisticRegression

# 피처 분류
numeric_features = ['age', 'income']
nominal_features = ['city', 'gender']       # 순서 없음 → One-Hot
ordinal_features = ['education']             # 순서 있음 → Ordinal

# 전처리 정의
numeric_transformer = StandardScaler()
nominal_transformer = OneHotEncoder(drop='first', sparse_output=False)
ordinal_transformer = OrdinalEncoder(
    categories=[['고졸', '학사', '석사', '박사']]
)

# ColumnTransformer로 조합
preprocessor = ColumnTransformer(
    transformers=[
        ('num', numeric_transformer, numeric_features),
        ('nom', nominal_transformer, nominal_features),
        ('ord', ordinal_transformer, ordinal_features),
    ]
)

# Pipeline으로 모델과 연결
pipe = Pipeline([
    ('preprocessor', preprocessor),
    ('classifier', LogisticRegression(max_iter=1000))
])

# 학습 & 예측
pipe.fit(X_train, y_train)
y_pred = pipe.predict(X_test)

# ✗ 잘못된 순서
df_encoded = pd.get_dummies(df, columns=['city'])  # 전체 데이터로 인코딩
X_train, X_test = train_test_split(df_encoded)      # 그 다음 분할

# ✓ 올바른 순서
X_train, X_test = train_test_split(df)               # 먼저 분할
encoder.fit(X_train)                                  # 훈련 데이터로만 학습
X_train_enc = encoder.transform(X_train)
X_test_enc = encoder.transform(X_test)

# 해결: handle_unknown='ignore' 설정
ohe = OneHotEncoder(handle_unknown='ignore', sparse_output=False)
ohe.fit(X_train)

# 훈련에 없던 '세종'이 테스트에 등장해도 에러 없이 전부 0으로 처리
X_test_enc = ohe.transform(X_test)

# 훈련 데이터: city = ['서울', '부산', '대구']
train_encoded = pd.get_dummies(train_df)  # 3개 컬럼 생성

# 테스트 데이터: city = ['서울', '부산']  (대구 없음)
test_encoded = pd.get_dummies(test_df)    # 2개 컬럼 생성 ← 불일치!

# 불일치 해결 (get_dummies를 꼭 써야 한다면)
test_encoded = test_encoded.reindex(columns=train_encoded.columns, fill_value=0)

범주형 변수 발견
    │
    ├─ 순서가 있는가?
    │      ├─ Yes → Ordinal Encoding
    │      └─ No  → 카디널리티 확인
    │                 ├─ 낮음 (< 10) → One-Hot Encoding
    │                 ├─ 중간 (10-50) → Binary 또는 Frequency
    │                 └─ 높음 (> 50) → Frequency, Target, 또는 임베딩
    │
    └─ 트리 모델인가?
           ├─ Yes → Label Encoding도 OK
           └─ No  → 위 흐름도 따르기