На каких признаках можно обучать модели, какие они бывают?

Модели машинного обучения обучаются на признаках (features), которые описывают объекты. Признаки бывают разными по типу данных и требуют разной предобработки. Вот основные категории:

1. Числовые (Numerical / Continuous)
   Вещественные числа, могут принимать любое значение в диапазоне.
   Примеры: возраст, цена, температура, рост, зарплата, расстояние, время в пути.
   Обработка: стандартизация (StandardScaler), нормализация (MinMaxScaler), логарифмирование, обработка выбросов, заполнение пропусков (mean/median).
2. Целочисленные дискретные (Discrete Numerical / Integer)
   Целые числа, часто счётные величины.
   Примеры: количество детей, число покупок, рейтинг (1–5), количество просмотров.
   Обработка: почти как числовые, иногда рассматривают как категориальные (ordinal).
3. Категориальные номинальные (Nominal Categorical)
   Категории без естественного порядка.
   Примеры: пол, город, бренд, цвет, тип устройства, страна, ОС.
   Обработка: One-Hot Encoding (OHE), Label Encoding (только для деревьев), Target Encoding / Mean Encoding, Frequency Encoding, embeddings (для очень большого числа категорий).
4. Категориальные порядковые (Ordinal Categorical)
   Категории с естественным порядком.
   Примеры: уровень образования (school → bachelor → master → phd), размер одежды (S → M → L → XL), удовлетворённость (low → medium → high).
   Обработка: Ordinal Encoding (присваиваем числа по порядку), иногда OHE, если порядок не очень строгий.
5. Бинарные (Binary)
   Два возможных значения (0/1, да/нет, true/false).
   Примеры: есть_дети (1/0), премиум_пользователь, фрод, мобильное_устройство.
   Обработка: уже готов к использованию, иногда оставляют как числовой признак.
6. Текстовые (Text / Categorical high-cardinality)
   Свободный текст или строки с очень большим числом уникальных значений.
   Примеры: название товара, описание вакансии, отзыв, адрес, заголовок поста.
   Обработка: TF-IDF, Bag-of-Words, Word2Vec / FastText / GloVe, Sentence Transformers, BERT / RuBERT embeddings, hashing trick.
7. Дата и время (Datetime / Temporal)
   Временные метки.
   Примеры: дата регистрации, время покупки, timestamp события.
   Обработка: извлечение фич: год, месяц, день, день_недели, час, is_weekend, is_holiday, время_с_начала_кампании, разница_между_датами, синус/косинус циклических признаков (час/день_месяца).
8. Географические / Координаты (Geospatial)
   Широта/долгота, почтовый индекс, регион.
   Примеры: lat/lon, город + страна, IP-адрес → геолокация.
   Обработка: Haversine distance, кластеризация (k-means на координатах), гео-хэши (geohash), расстояние до ключевых точек, региональные признаки.
9. Изображения (Image / Pixel-based)
   Пиксели или уже извлечённые признаки.
   Примеры: фото товара, скриншот, медицинское изображение.
   Обработка: CNN (ResNet, EfficientNet, ViT), transfer learning, извлечение признаков через предобученные сети (embeddings), аугментация.
10. Последовательности / Временные ряды (Sequential / Time Series)
    Упорядоченные данные во времени.
    Примеры: история транзакций, ряд цен акций, последовательность кликов.
    Обработка: лаговые признаки (lags), rolling statistics (mean, std, min, max), Fourier / wavelet transform, embeddings последовательностей (GRU4Rec, Transformer).
11. Графовые / Сетевые (Graph / Network)
    Вершины и рёбра.
    Примеры: социальный граф, граф транзакций, knowledge graph.
    Обработка: node2vec, GraphSAGE, GCN, GAT, link prediction, node classification.
12. Мультимодальные / Комбинированные
    Сочетание нескольких типов (текст + изображение + табличные данные).
    Примеры: описание товара + фото + цена + категория.
    Обработка: late fusion, early fusion, two-tower модели, multimodal transformers (CLIP, Flamingo и наследники).

Коротко: практически любые данные можно превратить в признаки — от простых чисел до изображений, текста, графов и последовательностей. Главное — правильно закодировать тип данных и подобрать подходящую модель / архитектуру.

Что такое стандартизация (этап предобработки), зачем её делать и что это такое?

Стандартизация (Standardization, Z-score normalization) — это метод масштабирования числовых признаков, при котором приводим каждый признак к виду:

z = (x − μ) / σ

где:
• x — исходное значение признака
• μ — среднее значение признака по всей выборке
• σ — стандартное отклонение признака

После стандартизации:
• среднее значение каждого признака ≈ 0
• стандартное отклонение каждого признака = 1
• распределение признака становится центрированным и нормированным (но не обязательно нормальным)

Зачем нужна стандартизация

1. Алгоритмы, чувствительные к масштабу признаков
   Без стандартизации признаки с большими значениями будут доминировать:
   • Градиентный спуск сходится намного медленнее и хуже (овальные эллипсоидные контуры loss)
   • KNN, SVM, SVC, SVR — расстояния искажаются
   • PCA — главные компоненты определяются в основном самыми «большими» по масштабу признаками
   • Нейронные сети — взрывы/затухание градиентов, медленная сходимость
2. Ускорение обучения и стабильность
   Стандартизованные данные → симметричные и круглые контуры функции потерь → градиентный спуск идёт быстрее и стабильнее
3. Сравнимость коэффициентов модели
   В линейных моделях (линейная/логистическая регрессия) веса признаков становятся сопоставимыми — можно интерпретировать, какой признак важнее
4. Улучшение работы с разными порядками величин
   Например: возраст (20–80) и зарплата (30 000–300 000) — без стандартизации зарплата будет доминировать

Когда стандартизацию делать обязательно / очень желательно

• Линейные модели + градиентный спуск (Logistic Regression, SVM, Neural Networks, Ridge/Lasso)
• Методы на основе расстояний (KNN, K-Means, DBSCAN, Hierarchical clustering)
• PCA, LDA, t-SNE, UMAP
• Градиентный бустинг — не критично (деревья нечувствительны), но иногда помогает на границе

Когда можно обойтись без стандартизации

• Деревья решений и все на их основе: Random Forest, XGBoost, LightGBM, CatBoost — сами по себе нечувствительны к масштабу
• Наивный Байес (особенно GaussianNB — предполагает нормальность, но часто работает и без)

Популярные реализации

• StandardScaler из sklearn (самый распространённый)
• scale() из sklearn.preprocessing
• в pandas: (df - df.mean()) / df.std()

Коротко для собеседования:

Стандартизация — приведение признаков к нулевому среднему и единичной дисперсии (z = (x − μ)/σ). Делается, чтобы устранить разницу в масштабах, ускорить градиентный спуск, улучшить сходимость и корректность работы алгоритмов, чувствительных к расстояниям и масштабам (SVM, KNN, PCA, нейросети). Деревьям и бустингу обычно не нужна.

Как обрабатывать пропуски?

Пропуски (NaN, None, null, -999 и т.д.) нужно обязательно обрабатывать, потому что почти все алгоритмы машинного обучения не умеют с ними работать напрямую. Выбор метода зависит от природы пропусков, их количества, типа признака и задачи.

Основные стратегии обработки пропусков

1. Удаление строк / объектов с пропусками (Drop rows)
   Самый простой и «чистый» способ.
   Когда использовать:
   • пропусков мало (< 5–10%)
   • данные позволяют потерять часть записей
   • нет сильного смещения при удалении
   Реализация: df.dropna(), df.dropna(subset=[...])
2. Удаление столбцов / признаков (Drop columns)
   Когда использовать:
   • в признаке > 60–80% пропусков
   • признак не очень важен по бизнес-логике
   • есть другие коррелирующие признаки
   Реализация: df.drop(columns=..., inplace=True)
3. Заполнение константой (Constant imputation)
   Самые частые варианты:
   • 0 (для сумм, количеств, когда пропуск = отсутствие)
   • -1, -999 (для числовых, чтобы алгоритм видел аномалию)
   • «missing», «other», «unknown» (для категориальных)
   • медиана / мода по всему датасету
4. Заполнение статистикой по столбцу (Simple imputation)
   Самые популярные:
   • Среднее (mean) — для числовых без сильных выбросов
   • Медиана (median) — для числовых с выбросами / скошенным распределением
   • Мода (most frequent) — для категориальных
   Реализация: SimpleImputer(strategy='mean/median/most_frequent')
5. Заполнение с учётом других признаков (KNN Imputation, Iterative Imputer)
   Более точные методы:
   • KNNImputer — берёт k ближайших соседей и усредняет их значения
   • IterativeImputer (MICE-подобный) — моделирует каждый признак с пропусками как функцию от остальных (по очереди)
   Когда использовать: пропусков 10–40%, важные признаки, есть корреляции между столбцами.
6. Заполнение на основе временного порядка (Time-based imputation)
   Для временных рядов / последовательностей:
   • forward fill / backward fill (ffill(), bfill())
   • линейная / полиномиальная интерполяция (interpolate())
   • rolling mean/median с окном
7. Создание индикатора пропуска (Missing indicator)
   Добавить бинарный признак: 1 — если было пропущено, 0 — если нет.
   Очень полезно, когда сам факт пропуска несёт информацию (например, доход не указан → определённая группа клиентов).
   Реализация: MissingIndicator() + SimpleImputer
8. Модели, которые умеют работать с пропусками «из коробки»
   • XGBoost, LightGBM, CatBoost — умеют обрабатывать NaN как отдельную категорию
   • CatBoost — особенно хорошо работает с категориальными пропусками
   В этом случае часто достаточно просто оставить NaN и передать в модель.

Рекомендуемый порядок действий на практике

