OHE в SKLearn: эффективное преобразование категориальных данных

Исходные данные: После OHE:
Цвет Красный Синий Зелёный
Красный 1 0 0
Синий 0 1 0
Зелёный 0 0 1
Красный 1 0 0

from sklearn.preprocessing import OneHotEncoder

# Создаем экземпляр кодировщика
encoder = OneHotEncoder()

# Допустим, у нас есть данные
X = [['красный'], ['синий'], ['зеленый'], ['красный']]

# Обучаем и трансформируем данные
encoded_X = encoder.fit_transform(X)

# Получаем разреженную матрицу, которую можно преобразовать в массив
# encoded_X.toarray()
# array([[1\., 0., 0.],
# [0\., 1., 0.],
# [0\., 0., 1.],
# [1\., 0., 0.]])

# Используем drop для исключения первой категории
encoder = OneHotEncoder(drop='first')
encoded_X = encoder.fit_transform(X).toarray()
# array([[0\., 0.], # красный (первая категория) исключена
# [1\., 0.], # синий
# [0\., 1.], # зеленый
# [0\., 0.]]) # красный

feature_names = encoder.get_feature_names_out(['color'])
print(feature_names)
# ['color_красный' 'color_синий' 'color_зеленый']

import numpy as np
import pandas as pd
from sklearn.preprocessing import OneHotEncoder

# Создаем данные с пропусками
X = np.array([['красный'], [None], ['зеленый'], ['синий'], [None]])
df = pd.DataFrame(X, columns=['цвет'])

# Заменяем None на строку 'missing'
df['цвет'].fillna('missing', inplace=True)

# Применяем OHE
encoder = OneHotEncoder(sparse=False, handle_unknown='ignore')
encoded = encoder.fit_transform(df)

# Получаем имена признаков
feature_names = encoder.get_feature_names_out(['цвет'])

# Создаем DataFrame с закодированными данными
encoded_df = pd.DataFrame(encoded, columns=feature_names)
print(encoded_df)

# Создаем тренировочные данные
X_train = np.array([['красный'], ['синий'], ['зеленый']])

# Создаем тестовые данные с новой категорией
X_test = np.array([['красный'], ['фиолетовый'], ['синий']])

# Обучаем кодировщик с handle_unknown='ignore'
encoder = OneHotEncoder(handle_unknown='ignore')
encoder.fit(X_train)

# Преобразуем тестовые данные
encoded_test = encoder.transform(X_test).toarray()
print(encoded_test)
# array([[1\., 0., 0.], # красный
# [0\., 0., 0.], # фиолетовый (неизвестная категория)
# [0\., 1., 0.]]) # синий

# Пример с min_frequency
encoder = OneHotEncoder(min_frequency=2) # Категории должны встречаться минимум 2 раза
encoder.fit_transform([['a'], ['b'], ['a'], ['c']])

# Категории 'a' и 'b' будут кодироваться отдельно,
# а 'c' попадет в категорию 'infrequent_sklearn'

import numpy as np
from sklearn.preprocessing import OneHotEncoder
import sys

# Создаем данные с 1000 строк и 1 признаком, имеющим 100 категорий
np.random.seed(42)
data = np.random.randint(0, 100, size=(1000, 1))

# Кодирование с разреженной матрицей (по умолчанию)
encoder_sparse = OneHotEncoder()
encoded_sparse = encoder_sparse.fit_transform(data)

# Кодирование с плотной матрицей
encoder_dense = OneHotEncoder(sparse=False)
encoded_dense = encoder_dense.fit_transform(data)

# Сравниваем размер в памяти
sparse_size = sys.getsizeof(encoded_sparse)
dense_size = sys.getsizeof(encoded_dense)

print(f"Размер разреженной матрицы: {sparse_size} байт")
print(f"Размер плотной матрицы: {dense_size} байт")
print(f"Экономия памяти: {(1 – sparse_size/dense_size)*100:.2f}%")

# Использование max_categories для ограничения количества столбцов
encoder = OneHotEncoder(max_categories=10)
encoded = encoder.fit_transform(data)

# Получаем количество созданных признаков
num_features = encoded.shape[1]
print(f"Количество созданных признаков: {num_features}")
# Вместо 100 получим только 10

# Предположим, у нас есть генератор, который выдает данные пакетами
def data_generator(batch_size=1000):
for i in range(10): # 10 пакетов
yield np.random.randint(0, 100, size=(batch_size, 1))

# Сначала обучаем кодировщик на небольшом образце
initial_batch = next(data_generator())
encoder = OneHotEncoder()
encoder.fit(initial_batch)

# Затем преобразуем каждый пакет отдельно
for i, batch in enumerate(data_generator()):
encoded_batch = encoder.transform(batch)
# Здесь можно сохранять преобразованные данные или обрабатывать их дальше
print(f"Batch {i+1} transform complete. Shape: {encoded_batch.shape}")

from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import OneHotEncoder, OrdinalEncoder
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.model_selection import cross_val_score
import pandas as pd
import numpy as np

# Загружаем данные (например, Adult Income dataset)
# data = pd.read_csv('adult.csv')
# X = data.drop('income', axis=1)
# y = data['income']

# Для примера создадим синтетические данные
np.random.seed(42)
# Создаем категориальные признаки, имеющие корреляцию с целевой переменной
cat1 = np.random.choice(['A', 'B', 'C'], size=1000)
cat2 = np.random.choice(['X', 'Y', 'Z'], size=1000)
# Создаем числовой признак
num1 = np.random.normal(0, 1, 1000)

