Какие знаешь алгоритмы машинного обучения?

Какие знаешь алгоритмы машинного обучения

Это важный технический вопрос, проверяющий глубину ваших знаний. Хороший ответ показывает не только список алгоритмов, но и понимание их применения, сильных и слабых сторон.

1. Структура ответа на собеседовании

Не просто перечисляйте алгоритмы. Лучше:

1. Классифицируйте по типам задач (классификация, регрессия, кластеризация)
2. Расскажите о 2-3 любимых с деталями
3. Покажите, когда какой использовать
4. Честно скажите о пробелах

Хороший ответ:
"Я хорошо знаю основные алгоритмы классификации: логистическую 
регрессию, деревья решений, Random Forest, XGBoost. Последние два
часто использую на практике, потому что они показывают отличный 
balance между accuracy и интерпретируемостью. Также немного знаю 
глубокие сети, но это не моя основная специализация."

Плохой ответ:
"Я знаю все алгоритмы машинного обучения" ❌
(Неправдоподобно, не показывает глубину)

2. Главные классы алгоритмов

class MLAlgorithmsOverview:
    
    @staticmethod
    def supervised_learning():
        """Обучение с учителем"""
        return {
            "classification": {
                "linear": [
                    "Logistic Regression",
                    "SVM (Support Vector Machines)"
                ],
                "tree_based": [
                    "Decision Trees",
                    "Random Forest",
                    "XGBoost",
                    "LightGBM",
                    "CatBoost"
                ],
                "neural_networks": [
                    "Multi-layer Perceptron (MLP)",
                    "CNN (для images)",
                    "RNN/LSTM (для sequences)",
                    "Transformers/BERT"
                ],
                "ensemble": [
                    "Voting",
                    "Stacking",
                    "Bagging"
                ]
            },
            "regression": {
                "linear": [
                    "Linear Regression",
                    "Ridge/Lasso/ElasticNet"
                ],
                "tree_based": [
                    "Regression Trees",
                    "Random Forest Regressor",
                    "XGBoost Regressor",
                    "Gradient Boosting"
                ],
                "kernel_methods": [
                    "SVR (Support Vector Regression)",
                    "Gaussian Processes"
                ]
            }
        }
    
    @staticmethod
    def unsupervised_learning():
        """Обучение без учителя"""
        return {
            "clustering": [
                "K-Means",
                "DBSCAN",
                "Hierarchical Clustering",
                "GMM (Gaussian Mixture Models)"
            ],
            "dimensionality_reduction": [
                "PCA (Principal Component Analysis)",
                "t-SNE",
                "UMAP",
                "Autoencoders"
            ],
            "anomaly_detection": [
                "Isolation Forest",
                "Local Outlier Factor (LOF)",
                "One-Class SVM"
            ]
        }
    
    @staticmethod
    def reinforcement_learning():
        """Обучение с подкреплением"""
        return {
            "value_based": [
                "Q-Learning",
                "Deep Q-Networks (DQN)"
            ],
            "policy_based": [
                "Policy Gradient",
                "Actor-Critic"
            ]
        }

3. Детальный разбор основных алгоритмов

A. Logistic Regression (классификация)

from sklearn.linear_model import LogisticRegression
from sklearn.metrics import roc_auc_score, precision_recall_curve

class LogisticRegressionExplained:
    """
    Когда использовать:
    - Бинарная классификация (реже multiclass)
    - Нужна интерпретируемость (коэффициенты = вес признаков)
    - Быстро нужна baseline
    - Нелинейность не требуется
    """
    
    def __init__(self):
        self.model = LogisticRegression(max_iter=1000)
    
    def train_and_explain(self, X_train, y_train):
        self.model.fit(X_train, y_train)
        
        # Коэффициенты = влияние каждого признака
        for feature_name, coef in zip(feature_names, self.model.coef_[0]):
            print(f"{feature_name}: {coef:.4f}")
            # Положительный = увеличивает вероятность класса 1
    
    def advantages(self):
        return [
            "Интерпретируемость",
            "Быстрое обучение",
            "Вероятностные выходы",
            "Хорошо для линейных зависимостей"
        ]
    
    def disadvantages(self):
        return [
            "Не захватывает нелинейные зависимости",
            "Требует масштабирования",
            "Чувствителен к outliers",
            "Требует балансировки классов"
        ]