• Посмотреть долю пропусков по столбцам (df.isna().mean().sort_values(ascending=False))
• Понять природу пропусков (MCAR, MAR, MNAR) — по возможности через бизнес-логику
• Удалить столбцы с почти 100% пропусков
• Для оставшихся:
  • < 5–10% → удалить строки
  • 10–40% → KNN / Iterative / медиана + индикатор
  • > 40–50% → константа / индикатор / оставить для CatBoost
• Обязательно проверять на валидации, какой способ даёт лучший score

Коротко для собеседования:

Пропуски обрабатывают удалением (строк/столбцов), заполнением статистикой (mean/median/mode), KNN/итеративной импутацией, константой, индикатором пропуска или оставляют как есть (CatBoost, XGBoost). Выбор зависит от доли пропусков, типа признака, природы пропусков и чувствительности модели к масштабу.

Какие методы отбора признаков существуют?

Отбор признаков — это процесс выбора наиболее информативных и полезных признаков для модели, чтобы уменьшить размерность, ускорить обучение, снизить переобучение и иногда даже повысить качество предсказаний.

Основные категории методов отбора признаков

1. Filter methods (фильтрующие методы)
   Оценивают каждый признак независимо от модели (быстро, не используют модель).
   Популярные метрики:
   • Корреляция (Pearson, Spearman) с целевой переменной
   • Mutual Information (взаимная информация)
   • Chi² (χ²) — для категориальных признаков и целевой
   • ANOVA F-value — для числовых признаков и категориальной целевой
   • Variance Threshold — удаляем признаки с низкой дисперсией
   • Information Gain, Gain Ratio
   • Univariate feature selection: SelectKBest, SelectPercentile
   Плюсы: очень быстро, независимо от модели.
   Минусы: игнорируют взаимодействия между признаками.
2. Wrapper methods (обёрточные методы)
   Используют саму модель для оценки качества подмножества признаков.
   Основные подходы:
   • Forward Selection — начинаем с пустого набора, добавляем по одному лучшему
   • Backward Elimination — начинаем со всех, удаляем по одному худшему
   • Recursive Feature Elimination (RFE) — обучаем модель → удаляем наименее важный признак → повторяем
   • Stepwise selection (комбинация forward + backward)
   • Genetic algorithms, Simulated Annealing (редко)
   Плюсы: учитывают конкретную модель и взаимодействия.
   Минусы: очень медленно (много переобучений модели).
3. Embedded methods (встроенные методы)
   Отбор происходит внутри процесса обучения модели.
   Самые популярные:
   • Lasso (L1-регуляризация) — веса некоторых признаков зануляются
   • Ridge (L2) — не зануляет, но уменьшает веса
   • Elastic Net (L1 + L2)
   • Деревья решений / Random Forest / Gradient Boosting — feature importance (Gini impurity decrease, gain, cover, permutation importance)
   • CatBoost — встроенная важность признаков + обработка категориальных
   • LightGBM / XGBoost — gain, split, cover importance
   Плюсы: баланс скорости и качества, учитывает взаимодействия.
   Минусы: привязан к конкретному типу модели.
4. Гибридные и современные подходы
   • Boruta — оборачивает Random Forest, сравнивает важность реальных признаков с «теневыми» (shuffle-копиями)
   • Permutation Importance — перестановочная важность (работает с любой моделью, независимо от типа)
   • SHAP values-based selection — отбор по суммарному вкладу SHAP
   • AutoML-подходы (TPOT, Feature-engine, auto-sklearn) — автоматический отбор
   • Двухэтапный отбор: сначала filter → потом wrapper/embedded

Краткое сравнение подходов

Метод	Скорость	Учитывает взаимодействия	Зависит от модели	Когда использовать
Filter	Очень быстро	Нет	Нет	Огромное количество признаков, начальный отсев
Wrapper	Очень медленно	Да	Да	Маленький датасет, важна максимальная точность
Embedded	Быстро-средне	Да	Да	Деревья/бустинг/линейные модели с регуляризацией
Boruta / Permutation	Средне-медленно	Да	Частично	Когда нужна надёжная оценка важности

На практике чаще всего комбинируют: filter → embedded/permutation → (при необходимости) RFE/Boruta.

Коротко для собеседования:

Методы отбора признаков делятся на filter (быстрые, независимые от модели: корреляция, mutual information, chi²), wrapper (медленные, используют модель: forward/backward, RFE) и embedded (встроенные в обучение: L1, feature importance в деревьях и бустинге). Самые популярные в индустрии — embedded в градиентном бустинге + permutation importance.

Это хорошо или плохо, если в датасете очень много признаков?

Обычно **плохо**, и чаще всего **очень плохо** — особенно если количество признаков значительно превышает количество объектов (n_features >> n_samples) или даже просто измеряется тысячами/десятками тысяч.

Почему большое количество признаков — это проблема (основные риски):

1. Проклятие размерности (Curse of Dimensionality)
   Пространство становится разреженным → расстояния теряют смысл → алгоритмы на основе расстояний (KNN, SVM, кластеризация) деградируют.
2. Переобучение (Overfitting)
   Модель почти всегда может идеально запомнить тренировочную выборку (в высокомерном пространстве почти все точки линейно разделимы случайным образом), но на новых данных качество резко падает.
3. Шум и неинформативные признаки
   Чем больше признаков — тем выше вероятность, что большинство из них либо шум, либо слабо коррелированы с целевой переменной, либо дублируют информацию других признаков.
4. Медленное обучение и инференс
   Время обучения и предсказания растёт линейно (а иногда квадратично или хуже) с числом признаков → в продакшене это критично.
5. Сложность интерпретации
   Невозможно понять, что именно влияет на предсказание → модель превращается в «чёрный ящик» даже для простых алгоритмов.
6. Проблемы с вычислительными ресурсами
   Память, GPU/TPU, время экспериментов — всё растёт экспоненциально при очень большом числе фич.

Когда много признаков — это нормально или даже хорошо

• Очень большой объём данных (миллионы–миллиарды строк) — тогда даже 10 000–100 000 признаков не так страшно
• Модели, устойчивые к большому числу признаков:
  • Градиентный бустинг (XGBoost, LightGBM, CatBoost) — отлично справляются
  • Линейные модели с сильной L1-регуляризацией (Lasso)
  • Нейросети с dropout и/или batch-norm
  • Трансформеры (самовнимание само отбирает важное)
• Признаки уже качественно отобраны или сгенерированы (embeddings из предобученных моделей, auto-features и т.д.)
• Задача, где почти все признаки несут полезную информацию (геномика, текст после TF-IDF, высокочастотные временные ряды)

Что делать, если признаков слишком много (практический чек-лист)

• Посчитать корреляции / mutual information с таргетом → отсечь слабые
• Удалить признаки с дисперсией ≈ 0 или очень низкой
• Удалить сильно коррелирующие между собой признаки (VIF, correlation threshold > 0.9–0.95)
• Использовать встроенный отбор: feature importance в бустинге, коэффициенты Lasso
• Снижение размерности: PCA, TruncatedSVD, UMAP, autoencoders
• Отбор по permutation importance или SHAP
• Проверить на кросс-валидации: растёт ли качество при уменьшении числа признаков

Коротко для собеседования:

Очень много признаков — почти всегда плохо: проклятие размерности, переобучение, шум, медленное обучение. Хорошо только при огромном объёме данных и моделях, устойчивых к высокой размерности (бустинг, трансформеры + регуляризация). В 95% индустриальных кейсов количество признаков нужно активно сокращать через отбор и снижение размерности.

Как понять, что признаков много?

Нет жёсткого универсального числа, но на практике в индустрии и на собеседованиях ориентируются на следующие пороги и соотношения:

1. Соотношение число признаков к числу объектов (n_features / n_samples)
   Самый важный индикатор.
   • > 0.1–0.2 → уже потенциально много (особенно если < 10 000 объектов)
   • > 1 (признаков больше, чем строк) → почти всегда плохо
   • >> 1 (в 5–10–100 раз больше) → высокая вероятность переобучения и проклятия размерности
2. Абсолютное количество признаков
   Ориентировочные пороги (2025–2026 годы, типичные датасеты):
   • < 50–100 → мало, комфортно для любой модели
   • 100–500 → нормально, но уже стоит подумать об отборе
   • 500–5 000 → много, почти всегда требуется отбор / снижение размерности
   • 5 000–50 000 → очень много (типично для текстов после TF-IDF, one-hot на категориях, raw изображений)
   • > 50 000–100 000 → экстремально много (геномика, очень широкие таблицы, embeddings + hand-crafted фичи)
3. Поведение модели — практические признаки «слишком много фич»
   • Сильный разрыв между train и validation / test score (переобучение)
   • Модель показывает почти идеальный score на train даже при минимальной регуляризации
   • Градиентный спуск сходится очень медленно или нестабильно (особенно в линейных моделях и нейросетях)
   • Feature importance в бустинге сильно «размазана» по тысячам признаков с близкими маленькими значениями
   • Permutation importance / SHAP показывает, что большинство признаков почти не влияют
4. Время и ресурсы
   • Обучение одной модели занимает часы вместо минут
   • Память заканчивается даже на относительно небольшом датасете
   • Кросс-валидация / подбор гиперпараметров становится нереалистичным по времени
5. Типичные сценарии, когда признаков «много»
   • После one-hot encoding на категориальных признаках с высокой кардинальностью
   • TF-IDF / CountVectorizer на текстах без ограничения max_features
   • Конкатенация множества таблиц / источников без отбора
   • Raw пиксели изображений без CNN / transfer learning
   • Embeddings + hand-crafted признаки + lags + rolling stats во временных рядах

Короткие ориентиры для ответа на собеседовании:

Признаков много, если:
• n_features > 0.1–0.2 × n_samples
• абсолютное количество > 1 000–5 000 при типичных объёмах данных
• модель сильно переобучается без жёсткой регуляризации
• большинство признаков имеют низкую важность / вклад

Если хотя бы 2–3 из этих пунктов выполняются — пора активно сокращать размерность.

Почему большое количество признаков — это плохо (помимо того, что модель не улавливает закономерность)?

Даже если предположить, что модель каким-то чудом не переобучается и всё-таки улавливает реальные закономерности — большое количество признаков всё равно создаёт множество серьёзных проблем. Вот основные из них:

1. Экспоненциально растёт требуемый объём данных
   Чтобы надёжно оценить распределение в пространстве высокой размерности, нужно экспоненциально больше примеров. При 1000 признаках даже миллионы строк часто недостаточно — остаются огромные «пустоты», где модель вынуждена интерполировать/экстраполировать вслепую.
2. Расстояния между объектами перестают быть информативными
   В высоких размерностях (обычно начиная с 20–50 измерений) почти все пары точек находятся примерно на одинаковом расстоянии (concentration of measure phenomenon). Метрики (евклидова, косинусная и др.) теряют способность различать «близко» и «далеко» → алгоритмы, основанные на расстояниях, практически перестают работать.
3. Значительно замедляется обучение и инференс
   Время обучения и предсказания почти всегда растёт линейно (а иногда квадратично) с числом признаков:
   • матричные операции в линейных моделях и нейросетях
   • построение деревьев и поиск сплитов в бустинге
   • вычисление ядер в SVM
   • forward/backward pass в нейросетях
   → на продакшене это может сделать модель неприемлемо медленной.
4. Огромный расход памяти и вычислительных ресурсов
   Каждый признак увеличивает размер матрицы X → при 100 000 признаках и 1 млн строк уже гигабайты RAM только на хранение данных. GPU/TPU тоже быстро упираются в память.
5. Сложность отладки и интерпретации модели
   Когда признаков тысячи — почти невозможно понять:
   • какие признаки реально влияют
   • почему модель приняла то или иное решение
   • откуда взялся bias / дрейф / ошибка
   → модель становится полностью чёрным ящиком, что неприемлемо для большинства бизнес-задач.
6. Значительно усложняется подбор гиперпараметров
   Больше признаков → более «шумный» и сложный ландшафт функции потерь → Optuna / Hyperopt / Bayesian optimization требуют в разы больше итераций, чтобы найти хороший набор гиперпараметров.
7. Выше риск утечек данных (data leakage)
   Чем больше признаков — тем выше вероятность случайно включить в обучение признак, который содержит информацию из будущего / из тестовой выборки / из целевой переменной (особенно после one-hot, target encoding, feature generation).
8. Сложнее поддерживать и обновлять пайплайн
   Много признаков = много источников данных, много трансформаций, больше точек отказа, сложнее мониторить дрейф признаков, дольше деплой новых версий модели.

Коротко и жёстко для собеседования:

Большое количество признаков плохо не только из-за переобучения. Это ещё: экспоненциальный рост нужного объёма данных, потеря смысла расстояний, сильное замедление обучения и инференса, огромный расход памяти, практически нулевая интерпретируемость, сложность тюнинга и поддержки пайплайна, повышенный риск утечек.

Поэтому в индустрии почти всегда активно сокращают число признаков до нескольких десятков — сотен максимум, если только это не специфические задачи с трансформерами / embeddings / очень большими данными.

Как можно бороться с большим объёмом признаков, как их сократить?

Сокращение числа признаков (feature selection + dimensionality reduction) — один из самых важных шагов в реальных ML-проектах. Вот основные, проверенные на практике способы, от самых простых и быстрых до более продвинутых:

1. Удаление полностью бесполезных признаков (быстрый ручной/автоматический отсев)
   • Признаки с нулевой или почти нулевой дисперсией (VarianceThreshold)
   • Признаки, где > 90–95% значений одинаковые (константы, почти константы)
   • Дубликаты признаков (полностью идентичные столбцы)
   • Признаки с экстремально высокой кардинальностью и низкой информативностью (ID, хэши, длинные строки без смысла)
2. Удаление сильно коррелирующих между собой признаков
   • Посчитать корреляционную матрицу (Pearson / Spearman)
   • Удалить один из пары признаков с |corr| > 0.90–0.95 (оставляем тот, который сильнее коррелирует с таргетом)
   • VIF (Variance Inflation Factor) > 10–20 — признак сильно коллинеарен с остальными
3. Filter-методы (быстрые и независимые от модели)
   • Mutual Information (самый мощный универсальный)
   • Корреляция с таргетом
   • Chi² (для категориальной целевой)
   • ANOVA F-test (для числовых признаков + категориальная цель)
   • SelectKBest / SelectPercentile / SelectFpr из sklearn
4. Embedded-методы (самые популярные в индустрии)
   • Lasso (L1-регуляризация) → веса многих признаков зануляются автоматически
   • Feature importance из Random Forest / XGBoost / LightGBM / CatBoost (gain, split, cover)
   • Permutation importance (перестановочная важность) — универсально для любой модели
   • SHAP values — суммарный |SHAP| по признакам → отбираем топ-N
5. Wrapper-методы (точные, но медленные)
   • Recursive Feature Elimination (RFE) — обучаем модель → удаляем наименее важный → повторяем
   • Boruta — оборачивает Random Forest, сравнивает с теневыми (shuffle) признаками
   • Forward / Backward selection (редко используют вручную из-за времени)
6. Снижение размерности (Dimensionality Reduction)
   • PCA / TruncatedSVD — линейное, быстрое, сохраняет ~90–95% дисперсии
   • UMAP / t-SNE — нелинейное, для визуализации и иногда как фичи
   • Autoencoders (особенно denoising или variational) — нелинейное, мощное для больших данных
   • Factor Analysis, NMF (Non-negative Matrix Factorization)
7. Target / Mean / Frequency Encoding + отсев
   Для категориальных с высокой кардинальностью:
   • Заменить на target encoding → затем отобрать по важности или корреляции
   • Frequency / count encoding → отсечь редкие категории
8. Автоматический отбор через модели, устойчивые к шуму
   • CatBoost / LightGBM с встроенной обработкой категориальных и NaN → оставить много фич, модель сама отберёт
   • Но даже в этом случае полезно предварительно убрать явный мусор
9. Комбинированный подход (самый эффективный на практике)
   1. Удалить очевидный мусор (variance=0, >95% пропусков, дубликаты)
   2. Filter: отсечь топ-500–1000 по mutual information / корреляции
   3. Embedded: обучить бустинг → взять топ-100–300 по importance / SHAP
   4. (опционально) PCA на оставшихся → 50–150 компонент
   5. Проверить на кросс-валидации: качество не упало, а время / память сильно снизились

Цель — сократить до 50–500 признаков (в зависимости от объёма данных), чтобы:

• избежать переобучения
• ускорить обучение в 5–50 раз
• снизить потребление памяти
• упростить деплой и мониторинг
• повысить интерпретируемость

Коротко для собеседования:

Борются с большим числом признаков через: удаление мусора → filter-методы (mutual info, корреляция) → embedded (Lasso, feature importance бустинга, SHAP, permutation) → wrapper (RFE, Boruta) → снижение размерности (PCA, UMAP, autoencoders). Самый популярный стек в индустрии: filter + бустинг importance + SHAP → проверка на CV.

Какие методы поиска выбросов вы знаете?

Вот наиболее часто используемые и спрашиваемые на собеседованиях методы обнаружения выбросов. Группирую их по типам подхода.

1. Статистические методы (на основе распределения)
   • Z-score / Modified Z-score (MAD) — |z| > 3–3.5
   • IQR-метод (Tukey) — значения за пределами [Q1−1.5×IQR; Q3+1.5×IQR]
   • Grubbs’ test, Dixon’s Q-test — для небольшого числа выбросов
   • ESD (Generalized Extreme Studentized Deviate) — для нескольких выбросов
2. Методы на основе расстояний
   • K-Nearest Neighbors (KNN) distance — среднее расстояние до k ближайших соседей
   • Local Outlier Factor (LOF) — сравнивает локальную плотность точки с соседями
   • DBSCAN — точки, не попавшие ни в один кластер (label = -1)
   • Isolation-based — точки, которые изолируются быстрее остальных
3. Методы на основе изоляции (Isolation-based)
   • Isolation Forest — строит случайные деревья, выбросы изолируются быстрее (меньше глубина пути)
   • Extended Isolation Forest (EIF) — улучшенная версия с гиперплоскостями
4. Методы на основе плотности
   • DBSCAN / HDBSCAN — шумовые точки
   • LOF (уже упоминался)
   • COPOD (COPula-based Outlier Detection) — использует копулы для оценки хвостов распределения
   • HBOS (Histogram-based Outlier Score) — быстрый, основан на гистограммах одномерных признаков
5. Реконструкционные методы (на основе автоэнкодеров)
   • Autoencoder + reconstruction error — высокая ошибка = выброс
   • Variational Autoencoder (VAE) — KL-дивергенция + reconstruction
   • Denoising Autoencoder
   • LSTM / Transformer-based autoencoders для последовательностей
6. Методы на основе one-class классификации
   • One-Class SVM — обучается только на «нормальных» данных, отделяет их от остального пространства
   • One-Class Random Forest / Isolation Forest (пересекается)
7. Быстрые и лёгкие методы для больших данных
   • HBOS (Histogram-based)
   • ECOD (Evolutionary Copula Outlier Detection)
   • FastABOD
   • LODA (Lightweight Online Detector of Anomalies)
8. Контекстно-зависимые / временные / пространственные
   • ARIMA / Prophet + остатки
   • STL decomposition + аномалии в остатках
   • Matrix Profile (для временных рядов)
   • Collective And Point Outliers в последовательностях
