Перейти к содержанию

Шпаргалка: интервью по ML

~10 минут чтения

Предварительно: Метрики | Выбор модели | sklearn

Концентрат самых частых вопросов с собеседований по ML. Формат: вопрос -> типичная слабая ошибка -> сильный ответ. Для глубокого разбора каждой темы -- ссылки на профильные статьи.

Classic ML

Что такое bias-variance tradeoff?

❌ «Bias -- это когда модель плохая, variance -- когда хорошая на train» -- путаница понятий.

✅ Bias -- ошибка из-за упрощённых предположений модели (underfitting). Variance -- ошибка из-за чувствительности к конкретной выборке (overfitting). Формально: \(\text{MSE} = \text{Bias}^2 + \text{Variance} + \text{Irreducible Error}\). Увеличение сложности модели снижает bias, но повышает variance (и наоборот). Цель -- найти точку минимума total error. Примеры: линейная регрессия = high bias / low variance, глубокое дерево = low bias / high variance.

Как бороться с переобучением?

❌ «Добавить больше данных» -- верно, но слишком поверхностно.

✅ Системный подход по категориям: (1) Регуляризация: L1 (Lasso, sparsity), L2 (Ridge, shrinkage), Elastic Net, Dropout (для NN). (2) Данные: больше данных, аугментация, noise injection. (3) Архитектура: уменьшить complexity (max_depth, min_samples_leaf), feature selection. (4) Тренировка: cross-validation, early stopping. (5) Ансамбли: bagging уменьшает variance (RF), stacking. Диагностика: learning curves (train vs val gap), val loss растёт при стабильном train loss.

Чем отличаются Random Forest и Gradient Boosting?

❌ «RF параллельный, GB последовательный» -- описание без понимания зачем.

✅ RF (Bagging): деревья обучаются параллельно и независимо на bootstrap-выборках. Усредняет предсказания -> уменьшает variance. Устойчив к переобучению, больше деревьев = лучше (converges). GB (Boosting): деревья обучаются последовательно, каждое исправляет ошибки предыдущих (fit residuals). Уменьшает bias. Легко переобучается -> нужен early stopping, learning rate. Когда что: RF -- когда нужна робастность, шумные данные, параллелизм. GB -- когда нужно максимальное качество на чистых данных. На практике XGBoost/LightGBM побеждают RF на большинстве табличных задач.

L1 vs L2 регуляризация?

❌ «Оба уменьшают переобучение» -- не объясняет разницу.

✅ L1 (Lasso): добавляет \(\lambda \sum|w_i|\) к loss. Создаёт sparse модели (веса = 0) -> встроенный feature selection. Геометрически: ромбовидное ограничение, оптимум попадает на оси. L2 (Ridge): добавляет \(\lambda \sum w_i^2\). Уменьшает веса, но не до нуля -> устойчив к мультиколлинеарности. Геометрически: круглое ограничение. Elastic Net = \(\alpha L1 + (1-\alpha) L2\) -- баланс обоих. Связь с Bayesian: L2 = Gaussian prior, L1 = Laplace prior (MAP estimation).

Precision vs Recall? Когда что важнее?

❌ «Precision -- точность модели, Recall -- полнота» -- пересказ определений.

✅ Precision = TP/(TP+FP) -- «из тех кого назвали больным, сколько реально больны». Recall = TP/(TP+FN) -- «из всех больных, скольких нашли». Precision важнее когда FP дорого: спам-фильтр (потерять важное письмо), рекомендации (раздражать пользователя). Recall важнее когда FN дорого: медицина (пропустить рак), фрод (пропустить мошенника). F1 = гармоническое среднее -- штрафует за перекос. F-beta: \(\beta > 1\) вес на Recall, \(\beta < 1\) на Precision.

Когда использовать ROC-AUC, когда PR-AUC?

❌ «ROC-AUC всегда стандарт» -- опасное упрощение при дисбалансе.

✅ ROC-AUC (TPR vs FPR): хорош при балансе классов. При сильном дисбалансе FPR = FP/(FP+TN) -- огромный TN маскирует плохой precision. PR-AUC (Precision vs Recall): не использует TN -> честная оценка при дисбалансе 1:100+. Правило: дисбаланс до 1:10 -- ROC-AUC, дисбаланс 1:100+ -- PR-AUC. Для сравнения моделей без фиксированного порога -- оба, но PR-AUC информативнее на реальных данных.