# Создаем целевую переменную, зависящую от признаков
y = ((cat1 == 'A') * 1 + (cat2 == 'X') * 1.5 + num1 * 0.5 > 0.5).astype(int)

# Создаем DataFrame
X = pd.DataFrame({
'cat1': cat1,
'cat2': cat2,
'num1': num1
})

# Определяем категориальные и числовые признаки
categorical_features = ['cat1', 'cat2']
numeric_features = ['num1']

# Построим пайплайн с OneHotEncoder
ohe_pipeline = Pipeline([
('preprocessor', ColumnTransformer([
('num', 'passthrough', numeric_features),
('cat', OneHotEncoder(drop='first'), categorical_features)
])),
('classifier', LogisticRegression())
])

# Построим пайплайн с OrdinalEncoder для сравнения
ord_pipeline = Pipeline([
('preprocessor', ColumnTransformer([
('num', 'passthrough', numeric_features),
('cat', OrdinalEncoder(), categorical_features)
])),
('classifier', LogisticRegression())
])

# Оценим качество с кросс-валидацией
ohe_scores = cross_val_score(ohe_pipeline, X, y, cv=5, scoring='accuracy')
ord_scores = cross_val_score(ord_pipeline, X, y, cv=5, scoring='accuracy')

print(f"One-Hot Encoding средняя точность: {ohe_scores.mean():.4f}")
print(f"Ordinal Encoding средняя точность: {ord_scores.mean():.4f}")
print(f"Улучшение: {(ohe_scores.mean() – ord_scores.mean())*100:.2f}%")

from sklearn.preprocessing import OneHotEncoder
import pandas as pd
import numpy as np

# Имитируем данные о взаимодействии пользователей с товарами
np.random.seed(42)
n_users = 1000
n_products = 5000
n_interactions = 10000

# Создаем случайные взаимодействия
user_ids = np.random.randint(0, n_users, n_interactions)
product_ids = np.random.randint(0, n_products, n_interactions)
ratings = np.random.randint(1, 6, n_interactions) # Рейтинги от 1 до 5

# Создаем DataFrame
interactions_df = pd.DataFrame({
'user_id': user_ids,
'product_id': product_ids,
'rating': ratings
})

# Подсчитываем частоту каждого товара
product_counts = interactions_df['product_id'].value_counts()

# Находим самые популярные товары (верхние 100)
top_products = product_counts.nlargest(100).index.tolist()

# Создаем признак 'is_top_product'
interactions_df['is_top_product'] = interactions_df['product_id'].isin(top_products)

# Применяем OHE только к топовым товарам
encoder = OneHotEncoder(sparse=True, handle_unknown='ignore')
top_product_ids = interactions_df[interactions_df['is_top_product']]['product_id'].values.reshape(-1, 1)
encoded_products = encoder.fit_transform(top_product_ids)

print(f"Оригинальное количество товаров: {n_products}")
print(f"Количество кодированных топовых товаров: {encoded_products.shape[1]}")
print(f"Снижение размерности: {(1 – encoded_products.shape[1]/n_products)*100:.2f}%")

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.preprocessing import OneHotEncoder
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.ensemble import RandomForestClassifier
import pandas as pd
import numpy as np

# Создаем синтетические данные для анализа отзывов на товары
np.random.seed(42)
n_samples = 500

# Имитируем тексты отзывов
positive_texts = [
"Отличный товар, очень доволен покупкой",
"Хорошее качество, рекомендую",
"Превзошел все ожидания, однозначно стоит своих денег"
]

negative_texts = [
"Плохое качество, не рекомендую",
"Товар сломался через неделю, разочарован",
"Не соответствует описанию, пустая трата денег"
]

# Генерируем отзывы и категории товаров
categories = ['Электроника', 'Одежда', 'Книги', 'Домашний быт', 'Спорт']
sentiments = ['положительный', 'отрицательный']

reviews = []
for _ in range(n_samples):
sentiment = np.random.choice(sentiments)
category = np.random.choice(categories)

if sentiment == 'положительный':
text = np.random.choice(positive_texts)
rating = np.random.randint(4, 6) # 4-5 звезд
else:
text = np.random.choice(negative_texts)
rating = np.random.randint(1, 3) # 1-2 звезды

reviews.append({
'text': text,
'category': category,
'rating': rating,
'sentiment': sentiment
})

# Создаем DataFrame
reviews_df = pd.DataFrame(reviews)

# Создаем пайплайн для комбинирования TF-IDF и OHE
preprocessor = ColumnTransformer([
('text_features', TfidfVectorizer(max_features=100), 'text'),
('category_features', OneHotEncoder(), ['category'])
])

# Полный пайплайн с классификатором
full_pipeline = Pipeline([
('preprocessor', preprocessor),
('classifier', RandomForestClassifier())
])

# Подготавливаем данные
X = reviews_df[['text', 'category']]
y = reviews_df['sentiment'] == 'положительный' # Бинарная цель

# Обучаем модель
full_pipeline.fit(X, y)

# Получаем важность признаков из Random Forest
feature_names = (
[f"text_{i}" for i in range(100)] + # TF-IDF features
[f"category_{c}" for c in preprocessor.named_transformers_['category_features'].get_feature_names_out()]
)

feature_importances = full_pipeline.named_steps['classifier'].feature_importances_
sorted_idx = feature_importances.argsort()[::-1][:10] # Top 10 features

print("Топ-10 важных признаков:")
for idx in sorted_idx:
print(f"{feature_names[idx]}: {feature_importances[idx]:.4f}")