9. Ансамблевые и мета-подходы
   • PyOD / ADTK — библиотеки, которые комбинируют десятки методов
   • Voting / averaging нескольких скореров (Isolation Forest + LOF + Autoencoder + HBOS и т.д.)

Самые популярные в индустрии (2025–2026)

• Isolation Forest (быстрый, масштабируемый, не требует тюнинга k)
• LOF и DBSCAN/HDBSCAN (когда нужна плотностная интерпретация)
• Autoencoder-based (особенно если уже есть нейросети в пайплайне)
• HBOS / COPOD / ECOD (очень быстрые, хороши для табличных данных)
• IQR + Z-score (первые простые проверки, baseline)

Коротко для ответа на собеседовании:

Основные методы: статистические (Z-score, IQR), на основе расстояний (LOF, DBSCAN), изоляционные (Isolation Forest), плотностные (HBOS, COPOD), реконструкционные (Autoencoders), one-class (One-Class SVM). В продакшене чаще всего используют Isolation Forest, LOF, HBOS, COPOD и автоэнкодеры — они хорошо масштабируются и не требуют сильного тюнинга.

Что такое дисбаланс классов и почему это плохо?

Дисбаланс классов (class imbalance) — это ситуация в задаче классификации, когда один (или несколько) классов представлены в данных значительно чаще, чем остальные.

Примеры реальных пропорций:

• Фрод / не фрод — 1 : 100–1000
• Отток клиентов — 5–15% (1 : 6–20)
• Брак на производстве — 0.1–2%
• Редкие заболевания в медицине — 1 : 1000–10 000
• Обнаружение объектов на изображении — фон занимает 90–99% пикселей

Почему дисбаланс классов — это плохо

1. Модель «учится» игнорировать редкий класс
   Если 95% объектов — класс 0, то модель может просто всегда предсказывать 0 и получить accuracy 95%. Это оптимально по умолчанию, но абсолютно бесполезно для бизнеса.
2. Accuracy становится бесполезной метрикой
   При сильном дисбалансе accuracy обманчиво высокая, даже если модель не находит ни одного положительного примера.
3. Смещение в сторону мажорного класса
   Большинство алгоритмов (особенно деревья, логистическая регрессия без балансировки) оптимизируют среднюю ошибку по всем объектам → минимизация ошибок на мажорном классе даёт больший выигрыш, чем на минорном.
4. Плохо работают вероятностные предсказания
   Модель недооценивает вероятности редкого класса → калиброванные вероятности смещаются вниз (например, максимальная вероятность фрода может быть всего 0.2–0.3 даже при реальном фроде).
5. Проблемы с градиентным спуском в нейросетях
   Градиенты от минорного класса «теряются» на фоне огромного количества градиентов от мажорного → обучение идёт медленно или вообще останавливается на минорном классе.
6. Сложнее интерпретировать feature importance
   Важность признаков начинает отражать в первую очередь мажорный класс, а не то, что отличает редкий класс.
7. Резко падают метрики на минорном классе
   Precision, Recall, F1-score, PR-AUC, ROC-AUC (частично) — всё сильно страдает, если не бороться с дисбалансом.

Когда дисбаланс особенно опасен

• Задачи, где минорный класс критически важен (фрод, отток, дефекты, рак, терроризм, отказ оборудования)
• Когда стоимость ложноположительного и ложноотрицательного сильно различается
• При очень сильном дисбалансе (1:100 и хуже)

Коротко для собеседования:

Дисбаланс классов — когда один класс сильно преобладает. Это плохо, потому что модель учится игнорировать редкий класс, accuracy становится обманчивой, метрики на минорном классе падают, вероятности смещаются, а градиентный спуск плохо работает с минорным классом. В задачах, где редкий класс критичен (фрод, отток, дефекты), без борьбы с дисбалансом модель бесполезна.

Как можно сбалансировать выборку, какие есть методы (under sampling, oversampling)?

Существует несколько основных подходов к борьбе с дисбалансом классов. Их можно разделить на три большие группы: изменение выборки (sampling), изменение весов классов и изменение функции потерь / архитектуры модели.

1. Методы изменения выборки (Sampling methods)

1. Under-sampling (недосэмплирование мажорного класса)
   Уменьшаем количество объектов мажорного класса до уровня минорного.
   Варианты:
   • Random Under-Sampling — случайное удаление объектов мажорного класса
   • NearMiss (1, 2, 3) — удаляем объекты мажорного класса, которые находятся близко к минорным
   • Tomek Links — удаляем пары объектов разных классов, которые являются ближайшими соседями
   • Edited Nearest Neighbors (ENN) — удаляем объекты мажорного класса, чьи соседи в основном другого класса
   • Cluster Centroids — кластеризуем мажорный класс и заменяем кластеры на центроиды
2. Over-sampling (пересэмплирование минорного класса)
   Увеличиваем количество объектов минорного класса.
   Варианты:
   • Random Over-Sampling — простое дублирование минорных объектов (риск переобучения)
   • SMOTE (Synthetic Minority Over-sampling Technique) — создаёт синтетические примеры, интерполируя между ближайшими соседями минорного класса
   • Borderline-SMOTE — SMOTE только для объектов на границе классов
   • ADASYN — адаптивный SMOTE: больше синтетических примеров создаётся там, где модель ошибается сильнее
   • SMOTE-NC / SMOTE-N — для категориальных признаков
   • GAN-based oversampling (CTGAN, TableGAN) — генеративные модели для создания реалистичных синтетических примеров
3. Гибридные методы (комбинация under + over)
   • SMOTE + Tomek Links / ENN
   • SMOTE + Edited Nearest Neighbors
   • SMOTE + Cluster Centroids

2. Методы без изменения выборки (рекомендуются чаще всего в продакшене)

4. Class weights / sample weights
   Присваиваем больший вес минорному классу в функции потерь.
   • В sklearn: class_weight='balanced' или вручную {0:1, 1:10}
   • В XGBoost / LightGBM / CatBoost: scale_pos_weight или class_weights
   • В PyTorch / TensorFlow: weighted CrossEntropyLoss / weighted sampler
5. Изменение функции потерь
   • Focal Loss — снижает вклад легко классифицируемых примеров
   • Dice Loss / Tversky Loss — популярны в сегментации
   • Asymmetric Loss — разные веса для FP и FN
6. Threshold moving / probability calibration
   После обучения сдвигаем порог классификации (не 0.5, а 0.1–0.3 для минорного класса), чтобы увеличить recall минорного класса.
7. Ensemble-методы с балансировкой
   • Balanced Random Forest
   • RUSBoost / SMOTEBoost / EasyEnsemble / BalancedBagging
   • XGBoost / LightGBM с subsample + scale_pos_weight

Что обычно используют в индустрии (2025–2026)

• Самый частый и надёжный вариант: class_weight='balanced' или scale_pos_weight в бустинге
• Если дисбаланс очень сильный (1:50+): class weights + focal loss / threshold tuning
• SMOTE и его вариации — только если данных мало и бустинг с весами даёт плохой recall
• Under-sampling — редко, только если датасет огромный (>10 млн строк) и память/время критичны
• Генеративные методы (GAN, VAE, diffusion) — пока в основном в research и специфических задачах (медицина, фрод)

Коротко для собеседования:

Основные способы балансировки: under-sampling (Random, NearMiss, Tomek), over-sampling (Random, SMOTE, ADASYN, Borderline-SMOTE), class weights в функции потерь (самый популярный в продакшене), focal loss, threshold tuning, ensemble-методы (Balanced RF, RUSBoost). В большинстве реальных задач начинают с class weights в XGBoost/LightGBM/CatBoost — это просто, быстро и эффективно.

Что делать, если в данных есть дисбаланс классов? И как с ним бороться (Upsampling, Downsampling, SMOTE)?

Дисбаланс классов — одна из самых частых проблем в реальных задачах классификации. Самое главное правило: не игнорировать его и не доверять метрике accuracy.

Порядок действий, который обычно ожидают услышать на собеседовании (middle+/senior):

1. Выбрать правильные метрики
   Accuracy почти всегда бесполезна.
   Обязательно смотрим:
   • Precision / Recall / F1-score (macro, micro, weighted)
   • PR-AUC (Precision-Recall AUC) — почти всегда лучше ROC-AUC при сильном дисбалансе
   • ROC-AUC — всё ещё полезен, но менее чувствителен
   • Confusion matrix в абсолютных числах и в процентах
   • Business-метрики (стоимость ошибки, lift, precision@k и т.д.)
2. Понять бизнес-контекст и стоимость ошибок
   • Что дороже: пропустить фрод / отток / дефект или ложный сигнал?
   • Это сразу определяет, на что оптимизировать: recall минорного класса, precision или их баланс (Fβ-score с β > 1)
3. Простейшие и самые эффективные способы борьбы (в порядке приоритета 2025–2026)

Методы борьбы с дисбалансом (от самого рекомендуемого к менее)

• Class weights / sample weights — №1 в большинстве продакшен-кейсов
  • XGBoost / LightGBM / CatBoost: scale_pos_weight или class_weights
  • sklearn: class_weight='balanced' или словарь {0:1, 1:10}
  • Нейросети: weighted CrossEntropyLoss
  Плюсы: просто, быстро, не меняет объём данных, обычно даёт лучший результат
• Focal Loss, Asymmetric Loss, Dice Loss и другие специализированные лоссы
  Особенно хорошо работают в нейросетях и при экстремальном дисбалансе (1:100+)
• Threshold tuning / probability calibration
  После обучения сдвигаем порог (не 0.5, а 0.1–0.3) → повышаем recall минорного класса
  Плюс калибровка вероятностей (Platt scaling, Isotonic regression, Temperature scaling)