Deep Learning

Как работает attention в трансформере?

❌ «Attention -- это механизм внимания, который смотрит на важные слова» -- описание без математики.

✅ Self-Attention: для каждого токена создаём Q, K, V через линейные проекции. \(\text{Attention}(Q,K,V) = \text{softmax}(QK^T / \sqrt{d_k}) \cdot V\). Деление на \(\sqrt{d_k}\) -- при большом \(d_k\) dot product растёт, softmax уходит в насыщение, градиенты мертвы. Multi-Head: несколько голов параллельно, каждая учит разные паттерны (синтаксис, семантика, позиция). Конкатенация + линейный слой. Преимущества: параллельность (не как RNN), глобальный контекст за O(1) шагов, любые зависимости.

Vanishing/exploding gradients -- что это и как бороться?

❌ «Градиенты исчезают в глубоких сетях» -- описание симптома без причины.

✅ Vanishing: при backprop через \(L\) слоёв градиент = произведение \(L\) производных. Sigmoid/tanh: \(\sigma'(x) \leq 0.25\), после 10 слоёв: \(0.25^{10} \approx 10^{-6}\). Решения: ReLU (\(f'(x) = 1\) для \(x > 0\)), skip connections (ResNet: \(f(x) + x\), градиент идёт напрямую), BatchNorm/LayerNorm. Exploding: градиенты растут экспоненциально (часто в RNN). Решения: gradient clipping (\(\|\nabla\| > \theta \to \nabla \cdot \theta / \|\nabla\|\)), LSTM/GRU (gate механизмы), proper initialization (He, Xavier).

BatchNorm vs LayerNorm -- в чём разница?

❌ «Оба нормализуют данные» -- не объясняет когда какой.

✅ BatchNorm: нормализует по батчу (для каждого признака отдельно). Хорош для CNN. Зависит от batch size (маленький batch = нестабильные статистики). Разное поведение train/eval (running mean/std). LayerNorm: нормализует по признакам (для каждого примера отдельно). Хорош для Transformer/RNN. Не зависит от batch size. Одинаковое поведение train/eval. Правило: CNN -> BatchNorm, Transformer/RNN -> LayerNorm, sequence-to-sequence -> LayerNorm.

Чем отличаются BERT и GPT?

❌ «BERT для понимания, GPT для генерации» -- верно, но почему?

✅ BERT: Encoder-only, bidirectional (видит весь контекст). Pretraining: MLM (маскируем 15% токенов) + NSP. Хорош для understanding: классификация, NER, QA, sentence similarity. GPT: Decoder-only, autoregressive (видит только прошлое). Pretraining: causal LM (предсказывает следующий токен). Хорош для генерации. Ключевое различие: bidirectional attention (BERT) vs causal mask (GPT). T5/BART: encoder-decoder (оба направления). В 2025+: decoder-only доминирует (GPT-4, Claude, Llama) из-за scaling laws и emergent abilities.

Как эффективно дообучить большую модель?

❌ «Full fine-tuning всех весов» -- дорого и не нужно.