B. Random Forest (мощный и универсальный)

from sklearn.ensemble import RandomForestClassifier
import numpy as np

class RandomForestExplained:
    """
    Когда использовать:
    - Когда нужен хороший baseline без гиперпараметров
    - Смешанные типы признаков (числовые + категориальные)
    - Нужна важность признаков (feature importance)
    - Устойчив к outliers
    """
    
    def __init__(self):
        self.model = RandomForestClassifier(
            n_estimators=100,
            max_depth=10,
            random_state=42,
            n_jobs=-1  # Параллельно
        )
    
    def how_it_works(self):
        """
        1. Создаёт N деревьев (bootstrap samples)
        2. Каждое дерево обучается на случайном подмножестве данных
        3. Для классификации: большинство голосов
        4. Результат: более стабильная модель (меньше переобучения)
        """
        pass
    
    def feature_importance(self, feature_names):
        # Важность признаков
        importances = self.model.feature_importances_
        indices = np.argsort(importances)[::-1]
        
        for i in range(len(feature_names)):
            print(f"{feature_names[indices[i]]}: {importances[indices[i]]:.4f}")
    
    def advantages(self):
        return [
            "Не требует масштабирования",
            "Обрабатывает категориальные и числовые признаки",
            "Feature importance из коробки",
            "Устойчив к outliers",
            "Быстрое обучение",
            "Хороший баланс bias-variance"
        ]
    
    def disadvantages(self):
        return [
            "Менее интерпретируем чем деревья",
            "Хуже XGBoost на большинстве задач",
            "Может переобучиться на шумных данных"
        ]

C. XGBoost (самый популярный в индустрии)

import xgboost as xgb

class XGBoostExplained:
    """
    Когда использовать:
    - Нужны максимальные метрики
    - У вас есть время на гиперпараметры
    - Размер данных: 10K - 10M
    - Хотите выиграть Kaggle
    """
    
    def __init__(self):
        self.model = xgb.XGBClassifier(
            n_estimators=100,
            max_depth=5,
            learning_rate=0.1,
            subsample=0.8,
            colsample_bytree=0.8,
            lambda=1.0,  # L2 regularization
            alpha=0.0,   # L1 regularization
            random_state=42
        )
    
    def how_it_works(self):
        """
        1. Последовательно добавляет деревья
        2. Каждое новое дерево уменьшает ошибку предыдущих
        3. Использует gradient descent для оптимизации
        4. Имеет встроенную регуляризацию
        5. Может работать с пропущенными значениями
        """
        pass
    
    def hyperparameter_tuning(self):
        """Важные гиперпараметры"""
        return {
            "n_estimators": "Количество деревьев (100-1000)",
            "max_depth": "Глубина деревьев (3-10)",
            "learning_rate": "Скорость обучения (0.01-0.3)",
            "subsample": "Доля строк per tree (0.5-1.0)",
            "colsample_bytree": "Доля признаков per tree (0.5-1.0)",
            "lambda": "L2 регуляризация (0-10)",
            "alpha": "L1 регуляризация (0-10)"
        }
    
    def advantages(self):
        return [
            "Лучшие метрики на большинстве задач",
            "Встроенная регуляризация",
            "Работает с пропущенными значениями",
            "Feature importance",
            "Параллельное обучение",
            "Хорошая документация"
        ]
    
    def disadvantages(self):
        return [
            "Требует настройки гиперпараметров",
            "Медленнее чем LightGBM на больших данных",
            "Может переобучиться",
            "Нужно понимание gradient boosting"
        ]

D. Neural Networks (глубокое обучение)

import torch
import torch.nn as nn

class NeuralNetworkExplained:
    """
    Когда использовать:
    - Огромные объёмы данных (млн+ примеров)
    - Изображения (CNN)
    - Последовательности (RNN/LSTM)
    - NLP (Transformers)
    - Нет времени на feature engineering
    """
    
    class SimpleNN(nn.Module):
        def __init__(self, input_size, hidden_size=128):
            super().__init__()
            self.fc1 = nn.Linear(input_size, hidden_size)
            self.relu = nn.ReLU()
            self.fc2 = nn.Linear(hidden_size, 64)
            self.fc3 = nn.Linear(64, 1)
            self.sigmoid = nn.Sigmoid()
        
        def forward(self, x):
            x = self.relu(self.fc1(x))
            x = self.relu(self.fc2(x))
            x = self.sigmoid(self.fc3(x))
            return x
    
    def advantages(self):
        return [
            "Очень мощные на больших данных",
            "Автоматический feature engineering",
            "Специализированные архитектуры (CNN, RNN)",
            "Хорошо обобщаются",
            "Могут быть интегрированы в production"
        ]
    
    def disadvantages(self):
        return [
            "Требуют больше данных чем другие алгоритмы",
            "Долгое обучение",
            "Требуют GPU",
            "Менее интерпретируемы (black box)",
            "Требуют careful tuning",
            "Нужны навыки deep learning"
        ]