• SMOTE и его семейство (over-sampling минорного класса)
  • SMOTE — классика, интерполяция между ближайшими соседями
  • Borderline-SMOTE, ADASYN, SMOTE-NC (для категориальных)
  Когда использовать: мало данных (< 10–50 тыс. строк), бустинг с весами даёт плохой recall
  Минусы: риск переобучения, создание нереалистичных примеров, плохо работает на высокоразмерных данных
• Under-sampling мажорного класса
  • Random Under-Sampling
  • NearMiss, Tomek Links, ENN, Cluster Centroids
  Когда использовать: очень большой датасет (> 1–10 млн строк), память/время критичны
  Минусы: теряем много информации из мажорного класса → часто падает качество
• Гибридные подходы
  • SMOTE + Tomek / ENN
  • SMOTE + under-sampling
  • Balanced Random Forest / RUSBoost / EasyEnsemble
• Генеративные методы (редко в продакшене пока)
  • CTGAN, TabDDPM, VAEs для генерации синтетических минорных примеров
  • Применяют в основном в медицине, фроде, когда данных катастрофически мало

Реальный порядок действий в большинстве проектов:

1. Считаем метрики на дисбалансе (PR-AUC, F1, recall минорного класса)
2. Ставим class_weight='balanced' или scale_pos_weight = count(negative)/count(positive)
3. Смотрим, насколько вырос recall / F1 / PR-AUC
4. Если всё ещё плохо — пробуем Focal Loss / threshold tuning
5. Только если данных мало и recall всё равно низкий — SMOTE / ADASYN
6. Under-sampling — почти никогда первым выбором

Коротко для ответа на собеседовании:

При дисбалансе классов в первую очередь используем class weights в бустинге (scale_pos_weight), смотрим PR-AUC и F1-score вместо accuracy. Далее — threshold tuning и/или Focal Loss. SMOTE и ADASYN применяем, только если мало данных и веса не помогают. Under-sampling — редко, только на очень больших датасетах. Главное — понимать стоимость ошибок и оптимизировать бизнес-метрику, а не просто балансировать выборку.

Какие методы отбора признаков (feature selection) вы знаете (Filter, Wrapper, Embedded)?

Существует три классических семейства методов отбора признаков. Они отличаются по тому, как именно оценивается полезность признаков.

1. Filter methods (фильтрующие методы)
   Оценивают каждый признак независимо от модели, которую потом будем обучать.
   Работают очень быстро, не требуют обучения модели.
   Основные метрики и подходы:
   • Pearson / Spearman correlation с целевой переменной
   • Mutual Information (взаимная информация)
   • Chi² (χ²-критерий) — для категориальных признаков и целевой
   • ANOVA F-value / Fisher score
   • Information Gain, Gini impurity decrease
   • Variance Threshold (удаляем признаки с очень низкой дисперсией)
   • SelectKBest, SelectPercentile, SelectFpr / SelectFdr
   Плюсы: скорость, независимость от модели.
   Минусы: не учитывают взаимодействия между признаками.
2. Wrapper methods (обёрточные методы)
   Используют саму целевую модель как «чёрный ящик» для оценки качества подмножества признаков.
   Основные подходы:
   • Forward Selection — начинаем с пустого набора, по одному добавляем лучший признак
   • Backward Elimination — начинаем со всех признаков, по одному удаляем худший
   • Recursive Feature Elimination (RFE) — обучаем модель → удаляем наименее важный признак → повторяем
   • Stepwise selection (гибрид forward + backward)
   • Эволюционные алгоритмы, генетические алгоритмы (редко)
   Плюсы: учитывают конкретную модель и взаимодействия признаков.
   Минусы: очень медленные (многократное обучение модели), склонны к переобучению на маленьких выборках.
3. Embedded methods (встроенные методы)
   Отбор признаков происходит внутри процесса обучения модели — важность признаков извлекается «изнутри» алгоритма.
   Самые популярные реализации:
   • Lasso (L1-регуляризация) — многие коэффициенты зануляются автоматически
   • Elastic Net (L1 + L2)
   • Деревья решений / Random Forest / Gradient Boosting:
   – feature importance по gain / split / cover
   – permutation importance (перестановочная важность)
   • XGBoost / LightGBM / CatBoost — встроенные метрики важности + SHAP values
   • Нейронные сети — dropout + анализ весов / градиентов / attention scores (редко используется как основной метод)
   Плюсы: хороший баланс скорости и качества, учитывает взаимодействия, работает с конкретной моделью.
   Минусы: привязан к типу модели (нельзя взять Lasso importance и сразу использовать в CatBoost без переобучения).

Краткое сравнение (что чаще всего спрашивают)

Критерий	Filter	Wrapper	Embedded
Скорость	Очень быстро	Очень медленно	Быстро-средне
Учитывает взаимодействия признаков	Нет	Да	Да
Зависит от модели	Нет	Да	Да
Риск переобучения	Низкий	Высокий	Средний
Самые популярные в индустрии	Mutual Info, корреляция	RFE (редко)	Бустинг importance + SHAP + Lasso

На практике в 2025–2026 годах чаще всего используют комбинацию:

• Filter (быстрый отсев) → Embedded (бустинг / Lasso / SHAP) → (при необходимости) RFE или Boruta

Короткий ответ для собеседования:

Filter — быстрые, независимые от модели (корреляция, mutual information, chi², variance threshold).
Wrapper — медленные, используют модель (forward/backward selection, RFE).
Embedded — встроенные в обучение (Lasso, feature importance в деревьях и бустинге, SHAP). В продакшене доминируют embedded-методы на градиентном бустинге + permutation / SHAP importance.

Как оценивать важность признаков (feature importance)?

Оценка важности признаков (feature importance) — это способ понять, какие признаки вносят наибольший вклад в предсказания модели. Существует несколько подходов, и выбор зависит от типа модели и задачи.

Основные методы оценки важности признаков

1. Встроенная важность в деревьях и бустинге (Tree-based feature importance)
   Самый популярный и часто используемый в индустрии подход.
   Варианты расчёта:
   • gain / information gain — суммарное уменьшение impurity (энтропии / Джини / MSE) по всем сплитам на этом признаке
   • cover / weighted number of observations — сколько объектов прошло через сплиты по этому признаку (взвешенно)
   • split count / frequency — сколько раз признак использовался для сплита
   Реализации:
   • XGBoost: get_score(importance_type='gain' / 'weight' / 'cover')
   • LightGBM: feature_importance(importance_type='gain' / 'split')
   • CatBoost: get_feature_importance(prettified=True)
   • RandomForest: feature_importances_
   Плюсы: быстро, бесплатно при обучении, довольно надёжно на табличных данных.
   Минусы: может переоценивать числовые признаки с большим количеством уникальных значений и коррелированные признаки.
2. Permutation Importance (перестановочная важность)
   Универсальный метод, работает с любой моделью (не только деревьями).
   Как считается:
   1. Обучаем модель → получаем baseline score на валидации
   2. Для каждого признака по очереди перемешиваем (shuffle) его значения → измеряем, насколько упал score
   3. Чем больше падение — тем важнее признак
   Реализации:
   • sklearn.inspection.permutation_importance
   • eli5.permutation_importance
   • boruta_py (использует именно permutation)
   Плюсы: модель-независимый, учитывает взаимодействия, надёжнее встроенной важности при корреляциях.
   Минусы: требует отдельного вычисления (медленнее), чувствителен к случайности (нужен n_repeats=10–50).
3. SHAP values (Shapley Additive explanations)
   Самый современный и интерпретируемый способ (основан на теории игр).
   Показывает вклад каждого признака в каждое конкретное предсказание (локальная важность) и в целом по модели (глобальная).
   Глобальная важность: mean(|SHAP|) по всем примерам.
   Реализации:
   • shap library (shap.TreeExplainer для бустинга, KernelExplainer для любых моделей)
   • shap.summary_plot, shap.bar_plot, shap.beeswarm
   Плюсы: теоретически обоснован, учитывает взаимодействия, показывает направление влияния (+/−), визуально красивый.
   Минусы: медленный на больших данных (особенно KernelExplainer), требует памяти.
4. Coefficient magnitude в линейных моделях
   • Линейная / логистическая регрессия: abs(coef_) после стандартизации признаков
   • Lasso / Ridge: величина коэффициентов (в Lasso многие зануляются)
   • Elastic Net
   Важно: признаки должны быть стандартизованы (StandardScaler), иначе сравнивать нельзя.
   Плюсы: просто и интерпретируемо.
   Минусы: только для линейных моделей, не учитывает нелинейные взаимодействия.
5. Drop-column importance (удаление столбца)
   Обучаем модель без каждого признака по очереди → смотрим, насколько упал score.
   Плюсы: максимально честный способ.
   Минусы: очень медленно (нужно переобучать модель n_features раз).
6. Другие менее частые методы
   • Mutual Information / корреляция (filter-подход, но не настоящая importance модели)
   • Boruta (оборачивает permutation importance над Random Forest)
   • LOFO (Leave-One-Feature-Out) — аналог drop-column, но быстрее
   • Partial Dependence / Accumulated Local Effects (PDP / ALE) — косвенно показывают влияние

Что используют в реальных проектах (2025–2026)

• Быстрый взгляд → встроенная importance бустинга (gain)
• Честная оценка → permutation importance (sklearn или eli5)
• Максимальная интерпретируемость и отчёт руководству / бизнесу → SHAP (summary plot + bar plot)
• Отбор признаков → комбинация: permutation / SHAP + встроенная важность → отбираем топ-50–300

Короткий ответ для собеседования:

Самые популярные способы: встроенная важность в бустинге (gain/split), permutation importance (универсальный и честный), SHAP values (самый интерпретируемый и теоретически обоснованный). Для линейных моделей — абсолютные значения коэффициентов после стандартизации. В продакшене чаще всего начинают с gain в XGBoost/LightGBM/CatBoost, затем проверяют permutation importance и визуализируют через SHAP.

Что такое permutations importance?

Permutation Importance — это один из самых надёжных и универсальных способов оценить, насколько важен каждый признак для качества предсказаний модели.

Идея очень простая и интуитивно понятная:

• Обучаем модель → получаем базовое качество (baseline score) на валидационной / тестовой выборке
• Для каждого признака по очереди случайным образом перемешиваем (shuffle) значения этого признака в выборке
• Снова считаем качество модели на этих «испорченных» данных
• Смотрим, насколько сильно упал score по сравнению с baseline
• Чем больше падение метрики после перемешивания признака — тем важнее этот признак

Почему это работает:

Если признак действительно важен — его случайное перемешивание сильно разрушает зависимость между признаком и целевой переменной → качество модели заметно падает. Если признак не важен — перемешивание почти ничего не меняет → score остаётся примерно тем же.

Ключевые преимущества Permutation Importance

1. Модель-независимый метод — работает с любой моделью (бустинг, нейросети, линейные модели, SVM, KNN и т.д.)
2. Учитывает взаимодействия между признаками (в отличие от встроенной importance в деревьях)
3. Оценивает реальный вклад в качество на отложенной выборке, а не на тренировочной
4. Менее склонен к переоценке числовых признаков с высокой кардинальностью (в отличие от gain в бустинге)
5. Легко интерпретировать: падение метрики прямо показывает, насколько модель зависит от признака

Недостатки и нюансы

• Медленнее встроенной важности (нужно делать много предсказаний для каждого признака)
• Чувствителен к случайности → рекомендуется делать несколько перестановок (n_repeats = 10–50) и брать среднее
• Если признаки сильно коррелированы — важность может «размазываться» между ними
• На очень больших датасетах может занимать много времени (но можно делать на подвыборке)

Реализации (самые популярные)

• sklearn.inspection.permutation_importance — стандарт в sklearn
• eli5.permutation_importance — удобный вывод и визуализация
• Вручную через numpy.random.permutation
• В shap library есть permutation explainer (но чаще используют TreeExplainer для бустинга)

Коротко для собеседования (самый частый ожидаемый ответ):

Permutation Importance — метод оценки важности признаков: обучаем модель, считаем baseline-метрику на валидации, затем по очереди перемешиваем значения каждого признака и смотрим, насколько сильно падает качество. Чем больше падение — тем важнее признак. Это универсальный, честный и модель-независимый способ, который хорошо учитывает взаимодействия и реальную пользу признака.

На практике чаще всего используют именно permutation importance или SHAP, когда встроенная важность бустинга вызывает сомнения.

Какие существуют методы сокращения размерности?

Методы сокращения размерности (Dimensionality Reduction)

Сокращение размерности — это преобразование данных из пространства высокой размерности в пространство меньшей размерности с минимальной потерей полезной информации. Основные цели: борьба с проклятием размерности, ускорение обучения, уменьшение переобучения, улучшение визуализации, упрощение интерпретации.

1. PCA (Principal Component Analysis) — Метод главных компонент
   Линейный метод.
   Находит ортогональные направления максимальной дисперсии данных → новые оси (главные компоненты).
   Используется: когда данные примерно линейны, нужно сохранить максимум дисперсии.
   Варианты: Kernel PCA (нелинейный), Incremental PCA (для больших данных), TruncatedSVD (для разреженных матриц, например TF-IDF).
   Реализация: sklearn.decomposition.PCA, TruncatedSVD.
2. UMAP (Uniform Manifold Approximation and Projection)
   Нелинейный метод, очень популярен в 2020-х годах.
   Сохраняет как локальную, так и глобальную структуру данных лучше, чем t-SNE.
   Быстрее t-SNE, масштабируется на большие датасеты, даёт более стабильные результаты.
   Используется: визуализация, как предобработка перед классификацией/кластеризацией.
   Реализация: umap-learn библиотека.
3. t-SNE (t-distributed Stochastic Neighbor Embedding)
   Нелинейный метод, классика для визуализации.
   Сильно сохраняет локальную структуру (близкие точки остаются близкими).
   Минусы: не сохраняет глобальную структуру, нестабильные результаты при разных random_state, очень медленный на больших данных, нельзя использовать для новых точек без переобучения.
   Реализация: sklearn.manifold.TSNE.
4. Autoencoders (автоэнкодеры) и Variational Autoencoders (VAE)
   Нейросетевые методы.
   Обучают сеть с узким «бутылочным горлышком» (bottleneck layer) → сжимают данные в низкоразмерное представление.
   Плюсы: нелинейное сжатие, можно использовать denoising autoencoder для удаления шума.
   VAE добавляет вероятностную интерпретацию (генеративная модель).
   Реализация: PyTorch / TensorFlow / Keras.
5. LDA (Linear Discriminant Analysis)
   Линейный метод с учителем (supervised).
   Максимизирует разделимость классов (межклассовая дисперсия / внутриклассовая дисперсия).
   Используется: когда есть метки классов, нужно снизить размерность перед классификацией.
   Минус: максимум c-1 компонент (c — число классов).
   Реализация: sklearn.discriminant_analysis.LinearDiscriminantAnalysis.
6. Non-negative Matrix Factorization (NMF)
   Разложение матрицы на две неотрицательные матрицы.
   Хорошо работает с данными, где значения неотрицательны (TF-IDF, изображения, химия).
   Интерпретируемые компоненты (как «темы» в текстах).
   Реализация: sklearn.decomposition.NMF.
7. Factor Analysis (FA)
   Похож на PCA, но предполагает, что наблюдаемые признаки — линейная комбинация скрытых факторов + шум.
   Используется в психометрии, маркетинге.
8. Isomap, Locally Linear Embedding (LLE), Spectral Embedding
   Нелинейные классические методы (manifold learning).
   Сейчас используются редко, потому что UMAP почти всегда лучше.
9. Random Projection
   Очень быстрый линейный метод.
   Проецирует данные на случайные направления (Johnson-Lindenstrauss lemma).
   Используется: когда нужно очень быстро снизить размерность на огромных данных (миллионы строк × десятки тысяч признаков).
   Реализация: sklearn.random_projection.GaussianRandomProjection, SparseRandomProjection.

Что чаще всего используют в индустрии (2025–2026)

• Табличные данные → PCA / TruncatedSVD
• Визуализация и кластеризация → UMAP (почти всегда побеждает t-SNE)
• Когда есть метки → LDA
• Глубокое обучение / большие данные → Autoencoders / VAE
• Огромные разреженные матрицы (текст, TF-IDF) → TruncatedSVD
• Быстрый baseline → Random Projection

Коротко для собеседования:

Линейные: PCA, TruncatedSVD, LDA, Random Projection.
Нелинейные: UMAP (самый популярный сейчас), t-SNE (для визуализации), Autoencoders / VAE (нейросетевые).
Другие: NMF (неотрицательные данные), Isomap / LLE (редко).
В продакшене доминируют PCA + UMAP + автоэнкодеры, в зависимости от задачи и типа данных.

Опишите метод главных компонент (PCA).

PCA — это линейный метод сокращения размерности и извлечения признаков, который преобразует набор из p исходных признаков в набор из k ≤ p новых ортогональных (независимых) признаков, называемых главными компонентами. При этом сохраняется максимум возможной дисперсии исходных данных.

Основная идея PCA

Найти такие новые оси (направления) в пространстве признаков, вдоль которых данные имеют наибольшую дисперсию. Первая главная компонента — направление максимальной дисперсии, вторая — максимальной дисперсии при условии ортогональности первой, и так далее.

Математическая суть (как это работает)

1. Центрируем данные: вычитаем из каждого признака его среднее значение (mean = 0 по каждому столбцу)
2. (Опционально, но очень часто) Стандартизируем признаки (делим на стандартное отклонение → дисперсия = 1 по каждому признаку)
3. Вычисляем ковариационную матрицу Σ размером p × p
4. Находим собственные значения (eigenvalues) и собственные векторы (eigenvectors) матрицы Σ
5. Сортируем собственные векторы по убыванию соответствующих собственных значений
6. Берём первые k собственных векторов → это матрица проекции W (p × k)
7. Проецируем исходные данные на новые оси: X_new = X_centered × W

Собственные значения показывают, сколько дисперсии объясняет каждая главная компонента.

Ключевые свойства главных компонент

• Они ортогональны друг другу (независимы)
• Первая компонента объясняет максимум дисперсии
• Вторая — максимум оставшейся дисперсии
• И так далее → дисперсия убывает
• Сумма дисперсий всех главных компонент = сумма дисперсий всех исходных признаков (после стандартизации)

Когда и зачем используют PCA

1. Сокращение размерности перед обучением моделей (особенно чувствительных к масштабу: SVM, KNN, нейросети, логистическая регрессия)
2. Удаление коллинеарности и мультиколлинеарности
3. Ускорение обучения и инференса
4. Уменьшение переобучения при большом числе признаков
5. Визуализация данных (проекция на 2–3 компоненты)
6. Шумоподавление (оставляем только компоненты с большой дисперсией)

Важные нюансы и ограничения

• Линейный метод → плохо работает, если зависимости нелинейные (тогда лучше UMAP, t-SNE, autoencoders)
• Чувствителен к масштабу → почти всегда нужна стандартизация перед PCA
• Главные компоненты не интерпретируемы напрямую (это линейные комбинации исходных признаков)
• Не учитывает целевую переменную (unsupervised) → если есть метки, часто лучше LDA
• На разреженных данных (текст, TF-IDF) используют TruncatedSVD вместо классического PCA