✅ (1) Full fine-tuning: обновляем все веса. Максимальное качество, но O(параметры) памяти. Для моделей <1B. (2) LoRA: добавляем low-rank матрицы \(W' = W + BA\) (\(\text{rank}(BA) \ll \text{rank}(W)\)). Экономия памяти 10-100x, качество ~full FT. (3) QLoRA: LoRA + 4-bit quantization основных весов. Позволяет fine-tune 70B на одном GPU. (4) Prompt tuning: обучаем только soft prompt-токены, веса заморожены. (5) Adapter layers: маленькие слои между основными. Практика: LoRA/QLoRA -- стандарт 2025 для LLM.

System Design ML

Опиши ML pipeline для рекомендательной системы.

❌ «Собираем данные, обучаем модель, деплоим» -- нет архитектуры.

✅ 4 слоя: (1) Data Layer: сбор событий (клики, просмотры, покупки), Feature Store (user/item features), data validation (Great Expectations). (2) Training: offline обучение, hyperparameter tuning (Optuna), model validation, model registry (MLflow). (3) Serving: two-stage -- candidate generation (ANN/HNSW, ~1000 кандидатов) + ranking model (XGBoost/NN на top-K). Business rules (фильтры, diversity). A/B testing. (4) Monitoring: online метрики (CTR, conversion), data/concept drift detection, latency/throughput, alerting.

Как обрабатывать миллионы пользователей в реалтайме?

❌ «Нужны мощные серверы и GPU» -- не архитектурное решение.

✅ (1) Two-stage: candidate generation (HNSW/Faiss, O(log N)) + ranking (точная модель на top-100). (2) Caching: precompute embeddings offline, cache popular items (Redis), user feature cache. (3) Batching: группировать запросы, GPU batch inference (увеличивает throughput в 10-50x). (4) Sharding: разделение по user_id, распределённые embedding tables. (5) Approximation: quantization embeddings (float32 -> int8), model pruning/distillation. (6) Feature Store: precomputed features, online serving с p99 < 10ms.

Зачем нужен Feature Store?

❌ «Это база данных для фичей» -- упрощение.

✅ Проблемы без него: дублирование кода фичей между командами, training-serving skew (фичи считаются по-разному в training и production -- главный источник багов в ML), сложно переиспользовать, нет версионирования. Feature Store даёт: (1) единый источник фичей, (2) offline (batch) и online (realtime) serving из одного определения, (3) point-in-time correctness (нет data leakage), (4) мониторинг drift, (5) lineage (откуда фичи). Примеры: Feast (open-source), Tecton (managed), Hopsworks, Vertex AI Feature Store.

Coding

Implement Softmax

def softmax(x):
    # Стабильная версия
    x_shifted = x - np.max(x, axis=-1, keepdims=True)
    exp_x = np.exp(x_shifted)
    return exp_x / np.sum(exp_x, axis=-1, keepdims=True)

Implement Cross-Entropy

def cross_entropy(y_true, y_pred):
    # y_true: one-hot [batch, classes]
    # y_pred: probabilities [batch, classes]
    epsilon = 1e-15
    y_pred = np.clip(y_pred, epsilon, 1 - epsilon)
    return -np.sum(y_true * np.log(y_pred)) / len(y_true)

def binary_cross_entropy(y_true, y_pred):
    epsilon = 1e-15
    y_pred = np.clip(y_pred, epsilon, 1 - epsilon)
    return -np.mean(y_true * np.log(y_pred) + (1 - y_true) * np.log(1 - y_pred))

Implement KMeans

def kmeans(X, k, max_iters=100):
    # Random initialization
    centroids = X[np.random.choice(len(X), k, replace=False)]

    for _ in range(max_iters):
        # Assign clusters
        distances = np.linalg.norm(X[:, np.newaxis] - centroids, axis=2)
        labels = np.argmin(distances, axis=1)

        # Update centroids
        new_centroids = np.array([X[labels == i].mean(axis=0) for i in range(k)])

        if np.allclose(centroids, new_centroids):
            break
        centroids = new_centroids

    return labels, centroids

Implement Gradient Descent

def gradient_descent(X, y, lr=0.01, epochs=1000):
    m, n = X.shape
    w = np.zeros(n)
    b = 0

    for _ in range(epochs):
        y_pred = X @ w + b
        error = y_pred - y

        # Gradients
        dw = (1/m) * X.T @ error
        db = (1/m) * np.sum(error)

        # Update
        w -= lr * dw
        b -= lr * db

    return w, b

NLP Специфика

Как работает BPE (Byte Pair Encoding)?

❌ «Это способ разбить текст на токены» -- нет алгоритма.

✅ Алгоритм: (1) начинаем с символов, (2) находим самую частую пару символов в корпусе, (3) объединяем в новый токен, (4) повторяем до нужного размера словаря. Пример: "low lower lowest" -> начинаем с {l,o,w,e,r,s,t}, находим частую пару "lo" -> merge -> "low" -> merge -> ... Преимущества: баланс размера словаря и покрытия, обрабатывает OOV (разбивает на sub-word), работает для любого языка без лингвистических правил. Варианты: WordPiece (BERT) -- вероятностный merge, Unigram (SentencePiece) -- вероятностная модель.

Word2Vec vs FastText vs BERT embeddings?

❌ «Все дают вектора для слов, BERT лучше» -- не объясняет почему.

✅ Word2Vec: один статический вектор на слово (Skip-gram/CBOW). "bank" = один вектор для всех значений. FastText: использует sub-word n-grams -> лучше для OOV и морфологически богатых языков (русский!). Один статический вектор. BERT: контекстуальные embeddings -- "bank" в "river bank" != "bank account". Предобучены на MLM (masked language modeling). Каждый слой = разный уровень абстракции. Когда что: FastText для простых задач/малых данных, BERT для NLU (classification, NER, QA), sentence-transformers для semantic search.

Опиши RAG архитектуру.

❌ «Это когда LLM ищет в документах» -- нет архитектуры.

✅ 3 фазы: (1) Indexing (offline): разбиваем документы на chunks (500-1000 токенов с overlap), создаём embeddings (sentence-transformers), индексируем в vector DB (FAISS, Qdrant, Weaviate). (2) Retrieval (online): query -> embedding -> ANN search top-K похожих chunks -> reranking (cross-encoder, опционально). (3) Generation: промпт = system instructions + retrieved context + query, LLM генерирует grounded ответ. Проблемы: качество retrieval = bottleneck (garbage in = garbage out), chunking strategy критична, long context window помогает но не решает, hallucinations несмотря на context.

Теория вероятностей

Формула Байеса и пример?

❌ «P(A|B) = P(B|A) * P(A) / P(B)» -- формула без интуиции.

✅ \(P(A|B) = \frac{P(B|A) \cdot P(A)}{P(B)}\). Интуиция: обновляем убеждения (prior) в свете новых данных (likelihood). Пример: тест на болезнь. P(болезнь) = 0.01, P(+|болен) = 0.99, P(+|здоров) = 0.05. P(+) = 0.99*0.01 + 0.05*0.99 = 0.0594. P(болен|+) = 0.99*0.01/0.0594 = 16.7%! Только 17% с положительным тестом реально больны -- base rate fallacy. Это классический вопрос на собеседовании: проверяет, понимает ли кандидат, что low prevalence + imperfect test = высокий FPR.

Чем отличается MLE от MAP?

❌ «MLE максимизирует likelihood, MAP тоже но с prior» -- тавтология.

✅ MLE: \(\theta_\text{MLE} = \arg\max P(\text{data}|\theta)\) -- только данные, может переобучаться (на малых данных подстроится под шум). MAP: \(\theta_\text{MAP} = \arg\max P(\theta|\text{data}) = \arg\max P(\text{data}|\theta) \cdot P(\theta)\) -- данные + prior (наше «предубеждение» о параметрах). Ключевой инсайт: prior = регуляризация. Gaussian prior \(P(\theta) \propto e^{-\lambda\|\theta\|^2}\) -> L2 (Ridge). Laplace prior \(P(\theta) \propto e^{-\lambda\|\theta\|_1}\) -> L1 (Lasso). При \(n \to \infty\) MLE = MAP (данные доминируют over prior).

Быстрые ответы

Вопрос Короткий ответ
Почему ReLU лучше sigmoid? Нет vanishing gradient, быстрее считать
Зачем dropout? Регуляризация, предотвращает co-adaptation
Почему Adam популярен? Adaptive LR + momentum, работает из коробки
Что такое gradient clipping? Ограничение нормы градиента для стабильности
Зачем warmup? Стабилизация в начале, особенно для больших LR
Что такое label smoothing? Soft targets (0.9 вместо 1), улучшает calibration
Чем отличается bagging от boosting? Bagging параллельно, boosting последовательно
Почему XGBoost быстрее? Histogram-based, оптимизации, параллелизм
Что такое attention? Weighted sum где веса зависят от контекста
Зачем positional encoding? Transformer не знает порядок без него

Источники

  1. Hastie, Tibshirani, Friedman -- "The Elements of Statistical Learning" (ESL) -- bias-variance, regularization, ensemble theory
  2. Vaswani et al. -- "Attention Is All You Need" (NeurIPS 2017) -- self-attention, Transformer
  3. Devlin et al. -- "BERT: Pre-training of Deep Bidirectional Transformers" (NAACL 2019) -- BERT
  4. Hu et al. -- "LoRA: Low-Rank Adaptation of Large Language Models" (ICLR 2022) -- parameter-efficient fine-tuning
  5. Lewis et al. -- "Retrieval-Augmented Generation" (NeurIPS 2020) -- RAG architecture

See Also