4. Как выбирать алгоритм

class AlgorithmSelection:
    
    @staticmethod
    def decision_tree(task, data_size, need_interpretability, time_budget):
        """
        Схема выбора алгоритма
        """
        
        # Если нужна интерпретируемость
        if need_interpretability:
            if task == "classification":
                return "Logistic Regression или Decision Trees"
            else:
                return "Linear Regression"
        
        # Если данных мало (< 10K)
        if data_size < 10000:
            if time_budget == "fast":
                return "Random Forest"
            else:
                return "XGBoost с кросс-валидацией"
        
        # Если данных много (> 100K)
        if data_size > 100000:
            if task == "image":
                return "CNN (ResNet, EfficientNet)"
            elif task == "sequence":
                return "Transformer или LSTM"
            else:
                return "LightGBM или Neural Network"
        
        # Дефолт: XGBoost (работает везде)
        return "XGBoost"

# Матрица выбора
print("""
┌─────────────────┬──────────────────┬────────────────────┬──────────────┐
│ Тип задачи      │ Размер данных    │ Нужна простота     │ Рекомендация │
├─────────────────┼──────────────────┼────────────────────┼──────────────┤
│ Классификация   │ < 10K            │ Да                 │ Log Reg      │
│ Классификация   │ 10K-1M           │ Нет                │ XGBoost      │
│ Классификация   │ > 1M             │ Нет                │ LightGBM/NN  │
│ Регрессия       │ < 10K            │ Да                 │ Lin Reg      │
│ Регрессия       │ 10K-1M           │ Нет                │ XGBoost      │
│ Изображения     │ > 10K            │ Нет                │ CNN          │
│ Текст           │ > 10K            │ Нет                │ Transformers │
│ Временные ряды  │ > 1K             │ Нет                │ LSTM/Prophet │
│ Кластеризация   │ < 100K           │ -                  │ K-Means      │
│ Кластеризация   │ > 100K           │ -                  │ DBSCAN       │
└─────────────────┴──────────────────┴────────────────────┴──────────────┘
""")

5. Пример полного ответа на собеседовании

"На работе я использовал много алгоритмов в зависимости от задачи.

Для классификации (fraud, churn prediction):
- Начинаю с Logistic Regression как baseline — быстро и интерпретируемо
- Потом пробую Random Forest — обычно показывает +5-10% улучшение
- Финализирую XGBoost с grid search — это даёт лучший результат

Для регрессии (price prediction):
- Аналогично: Linear → Random Forest → XGBoost
- Иногда добавляю Gradient Boosting если нужна интерпретируемость

Для работы с текстом/изображениями:
- Использовал предтренированные модели (BERT, ResNet)
- Fine-tuning на собственных данных

Для кластеризации:
- K-Means для быстрого результата
- DBSCAN когда нужны произвольные кластеры

Специальные задачи:
- Anomaly Detection: Isolation Forest
- Dimensionality Reduction: PCA, UMAP
- Временные ряды: Prophet, LSTM

Правило выбора: Начинаю с простого, потом усложняю. Не использую 
сложный алгоритм, если простой работает одинаково."

6. Что сказать о пробелах

"Я хорошо знаю supervised learning (классификация, регрессия).
Немного менее опытен с:
- Reinforcement Learning (читал теорию, не использовал на практике)
- Очень глубокие архитектуры трансформеров
- Некоторые специальные алгоритмы (Bayesian Methods, Gaussian Processes)

Но я легко учусь и готов углубляться в нужные области."

Вывод: Хороший ответ на вопрос об алгоритмах показывает: (1) практический опыт, (2) понимание когда какой алгоритм использовать, (3) знание pros/cons каждого, (4) честность о пробелах, (5) готовность к обучению.