Коротко для собеседования (самый частый ожидаемый ответ):

PCA — линейный метод сокращения размерности. Центрирует и (обычно) стандартизирует данные, вычисляет ковариационную матрицу, находит её собственные векторы и значения, сортирует по убыванию дисперсии и проецирует данные на первые k главных компонент. Цель — сохранить максимум дисперсии при минимальном числе новых признаков. Самый популярный и быстрый способ борьбы с высокой размерностью и коллинеарностью.

Каковы предположения (assumptions) линейной регрессии?

Классическая линейная регрессия (Ordinary Least Squares, OLS) даёт несмещённые, состоятельные и эффективные оценки только при выполнении следующих ключевых предположений. На собеседованиях чаще всего спрашивают именно их в таком порядке:

1. Линейность зависимости (Linearity)
   Зависимая переменная y линейно зависит от независимых переменных X:
   y = β₀ + β₁x₁ + β₂x₂ + … + βₚxₚ + ε
   Если связь нелинейная — модель будет давать систематическую ошибку (bias).
2. Независимость наблюдений (Independence of observations)
   Ошибки εᵢ и εⱼ независимы друг от друга для любых i ≠ j.
   Нарушение: автокорреляция (временные ряды, пространственные данные, кластерные данные).
3. Гомоскедастичность (Homoscedasticity / Constant variance)
   Дисперсия ошибок одинакова при всех значениях X:
   Var(εᵢ | X) = σ² = const
   Нарушение: heteroscedasticity (дисперсия растёт/убывает с ростом X) → оценки β несмещённые, но неэффективные, стандартные ошибки неверные → доверительные интервалы и p-value искажены.
4. Нормальность остатков (Normality of residuals)
   Ошибки εᵢ ~ N(0, σ²) (нормально распределены с нулевым математическим ожиданием).
   Важно для:
   • корректных t- и F-тестов
   • доверительных интервалов и p-value
   При больших выборках (по ЦПТ) это предположение можно ослабить.
5. Отсутствие мультиколлинеарности (No perfect multicollinearity)
   Независимые переменные X₁, …, Xₚ линейно независимы.
   Если есть точная мультиколлинеарность → матрица XᵀX вырождена → нельзя найти уникальные β.
   При сильной (но не идеальной) мультиколлинеарности → оценки β нестабильны, имеют большие стандартные ошибки, трудно интерпретировать коэффициенты.
6. Математическое ожидание ошибок равно нулю (Zero conditional mean)
   E(εᵢ | X) = 0
   То есть нет систематического смещения, все нелинейные эффекты и взаимодействия уже учтены в модели.
7. Отсутствие автокорреляции ошибок (No autocorrelation)
   Cov(εᵢ, εⱼ | X) = 0 для i ≠ j
   Часто выделяют отдельно от независимости наблюдений, особенно во временных рядах.

Самые важные на практике (что чаще всего спрашивают строго)

• Линейность
• Независимость наблюдений
• Гомоскедастичность
• Нормальность остатков (для вывода и тестов)
• Отсутствие (сильной) мультиколлинеарности

Короткий и точный ответ, который обычно хотят услышать:

Классические предположения линейной регрессии OLS:
1. Линейная зависимость y от X
2. Независимость наблюдений
3. Гомоскедастичность ошибок (постоянная дисперсия)
4. Нормальность остатков
5. Отсутствие идеальной мультиколлинеарности
6. E(ε | X) = 0

Если нарушаются — оценки β остаются несмещёнными, но теряют эффективность, стандартные ошибки искажаются, тесты и интервалы становятся некорректными. В таких случаях переходят к робастным методам, GLS, Ridge/Lasso, бутстрэпу и т.д.

Почему перед деревьями не нужно делать масштабирование признаков?

Деревья решений (включая Random Forest, XGBoost, LightGBM, CatBoost и любые другие древовидные модели) **нечувствительны к масштабу и распределению признаков**. Масштабирование (стандартизация, нормализация, MinMax) перед ними не требуется и практически никогда не улучшает качество модели.

Почему так происходит (основные причины)

1. Деревья принимают решения на основе порогов (thresholds)
   В каждом узле дерево ищет признак и пороговое значение, которое лучше всего разделяет данные по целевой переменной (например, Gini, энтропия, MSE).
   Пример:
   • Признак «возраст»: 18–80 лет
   • Признак «зарплата»: 30 000–300 000 руб.
   Дерево найдёт сплит вида «зарплата ≤ 85 432» или «возраст ≤ 37» — абсолютные значения не важны, важен только порядок и то, как порог разделяет классы/значения.
2. Порядок значений сохраняется при любом монотонном преобразовании
   Если умножить все значения признака на 1000, прибавить 500 или взять логарифм — порядок объектов остаётся тем же самым.
   А дерево решений смотрит именно на **порядок** (ранжирование), а не на абсолютные расстояния или масштаб.
3. Каждый признак рассматривается независимо
   В отличие от линейных моделей, SVM, KNN, нейросетей — в дереве на каждом шаге выбирается **один** признак и **один** порог.
   Нет матричных операций, нет вычисления расстояний между объектами → масштаб одного признака не влияет на другие.
4. Feature importance тоже не зависит от масштаба
   Важность признака (gain, cover, split) считается по тому, сколько раз и насколько сильно он улучшил разделение — масштаб здесь не играет роли.

Когда масштабирование всё-таки может быть полезно даже с деревьями (очень редкие случаи)

• Если вы используете **монотонные ограничения** (monotonic constraints) в XGBoost/LightGBM — иногда масштаб может влиять на стабильность поиска порогов
• При комбинировании деревьев с линейными моделями в одном пайплайне (например, stacking или two-stage модели)
• Если признаки имеют экстремально разные порядки (10⁻⁶ и 10⁹) — численная стабильность в некоторых реализациях может немного страдать (но на практике почти никогда)

Поэтому в 99,9% случаев перед любыми древовидными моделями (Decision Tree, Random Forest, XGBoost, LightGBM, CatBoost) **масштабирование не делают**.

Коротко и чётко для собеседования:

Деревья решений нечувствительны к масштабу признаков, потому что они принимают решения на основе порогов и порядка значений, а не абсолютных расстояний или величин. Масштабирование, стандартизация или нормализация перед деревьями и бустингом не требуется и не улучшает качество модели. Это одно из главных преимуществ древовидных алгоритмов по сравнению с линейными моделями, KNN, SVM и нейросетями.

Почему в метрических моделях обязательно делать масштабирование признаков?

Метрические модели (или модели, основанные на расстояниях) — это алгоритмы, которые в процессе работы явно или неявно вычисляют расстояния между объектами (евклидово, манхэттенское, косинусное, Минковского и т.д.). К ним относятся:

• K-Nearest Neighbors (KNN)
• K-Means, K-Medoids, DBSCAN, HDBSCAN
• SVM / SVC / SVR (особенно с RBF-ядром)
• Hierarchical clustering
• LOF, Isolation Forest (частично)
• Многие нейросети с евклидовыми расстояниями в embedding-пространстве

В этих алгоритмах масштаб признаков **напрямую влияет на результат**, потому что расстояние считается по формуле вида:

d(x, y) = √ Σ (xᵢ − yᵢ)² или Σ |xᵢ − yᵢ|

Если один признак имеет диапазон 0–1000, а другой 0–1, то первый признак будет доминировать в сумме — даже если второй на самом деле гораздо важнее для разделения классов.

Конкретные проблемы без масштабирования

1. Доминирование признаков с большим диапазоном
   Признак «зарплата» (30 000–300 000) будет влиять на расстояние в сотни раз сильнее, чем «возраст» (20–80). KNN будет находить «похожих» соседей почти исключительно по зарплате, игнорируя возраст, даже если возраст гораздо важнее.
2. Искажение метрик расстояния
   Евклидово расстояние становится бессмысленным, когда признаки в разных масштабах. Все точки «сдвигаются» вдоль осей с большим разбросом.
3. Неправильная работа градиентного спуска в SVM / Kernel SVM
   Без масштабирования контуры функции потерь становятся очень вытянутыми → градиентный спуск сходится медленно, требует гораздо больше итераций или вообще не сходится стабильно.
4. Ошибки в кластеризации
   K-Means минимизирует внутрикластерную дисперсию. Если масштаб разный — кластеры будут определяться почти исключительно по «большим» признакам.
5. Нестабильность и переобучение
   Модель становится слишком чувствительной к шуму в признаках с большим масштабом, а полезная информация из маленьких признаков теряется.

Какое масштабирование обычно используют

• Стандартизация (StandardScaler, z-score) — самый частый и рекомендуемый выбор: среднее = 0, std = 1
• MinMaxScaler — если нужен диапазон [0, 1] или [-1, 1] (иногда для нейросетей или когда данные строго положительные)
• RobustScaler — если много выбросов (берёт медиану и IQR)

Короткий и точный ответ для собеседования:

В метрических моделях (KNN, K-Means, SVM с RBF, DBSCAN и т.д.) обязательно делать масштабирование, потому что эти алгоритмы явно используют расстояния между объектами. Без масштабирования признаки с большим диапазоном значений будут доминировать в расчёте расстояния, искажая результаты: соседи будут находиться неправильно, кластеры — неверно, SVM будет плохо сходиться. Поэтому признаки приводят к одному масштабу (чаще всего стандартизацией), чтобы каждый признак вносил сопоставимый вклад в метрику расстояния.

Приведите методы преобразования ненормального распределения к нормальному.

Вот наиболее часто используемые и спрашиваемые на собеседованиях методы приведения распределения признака к более нормальному (или хотя бы симметричному и менее скошенному виду):

