Categorical Encoder Expert
Эксперт по кодированию категориальных переменных для машинного обучения.
Выбор на основе кардинальности
| Кардинальность | Рекомендация |
|---|
| Низкая (<10) | One-hot, Dummy |
| Средняя (10-50) | Target, Frequency, Binary |
| Высокая (>50) | Hash, Embeddings |
| Порядковая | Ordinal |
One-Hot Encoding
from sklearn.preprocessing import OneHotEncoder
import pandas as pd
# Для pandas
df_encoded = pd.get_dummies(df, columns=['category_col'], prefix='cat')
# Для sklearn
encoder = OneHotEncoder(sparse_output=False, handle_unknown='ignore')
X_train_encoded = encoder.fit_transform(X_train[['category_col']])
X_test_encoded = encoder.transform(X_test[['category_col']])
# Получить названия признаков
feature_names = encoder.get_feature_names_out(['category_col'])
Target Encoding с кросс-валидацией
from sklearn.model_selection import KFold
import numpy as np
def target_encode_cv(X, y, column, n_splits=5, alpha=1.0):
"""
Target кодирование с CV для предотвращения переобучения
"""
kf = KFold(n_splits=n_splits, shuffle=True, random_state=42)
encoded = np.zeros(len(X))
global_mean = y.mean()
for train_idx, val_idx in kf.split(X):
# Вычислить средние на тренировочной выборке
category_means = y.iloc[train_idx].groupby(
X[column].iloc[train_idx]
).mean()
# Байесовское сглаживание
category_counts = X[column].iloc[train_idx].value_counts()
smoothed_means = (
category_counts * category_means + alpha * global_mean
) / (category_counts + alpha)
# Закодировать валидационную выборку
encoded[val_idx] = X[column].iloc[val_idx].map(
smoothed_means
).fillna(global_mean)
return encoded
Binary Encoding
import category_encoders as ce
# Binary кодирование уменьшает размерность
binary_encoder = ce.BinaryEncoder(cols=['high_cardinality_col'])
X_train_binary = binary_encoder.fit_transform(X_train)
X_test_binary = binary_encoder.transform(X_test)
# Для 100 категорий: one-hot = 100, binary = 7 признаков
print(f"Исходных категорий: {X_train['col'].nunique()}")
print(f"Binary признаков: {len([c for c in X_train_binary.columns if 'col' in c])}")
Frequency и Count Encoding
def frequency_encode(train_series, test_series=None):
"""Кодирование по частоте появления"""
freq_map = train_series.value_counts(normalize=True).to_dict()
train_encoded = train_series.map(freq_map)
if test_series is not None:
test_encoded = test_series.map(freq_map).fillna(0)
return train_encoded, test_encoded
return train_encoded
def count_encode(train_series, test_series=None):
"""Кодирование по количеству"""
count_map = train_series.value_counts().to_dict()
train_encoded = train_series.map(count_map)
if test_series is not None:
test_encoded = test_series.map(count_map).fillna(0)
return train_encoded, test_encoded
return train_encoded
Embeddings для высокой кардинальности
from sklearn.decomposition import TruncatedSVD
from sklearn.preprocessing import OneHotEncoder
def create_categorical_embeddings(X_train, X_test, column, n_components=10):
"""Создать эмбеддинги из one-hot"""
# One-hot кодирование
encoder = OneHotEncoder(sparse_output=True, handle_unknown='ignore')
X_train_oh = encoder.fit_transform(X_train[[column]])
X_test_oh = encoder.transform(X_test[[column]])
# Понижение размерности
svd = TruncatedSVD(n_components=n_components, random_state=42)
X_train_emb = svd.fit_transform(X_train_oh)
X_test_emb = svd.transform(X_test_oh)
return X_train_emb, X_test_emb, encoder, svd
Multiple Encoding Strategy
def multi_encode_categorical(df, column, target=None):
"""Создать множественные кодирования"""
encodings = {}
# Frequency
encodings[f'{column}_freq'] = frequency_encode(df[column])
# Count
encodings[f'{column}_count'] = count_encode(df[column])
# Target (если есть)
if target is not None:
encodings[f'{column}_target'] = target_encode_cv(df, target, column)
# Ordinal для древесных моделей
from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
encodings[f'{column}_ordinal'] = le.fit_transform(df[column])
return pd.DataFrame(encodings)
Production-ready Encoder
class RobustCategoricalEncoder:
def __init__(self, encoding_type='onehot', handle_unknown='mode'):
self.encoding_type = encoding_type
self.handle_unknown = handle_unknown
self.encoders = {}
self.fallback_values = {}
def fit(self, X, y=None):
for column in X.select_dtypes(include=['object', 'category']).columns:
if self.encoding_type == 'onehot':
encoder = OneHotEncoder(
sparse_output=False,
handle_unknown='ignore'
)
encoder.fit(X[[column]])
self.encoders[column] = encoder
elif self.encoding_type == 'target' and y is not None:
target_map = y.groupby(X[column]).mean().to_dict()
self.encoders[column] = target_map
self.fallback_values[column] = y.mean()
return self
def transform(self, X):
X_transformed = X.copy()
for column, encoder in self.encoders.items():
if self.encoding_type == 'onehot':
encoded = encoder.transform(X_transformed[[column]])
feature_names = encoder.get_feature_names_out([column])
encoded_df = pd.DataFrame(
encoded,
columns=feature_names,
index=X.index
)
X_transformed = pd.concat([
X_transformed.drop(column, axis=1),
encoded_df
], axis=1)
elif self.encoding_type == 'target':
X_transformed[column] = X_transformed[column].map(
encoder
).fillna(self.fallback_values[column])
return X_transformed
Рекомендации для моделей
| Модель | Рекомендуемое кодирование |
|---|
| Древесные (RF, XGB) | Ordinal, Target, Frequency |
| Линейные (LR, SVM) | One-hot, избегать ordinal |
| Нейронные сети | Embeddings для высокой кардинальности |
| На основе расстояния | Стандартизированные закодированные |
Предотвращение утечки данных
# ПРАВИЛЬНО: fit только на train
encoder.fit(X_train)
X_train_enc = encoder.transform(X_train)
X_test_enc = encoder.transform(X_test)
# НЕПРАВИЛЬНО: fit на всех данных
encoder.fit(X_all) # Утечка!
Валидация
def validate_encoding(X_original, X_encoded):
"""Валидировать результаты кодирования"""
print(f"Исходная размерность: {X_original.shape}")
print(f"Закодированная размерность: {X_encoded.shape}")
print(f"Память: {X_encoded.memory_usage(deep=True).sum() / 1024**2:.2f} MB")
# Проверить NaN
null_count = X_encoded.isnull().sum().sum()
if null_count > 0:
print(f"Предупреждение: {null_count} пустых значений")
# Коэффициент расширения
print(f"Расширение: {X_encoded.shape[1] / X_original.shape[1]:.2f}x")
Лучшие практики
- Fit только на train — избегайте утечки данных
- Обрабатывайте unknown — используйте fallback стратегию
- Используйте CV для target encoding — предотвращает переобучение
- Мониторьте размерность — one-hot взрывает размерность
- Выбирайте по модели — разные модели предпочитают разное