1. Логарифмирование (Log / Log1p)
   Самый популярный и простой метод для правосторонней (положительной) скошенности.
   Применение: цены, зарплаты, время ожидания, количество просмотров и т.д.
   Реализация: np.log1p(x) или np.log(x + 1e-6)
   Ограничение: работает только с x > 0 (или близко к нулю после +ε).
2. Квадратный корень (Square Root)
   Менее агрессивное, чем логарифм.
   Применение: умеренная правосторонняя скошенность (например, счётчики, площади).
   Реализация: np.sqrt(x)
   Ограничение: x ≥ 0.
3. Обратное преобразование (Reciprocal / 1/x)
   Сильно сжимает большие значения.
   Применение: очень сильная правосторонняя скошенность.
   Реализация: 1 / (x + 1e-6)
   Ограничение: чувствительно к значениям близким к нулю.
4. Box-Cox преобразование
   Семейство степенных преобразований с автоматическим подбором параметра λ.
   Формула: x^λ - 1 / λ (при λ ≠ 0), иначе логарифм.
   Реализация: scipy.stats.boxcox(x)
   Ограничение: требует x > 0.
5. Yeo-Johnson преобразование
   Самый универсальный из power-трансформаций — работает с любыми значениями (включая отрицательные и нули).
   Реализация: sklearn.preprocessing.PowerTransformer(method='yeo-johnson')
   На практике чаще всего выбирают именно его, когда данные не строго положительные.
6. Квадрат / Куб / Высшая степень
   Применение: левосторонняя (отрицательная) скошенность.
   Реализация: x**2, x**3 и т.д.
   Используется реже.
7. Quantile Transformation (квантильное преобразование)
   Самый агрессивный метод — принудительно приводит распределение к нормальному или равномерному.
   Реализация: sklearn.preprocessing.QuantileTransformer(output_distribution='normal')
   Плюс: почти всегда даёт «нормальный» вид.
   Минус: теряет исходный смысл значений, может переобучаться на выбросах.
8. Rank-трансформация
   Преобразует значения в их ранги (порядковые номера).
   Реализация: pd.Series(x).rank() или scipy.stats.rankdata(x)
   Полностью убирает исходную форму распределения → становится равномерным.
9. Winsorization / Clipping + трансформация
   Сначала обрезаем экстремальные выбросы (например, до 1% и 99% перцентилей), потом применяем log / Yeo-Johnson.
   Реализация: scipy.stats.mstats.winsorize или np.clip

Практический порядок действий на реальном проекте

• Смотрим skew (асимметрию), kurtosis, гистограмму, boxplot
• Если skew > |0.8–1.0| и x > 0 → сначала log1p
• Если после лога всё ещё плохо или есть отрицательные/нули → Yeo-Johnson
• Если нужен максимально «нормальный» вид → QuantileTransformer(normal)
• Если выбросы мешают → сначала winsorize/clip → потом power-трансформация

Короткий ответ, который обычно ждут на собеседовании:

Основные методы приведения к нормальному распределению: логарифмирование (log1p), квадратный корень, Box-Cox (для x > 0), Yeo-Johnson (самый универсальный), Quantile Transformation (самый агрессивный). На практике чаще всего начинают с log1p или Yeo-Johnson из sklearn.PowerTransformer — это покрывает большинство случаев.

Как оценить важность признаков в дереве?

В деревьях решений (и особенно в ансамблях на их основе: Random Forest, XGBoost, LightGBM, CatBoost) существует несколько стандартных способов оценки важности признаков. Вот самые часто используемые и спрашиваемые на собеседованиях:

1. Gain / Information Gain / Split Gain
   Самый популярный и основной способ.
   Считается как суммарное уменьшение неопределённости (impurity reduction), которое принёс данный признак по всем сплитам, где он использовался.
   • Для классификации — уменьшение Gini / энтропии
   • Для регрессии — уменьшение MSE / variance
   Чем больше суммарный gain — тем важнее признак.
   В XGBoost / LightGBM / CatBoost это значение по умолчанию называется «gain».
   Плюсы: быстро, бесплатно при обучении.
   Минусы: может переоценивать признаки с большим количеством уникальных значений (например, ID, непрерывные признаки).
2. Cover / Weighted number of observations
   Показывает, сколько объектов (взвешенно) прошло через сплиты по этому признаку.
   Чем больше объектов «затронул» признак — тем он важнее.
   В XGBoost — importance_type='cover'
   В LightGBM — 'weight'
   Полезно, когда нужно понять, насколько признак часто используется на больших объёмах данных.
3. Split count / Frequency / Number of times used
   Просто считает, сколько раз признак был использован для разбиения узлов.
   В XGBoost — importance_type='weight'
   В LightGBM — 'split'
   Минус: сильно переоценивает признаки, которые используются много раз, даже если каждый сплит слабый.
4. Permutation Importance
   Не встроенный в дерево, но часто применяют именно к деревьям и бустингу.
   Обучаем модель → считаем baseline score → перемешиваем один признак → смотрим, насколько упал score.
   Реализация: sklearn.inspection.permutation_importance
   Плюсы: честнее встроенной важности, учитывает взаимодействия, работает на отложенной выборке.
   Минусы: требует времени на вычисления.
5. SHAP values (глобальная важность)
   Mean absolute SHAP value по всем примерам.
   Самый современный и интерпретируемый способ.
   Реализация: shap.TreeExplainer для бустинга → shap.summary_plot(type='bar') или shap.plots.bar
   Плюсы: показывает не только величину, но и направление влияния, учитывает взаимодействия.
   Минусы: медленнее, требует памяти.

Что обычно используют на практике (2025–2026)

• Быстрый взгляд → gain из XGBoost / LightGBM / CatBoost
• Когда сомневаемся в gain (корреляции, много уникальных значений) → permutation importance
• Когда нужна максимальная интерпретируемость и красивые отчёты → SHAP (mean(|SHAP|))
• Для сравнения нескольких моделей → permutation или SHAP (они модель-независимы)

Короткий ответ, который ждут на собеседовании:

В деревьях решений важность признаков чаще всего оценивают по gain — суммарному уменьшению impurity (Gini / энтропии / MSE) по всем сплитам, где признак использовался. Также смотрят cover (количество объектов, прошедших через сплит) и split count (сколько раз признак использовался). Для большей честности применяют permutation importance или SHAP values — они лучше учитывают взаимодействия и реальный вклад в качество модели на отложенной выборке.

Popularity bias, как бороться?

Popularity bias (популярностный уклон) — это ситуация, когда рекомендательная система сильно переоценивает популярные (часто просматриваемые / покупаемые / лайкаемые) объекты и почти полностью игнорирует длинный хвост (long tail) — менее популярные, но потенциально очень релевантные для конкретного пользователя элементы.

Почему возникает:

• В данных больше взаимодействий с популярными объектами → модель лучше их «выучивает»
• Коллаборативная фильтрация (особенно user-based / item-based) усиливает этот эффект
• Matrix Factorization и нейросети склонны к тому же, если не бороться
• В результате: рекомендации становятся однообразными («популярное всем нравится»)
• Пользователи видят меньше разнообразия → хуже удовлетворённость, ниже retention

Методы борьбы с popularity bias

1. Re-ranking / Post-processing
   Самый простой и часто самый эффективный способ в продакшене.
   • После генерации топ-N кандидатов пересортировать их с учётом популярности (penalty за слишком популярные объекты).
   • Примеры формул:
   score_final = score_model × (1 / log(1 + popularity))
   score_final = score_model / popularity^α (α подбирается)
   score_final = score_model × exp(-β × popularity)
   • Популярные реализации: xQuAD, Determinantal Point Processes (DPP), MMR (Maximal Marginal Relevance)
2. Обучение с inverse propensity weighting / IPS
   Взвешиваем лосс или градиенты обратно пропорционально популярности объекта.
   • Чем популярнее объект — тем меньше вес в обучении.
   • Формула: weight_i = 1 / (popularity_i + ε)^γ
   • Очень эффективно в моделях на основе pointwise / pairwise / listwise лоссов (BPR, WARP, ListNet и т.д.)
3. Прямое добавление популярности как признака (с осторожностью)
   Логарифм популярности / категория популярности как дополнительный признак в two-tower / DSSM / Wide&Deep.
   Минус: может усилить bias, если не контролировать.
4. Negative sampling с debiased стратегией
   Вместо случайного negative sampling брать negative с учётом популярности (например, oversample rare items как negative).
   • Популярно в моделях типа SASRec, BERT4Rec, TiSASRec
5. Regularization на разнообразие
   • Добавлять в лосс термин, штрафующий за слишком похожие рекомендации (diversity loss)
   • Использовать calibration loss (чтобы вероятности не были завышены на популярных)
6. Exploration / Bandit-подходы
   • Thompson Sampling, UCB, LinUCB — активно показывать long-tail объекты с некоторой вероятностью
   • Contextual bandits в реальном времени (очень мощно, но сложно внедрять)
7. Двухэтапные модели с explicit debiasing
   • Первый этап: candidate generation без bias
   • Второй этап: ranking с явной поправкой на популярность (IPS или re-ranking)
8. Counterfactual evaluation + logging correction
   Логировать propensity score (вероятность показа) и потом использовать IPS для оффлайн-оценки и дообучения

Самый частый промышленный стек (2025–2026):

• Обязательно: re-ranking с penalty по популярности (самый быстрый win)
• Обязательно: IPS / inverse propensity в pairwise / listwise лоссе
• Дополнительно: diversity regularization или DPP
• Если есть трафик и возможность — exploration через bandits

Popularity bias — когда рекомендации зацикливаются на самых популярных объектах. Борются через: re-ranking с penalty за популярность (самое простое и эффективное), inverse propensity weighting в обучении, negative sampling с упором на rare items, diversity loss и exploration (bandits). В продакшене почти всегда комбинируют re-ranking + IPS.