Skip to content

Машинное обучение Шпаргалка

Концепции машинного обучения, алгоритмы и реализация на Python.

01

С чего начать

Что такое машинное обучение?

Машинное обучение строит системы, которые обобщают данные, а не следуют вручную написанным правилам. Три парадигмы (обучение с учителем, без учителя и с подкреплением) покрывают большинство реальных задач. Соблюдение структурного рабочего процесса — особенно выделение чистого тестового набора — помогает избежать главного греха: переобучения под собственную оценку.

machine-learning
# Machine Learning: systems that learn patterns from data
# instead of being explicitly programmed.

# Three main paradigms:
# - Supervised:    learn f: X -> y from labeled (X, y) pairs
# - Unsupervised:  find structure in unlabeled X
# - Reinforcement: learn actions that maximize reward via trial-and-error

# Typical workflow:
# 1. Define problem & collect data
# 2. Preprocess & feature engineering
# 3. Split train / validation / test
# 4. Train model, tune hyperparameters
# 5. Evaluate on test set
# 6. Deploy & monitor

Основные библиотеки

scikit-learn — рабочая лошадка для табличного и классического ML: единый API fit/predict/transform для всех алгоритмов. NumPy и Pandas отвечают за обработку данных, Matplotlib/Seaborn — за визуализацию. Для глубокого обучения выбирайте PyTorch (удобен для исследований) или TensorFlow/Keras (удобен для продакшена) — оба покрывают один и тот же круг задач.

machine-learning
# The standard ML stack in Python
import numpy as np          # numerical arrays
import pandas as pd         # tabular data
import matplotlib.pyplot as plt  # plotting
import seaborn as sns       # statistical plots

# scikit-learn: classical ML (trees, SVM, linear models, preprocessing)
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score

# Deep learning (pick one):
import torch                # PyTorch
# import tensorflow as tf   # TensorFlow/Keras

# Install:
# pip install numpy pandas matplotlib seaborn scikit-learn torch

Разбиение на train / validation / test

Никогда не трогайте тестовый набор до финальной оценки: использование его для настройки приводит к утечке информации и завышает метрики. stratify=y сохраняет баланс классов, что критично для несбалансированной классификации. random_state делает разбиение воспроизводимым. Для небольших наборов данных используйте k-fold CV вместо фиксированного валидационного набора.

machine-learning
from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.2,      # 20% held out for test
    random_state=42,    # reproducibility
    stratify=y,         # keep class proportions (classification only)
)

# For a third validation set:
X_train, X_temp, y_train, y_temp = train_test_split(
    X, y, test_size=0.4, stratify=y, random_state=42)
X_val, X_test, y_val, y_test = train_test_split(
    X_temp, y_temp, test_size=0.5, stratify=y_temp, random_state=42)
# Now: 60% train, 20% val, 20% test

Первая модель (Iris)

Набор Iris — это «Hello World» машинного обучения: 150 образцов цветов, 4 признака, 3 класса. Этот фрагмент показывает канонический шаблон sklearn: загрузить данные, разбить, создать модель, обучить, предсказать, оценить. classification_report выдаёт precision/recall/F1 по каждому классу — это гораздо информативнее одной accuracy при несбалансированных задачах.

machine-learning
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report

iris = load_iris()
X, y = iris.data, iris.target

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=42)

model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("Accuracy:", accuracy_score(y_test, y_pred))
print(classification_report(y_test, y_pred, target_names=iris.target_names))

Воспроизводимость

Задавайте seed для numpy, random и вашего фреймворка глубокого обучения, чтобы инициализация весов и перемешивание были воспроизводимы. Передавайте random_state в каждый стохастический оценщик sklearn. Полная детерминированность (особенно на GPU) требует ещё детерминированных алгоритмов и переменных окружения — это полезно при отладке результатов, которые «должны» совпадать, но не совпадают.

machine-learning
import numpy as np
import random
import torch

SEED = 42
np.random.seed(SEED)
random.seed(SEED)
torch.manual_seed(SEED)
if torch.cuda.is_available():
    torch.cuda.manual_seed_all(SEED)

# For sklearn, pass random_state to each estimator:
# RandomForestClassifier(random_state=SEED)

# Force deterministic operations (slower but fully reproducible):
torch.use_deterministic_algorithms(True)

# Optional: pin GPU non-determinism
import os
os.environ["CUBLAS_WORKSPACE_CONFIG"] = ":4096:8"
02

Подготовка данных

Обработка пропущенных значений

Обучение импутера на всём наборе данных переносит статистику теста в обучение — всегда обучайте только на train. Медиана устойчивее к выбросам, чем среднее. Для категориальных признаков используйте 'most_frequent' или 'constant'. KNN-импутация умеет улавливать многомерную структуру, но дорога на больших данных. Подумайте, информативен ли сам факт пропуска (добавьте индикатор 'is_missing').

machine-learning
import pandas as pd
from sklearn.impute import SimpleImputer, KNNImputer

df = pd.DataFrame({"age": [25, np.nan, 35, 45],
                   "income": [50000, 60000, np.nan, 80000]})

# Drop rows with any missing values (use sparingly)
df_drop = df.dropna()

# Mean/median/mode imputation
imp = SimpleImputer(strategy="median")  # 'mean','most_frequent','constant'
df_imputed = pd.DataFrame(imp.fit_transform(df), columns=df.columns)

# KNN imputer (uses similar samples)
knn_imp = KNNImputer(n_neighbors=3)
df_knn = pd.DataFrame(knn_imp.fit_transform(df), columns=df.columns)

# Always fit imputers on TRAINING data only, then transform test
imp.fit(X_train)
X_train_imp = imp.transform(X_train)
X_test_imp  = imp.transform(X_test)   # uses train medians

Масштабирование и нормализация

Многие алгоритмы (SVM, KNN, логистическая регрессия, нейросети, PCA) чувствительны к масштабу, а деревья — как правило, нет. StandardScaler — выбор по умолчанию; MinMaxScaler нужен, когда требуются ограниченные диапазоны (например, изображения); RobustScaler — когда выбросы искажают StandardScaler. ВСЕГДА обучайте scaler на train и применяйте его же к test — никогда не вызывайте fit_transform на тесте.

machine-learning
from sklearn.preprocessing import StandardScaler, MinMaxScaler, RobustScaler

# Standardization: mean 0, std 1 (most common)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled  = scaler.transform(X_test)   # use train mean/std!

# Min-max: scale to [0, 1]
minmax = MinMaxScaler()
X_mm = minmax.fit_transform(X_train)

# Robust to outliers: uses median & IQR
robust = RobustScaler()
X_robust = robust.fit_transform(X_train)

Кодирование категориальных переменных

LabelEncoder предназначен для целевой переменной, OneHotEncoder — для номинальных признаков (без естественного порядка: one-hot не намекает, что красный < зелёный < синий). OrdinalEncoder — для упорядоченных категорий вроде размеров. handle_unknown='ignore' предотвращает ошибки на невиданных категориях во время теста. Для категорий с высокой кардинальностью (например, почтовых индексов) лучше подходит target/count-кодирование, чтобы не раздувать размерность.

machine-learning
from sklearn.preprocessing import LabelEncoder, OneHotEncoder, OrdinalEncoder

# Label encode TARGET (classification): strings -> integers
le = LabelEncoder()
y = le.fit_transform(["cat", "dog", "cat", "bird"])  # [0, 1, 0, 2]
le.inverse_transform([0, 1, 2])                       # back to strings

# One-hot encode FEATURES (nominal, no order)
ohe = OneHotEncoder(sparse_output=False, handle_unknown="ignore")
X_ohe = ohe.fit_transform(df[["color"]])  # red/green/blue -> 3 cols

# Ordinal encode (ordered categories)
oe = OrdinalEncoder(categories=[["low", "medium", "high"]])
X_ord = oe.fit_transform(df[["size"]])

# For high-cardinality features, consider target encoding
# or just drop them if they're IDs.

Работа с несбалансированными данными

Несбалансированные данные смещают модель в сторону мажоритарного класса. Самое чистое решение — class_weight='balanced' (без дублирования данных). SMOTE синтезирует новые примеры миноритарного класса, но может вносить шум — применяйте только к train. Oversampling и undersampling работают, но могут привести к переобучению или потере данных. Всегда оценивайте через precision, recall, F1 и AUC — никогда только через accuracy на несбалансированных данных.

machine-learning
from sklearn.utils import resample
from imblearn.over_sampling import SMOTE
from sklearn.utils.class_weight import compute_class_weight

# 1. Class weights (no resampling — preferred for trees/linear)
classes = np.unique(y_train)
weights = compute_class_weight("balanced", classes=classes, y=y_train)
class_weight = dict(zip(classes, weights))
model = RandomForestClassifier(class_weight=class_weight)

# 2. Oversample minority
df_majority = df[df.y == 0]
df_minority = df[df.y == 1]
df_minority_up = resample(df_minority, replace=True,
                          n_samples=len(df_majority), random_state=42)

# 3. SMOTE: synthesize new minority samples via k-nearest neighbors
smote = SMOTE(random_state=42)
X_res, y_res = smote.fit_resample(X_train, y_train)

# Always resample on TRAINING data only — never the test set!

Обнаружение выбросов

Выбросы искажают средние, стандартные отклонения и линейные модели. Z-score быстр, но предполагает нормальность и сам искажается выбросами (лучше использовать устойчивый IQR). Isolation Forest справляется с высокой размерностью и нелинейными границами. Решите, удалять, ограничивать (винзоризация) или сохранять выбросы, исходя из предметной области — иногда выбросы и есть те случаи, которые вас интересуют (мошенничество, аномалии).

machine-learning
import numpy as np
from sklearn.ensemble import IsolationForest

# Z-score: |x - mean| / std > 3 is an outlier
z_scores = np.abs((X - X.mean()) / X.std())
outliers = (z_scores > 3).any(axis=1)

# IQR method (more robust to outliers than z-score)
Q1, Q3 = X.quantile(0.25), X.quantile(0.75)
IQR = Q3 - Q1
outliers_iqr = ((X < (Q1 - 1.5 * IQR)) | (X > (Q3 + 1.5 * IQR))).any(axis=1)

# Isolation Forest (good for high-dimensional data)
iso = IsolationForest(contamination=0.05, random_state=42)
outliers_iso = iso.fit_predict(X)  # -1 = outlier, 1 = inlier

# Remove or cap (winsorize) outliers before training
X_clean = X[~outliers]
03

Инженерия признаков

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

PolynomialFeatures позволяет линейным моделям улавливать нелинейные связи, добавляя x^2, x*y и т. п. как новые признаки. interaction_only исключает чистые квадраты — полезно, когда нужны только перекрёстные члены. Число признаков растёт комбинаторно, поэтому всегда сочетайте это с регуляризацией (Ridge/Lasso), чтобы избежать переобучения, или применяйте после снижения размерности.

machine-learning
from sklearn.preprocessing import PolynomialFeatures

# Generate degree-2 features including interactions
poly = PolynomialFeatures(degree=2, interaction_only=False,
                          include_bias=False)
X_poly = poly.fit_transform(X)
# For X = [a, b], produces: [a, b, a^2, a*b, b^2]

# interaction_only=True keeps just [a, b, a*b] — no squares
poly_int = PolynomialFeatures(degree=2, interaction_only=True,
                              include_bias=False)
X_int = poly_int.fit_transform(X)

# Useful for linear models to capture non-linearity
# WARNING: feature count grows quickly — use with regularization

Биннинг и дискретизация

Биннинг превращает непрерывные признаки в дискретные интервалы, помогая моделям улавливать нелинейные эффекты и снижая чувствительность к выбросам. Квантильные бины (равная частота) избавляют от проблемы пустых интервалов, свойственной равномерным. Предметные бины (например, возрастные группы) часто лучше автоматических. Кодируйте бины через one-hot, чтобы модель воспринимала их как отдельные категории.

machine-learning
from sklearn.preprocessing import KBinsDiscretizer
import pandas as pd

# Equal-width bins (uniform spacing)
df["age_bin"] = pd.cut(df["age"], bins=5, labels=False)

# Equal-frequency bins (quantiles — same count per bin)
df["age_quantile"] = pd.qcut(df["age"], q=5, labels=False,
                              duplicates="drop")

# KBinsDiscretizer with strategy
kbd = KBinsDiscretizer(n_bins=5, encode="onehot-dense",
                        strategy="quantile")  # 'uniform','kmeans'
X_binned = kbd.fit_transform(X[["age"]])

# Custom bins with domain knowledge
df["age_group"] = pd.cut(df["age"],
                          bins=[0, 18, 35, 60, 100],
                          labels=["child","young","adult","senior"])

Извлечение текстовых признаков

Мешки слов (bag-of-words) просты, но трактуют все слова одинаково; TF-IDF снижает вес слов, частых во всех документах. ngram_range=(1,2) улавливает короткие фразы. В современном NLP используйте предобученные эмбеддинги (sentence-transformers, BERT) — они передают семантику, недоступную мешку слов. Всегда задавайте max_features и min_df, чтобы контролировать размер словаря и шум.

machine-learning
from sklearn.feature_extraction.text import TfidfVectorizer, CountVectorizer

corpus = [
    "machine learning is fun",
    "deep learning is a subset of machine learning",
    "python is great for data science",
]

# Bag of words (counts)
cv = CountVectorizer(max_features=1000, stop_words="english",
                     ngram_range=(1, 2))
X_counts = cv.fit_transform(corpus)

# TF-IDF: downweights common words
tfidf = TfidfVectorizer(max_features=1000, stop_words="english",
                        ngram_range=(1, 2), min_df=2)
X_tfidf = tfidf.fit_transform(corpus)

# For production, consider sentence-transformers for embeddings:
# from sentence_transformers import SentenceTransformer
# model = SentenceTransformer("all-MiniLM-L6-v2")
# embeddings = model.encode(corpus)

Признаки даты и времени

Сырые колонки datetime бесполезны для моделей — извлекайте осмысленные части (час, день недели, месяц). Циклические признаки (sin/cos) сохраняют непрерывность: час 23 близок к часу 0, чего не передаёт целочисленное кодирование. is_weekend и праздники отражают человеческие циклы. days_since — простая трендовая фича для временных рядов.

machine-learning
import pandas as pd

df["date"] = pd.to_datetime(df["date"])

# Extract calendar parts
df["year"]      = df["date"].dt.year
df["month"]     = df["date"].dt.month
df["day"]       = df["date"].dt.day
df["dayofweek"] = df["date"].dt.dayofweek    # 0=Mon
df["dayofyear"] = df["date"].dt.dayofyear
df["hour"]      = df["date"].dt.hour
df["is_weekend"] = df["date"].dt.dayofweek >= 5

# Cyclic encoding (preserves continuity: hour 23 -> 0)
df["hour_sin"] = np.sin(2 * np.pi * df["hour"] / 24)
df["hour_cos"] = np.cos(2 * np.pi * df["hour"] / 24)
df["month_sin"] = np.sin(2 * np.pi * df["month"] / 12)
df["month_cos"] = np.cos(2 * np.pi * df["month"] / 12)

# Time elapsed (useful as a trend feature)
df["days_since"] = (df["date"] - df["date"].min()).dt.days

Отбор признаков

Больше признаков не значит лучше: нерелевантные добавляют шум и риск переобучения. SelectKBest быстр и статистичен; RFE основателен, но медленный (многократно переобучает модель); SelectFromModel использует feature_importances_ дерева как одноразовый фильтр. Корреляционные фильтры дёшево убирают избыточные признаки. Всегда выполняйте отбор только на TRAIN и применяйте тот же селектор к test.

machine-learning
from sklearn.feature_selection import (SelectKBest, f_classif,
    RFE, SelectFromModel)
from sklearn.ensemble import RandomForestClassifier

# 1. Univariate: keep top-k by statistical test
selector = SelectKBest(f_classif, k=10)
X_new = selector.fit_transform(X, y)
selected = selector.get_support(indices=True)

# 2. Recursive Feature Elimination (model-based, iterative)
rfe = RFE(RandomForestClassifier(random_state=42),
          n_features_to_select=10)
X_rfe = rfe.fit_transform(X, y)

# 3. Select from model importance
sfm = SelectFromModel(RandomForestClassifier(random_state=42),
                      threshold="median")
X_sfm = sfm.fit_transform(X, y)

# 4. Correlation filter — drop one of highly-correlated pairs
corr = pd.DataFrame(X).corr().abs()
to_drop = [c for c in corr.columns
           if any(corr[c] > 0.95)]
X_filtered = X.drop(columns=to_drop)
04

Обучение с учителем

Линейная и логистическая регрессия

Линейные модели быстры, интерпретируемы и служат сильным базовым уровнем. LogisticRegression по умолчанию использует L2-регуляризацию; меньшее C означает более сильную регуляризацию. Для многих классов применяется softmax. Коэффициенты показывают важность признаков, но только после масштабирования: без него коэффициенты несопоставимы. Всегда начинайте с линейного бейзлайна, прежде чем пробовать сложные модели.

machine-learning
from sklearn.linear_model import LinearRegression, LogisticRegression

# Regression: predict a continuous value
lr = LinearRegression()
lr.fit(X_train, y_train)
y_pred = lr.predict(X_test)

# Inspect coefficients
print("Coef:", lr.coef_, "Intercept:", lr.intercept_)

# Classification: predict a class (uses softmax for multiclass)
clf = LogisticRegression(
    penalty="l2",            # 'l1' (Lasso), 'elasticnet', None
    C=1.0,                   # inverse of regularization strength
    max_iter=1000,
    multi_class="multinomial",
)
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)
y_proba = clf.predict_proba(X_test)  # class probabilities

Решающие деревья и случайный лес

Решающие деревья интерпретируемы, но обладают высокой дисперсией: небольшие изменения в данных дают совсем другое дерево. Случайный лес исправляет это усреднением множества деревьев, обученных на бутстрэп-выборках со случайными подмножествами признаков (бэггинг). max_features='sqrt' — стандарт для классификации. Важность признаков в лесу смещена в сторону высококардинальных признаков — для более честной картины попробуйте permutation_importance.

machine-learning
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier

# Single tree (high variance, easy to overfit)
tree = DecisionTreeClassifier(
    max_depth=5,              # limit depth to prevent overfitting
    min_samples_leaf=10,      # min samples per leaf
    random_state=42,
)
tree.fit(X_train, y_train)

# Random forest: ensemble of trees on bootstrapped samples
rf = RandomForestClassifier(
    n_estimators=200,         # number of trees
    max_depth=None,
    max_features="sqrt",      # features per split
    n_jobs=-1,                # use all CPUs
    random_state=42,
)
rf.fit(X_train, y_train)

# Feature importance (averaged across trees)
importances = pd.Series(rf.feature_importances_, index=X.columns)

Градиентный бустинг (XGBoost / LightGBM)

Градиентный бустинг строит деревья последовательно, и каждое исправляет ошибки предыдущего — обычно это лучшая производительность на табличных данных. GradientBoosting в sklearn медленный; HistGradientBoosting — его быстрый аналог на основе гистограмм. XGBoost и LightGBM — стандарт продакшена и соревнований, с нативной обработкой пропусков и ранней остановкой. Всегда используйте early_stopping с валидационным набором, чтобы найти оптимальное число деревьев.

machine-learning
from sklearn.ensemble import GradientBoostingClassifier, HistGradientBoostingClassifier
import lightgbm as lgb
import xgboost as xgb

# sklearn (slow on large data)
gbm = GradientBoostingClassifier(
    n_estimators=200, learning_rate=0.1, max_depth=3, random_state=42)
gbm.fit(X_train, y_train)

# sklearn's faster histogram-based version (like LightGBM)
hgbm = HistGradientBoostingClassifier(
    max_iter=200, learning_rate=0.1, max_leaf_nodes=31, random_state=42)
hgbm.fit(X_train, y_train)

# XGBoost (popular in competitions)
xgb_clf = xgb.XGBClassifier(
    n_estimators=200, learning_rate=0.1, max_depth=6,
    subsample=0.8, colsample_bytree=0.8, n_jobs=-1,
    eval_metric="logloss", random_state=42)
xgb_clf.fit(X_train, y_train, eval_set=[(X_val, y_val)], early_stopping_rounds=10)

# LightGBM (fastest on large data)
lgb_clf = lgb.LGBMClassifier(n_estimators=200, learning_rate=0.1, num_leaves=31)
lgb_clf.fit(X_train, y_train, eval_set=(X_val, y_val))

Опорные векторы (SVM)

SVM ищет гиперплоскость с максимальным зазором, разделяющую классы — мощный метод для небольших и средних наборов с чёткими границами. Масштабирование признаков обязательно (SVM основан на расстояниях). RBF-ядро справляется с нелинейностью; настраивайте C (регуляризацию) и gamma (ширину ядра) перебором по сетке. SVC плохо масштабируется по числу примеров (O(n^2)–O(n^3)) — при более 50 тыс. примеров используйте LinearSVC или ансамбль деревьев.

machine-learning
from sklearn.svm import SVC, SVR
from sklearn.preprocessing import StandardScaler

# SVC requires scaling!
scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train)
X_test_s  = scaler.transform(X_test)

# Kernels: 'linear', 'rbf' (Gaussian), 'poly', 'sigmoid'
svm = SVC(
    kernel="rbf",
    C=1.0,              # regularization (higher = fit harder)
    gamma="scale",      # kernel width
    probability=True,   # enable predict_proba (slower)
    random_state=42,
)
svm.fit(X_train_s, y_train)
y_pred = svm.predict(X_test_s)

# SVR for regression
svr = SVR(kernel="rbf", C=1.0, epsilon=0.1)
svr.fit(X_train_s, y_train)

Метод k ближайших соседей

KNN — простейший алгоритм машинного обучения: сохранить обучающие данные, а затем предсказывать голосованием среди k ближайших соседей. Масштабирование обязательно (метод основан на расстояниях). Малое k = низкое смещение и высокая дисперсия (переобучение); большое k = высокое смещение и низкая дисперсия (недообучение). KNN медленно предсказывает на больших наборах — в продакшене используйте приближённые ближайшие соседи (FAISS, HNSW).

machine-learning
from sklearn.neighbors import KNeighborsClassifier, KNeighborsRegressor

# KNN: classify by majority vote of k nearest training samples
knn = KNeighborsClassifier(
    n_neighbors=5,        # k — try odd values to break ties
    weights="uniform",    # or 'distance' (closer = more weight)
    metric="minkowski",   # 'euclidean','manhattan', etc.
    p=2,                  # 2=euclidean, 1=manhattan
    n_jobs=-1,
)
knn.fit(X_train_scaled, y_train)
y_pred = knn.predict(X_test_scaled)

# Choose k via cross-validation
from sklearn.model_selection import cross_val_score
for k in [1, 3, 5, 7, 9, 11]:
    score = cross_val_score(KNeighborsClassifier(n_neighbors=k),
                            X_train_scaled, y_train, cv=5).mean()
    print(f"k={k}: {score:.3f}")
05

Обучение без учителя

Кластеризация K-Means

K-Means разбивает данные на k сферических кластеров, минимизируя внутрикластерную дисперсию. n_init=10 запускает алгоритм из 10 случайных инициализаций и оставляет лучшую (значение по умолчанию изменилось в sklearn 1.4). Выбирайте k по локтю (инерции) или силуэту (силуэт более обоснован). K-Means предполагает сферические кластеры равного размера — для несферических используйте DBSCAN или смесь гауссиан.

machine-learning
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score

# Choose k via the elbow method or silhouette score
inertias, silhouettes = [], []
for k in range(2, 11):
    km = KMeans(n_clusters=k, n_init=10, random_state=42)
    labels = km.fit_predict(X)
    inertias.append(km.inertia_)
    silhouettes.append(silhouette_score(X, labels))

# Final model with chosen k
kmeans = KMeans(n_clusters=4, n_init=10, random_state=42)
clusters = kmeans.fit_predict(X)
centers = kmeans.cluster_centers_

# Predict cluster for new points
new_labels = kmeans.predict(X_new)

DBSCAN (на основе плотности)

DBSCAN находит кластеры произвольной формы и автоматически выявляет выбросы (метка -1) — указывать k не нужно. eps — критичный параметр; подбирайте его по графику k-расстояний («локоть» на отсортированных расстояниях до k-го соседа). min_samples управляет чувствительностью к шуму. DBSCAN плохо работает при разной плотности — HDBSCAN справляется лучше. Он не умеет предсказывать новые точки напрямую: переобучайте или используйте approximate_predict из HDBSCAN.

machine-learning
from sklearn.cluster import DBSCAN

# DBSCAN groups densely-connected points; marks sparse ones as noise (-1)
db = DBSCAN(
    eps=0.5,            # max distance between points in a cluster
    min_samples=5,      # min points to form a dense region
    metric="euclidean",
)
labels = db.fit_predict(X)
n_clusters = len(set(labels)) - (1 if -1 in labels else 0)
n_noise = list(labels).count(-1)

# Tune eps via the k-distance plot (k = min_samples)
from sklearn.neighbors import NearestNeighbors
nn = NearestNeighbors(n_neighbors=5).fit(X)
distances, _ = nn.kneighbors(X)
distances = np.sort(distances[:, -1])

# DBSCAN doesn't have predict() — refit to predict on new data
# Or use HDBSCAN for a more robust, parameter-light alternative

Иерархическая кластеризация

Иерархическая кластеризация строит дерево (дендрограмму) вложенных кластеров — полезно, когда нужно понять структуру на нескольких уровнях детализации. Дендрограмма наглядно показывает, где разрезать дерево для любого числа кластеров. Чаще всего используют связь 'ward' (минимизирует внутрикластерную дисперсию); 'single' хрупка (эффект цепочки). AgglomerativeClustering плохо масштабируется свыше ~10 тыс. примеров — для больших данных берите K-Means или HDBSCAN.

machine-learning
from sklearn.cluster import AgglomerativeClustering
from scipy.cluster.hierarchy import dendrogram, linkage
import matplotlib.pyplot as plt

# Compute linkage matrix (for dendrogram)
Z = linkage(X, method="ward")  # 'ward','complete','average','single'

# Plot dendrogram to choose number of clusters
plt.figure(figsize=(10, 5))
dendrogram(Z, truncate_mode="level", p=5)
plt.axhline(y=Z[-4, 2], color="r", linestyle="--")  # cut at 4 clusters
plt.show()

# Agglomerative clustering with chosen k
agg = AgglomerativeClustering(
    n_clusters=4,
    linkage="ward",   # minimizes variance
    metric="euclidean",
)
labels = agg.fit_predict(X)

Смеси гауссиан (GMM)

GMM — вероятностный аналог K-Means: каждый кластер является гауссианой со своим средним и ковариацией, поэтому метод работает с эллиптическими кластерами и даёт мягкие назначения (вероятности). covariance_type='full' наиболее гибок, но требует много параметров; 'diag' — хороший компромисс. Выбирайте k по BIC (меньше — лучше). GMM также умеет генерировать новые примеры — полезно для аугментации данных.

machine-learning
from sklearn.mixture import GaussianMixture

# GMM: probabilistic clustering — each cluster is a Gaussian
gmm = GaussianMixture(
    n_components=4,
    covariance_type="full",  # 'spherical','tied','diag','full'
    n_init=10,
    random_state=42,
)
gmm.fit(X)

labels = gmm.predict(X)
probs = gmm.predict_proba(X)   # soft clustering (responsibilities)

# Generative: sample new data
X_sampled, y_sampled = gmm.sample(100)

# Choose n_components via BIC (lower is better)
bics = []
for k in range(1, 11):
    g = GaussianMixture(n_components=k, n_init=10, random_state=42).fit(X)
    bics.append(g.bic(X))

Обнаружение аномалий

Обнаружение аномалий выявляет редкие подозрительные объекты: мошенничество, дефекты, вторжения. Isolation Forest — универсальный победитель (быстрый, хорошо масштабируется, работает с высокой размерностью). One-Class SVM хорошо работает, когда есть чистый обучающий набор «нормальных» примеров. LOF ловит локальные аномалии, которые пропускают глобальные методы. contamination задаёт ожидаемую долю аномалий; настраивайте её по знаниям о предметной области.

machine-learning
from sklearn.ensemble import IsolationForest
from sklearn.svm import OneClassSVM
from sklearn.neighbors import LocalOutlierFactor

# Isolation Forest: isolates anomalies with shallow trees
iso = IsolationForest(contamination=0.05, random_state=42)
labels = iso.fit_predict(X)  # -1 anomaly, 1 normal
scores = iso.decision_function(X)  # lower = more anomalous

# One-Class SVM: learns a boundary around normal data
ocsvm = OneClassSVM(kernel="rbf", nu=0.05, gamma="scale")
labels = ocsvm.fit_predict(X_train_normal)

# Local Outlier Factor: density-based (good for local anomalies)
lof = LocalOutlierFactor(n_neighbors=20, contamination=0.05)
labels = lof.fit_predict(X)
# For new data: lof.negative_outlier_factor_ (lower = more anomalous)
06

Регрессия

Линейная регрессия и регуляризованные варианты

OLS минимизирует квадратичную ошибку без регуляризации — высокая дисперсия при мультиколлинеарности. Ridge (L2) плавно сжимает коэффициенты, хорошо подходит, когда важно много признаков. Lasso (L1) обнуляет часть коэффициентов, выполняя отбор признаков. ElasticNet смешивает оба подхода и полезен при коррелированных признаках. Всегда масштабируйте признаки перед регуляризованной регрессией, чтобы штраф был справедлив для всех признаков.

machine-learning
from sklearn.linear_model import LinearRegression, Ridge, Lasso, ElasticNet

# Ordinary Least Squares
ols = LinearRegression()
ols.fit(X_train, y_train)

# Ridge (L2): shrinks coefficients, keeps all features
ridge = Ridge(alpha=1.0)
ridge.fit(X_train_scaled, y_train)

# Lasso (L1): shrinks some coefficients to 0 (feature selection)
lasso = Lasso(alpha=0.1, max_iter=10000)
lasso.fit(X_train_scaled, y_train)
print("Non-zero coefs:", (lasso.coef_ != 0).sum())

# ElasticNet: mix of L1 and L2
en = ElasticNet(alpha=0.1, l1_ratio=0.5)  # l1_ratio=1 -> pure Lasso
en.fit(X_train_scaled, y_train)

Метрики оценки регрессии

RMSE сильнее штрафует большие ошибки (из-за квадрата) и выражается в тех же единицах, что и y — самая распространённая метрика. MAE понятнее и устойчивее к выбросам. R2 — доля объяснённой дисперсии; 0 означает, что модель не лучше предсказания среднего. MAPE даёт процентную ошибку, но не определена при y=0. Выбирайте метрики по бизнес-цене ошибки: если большие промахи катастрофичны — RMSE; если все ошибки одинаково дороги — MAE.

machine-learning
from sklearn.metrics import (mean_squared_error, mean_absolute_error,
    r2_score, mean_absolute_percentage_error)

y_pred = model.predict(X_test)

mse  = mean_squared_error(y_test, y_pred)         # sensitive to outliers
rmse = np.sqrt(mse)                                # same units as y
mae  = mean_absolute_error(y_test, y_pred)         # robust to outliers
r2   = r2_score(y_test, y_pred)                    # 1=perfect, 0=mean, <0=worse
mape = mean_absolute_percentage_error(y_test, y_pred)  # % error

print(f"RMSE: {rmse:.3f}")
print(f"MAE:  {mae:.3f}")
print(f"R2:   {r2:.3f}")
print(f"MAPE: {mape:.1%}")

# Adjusted R2 accounts for number of features
n, p = X_test.shape
adj_r2 = 1 - (1 - r2) * (n - 1) / (n - p - 1)

Регрессия на решающих деревьях

Деревья-регрессоры дают кусочно-постоянные предсказания и не умеют экстраполировать за пределы обучающего диапазона. Случайный лес снижает дисперсию усреднением; градиентный бустинг снижает смещение последовательной коррекцией. Квантильная регрессия (loss='quantile') предсказывает процентиль, а не среднее — комбинируйте модели нижнего и верхнего квантилей для интервалов предсказания, когда нужны оценки неопределённости.

machine-learning
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor

# Single tree (piecewise constant predictions)
dt = DecisionTreeRegressor(max_depth=5, min_samples_leaf=10,
                            random_state=42)
dt.fit(X_train, y_train)

# Random forest regressor (averages trees)
rf = RandomForestRegressor(n_estimators=200, max_features="sqrt",
                            n_jobs=-1, random_state=42)
rf.fit(X_train, y_train)

# Gradient boosting regressor
gb = GradientBoostingRegressor(n_estimators=200, learning_rate=0.1,
                                max_depth=3, random_state=42)
gb.fit(X_train, y_train)

# Quantile regression — predict ranges instead of points
from sklearn.ensemble import GradientBoostingRegressor
gbr_lower = GradientBoostingRegressor(loss="quantile", alpha=0.1)
gbr_upper = GradientBoostingRegressor(loss="quantile", alpha=0.9)
gbr_lower.fit(X_train, y_train)
gbr_upper.fit(X_train, y_train)

Путь регуляризации

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

machine-learning
import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import lasso_path

# Compute Lasso coefficients for many alpha values
alphas, coefs, _ = lasso_path(X_train_scaled, y_train,
                               alphas=np.logspace(-3, 1, 100))

# Plot: each line is a coefficient vs alpha
plt.figure(figsize=(8, 5))
for coef in coefs:
    plt.plot(alphas, coef)
plt.xscale("log")
plt.xlabel("alpha (regularization strength)")
plt.ylabel("coefficient")
plt.title("Lasso regularization path")
plt.axhline(0, color="k", lw=0.5)
plt.show()

Анализ остатков

Графики остатков диагностируют неверную спецификацию модели. Случайное облако вокруг 0 означает, что модель подходит хорошо; U-образная форма намекает на пропущенную нелинейность (добавьте полиномиальные признаки или дерево); форма воронки указывает на гетероскедастичность (попробуйте логарифмировать y). Нормальность остатков важна для вывода (доверительных интервалов), но не для точности предсказаний.

machine-learning
import matplotlib.pyplot as plt
import seaborn as sns

residuals = y_test - y_pred

fig, axes = plt.subplots(1, 2, figsize=(12, 5))

# 1. Residuals vs predicted — should look random around 0
axes[0].scatter(y_pred, residuals, alpha=0.5)
axes[0].axhline(0, color="r", linestyle="--")
axes[0].set_xlabel("Predicted"); axes[0].set_ylabel("Residual")

# 2. Residual distribution — should be ~normal
sns.histplot(residuals, kde=True, ax=axes[1])
axes[1].set_xlabel("Residual")

plt.show()

# Patterns in residuals suggest model issues:
# - U-shape: missing non-linearity (add polynomial features)
# - Funnel: heteroscedasticity (try log-transforming y)
# - Skew: try transforming y or use a different loss
07

Классификация

Основы бинарной классификации

predict возвращает жёсткие метки классов (порог 0.5), predict_proba — вероятности, что обычно полезнее. Порог 0.5 по умолчанию редко оптимален: снижайте его ради большего recall (ловить больше положительных случаев, например при скрининге рака), повышайте ради precision (меньше ложных тревог, например в спам-фильтре). ROC-AUC измеряет, насколько хорошо вероятности ранжируют положительные объекты выше отрицательных, независимо от порога.

machine-learning
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import (confusion_matrix, classification_report,
    roc_auc_score, precision_recall_curve)

clf = LogisticRegression(max_iter=1000)
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)
y_proba = clf.predict_proba(X_test)[:, 1]  # P(class=1)

# Confusion matrix: TN FP / FN TP
cm = confusion_matrix(y_test, y_pred)
print(cm)
print(classification_report(y_test, y_pred))

# Adjust threshold (default 0.5) to trade precision for recall
y_pred_custom = (y_proba > 0.3).astype(int)  # higher recall

# ROC-AUC: probability ranking quality (threshold-independent)
print("ROC-AUC:", roc_auc_score(y_test, y_proba))

Матрица ошибок и производные метрики

Accuracy обманчива на несбалансированных данных: набор с 99% отрицательных даёт 99% accuracy, если предсказывать только отрицательные. Precision и recall вскрывают компромисс: precision отвечает «сколько из предсказанных положительных реальны?», recall — «сколько реальных положительных мы поймали?». F1 — их гармоническое среднее. Используйте macro-усреднение, когда классы должны весить одинаково, и weighted — когда важен их частотный вклад.

machine-learning
from sklearn.metrics import (confusion_matrix, precision_score,
    recall_score, f1_score)

# Binary: confusion_matrix returns [[TN, FP], [FN, TP]]
tn, fp, fn, tp = confusion_matrix(y_test, y_pred).ravel()

accuracy  = (tp + tn) / (tp + tn + fp + fn)
precision = tp / (tp + fp)    # of predicted positives, how many correct
recall    = tp / (tp + fn)    # of actual positives, how many caught
f1        = 2 * precision * recall / (precision + recall)  # harmonic mean
specificity = tn / (tn + fp)  # true negative rate

# sklearn shortcuts
print("Precision:", precision_score(y_test, y_pred))
print("Recall:    ", recall_score(y_test, y_pred))
print("F1:        ", f1_score(y_test, y_pred))

# Multi-class: average='macro' (unweighted) or 'weighted' (by class size)
print("Macro F1:", f1_score(y_test, y_pred, average="macro"))

Кривые ROC и PR

ROC-кривые откладывают recall (TPR) против доли ложноположительных по всем порогам; площадь под кривой (AUC) обобщает качество ранжирования (0.5 — случайность, 1.0 — идеал). PR-кривые информативнее ROC на несбалансированных данных: ROC может выглядеть обманчиво хорошо, когда отрицательных подавляющее большинство. Стремитесь к верхнему левому углу на ROC и верхнему правому на PR.

machine-learning
from sklearn.metrics import (roc_curve, precision_recall_curve,
    auc, RocCurveDisplay, PrecisionRecallDisplay)
import matplotlib.pyplot as plt

# ROC curve: TPR (recall) vs FPR at all thresholds
fpr, tpr, thresholds = roc_curve(y_test, y_proba)
roc_auc = auc(fpr, tpr)

# PR curve: precision vs recall (better for imbalanced data)
prec, rec, thresholds = precision_recall_curve(y_test, y_proba)
pr_auc = auc(rec, prec)

fig, axes = plt.subplots(1, 2, figsize=(12, 5))
RocCurveDisplay.from_predictions(y_test, y_proba, ax=axes[0])
PrecisionRecallDisplay.from_predictions(y_test, y_proba, ax=axes[1])
axes[0].set_title(f"ROC (AUC={roc_auc:.3f})")
axes[1].set_title(f"PR (AUC={pr_auc:.3f})")
plt.show()

Многоклассовая классификация

Для N>2 классов LogisticRegression использует softmax (multi_class='multinomial'). Precision/recall по классам показывают, какие классы модель путает. Нормируйте матрицу ошибок по строкам (истинный класс), чтобы увидеть recall каждого класса — полезно для поиска систематически ошибочных категорий. Каппа Коэна корректирует accuracy на случайные совпадения; log_loss измеряет качество предсказанных вероятностей (меньше — лучше).

machine-learning
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import (cohen_kappa_score, log_loss,
    classification_report, confusion_matrix, ConfusionMatrixDisplay)

# Multiclass: logistic regression uses softmax by default
clf = LogisticRegression(multi_class="multinomial", max_iter=1000)
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)
y_proba = clf.predict_proba(X_test)

# Per-class report
print(classification_report(y_test, y_pred))

# Confusion matrix (now NxN)
disp = ConfusionMatrixDisplay.from_predictions(
    y_test, y_pred, display_labels=clf.classes_,
    cmap="Blues", normalize="true")  # normalize per true class

# Multiclass metrics
print("Cohen's kappa:", cohen_kappa_score(y_test, y_pred))
print("Log loss:     ", log_loss(y_test, y_proba))

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

Модель с предсказанной вероятностью 80% должна быть права в 80% случаев, но многие классификаторы (Random Forest, SVM, Naive Bayes) выдают некалиброванные оценки. CalibratedClassifierCV исправляет это, подгоняя изотоническую регрессию или сигмоиду на отложенном наборе. Калибровка важна везде, где вы действуете по вероятностям (оценка риска, выбор порога), и не нужна, если используются только жёсткие метки классов.

machine-learning
from sklearn.calibration import CalibratedClassifierCV, calibration_curve
import matplotlib.pyplot as plt

# Many classifiers output poorly-calibrated probabilities
# (e.g. Random Forest, SVM). Calibrate them.

# Method 1: isotonic regression (more flexible, needs more data)
# Method 2: sigmoid (Platt scaling) — parametric, works with less data
calibrated = CalibratedClassifierCV(rf, method="isotonic", cv=5)
calibrated.fit(X_train, y_train)
y_proba = calibrated.predict_proba(X_test)[:, 1]

# Calibration curve: predicted prob vs observed frequency
prob_true, prob_pred = calibration_curve(y_test, y_proba, n_bins=10)
plt.plot([0, 1], [0, 1], "k--")
plt.plot(prob_pred, prob_true, "s-")
plt.xlabel("Predicted probability"); plt.ylabel("Observed frequency")
plt.show()
08

Кластеризация: углублённо

Выбор k: локоть и силуэт

Метод локтя ищет k, при котором инерция перестаёт быстро падать, — это субъективно и иногда незаметно. Оценка силуэта обоснованнее: она измеряет, насколько каждая точка похожа на свой кластер по сравнению с ближайшим чужим (диапазон от -1 до 1). Силуэт > 0.5 говорит о разумной структуре, > 0.7 — о сильной. Всегда визуализируйте оба и предпочитайте силуэт, когда локоть неоднозначен.

machine-learning
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score, silhouette_samples
import matplotlib.pyplot as plt

# Elbow method: inertia (sum of squared distances to centroid)
inertias = []
for k in range(1, 11):
    km = KMeans(n_clusters=k, n_init=10, random_state=42).fit(X)
    inertias.append(km.inertia_)

plt.plot(range(1, 11), inertias, "o-")
plt.xlabel("k"); plt.ylabel("Inertia"); plt.title("Elbow method")
plt.show()

# Silhouette: -1 (bad) to 1 (well-clustered), 0 = on boundary
silhouettes = []
for k in range(2, 11):
    labels = KMeans(n_clusters=k, n_init=10, random_state=42).fit_predict(X)
    silhouettes.append(silhouette_score(X, labels))

График силуэта

График силуэта показывает коэффициент силуэта каждого примера, сгруппированный по кластерам. Одинаковая ширина «ножей» говорит о сбалансированных кластерах; разная — о том, что некоторые кластеры доминируют. Красная пунктирная линия — среднее: кластеры со средним ниже неё разделены плохо. Используйте этот график для визуального сравнения разных значений k.

machine-learning
from sklearn.metrics import silhouette_samples
import matplotlib.pyplot as plt
import numpy as np

k = 4
km = KMeans(n_clusters=k, n_init=10, random_state=42).fit(X)
labels = km.labels_
sil_values = silhouette_samples(X, labels)

fig, ax = plt.subplots(figsize=(8, 6))
y_lower = 10
for i in range(k):
    ith = np.sort(sil_values[labels == i])
    y_upper = y_lower + len(ith)
    ax.fill_betweenx(np.arange(y_lower, y_upper), 0, ith, alpha=0.7)
    ax.text(-0.05, (y_lower + y_upper) / 2, str(i))
    y_lower = y_upper + 10
ax.axvline(sil_values.mean(), color="red", linestyle="--")
ax.set_xlabel("Silhouette coefficient"); ax.set_ylabel("Cluster")
plt.show()

HDBSCAN (иерархический DBSCAN)

HDBSCAN устраняет главный недостаток DBSCAN — необходимость подбирать eps. Он строит иерархию по уровням плотности и извлекает устойчивые кластеры, поэтому работает на данных с разной плотностью. min_cluster_size — основной параметр, и он интуитивен (наименьший интересующий вас кластер). Точки в разреженных областях получают метку -1 (шум). На реальных данных HDBSCAN часто даёт более осмысленные кластеры, чем K-Means.

machine-learning
import hdbscan  # pip install hdbscan

# HDBSCAN: DBSCAN that automatically chooses eps via hierarchy
clusterer = hdbscan.HDBSCAN(
    min_cluster_size=5,   # min points to form a cluster
    min_samples=None,     # how conservative to be about noise
    metric="euclidean",
    cluster_selection_method="eom",  # 'leaf' for fine-grained
)
labels = clusterer.fit_predict(X)

# Soft clustering: probability of cluster membership
probs = clusterer.probabilities_

# Compare clusters across parameter settings
clusterer.condensed_tree_.plot()

Оценка кластеризации

Внутренние метрики (силуэт, Davies-Bouldin, Calinski-Harabasz) оценивают качество кластеров без эталонных меток — полезно для выбора модели. Внешние метрики (ARI, NMI) сравнивают кластеризацию с известными метками — полезно для бенчмаркинга на размеченных данных. ARI и NMI учитывают случайность и инвариантны к перестановке меток. Единой лучшей метрики нет — используйте несколько и визуализируйте кластеры.

machine-learning
from sklearn.metrics import (silhouette_score, davies_bouldin_score,
    calinski_harabasz_score, adjusted_rand_score, normalized_mutual_info_score)

# Internal metrics (no ground truth)
print("Silhouette:        ", silhouette_score(X, labels))      # higher = better
print("Davies-Bouldin:    ", davies_bouldin_score(X, labels))   # lower = better
print("Calinski-Harabasz: ", calinski_harabasz_score(X, labels)) # higher = better

# External metrics (when you have ground-truth labels)
true_labels = y  # e.g. the actual iris species
print("Adjusted Rand:    ", adjusted_rand_score(true_labels, labels))
print("NMI:              ", normalized_mutual_info_score(true_labels, labels))

# ARI and NMI: 0 = random, 1 = perfect match
# Both are invariant to label permutations (cluster 1 vs cluster 2 doesn't matter)

Размерность для кластеризации

Кластеризация в высокой размерности страдает от проклятия размерности: расстояния теряют смысл. Сначала снизьте размерность до 5–50 с помощью PCA (линейно, быстро) или UMAP (нелинейно, сохраняет локальную структуру). t-SNE годится только для визуализации (у него нет transform для новых данных, а искажения делают его непригодным для входа кластеризации). Всегда визуализируйте кластеры в 2D через t-SNE или UMAP.

machine-learning
from sklearn.decomposition import PCA, UMAP  # umap-learn package
from sklearn.manifold import TSNE
from sklearn.cluster import KMeans

# Reduce dimensions BEFORE clustering high-dim data
# PCA: linear, fast, preserves global structure
pca = PCA(n_components=10, random_state=42).fit(X)
X_pca = pca.transform(X)

# UMAP: non-linear, fast, preserves local+global structure
reducer = UMAP(n_components=5, random_state=42)
X_umap = reducer.fit_transform(X)

# t-SNE: visualization only (no transform on new data)
X_tsne = TSNE(n_components=2, perplexity=30, random_state=42).fit_transform(X)

# Cluster on the embeddings
labels = KMeans(n_clusters=4, n_init=10, random_state=42).fit_predict(X_umap)

# Plot 2D embedding colored by cluster
plt.scatter(X_tsne[:, 0], X_tsne[:, 1], c=labels, cmap="tab10", s=10)
plt.show()
09

Снижение размерности

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

PCA находит ортогональные оси (главные компоненты), которые захватывают максимум дисперсии, позволяя сжать многомерные данные, сохранив большую часть информации. Масштабирование важно: PCA чувствителен к масштабу признаков. Задайте n_components=0.95, чтобы автоматически сохранить 95% дисперсии. PCA линеен и быстр, но предполагает, что дисперсия = информация, а это не всегда так (малодисперсные признаки могут быть дискриминативными).

machine-learning
from sklearn.decomposition import PCA

# PCA finds orthogonal axes of maximum variance
pca = PCA(n_components=2, random_state=42)
X_pca = pca.fit_transform(X_scaled)   # scaling matters!

# Explained variance: how much info each PC retains
print("Explained variance ratio:", pca.explained_variance_ratio_)
print("Total retained:", pca.explained_variance_ratio_.sum())

# Choose n_components to retain 95% of variance
pca_full = PCA(n_components=0.95, random_state=42).fit(X_scaled)
print("Components for 95%:", pca_full.n_components_)
X_reduced = pca_full.transform(X_scaled)

# Reconstruct (lossy) from compressed representation
X_reconstructed = pca_full.inverse_transform(X_reduced)

t-SNE для визуализации

t-SNE отлично подходит для 2D/3D-визуализации многомерных данных: он сохраняет локальные окрестности, поэтому кластеры видны визуально. perplexity (обычно 5–50) управляет балансом локальной и глобальной структуры. Искажения t-SNE: размеры кластеров и расстояния между ними НЕ имеют смысла, значимы только локальные окрестности. На больших данных он медленный — сначала снизьте размерность через PCA (например, до 50), затем применяйте t-SNE.

machine-learning
from sklearn.manifold import TSNE
import matplotlib.pyplot as plt

# t-SNE is for 2D/3D visualization, NOT as preprocessing
tsne = TSNE(
    n_components=2,
    perplexity=30,         # try 5-50; ~ sqrt(n_samples) is a heuristic
    learning_rate="auto",
    n_iter=1000,
    init="pca",            # better than random init
    random_state=42,
)
X_tsne = tsne.fit_transform(X_scaled)

plt.scatter(X_tsne[:, 0], X_tsne[:, 1], c=y, cmap="tab10", s=10)
plt.colorbar(); plt.show()

UMAP

UMAP — современная альтернатива t-SNE: быстрее, лучше масштабируется, сохраняет и локальную, и глобальную структуру и, что важно, поддерживает transform для новых данных, поэтому может быть шагом конвейера. n_neighbors управляет компромиссом между локальным и глобальным (малое значение = локальные детали, большое = глобальная структура); min_dist определяет плотность упаковки точек. В ML-конвейерах сжимайте UMAP до 5–50 измерений, а не до 2.

machine-learning
from umap import UMAP  # pip install umap-learn

# UMAP: faster than t-SNE, preserves more global structure,
# and supports transform on new data (good for ML pipelines)
reducer = UMAP(
    n_components=2,
    n_neighbors=15,    # smaller = local, larger = global
    min_dist=0.1,      # how tightly points pack
    metric="euclidean",
    random_state=42,
)
X_umap = reducer.fit_transform(X_scaled)

# Can transform new data (unlike t-SNE)
X_new_umap = reducer.transform(X_new)

# Use in a pipeline as a preprocessor before clustering/classification
from sklearn.pipeline import Pipeline
pipe = Pipeline([
    ("umap", UMAP(n_components=5, random_state=42)),
    ("clf",  RandomForestClassifier(random_state=42)),
])

LDA (линейный дискриминантный анализ)

В отличие от PCA (без учителя), LDA использует метки классов, чтобы найти проекцию, максимизирующую межклассовую дисперсию и минимизирующую внутриклассовую. Максимум n_components равен n_classes - 1, поэтому метод полезен только при небольшом числе классов. LDA также работает как линейный классификатор (предполагает гауссовы классы с общей ковариацией). Берите LDA, когда есть метки и нужно снижение размерности, максимизирующее разделимость классов.

machine-learning
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis

# LDA is SUPERVISED dimensionality reduction — uses class labels
# to find axes that best separate classes
lda = LinearDiscriminantAnalysis(n_components=2)
X_lda = lda.fit_transform(X_train, y_train)  # note: y_train passed in

# Also a classifier (Gaussian model per class)
y_pred = lda.predict(X_test)

# Max n_components = n_classes - 1
# For 3 classes, you get at most 2 LDA components

# Compare: PCA ignores class labels (unsupervised);
# LDA uses labels to maximize class separability

Truncated SVD (для разреженных данных)

TruncatedSVD (для текста известен как LSA) — альтернатива PCA для разреженных данных: он не центрирует данные, поэтому работает с разреженными матрицами вроде TF-IDF. Вместе с TF-IDF он порождает «темы» — группы совместно встречающихся слов. Для лучшего тематического моделирования попробуйте NMF или современные подходы на эмбеддингах. Для текста держите ~100–300 компонент; точное число зависит от размера корпуса и задачи.

machine-learning
from sklearn.decomposition import TruncatedSVD

# PCA doesn't work on sparse matrices (it needs to center data)
# Use TruncatedSVD instead — works directly on sparse TF-IDF, etc.

from scipy.sparse import csr_matrix
X_sparse = csr_matrix(X_tfidf)  # e.g. from TfidfVectorizer

svd = TruncatedSVD(n_components=100, random_state=42)
X_reduced = svd.fit_transform(X_sparse)

# Often combined with TF-IDF for LSA (Latent Semantic Analysis)
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.decomposition import TruncatedSVD

vectorizer = TfidfVectorizer(max_features=10000)
lsa = Pipeline([
    ("tfidf", vectorizer),
    ("svd",   TruncatedSVD(n_components=100, random_state=42)),
])
X_topics = lsa.fit_transform(documents)
10

Оценка модели

Кросс-валидация

Кросс-валидация даёт устойчивую оценку качества, усредняя по нескольким разбиениям train/test. StratifiedKFold сохраняет баланс классов при классификации (критично для несбалансированных данных). RepeatedStratifiedKFold прогоняет CV несколько раз с разными разбиениями — оценки стабильнее, но вычислений больше. Всегда используйте CV для выбора модели, а не одно фиксированное разбиение train/test.

machine-learning
from sklearn.model_selection import (cross_val_score, cross_validate,
    StratifiedKFold, KFold, RepeatedStratifiedKFold)

# Basic 5-fold CV
scores = cross_val_score(model, X, y, cv=5, scoring="accuracy")
print(f"{scores.mean():.3f} +/- {scores.std():.3f}")

# Stratified (preserves class balance — use for classification)
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
scores = cross_val_score(model, X, y, cv=cv, scoring="f1_macro")

# Multiple metrics at once
results = cross_validate(model, X, y, cv=cv,
    scoring=["accuracy", "f1_macro", "roc_auc_ovr"],
    return_train_score=True)
print(results["test_f1_macro"].mean())

# Repeated CV for more stable estimates
rcv = RepeatedStratifiedKFold(n_splits=5, n_repeats=3, random_state=42)

Кривые обучения

Кривые обучения показывают качество на train и validation в зависимости от размера данных — лучшая диагностика смещения и дисперсии. Большой разрыв между высоким train и низким validation означает переобучение (добавьте данные, регуляризуйте, упростите модель). Оба балла низкие и близкие — недообучение (нужна более сложная модель или новые признаки). Если справа кривые всё ещё растут, дополнительные данные помогут.

machine-learning
from sklearn.model_selection import learning_curve
import matplotlib.pyplot as plt

train_sizes, train_scores, val_scores = learning_curve(
    model, X, y,
    train_sizes=np.linspace(0.1, 1.0, 10),
    cv=5, scoring="accuracy", n_jobs=-1, random_state=42,
)

train_mean = train_scores.mean(axis=1)
val_mean   = val_scores.mean(axis=1)

plt.plot(train_sizes, train_mean, "o-", label="Train")
plt.plot(train_sizes, val_mean,   "o-", label="Validation")
plt.xlabel("Training samples"); plt.ylabel("Accuracy")
plt.legend(); plt.show()

# Diagnose:
# - High train, low val  -> overfitting (high variance) -> more data or regularize
# - Both low and close   -> underfitting (high bias) -> more complex model/features
# - Gap closing with data -> more data helps

Кривые валидации (гиперпараметр)

Кривые валидации показывают качество в зависимости от одного значения гиперпараметра — полезно, чтобы понять поведение модели и найти разумный диапазон перед перебором по сетке. Оценка на train растёт с усложнением модели, а на validation достигает пика и падает. Пик — оптимальная точка: до него недообучение, после — переобучение.

machine-learning
from sklearn.model_selection import validation_curve
import matplotlib.pyplot as plt

param_range = [1, 2, 4, 8, 16, 32, 64]
train_scores, val_scores = validation_curve(
    RandomForestClassifier(random_state=42),
    X, y,
    param_name="max_depth",
    param_range=param_range,
    cv=5, scoring="accuracy", n_jobs=-1,
)

plt.plot(param_range, train_scores.mean(axis=1), "o-", label="Train")
plt.plot(param_range, val_scores.mean(axis=1),   "o-", label="Validation")
plt.xlabel("max_depth"); plt.ylabel("Accuracy")
plt.legend(); plt.show()

# Sweet spot is where validation peaks before overfitting

Как читать classification_report

Macro-среднее в classification_report трактует все классы одинаково (хорошо, когда важны редкие классы); weighted-среднее отражает частоту классов (хорошо, когда доминирует качество на большинстве). Выбирайте стратегию усреднения по бизнес-цене ошибки на каждом классе. При сильном дисбалансе дополняйте PR-AUC и recall по классам: accuracy и даже F1 могут скрыть модель, которая просто предсказывает мажоритарный класс.

machine-learning
from sklearn.metrics import classification_report

report = classification_report(y_test, y_pred, output_dict=True)

# Per-class metrics + macro/weighted averages
import pandas as pd
df_report = pd.DataFrame(report).T
print(df_report[["precision", "recall", "f1-score", "support"]])

# 'macro' avg     = unweighted mean across classes (treats all equally)
# 'weighted' avg  = support-weighted mean (reflects class imbalance)
# Focus on:
# - macro F1 if all classes matter equally (e.g. digit recognition)
# - weighted F1 if rare classes matter less
# - recall of the positive class if it's the costly one (fraud, disease)

# For imbalanced classification, also report:
# - Precision-Recall AUC
# - Brier score (probability calibration)

Метрики регрессии подробно

Выбирайте метрики регрессии по бизнес-цене ошибки. RMSE — если большие ошибки непропорционально плохи (квадратичный штраф); MAE — если все ошибки одного размера одинаково плохи. R2 безразмерен и сравним между наборами данных. Max error показывает худший случай. Пользовательские асимметричные потери (например, сильнее штрафовать занижение) отражают реальные издержки: дефицит и избыток запаса стоят по-разному.

machine-learning
from sklearn.metrics import (mean_squared_error, mean_absolute_error,
    r2_score, explained_variance_score, max_error)

# RMSE — penalizes large errors; same units as y
rmse = mean_squared_error(y_test, y_pred, squared=False)

# MAE — robust to outliers; same units as y
mae = mean_absolute_error(y_test, y_pred)

# R^2 — fraction of variance explained (1.0 = perfect, 0 = predict mean)
r2 = r2_score(y_test, y_pred)

# Explained variance — like R^2 but ignores mean offset
evs = explained_variance_score(y_test, y_pred)

# Max error — single largest absolute error (worst-case)
max_err = max_error(y_test, y_pred)

# Custom asymmetric loss: penalize under-prediction more
def asymmetric_error(y_true, y_pred, under_penalty=2.0):
    error = y_true - y_pred
    return np.where(error > 0, under_penalty * error**2, error**2).mean()
11

Стратегии кросс-валидации

Варианты K-Fold

Выбор правильной стратегии CV критичен. KFold — базовый вариант. StratifiedKFold — для классификации (сохраняет баланс классов). GroupKFold — когда примеры коррелированы (несколько строк на пользователя или пациента: предотвращает утечку между train и val). TimeSeriesSplit — для временных данных (всегда обучаем на прошлом, валидируем на будущем). Неверная стратегия CV даёт завышенные оценки.

machine-learning
from sklearn.model_selection import (KFold, StratifiedKFold,
    GroupKFold, TimeSeriesSplit, RepeatedKFold)

# Standard K-fold (regression or balanced classification)
kf = KFold(n_splits=5, shuffle=True, random_state=42)

# Stratified (classification — preserves class proportions)
skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

# Group K-fold (when samples are not independent — e.g. multiple rows per patient)
gkf = GroupKFold(n_splits=5)  # pass groups=patient_ids to CV

# Time series split (no shuffle — preserves temporal order)
tscv = TimeSeriesSplit(n_splits=5)

# Use with cross_val_score:
scores = cross_val_score(model, X, y, cv=gkf, groups=groups, scoring="f1")

Кросс-валидация временных рядов

TimeSeriesSplit соблюдает временной порядок: каждый фолд обучается на прошлом и валидируется на будущем, но никогда наоборот. Это соответствует реальному прогнозированию и предотвращает утечку. Используйте параметр gap, когда соседние примеры автокоррелированы (например, завтрашняя цена коррелирует с сегодняшней). Обычный перемешанный KFold на временных рядах даёт сильно завышенные оценки — типичная ошибка новичка.

machine-learning
from sklearn.model_selection import TimeSeriesSplit
import matplotlib.pyplot as plt
import numpy as np

tscv = TimeSeriesSplit(n_splits=5, test_size=100)
# gap parameter (sklearn 1.0+): prevent leakage from train to test
tscv = TimeSeriesSplit(n_splits=5, test_size=100, gap=10)

for fold, (train_idx, test_idx) in enumerate(tscv.split(X)):
    X_tr, X_te = X[train_idx], X[test_idx]
    y_tr, y_te = y[train_idx], y[test_idx]
    model.fit(X_tr, y_tr)
    score = model.score(X_te, y_te)
    print(f"Fold {fold}: train={len(train_idx)}, test={len(test_idx)}, score={score:.3f}")

# NEVER shuffle time-series data for CV — that leaks future into past
# Use gap to avoid leakage from autocorrelated near-future points

CV с учётом групп

Когда в данных есть группы (несколько примеров на пациента, пользователя или сессию), стандартное случайное разбиение приводит к утечке: модель видит одну и ту же сущность в train и test, и оценки завышаются. GroupKFold держит каждую группу целиком в одном фолде. Типичные случаи: медицина (несколько снимков на пациента), рекомендательные системы (несколько оценок на пользователя), изображения (несколько кадров одной сцены). Отсутствие группового CV — одна из самых частых скрытых ошибок в ML.

machine-learning
from sklearn.model_selection import GroupKFold, GroupShuffleSplit

# When the same entity appears in multiple rows (e.g. multiple X-rays per patient),
# random splits leak: the model memorizes patient-specific features
# instead of learning generalizable patterns.

# Solution: keep all rows of a group in the same split
gkf = GroupKFold(n_splits=5)
scores = cross_val_score(model, X, y, cv=gkf, groups=df["patient_id"])

# GroupShuffleSplit: random train/test split respecting groups
gss = GroupShuffleSplit(n_splits=5, test_size=0.2, random_state=42)
for train_idx, test_idx in gss.split(X, groups=df["patient_id"]):
    ...

# Always pass the groups argument to CV functions
# Common scenarios: patients, users, sessions, image batches

Вложенная CV (честный подбор гиперпараметров)

Оценка CV, которую выдаёт обычный GridSearchCV, завышена: он выбрал лучшие гиперпараметры на тех же фолдах, на которых потом считает качество. Вложенная CV это исправляет: внешний цикл CV оценивает всю процедуру подбора на действительно отложенных фолдах. Результат — несмещённая оценка того, как весь конвейер (включая настройку) покажет себя на новых данных. Используйте её для честного бенчмаркинга, особенно при сравнении моделей.

machine-learning
from sklearn.model_selection import (GridSearchCV, cross_val_score,
    StratifiedKFold)

# Outer loop: estimate generalization performance
# Inner loop: tune hyperparameters
# Without nesting, GridSearchCV's CV score is optimistic (it selected the best
# hyperparameters using the same data)

inner_cv = StratifiedKFold(n_splits=3, shuffle=True, random_state=42)
outer_cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

grid = GridSearchCV(
    RandomForestClassifier(random_state=42),
    param_grid={"max_depth": [3, 5, 10], "n_estimators": [50, 100]},
    cv=inner_cv, scoring="f1", n_jobs=-1,
)

nested_scores = cross_val_score(grid, X, y, cv=outer_cv, scoring="f1")
print(f"Nested CV F1: {nested_scores.mean():.3f} +/- {nested_scores.std():.3f}")

# Fit the final model on all data
grid.fit(X, y)
best_model = grid.best_estimator_

CV с предобработкой (Pipeline)

Предобработка должна обучаться только на обучающем фолде, иначе статистика тестового фолда (средние, медианы, коэффициенты масштабирования) утечёт в обучение и оценки CV станут завышенными. Решение — обернуть всё в Pipeline: scikit-learn гарантирует, что каждый фолд CV обучит свою предобработку только на тренировочной части. Это важнейшая практика честной оценки ML. Никогда не обучайте предобработку на всём наборе до CV.

machine-learning
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import cross_val_score
from sklearn.impute import SimpleImputer

# RIGHT: wrap preprocessing in a Pipeline so each fold fits
# its own scaler/imputer on the training portion only
pipe = Pipeline([
    ("impute",  SimpleImputer(strategy="median")),
    ("scale",   StandardScaler()),
    ("model",   RandomForestClassifier(random_state=42)),
])

scores = cross_val_score(pipe, X, y, cv=5, scoring="f1")

# WRONG: fit scaler on the whole dataset, then CV
# (leaks test-fold statistics into training)
# scaler.fit(X)              # NO - includes future test folds
# X_scaled = scaler.transform(X)
# cross_val_score(model, X_scaled, y, cv=5)  # optimistic scores

# Pipelines also make deployment easier (one object, no leakage)
12

Подбор гиперпараметров

Поиск по сетке

GridSearchCV исчерпывающе перебирает все комбинации — основательно, но дорого (комбинаторный взрыв). Используйте его при небольшой и хорошо продуманной сетке параметров. Всегда передавайте подходящую метрику scoring (по умолчанию accuracy, что неверно для несбалансированной классификации). refit=True переобучает лучшую модель на всех тренировочных данных, чтобы возвращённый оценщик был готов к использованию.

machine-learning
from sklearn.model_selection import GridSearchCV

# Exhaustive search over all combinations
param_grid = {
    "n_estimators": [50, 100, 200],
    "max_depth":    [3, 5, 10, None],
    "min_samples_leaf": [1, 5, 10],
}
# 3 * 4 * 3 = 36 combinations, * 5 folds = 180 fits

grid = GridSearchCV(
    RandomForestClassifier(random_state=42),
    param_grid=param_grid,
    cv=5,
    scoring="f1",
    n_jobs=-1,
    refit=True,         # refit best model on full data
    return_train_score=True,
)
grid.fit(X_train, y_train)

print("Best params: ", grid.best_params_)
print("Best CV F1:  ", grid.best_score_)
best_model = grid.best_estimator_

Случайный поиск

RandomizedSearchCV выбирает n_iter комбинаций из распределений — гораздо эффективнее перебора по сетке, когда параметров много. Используйте loguniform для скорости обучения и силы регуляризации (они охватывают порядки величин). 50–100 итераций обычно находят почти оптимальную конфигурацию. Случайность также помогает выбраться из локальных оптимумов, которые мог пропустить перебор по сетке.

machine-learning
from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import randint, loguniform

# Sample from distributions instead of enumerating all combos
# Much more efficient when the grid is large
param_dist = {
    "n_estimators":     randint(50, 500),     # discrete uniform
    "max_depth":        [3, 5, 10, None],
    "min_samples_leaf": randint(1, 20),
    "learning_rate":    loguniform(1e-3, 1e0),  # log-uniform
}

rand_search = RandomizedSearchCV(
    GradientBoostingClassifier(random_state=42),
    param_distributions=param_dist,
    n_iter=50,           # number of parameter settings sampled
    cv=5,
    scoring="f1",
    n_jobs=-1,
    random_state=42,
)
rand_search.fit(X_train, y_train)
print("Best params:", rand_search.best_params_)

Байесовская оптимизация (Optuna)

Optuna использует байесовскую оптимизацию, чтобы разумно выбирать следующие гиперпараметры по результатам прошлых испытаний — гораздо экономнее по числу запусков, чем сетка или случайный поиск. Она также поддерживает прунинг (раннюю остановку плохих испытаний), условные пространства параметров и многокритериальную оптимизацию. Объект study хранит все испытания, поэтому можно визуализировать важность параметров и историю оптимизации. Лучше всего подходит для дорогих моделей с множеством гиперпараметров.

machine-learning
import optuna

def objective(trial):
    # Suggest hyperparameters
    n_estimators = trial.suggest_int("n_estimators", 50, 500)
    max_depth    = trial.suggest_int("max_depth", 3, 20)
    lr           = trial.suggest_float("learning_rate", 1e-3, 1e0, log=True)
    min_samples  = trial.suggest_int("min_samples_leaf", 1, 20)

    model = GradientBoostingClassifier(
        n_estimators=n_estimators, max_depth=max_depth,
        learning_rate=lr, min_samples_leaf=min_samples,
        random_state=42,
    )
    # 5-fold CV F1
    score = cross_val_score(model, X_train, y_train, cv=5,
                            scoring="f1", n_jobs=-1).mean()
    return score  # Optuna maximizes by default

study = optuna.create_study(direction="maximize")
study.optimize(objective, n_trials=100, timeout=600)

print("Best trial:", study.best_trial.params)
print("Best F1:    ", study.best_trial.value)

Halving Search (последовательное сокращение)

Halving search — итеративная стратегия распределения ресурсов: много кандидатов оценивается на малой части данных, затем худшие отбрасываются, а выжившие переоцениваются на большем объёме (данных или деревьев). Это гораздо быстрее полного перебора по сетке и часто находит похожие решения. Для ещё больших пространств используйте HalvingRandomSearchCV. Параметр 'factor' определяет агрессивность отсева. Хороший выбор по умолчанию, когда гиперпараметров много, а времени мало.

machine-learning
from sklearn.experimental import enable_halving_search_cv  # noqa
from sklearn.model_selection import HalvingGridSearchCV, HalvingRandomSearchCV

# Allocate more resources to promising candidates iteratively
halving = HalvingGridSearchCV(
    RandomForestClassifier(random_state=42),
    param_grid={"max_depth": [3, 5, 10, None],
                "n_estimators": [50, 100, 200]},
    cv=5,
    scoring="f1",
    factor=3,           # eliminate bottom 2/3 each round
    aggressive_elimination=False,
    n_jobs=-1,
)
halving.fit(X_train, y_train)
print("Best params:", halving.best_params_)
print("Best score: ", halving.best_score_)

# Much faster than full GridSearchCV — evaluates many candidates
# cheaply first, then invests more resources in the promising ones.

Практика подбора

Главные грехи настройки: оптимизация на тестовом наборе, подбор до переобучения на валидации и выдача CV-оценок как финального качества. Настраивайте через CV на тренировочных данных, затем один раз оцените финальную модель на чистом отложенном тесте. Просмотрите весь cv_results_, чтобы убедиться, что выбранные гиперпараметры устойчивы (малое std по фолдам), а не просто удачный seed. Начинайте с грубого поиска и уточняйте — основной выигрыш дают несколько ключевых параметров.

machine-learning
# 1. Tune on a VALIDATION set or via CV — never on the test set
# 2. Use the metric you actually care about (scoring=...)
# 3. Set random_state for reproducibility
# 4. Start coarse (randomized, few iterations), then refine around the best
# 5. Don't over-tune — small improvements may be noise

# Inspect full results to understand hyperparameter sensitivity
import pandas as pd
results = pd.DataFrame(grid.cv_results_)
cols = ["param_max_depth", "param_n_estimators",
        "mean_test_score", "std_test_score", "rank_test_score"]
print(results[cols].sort_values("rank_test_score").head(10))

# Refit the best model on the FULL training set (automatic with refit=True)
# Then evaluate ONCE on the held-out test set
test_score = grid.best_estimator_.score(X_test, y_test)
print(f"Test score: {test_score:.3f}")
13

Ансамблевое обучение

Бэггинг (bootstrap aggregating)

Бэггинг обучает много моделей на бутстрэп-выборках (с возвращением) и усредняет предсказания — снижает дисперсию, не увеличивая смещение. Случайный лес добавляет случайность по признакам на каждом разбиении, чтобы деревья были разнообразнее. OOB-оценка (out-of-bag) проверяет каждое дерево на ~37% примеров, которых оно не видело, — бесплатная оценка валидации без отдельного набора. OOB удобен для малых наборов, где жалко выделять валидацию.

machine-learning
from sklearn.ensemble import BaggingClassifier, RandomForestClassifier

# Bagging: train multiple models on bootstrap samples (with replacement)
bag = BaggingClassifier(
    estimator=DecisionTreeClassifier(),  # any base estimator
    n_estimators=100,
    max_samples=1.0,         # fraction of samples per bootstrap
    max_features=1.0,        # fraction of features per estimator
    bootstrap=True,
    n_jobs=-1,
    random_state=42,
)
bag.fit(X_train, y_train)

# Random Forest is bagging + random feature subsets at each split
# Out-of-bag (OOB) score: evaluate each tree on samples it didn't see
rf = RandomForestClassifier(n_estimators=200, oob_score=True,
                             random_state=42)
rf.fit(X_train, y_train)
print("OOB score:", rf.oob_score_)  # ~ validation accuracy for free

Бустинг

Бустинг обучает модели последовательно, и каждая исправляет ошибки предыдущей — снижает смещение (и отчасти дисперсию). AdaBoost перевзвешивает примеры; градиентный бустинг подгоняет остатки напрямую. learning_rate и n_estimators связаны: меньше learning_rate требует больше оценщиков, но часто обобщает лучше — всегда используйте раннюю остановку. HistGradientBoosting — быстрая гистограммная реализация в sklearn, сопоставимая с LightGBM.

machine-learning
from sklearn.ensemble import (AdaBoostClassifier,
    GradientBoostingClassifier, HistGradientBoostingClassifier)

# AdaBoost: weight misclassified samples higher each round
ada = AdaBoostClassifier(
    estimator=DecisionTreeClassifier(max_depth=1),
    n_estimators=200, learning_rate=0.5, random_state=42,
)
ada.fit(X_train, y_train)

# Gradient Boosting: fit each new tree to the residuals of the previous
gb = GradientBoostingClassifier(
    n_estimators=200, learning_rate=0.1, max_depth=3,
    subsample=0.8,        # stochastic GB — adds randomness
    random_state=42,
)
gb.fit(X_train, y_train)

# HistGradientBoosting: faster, native NaN handling, large-data friendly
hgb = HistGradientBoostingClassifier(
    max_iter=200, learning_rate=0.1, max_leaf_nodes=31,
    l2_regularization=0.0, early_stopping=True,
    random_state=42,
)
hgb.fit(X_train, y_train)

Стекинг (метаобучение)

Голосующий ансамбль усредняет предсказания разных моделей — мягкое голосование (по вероятностям) обычно лучше жёсткого (по большинству). Стекинг идёт дальше: метамодель учится оптимально объединять предсказания базовых моделей и часто выжимает дополнительное качество. Метамодель обучается на out-of-fold предсказаниях базовых моделей, чтобы избежать утечки (задаётся через cv). Берите разные базовые модели (разные алгоритмы) для максимального выигрыша — объединять три случайных леса бессмысленно.

machine-learning
from sklearn.ensemble import StackingClassifier, VotingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC

# Voting: simple average of predictions (hard=majority, soft=probabilities)
voting = VotingClassifier(
    estimators=[
        ("rf",  RandomForestClassifier(n_estimators=100, random_state=42)),
        ("svc", SVC(probability=True, random_state=42)),
        ("lr",  LogisticRegression(max_iter=1000)),
    ],
    voting="soft",     # use predict_proba
    weights=[2, 1, 1], # weight each model
)

# Stacking: train a meta-model on base model predictions
stacking = StackingClassifier(
    estimators=[
        ("rf",  RandomForestClassifier(n_estimators=100, random_state=42)),
        ("svc", SVC(probability=True, random_state=42)),
        ("lr",  LogisticRegression(max_iter=1000)),
    ],
    final_estimator=LogisticRegression(),  # meta-model
    cv=5,            # use CV predictions to train meta-model (avoids leakage)
    n_jobs=-1,
)
stacking.fit(X_train, y_train)

Voting, stacking и blending

Все три стратегии объединяют разные модели, повышая изощрённость: voting (проще всего, усреднение), blending (метамодель на отложенном наборе), stacking (метамодель на CV-предсказаниях, устойчивее). На практике предпочитают стекинг: метапризнаки на основе CV используют все тренировочные данные и снижают дисперсию. Blending проще и быстрее, но оставляет меньше данных для метамодели. Всем троим нужны разнообразные базовые модели, иначе выигрыша не будет.

machine-learning
# Voting:  simple average of predictions
# Stacking: meta-model trained on CV predictions of base models
# Blending: like stacking but meta-model trained on a single holdout set

# Blending (manual implementation):
# 1. Split train into train' and holdout
# 2. Train base models on train'
# 3. Get predictions on holdout
# 4. Train meta-model on (holdout_predictions, holdout_y)
# 5. Retrain base models on full train for final ensemble

from sklearn.model_selection import train_test_split
X_tr, X_hold, y_tr, y_hold = train_test_split(X_train, y_train, test_size=0.3,
                                               random_state=42)

# Train base models on X_tr
rf.fit(X_tr, y_tr); svc.fit(X_tr, y_tr); lr.fit(X_tr, y_tr)

# Get holdout predictions as new features
import numpy as np
holdout_preds = np.column_stack([
    rf.predict_proba(X_hold)[:, 1],
    svc.predict_proba(X_hold)[:, 1],
    lr.predict_proba(X_hold)[:, 1],
])
meta_model = LogisticRegression().fit(holdout_preds, y_hold)

Разнообразие и корреляция

Ансамбль превосходит своих участников только тогда, когда модели ошибаются некоррелированно. Если три модели делают одну и ту же ошибку, ансамбль повторит её. Измеряйте корреляцию предсказаний — чем ниже, тем лучше. Повышайте разнообразие, смешивая семейства алгоритмов (деревья, линейные, метрические), обучая на разных подмножествах признаков или используя разные режимы гиперпараметров. Разнообразие «тот же алгоритм с другим seed» слабое, алгоритмическое — сильное.

machine-learning
import numpy as np
from scipy.stats import spearmanr

# An ensemble only helps if models make DIFFERENT errors
# Measure prediction correlation between base models
preds = np.column_stack([rf.predict_proba(X_test)[:, 1],
                          svc.predict_proba(X_test)[:, 1],
                          lr.predict_proba(X_test)[:, 1]])
corr = spearmanr(preds).correlation
print("Prediction correlation matrix:")
print(corr)

# Low correlation = diverse models = better ensemble
# High correlation = redundant models = no benefit

# Ways to encourage diversity:
# 1. Different algorithms (tree + linear + nearest-neighbor)
# 2. Different feature subsets
# 3. Different hyperparameters
# 4. Different training samples (bagging)
# 5. Different random seeds (weakest form of diversity)
14

Основы глубокого обучения

Тензоры и autograd в PyTorch

Тензоры PyTorch — это массивы в духе numpy, которые отслеживают градиенты для автоматического дифференцирования. requires_grad=True включает autograd для тензора; вызов .backward() на скаляре вычисляет градиенты всех вышестоящих тензоров. Переносите тензоры на GPU через .to(device) для ускорения. .detach() отключает тензор от графа градиентов (для логирования или перевода в numpy).

machine-learning
import torch

# Tensors: like numpy arrays but on GPU and with autograd
x = torch.randn(3, 4, requires_grad=True)
y = torch.randn(4, 2, requires_grad=True)
z = x @ y               # matrix multiply
loss = z.sum()

# Automatic differentiation
loss.backward()         # populate .grad
print(x.grad.shape)     # torch.Size([3, 4])
print(y.grad.shape)     # torch.Size([4, 2])

# Move to GPU
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
x = x.to(device)

# Detach from graph (e.g. for logging)
numpy_array = z.detach().cpu().numpy()

Устройство цикла обучения

У любого цикла обучения PyTorch одна структура: zero_grad, forward, loss, backward, step. model.train() / model.eval() переключают поведение dropout и batchnorm — забыть переключить значит получить тихую ошибку. torch.no_grad() отключает отслеживание градиентов при инференсе (экономит память и вычисления). Всегда переносите батчи на то же устройство, что и модель. DataLoader отвечает за батчи и перемешивание, а цикл просто итерируется.

machine-learning
import torch
import torch.nn as nn
import torch.optim as optim

model = nn.Sequential(
    nn.Linear(784, 128), nn.ReLU(),
    nn.Linear(128, 64),  nn.ReLU(),
    nn.Linear(64, 10),
).to(device)

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=1e-3)

for epoch in range(epochs):
    model.train()                            # enable dropout/batchnorm
    for X_batch, y_batch in train_loader:
        X_batch, y_batch = X_batch.to(device), y_batch.to(device)

        optimizer.zero_grad()                # clear old gradients
        logits = model(X_batch)              # forward
        loss = criterion(logits, y_batch)    # compute loss
        loss.backward()                      # backprop
        optimizer.step()                     # update weights

    # Validation
    model.eval()                             # disable dropout/batchnorm
    with torch.no_grad():                    # no gradient tracking
        val_loss, correct = 0, 0
        for X_batch, y_batch in val_loader:
            logits = model(X_batch.to(device))
            val_loss += criterion(logits, y_batch.to(device))
            correct += (logits.argmax(1).cpu() == y_batch).sum().item()
    print(f"Epoch {epoch}: val_loss={val_loss/len(val_loader):.4f}, "
          f"val_acc={correct/len(val_loader.dataset):.4f}")

Основные слои

Linear + ReLU — базовый скрытый слой. Conv2d + MaxPool — для изображений; LSTM/GRU — для коротких последовательностей; Transformer — для длинных последовательностей и текста. BatchNorm стабилизирует обучение, Dropout регулирует. Учтите: CrossEntropyLoss в PyTorch уже применяет log-softmax, поэтому не добавляйте Softmax в конец классификационной модели — выдавайте сырые логиты.

machine-learning
import torch.nn as nn

# Linear (fully connected)
nn.Linear(in_features=128, out_features=64)

# Activations
nn.ReLU()        # default for hidden layers
nn.GELU()        # smoother, used in transformers
nn.Sigmoid()     # outputs in (0, 1)
nn.Softmax(dim=1)# multi-class probabilities (built into CrossEntropyLoss)

# Convolution (images)
nn.Conv2d(in_channels=3, out_channels=32, kernel_size=3, padding=1)
nn.MaxPool2d(kernel_size=2)   # downsample by 2
nn.BatchNorm2d(32)            # stabilize training
nn.Dropout(p=0.5)             # regularization

# Recurrent (sequences)
nn.LSTM(input_size=64, hidden_size=128, num_layers=2, batch_first=True)

# Transformer (attention)
nn.TransformerEncoderLayer(d_model=512, nhead=8, batch_first=True)

Оптимизаторы

Adam — самый популярный оптимизатор: адаптивная скорость обучения для каждого параметра, быстрое схождение, минимум настройки. AdamW исправляет ошибку weight decay в Adam и предпочтителен для трансформеров. SGD с моментом может лучше обобщать на CNN, но требует больше настройки. Планировщики скорости обучения (косинусный отжиг, one-cycle) часто дают бесплатные 1–2% точности. Скорость обучения — важнейший гиперпараметр, настраивайте её первой.

machine-learning
import torch.optim as optim

# SGD with momentum — robust default
optim.SGD(model.parameters(), lr=0.01, momentum=0.9, weight_decay=1e-4)

# Adam — adaptive, often faster convergence
optim.Adam(model.parameters(), lr=1e-3, weight_decay=1e-4)

# AdamW — proper weight decay (preferred over Adam for transformers)
optim.AdamW(model.parameters(), lr=1e-3, weight_decay=0.01)

# Learning rate scheduler — reduce LR over training
from torch.optim.lr_scheduler import CosineAnnealingLR, OneCycleLR
scheduler = CosineAnnealingLR(optimizer, T_max=epochs)
# or OneCycleLR for super-convergence (needs careful setup)

# In training loop:
optimizer.step()
scheduler.step()  # update LR each epoch (or batch for OneCycleLR)

Переобучение и регуляризация

Переобучение: ошибка на train продолжает падать, а на validation растёт. Dropout случайно отключает нейроны во время обучения, вынуждая сеть учить избыточные представления. Weight decay (L2) сжимает веса к нулю. Ранняя остановка следит за validation loss и останавливает обучение на плато — всегда сохраняйте лучший чекпойнт. Аугментация данных — сильнейший регуляризатор для изображений и текста. Уменьшение ёмкости модели — простейшее решение, когда остальное не помогает.

machine-learning
# 1. Dropout — randomly zero out units during training
nn.Dropout(p=0.5)

# 2. Weight decay (L2 regularization) via optimizer
optim.AdamW(model.parameters(), lr=1e-3, weight_decay=0.01)

# 3. Early stopping — stop when validation loss stops improving
best_val, patience, counter = float("inf"), 5, 0
for epoch in range(epochs):
    val_loss = validate(model, val_loader)
    if val_loss < best_val:
        best_val, counter = val_loss, 0
        torch.save(model.state_dict(), "best.pt")  # save best
    else:
        counter += 1
        if counter >= patience:
            print("Early stopping at epoch", epoch)
            break

# 4. Data augmentation (especially for images/text)
# 5. Batch normalization (mild regularizing effect)
# 6. Reduce model capacity (fewer layers/units)
15

Метрики оценки: углублённо

Precision, recall и F1

Precision и recall описывают компромисс между ложноположительными и ложноотрицательными срабатываниями. Выбирайте по бизнес-цене: precision для спама (ложное срабатывание = потерянное важное письмо), recall для скрининга рака (пропуск = недиагностированный случай). F1 уравновешивает обе метрики; F-beta позволяет сместить акцент — F2 удваивает вес recall, F0.5 удваивает вес precision. Всегда сообщайте и precision, и recall, а не только F1.

machine-learning
from sklearn.metrics import (precision_score, recall_score,
    f1_score, fbeta_score)

# Precision: TP / (TP + FP) — of predicted positives, how many are real
# Recall:    TP / (TP + FN) — of actual positives, how many we caught
# F1:        harmonic mean of precision and recall
# F-beta:    weighted (beta > 1 favors recall, < 1 favors precision)

precision = precision_score(y_test, y_pred)
recall    = recall_score(y_test, y_pred)
f1        = f1_score(y_test, y_pred)
f2        = fbeta_score(y_test, y_pred, beta=2.0)   # recall-weighted
f05       = fbeta_score(y_test, y_pred, beta=0.5)   # precision-weighted

# When to use which:
# - Precision matters when false positives are costly (spam filter)
# - Recall matters when false negatives are costly (cancer screening)
# - F2 when recall is more important; F0.5 when precision is more important

ROC-AUC и PR-AUC

ROC-AUC измеряет, насколько хорошо модель ранжирует положительные объекты выше отрицательных, — полезно, потому что метрика не зависит от порога. PR-AUC (average_precision_score) — площадь под кривой precision-recall, она информативнее при дисбалансе (ROC-AUC может выглядеть отлично, когда PR-AUC ужасен). Для многих классов 'ovr' (один против всех) и 'ovo' (один против одного) считают AUC по-разному; при сомнениях приводите обе. Для выбора рабочего порога используйте индекс Юдена J.

machine-learning
from sklearn.metrics import (roc_auc_score, average_precision_score,
    roc_curve, precision_recall_curve)

# ROC-AUC: probability that model ranks a random positive
#          above a random negative. Threshold-independent.
roc_auc = roc_auc_score(y_test, y_proba)

# PR-AUC (average precision): area under precision-recall curve.
# More informative than ROC-AUC on imbalanced data.
pr_auc = average_precision_score(y_test, y_proba)

# Multiclass ROC-AUC
roc_auc_ovr = roc_auc_score(y_test, y_proba_multi,
                            multi_class="ovr", average="macro")
roc_auc_ovo = roc_auc_score(y_test, y_proba_multi,
                            multi_class="ovo", average="macro")

# Find the optimal threshold (Youden's J = TPR - FPR)
fpr, tpr, thresholds = roc_curve(y_test, y_proba)
j_scores = tpr - fpr
best_threshold = thresholds[j_scores.argmax()]

Визуализация матрицы ошибок

Всегда визуализируйте матрицу ошибок, а не только агрегированные метрики: она показывает, какие классы путаются между собой, выявляя слабые места модели (например, классификатор цифр путает 4 и 9). Нормируйте по строкам (истинный класс), чтобы увидеть recall каждого класса — это важно при дисбалансе. ConfusionMatrixDisplay делает это одной строкой. Основные ошибки сосредоточены во внедиагональных ячейках.

machine-learning
from sklearn.metrics import (confusion_matrix,
    ConfusionMatrixDisplay)
import matplotlib.pyplot as plt

cm = confusion_matrix(y_test, y_pred)

# Display with sklearn
disp = ConfusionMatrixDisplay(confusion_matrix=cm,
                              display_labels=class_names)
fig, ax = plt.subplots(figsize=(8, 6))
disp.plot(cmap="Blues", ax=ax, values_format="d")  # or ".2%" for normalized
plt.title("Confusion matrix")
plt.show()

# Normalized per row (true class) — see per-class recall
cm_norm = cm.astype(float) / cm.sum(axis=1, keepdims=True)
disp = ConfusionMatrixDisplay(confusion_matrix=cm_norm,
                              display_labels=class_names)
disp.plot(cmap="Blues", values_format=".2%")

Повторение метрик регрессии

Сообщайте несколько метрик: RMSE — чувствительность к большим ошибкам, MAE — типичная ошибка, медианная абсолютная ошибка — устойчивость к выбросам, max error — худший случай для SLA, R2 — безразмерная интерпретируемость. На смещённых целевых переменных (доход, цены) попробуйте логарифмировать y и считать метрики в лог-пространстве: это соответствует мультипликативным ошибкам и стабилизирует дисперсию. Всегда проверяйте предсказания против факта на диаграмме рассеяния.

machine-learning
from sklearn.metrics import (mean_squared_error, mean_absolute_error,
    r2_score, median_absolute_error, max_error,
    explained_variance_score, d2_tweedie_score)

# RMSE (penalizes large errors, same units as y)
rmse = mean_squared_error(y_test, y_pred, squared=False)

# MAE (robust to outliers, same units as y)
mae = mean_absolute_error(y_test, y_pred)

# Median AE (extremely robust to outliers)
med_ae = median_absolute_error(y_test, y_pred)

# Max error (worst single prediction — useful for SLAs)
max_err = max_error(y_test, y_pred)

# R^2 (1=perfect, 0=mean prediction, <0=worse than mean)
r2 = r2_score(y_test, y_pred)

# Explained variance (like R^2 but ignores bias)
evs = explained_variance_score(y_test, y_pred)

Метрики, связанные с бизнесом

ML-метрики (accuracy, F1, AUC) — лишь прокси для того, что важно на самом деле, то есть бизнес-результата. Переводите бизнес-издержки в пользовательские метрики: ложноотрицательный фрод стоит X, ложноположительный — Y, клик по объявлению на позиции k приносит Z. Оптимизируйте реальную цель (прибыль, спасённые жизни, предотвращённый отток), а не прокси. Настройка порога под бизнес-задачу часто даёт больше пользы, чем выжимание лишних 0.01 AUC.

machine-learning
# Sometimes the right metric isn't in sklearn — define your own.

# Example 1: Cost matrix (asymmetric costs)
def cost_weighted_error(y_true, y_pred, cost_fp=1, cost_fn=10):
    cm = confusion_matrix(y_true, y_pred)
    tn, fp, fn, tp = cm.ravel()
    return (cost_fp * fp + cost_fn * fn) / len(y_true)

# Example 2: Profit at K (top-K precision weighted by revenue)
def profit_at_k(y_true, y_proba, revenue_per_hit, k=100):
    top_k_idx = np.argsort(y_proba)[::-1][:k]
    hits = y_true[top_k_idx].sum()
    return hits * revenue_per_hit - k * cost_per_contact

# Example 3: Custom threshold optimization
def optimize_threshold_for_profit(y_true, y_proba, profit_matrix):
    best_t, best_profit = 0.5, -float("inf")
    for t in np.linspace(0.01, 0.99, 99):
        y_pred = (y_proba >= t).astype(int)
        profit = profit_matrix(y_true, y_pred)
        if profit > best_profit:
            best_t, best_profit = t, profit
    return best_t, best_profit
16

Конвейеры (Pipeline)

Базовый Pipeline

Pipeline связывает предобработку и модель в один оценщик, гарантируя, что при CV предобработка обучается только на тренировочном фолде (без утечки). Это и упрощает развёртывание: один объект вместо отдельных scaler, imputer и модели. Используйте именованные шаги для ясности. Pipeline — самый чистый способ делать честный и воспроизводимый ML: сделайте его нормой, а не оптимизацией.

machine-learning
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.impute import SimpleImputer
from sklearn.ensemble import RandomForestClassifier

pipe = Pipeline([
    ("impute", SimpleImputer(strategy="median")),
    ("scale",  StandardScaler()),
    ("clf",    RandomForestClassifier(random_state=42)),
])

# Use like any estimator
pipe.fit(X_train, y_train)
y_pred = pipe.predict(X_test)
score = pipe.score(X_test, y_test)

# Access steps
pipe.named_steps["clf"]
pipe[:-1].get_feature_names_out()  # see transformed feature names

# Pipelines prevent leakage: each CV fold fits its own preprocessing

ColumnTransformer (разнородные данные)

ColumnTransformer применяет разную предобработку к числовым и категориальным колонкам — это необходимо для реальных табличных данных. Каждый подконвейер отвечает за свою импутацию и кодирование. remainder='drop' отбрасывает не перечисленные колонки, 'passthrough' оставляет их как есть. Оберните ColumnTransformer в Pipeline с моделью, чтобы получить CV без утечек при разнородной предобработке. Это готовый к продакшену шаблон для табличного ML.

machine-learning
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import (StandardScaler, OneHotEncoder)
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer

numeric_features     = ["age", "income", "score"]
categorical_features = ["city", "occupation"]

# Different preprocessing for different column types
preprocessor = ColumnTransformer(
    transformers=[
        ("num", Pipeline([
            ("impute", SimpleImputer(strategy="median")),
            ("scale",  StandardScaler()),
        ]), numeric_features),
        ("cat", Pipeline([
            ("impute", SimpleImputer(strategy="most_frequent")),
            ("onehot", OneHotEncoder(handle_unknown="ignore")),
        ]), categorical_features),
    ],
    remainder="drop",  # or 'passthrough' to keep other columns
)

full_pipe = Pipeline([
    ("preprocess", preprocessor),
    ("clf", RandomForestClassifier(random_state=42)),
])
full_pipe.fit(X_train, y_train)

Pipeline с подбором параметров

Pipeline прекрасно сочетается с GridSearchCV: можно совместно настраивать предобработку и гиперпараметры модели через синтаксис 'step__param'. Так находится лучшая предобработка именно для этой модели, что часто отличается от лучшей предобработки самой по себе. Всегда настраивайте весь конвейер, а не только модель. Совместная настройка честнее (вы не подглядываете в тест, выбирая предобработку) и часто даёт лучшие конфигурации.

machine-learning
from sklearn.model_selection import GridSearchCV

# Reference nested parameters with 'step__param' syntax
param_grid = {
    "preprocess__num__impute__strategy": ["mean", "median"],
    "clf__n_estimators": [50, 100, 200],
    "clf__max_depth":    [3, 5, 10, None],
}

grid = GridSearchCV(full_pipe, param_grid, cv=5, scoring="f1", n_jobs=-1)
grid.fit(X_train, y_train)
print("Best params:", grid.best_params_)

# Tune preprocessing AND model together — finds the best combo
# e.g. median imputation + 100 trees + max_depth=10

Пользовательские трансформеры

Пользовательские трансформеры позволяют инкапсулировать предметную предобработку (логарифмирование, извлечение признаков из дат, очистку текста) в переиспользуемые компоненты, совместимые с Pipeline. Наследуйтесь от BaseEstimator и TransformerMixin, реализуйте fit (часто просто возвращает self) и transform. Так ваша инженерия признаков остаётся версионируемой, тестируемой и без утечек — гораздо лучше, чем разбрасывать логику по ноутбукам. Для разовых функций используйте FunctionTransformer.

machine-learning
from sklearn.base import BaseEstimator, TransformerMixin
import numpy as np

class LogTransformer(BaseEstimator, TransformerMixin):
    def __init__(self, columns=None):
        self.columns = columns

    def fit(self, X, y=None):
        return self  # nothing to fit

    def transform(self, X):
        X = X.copy()
        if self.columns is None:
            return np.log1p(X)
        X[self.columns] = np.log1p(X[self.columns])
        return X

# Use in a pipeline
pipe = Pipeline([
    ("log",  LogTransformer(columns=["income", "price"])),
    ("scale", StandardScaler()),
    ("clf",   LogisticRegression()),
])

# For more complex logic, use FunctionTransformer or write a full class

Сохранение и загрузка Pipeline

joblib (а не pickle) — стандарт сериализации конвейеров sklearn: он эффективно работает с массивами numpy. Фиксируйте версию sklearn в продакшене: модель, сохранённая в одной версии, не гарантированно загрузится в другой. Для кросс-языкового развёртывания (обслуживание Python-модели из Java/Go) конвертируйте в ONNX через skl2onnx. Всегда сохраняйте весь конвейер, а не только модель, чтобы предобработка при инференсе была идентичной.

machine-learning
import joblib

# Save the entire fitted pipeline
joblib.dump(full_pipe, "model.pkl")

# Later (e.g. in a web service)
loaded = joblib.load("model.pkl")
predictions = loaded.predict(new_data)

# Why joblib over pickle?
# - More efficient for numpy arrays (which sklearn models contain)
# - Handles objects with large numerical arrays via compression

# Version compatibility:
# - sklearn versions must match between save and load in production
# - Pin sklearn in requirements.txt: scikit-learn==1.4.2

# For cross-language deployment, use ONNX:
# import skl2onnx
# onx = skl2onnx.convert_sklearn(full_pipe, ...)
17

Сохранение моделей

joblib против pickle

Для моделей sklearn используйте joblib: он оптимизирован под массивы numpy и из коробки поддерживает сжатие. pickle — запасной вариант для произвольных объектов Python. У обоих одна и та же проблема безопасности: НИКОГДА не загружайте недоверенные файлы pickle/joblib — при десериализации они могут выполнить произвольный код. Для передачи моделей в недоверенные среды используйте ONNX или сервер моделей с валидацией входных данных.

machine-learning
import joblib
import pickle

# joblib — preferred for sklearn (efficient with numpy arrays)
joblib.dump(model, "model.joblib", compress=3)
model = joblib.load("model.joblib")

# pickle — standard library, works for any picklable object
with open("model.pkl", "wb") as f:
    pickle.dump(model, f)
with open("model.pkl", "rb") as f:
    model = pickle.load(f)

# Compress to save disk space (joblib supports it natively)
joblib.dump(model, "model.joblib", compress=("xz", 3))

# Load partially for inspection without full deserialize
# (advanced, not commonly needed)

Версионирование моделей

Всегда версионируйте модели вместе с метаданными: версии фреймворков (sklearn, python), список признаков, хеш обучающих данных, метрики, git-коммит и временную метку. Это делает отладку продакшен-проблем выполнимой: когда модель ведёт себя иначе, можно сравнить метаданные и увидеть, что изменилось. Используйте семантическое версионирование: patch — переобучение, minor — новые признаки, major — ломающие изменения (новая предобработка, несовместимая со старыми предсказаниями).

machine-learning
# Save metadata alongside the model artifact
import joblib, json
from datetime import datetime

metadata = {
    "model_type": "RandomForestClassifier",
    "sklearn_version": sklearn.__version__,
    "python_version": sys.version,
    "features": list(X_train.columns),
    "target": "churn",
    "metrics": {"f1": 0.842, "roc_auc": 0.913},
    "trained_at": datetime.utcnow().isoformat(),
    "data_hash": hashlib.md5(pd.util.hash_pandas_object(X_train).values).hexdigest(),
    "git_commit": subprocess.check_output(["git", "rev-parse", "HEAD"]).decode().strip(),
}

joblib.dump({"model": model, "metadata": metadata}, "model_v1.2.0.joblib")

# Convention: semantic versioning
# v1.0.0 -> initial release
# v1.1.0 -> retrained on new data (backward compatible)
# v2.0.0 -> breaking change (new features, new preprocessing)

Экспорт в ONNX

ONNX — кросс-платформенный формат моделей: конвертируйте конвейер sklearn один раз и запускайте где угодно (Python, C++, Java, JavaScript, Go) без зависимостей Python. Это идеально для продакшена, когда среда обучения (Python) и среда обслуживания (например, микросервис на Go) различаются. ONNX Runtime для многих моделей ещё и быстрее sklearn. Оговорка: не у всех трансформеров и моделей sklearn есть эквиваленты в ONNX — проверьте поддержку skl2onnx перед выбором.

machine-learning
# pip install skl2onnx onnxruntime
from skl2onnx import convert_sklearn
from skl2onnx.common.data_types import FloatTensorType
import onnxruntime as rt

# Convert sklearn pipeline to ONNX
initial_type = [("float_input", FloatTensorType([None, X_train.shape[1]]))]
onnx_model = convert_sklearn(full_pipe, initial_types=initial_type,
                              target_opset=15)

with open("model.onnx", "wb") as f:
    f.write(onnx_model.SerializeToString())

# Run inference in any language (Python, C++, Java, JS, Go, ...)
sess = rt.InferenceSession("model.onnx")
input_name = sess.get_inputs()[0].name
predictions = sess.run(None, {input_name: X_test.astype(np.float32)})[0]

# Benefits: no Python at inference, fast, cross-platform

Основы мониторинга моделей

В продакшене модели деградируют по мере изменения мира — следите за дрейфом. Дрейф данных: меняется распределение входных признаков (например, демография пользователей). Дрейф концепции: меняется связь между признаками и целью (например, эволюционируют схемы мошенничества). PSI (Population Stability Index) — простая и интерпретируемая метрика дрейфа: значения > 0.25 требуют переобучения. Сочетайте алерты о дрейфе с регулярным переобучением. Всегда логируйте предсказания для последующего анализа.

machine-learning
# After deployment, monitor for:
# 1. Data drift: input distribution changes
# 2. Concept drift: P(y|X) changes
# 3. Prediction drift: output distribution changes
# 4. Performance degradation: metric drops over time

# Simple data drift check: PSI (Population Stability Index)
def psi(expected, actual, bins=10):
    expected_pct = np.histogram(expected, bins=bins)[0] / len(expected)
    actual_pct   = np.histogram(actual,   bins=bins)[0] / len(actual)
    # Avoid log(0)
    expected_pct = np.clip(expected_pct, 1e-4, None)
    actual_pct   = np.clip(actual_pct,   1e-4, None)
    return np.sum((actual_pct - expected_pct) * np.log(actual_pct / expected_pct))

# PSI < 0.1: stable, 0.1-0.25: minor drift, > 0.25: significant drift
for col in X.columns:
    score = psi(X_train[col], X_new[col])
    if score > 0.25:
        print(f"Drift detected in {col}: PSI={score:.3f}")

Стратегии переобучения

Выбирайте стратегию переобучения по скорости изменения данных. По расписанию (проще всего, предсказуемо). По падению качества (реактивно, только когда нужно). По дрейфу (раннее предупреждение до падения метрик). Онлайн-обучение (непрерывные обновления для быстро меняющихся данных, например фрода или рекомендаций). Всегда сравнивайте новую модель с текущей на свежих данных, разворачивайте в режиме shadow для сравнения живых предсказаний и предусматривайте автоматический откат при регрессе метрик.

machine-learning
# 1. Scheduled retraining (simplest)
#    Retrain weekly/monthly regardless of performance
schedule = "0 2 * * 0"  # every Sunday at 2am

# 2. Performance-triggered retraining
#    Retrain when a metric drops below threshold
if current_f1 < production_f1 * 0.95:  # 5% drop
    trigger_retrain()

# 3. Drift-triggered retraining
#    Retrain when PSI exceeds threshold
if max_psi > 0.25:
    trigger_retrain()

# 4. Online learning (incremental updates)
from sklearn.linear_model import SGDClassifier
model = SGDClassifier()
for X_batch, y_batch in stream:
    model.partial_fit(X_batch, y_batch, classes=[0, 1])

# Always:
# - Validate new model beats old on recent data before promoting
# - Shadow deploy: run new model in parallel, compare predictions
# - Roll back automatically if metrics regress
# - Keep training data fresh (drop old samples)
18

Регуляризация

L1 (Lasso) против L2 (Ridge)

L1 (Lasso) добавляет штраф по модулю, который обнуляет часть коэффициентов — встроенный отбор признаков, идеален, когда многие признаки нерелевантны. L2 (Ridge) добавляет квадратичный штраф, плавно сжимающий коэффициенты, — лучше, когда многие признаки дают небольшой вклад. ElasticNet смешивает оба и предпочтителен при коррелированных признаках (чистый Lasso случайно выбирает один и обнуляет остальные). Всегда сначала масштабируйте признаки, чтобы штраф был справедливым.

machine-learning
from sklearn.linear_model import Lasso, Ridge, ElasticNet
import numpy as np

# L1 (Lasso): penalty = alpha * sum(|coef|)
# Drives some coefficients to exactly 0 -> sparse -> feature selection
lasso = Lasso(alpha=0.1)
lasso.fit(X_train_scaled, y_train)
print("Non-zero coefs:", (lasso.coef_ != 0).sum(), "/", len(lasso.coef_))

# L2 (Ridge): penalty = alpha * sum(coef^2)
# Shrinks coefficients smoothly toward 0, keeps all features
ridge = Ridge(alpha=1.0)
ridge.fit(X_train_scaled, y_train)

# ElasticNet: mix of L1 and L2
# penalty = alpha * (l1_ratio * L1 + (1 - l1_ratio) * L2)
en = ElasticNet(alpha=0.1, l1_ratio=0.5)
en.fit(X_train_scaled, y_train)

# Rule of thumb:
# - L1: many features, only a few matter (sparse)
# - L2: many features, all matter a little
# - ElasticNet: correlated features (Lasso picks one randomly)

Регуляризация деревьев

Для деревьев max_depth и min_samples_leaf — сильнейшие регуляризаторы: они не дают дереву запомнить отдельные примеры. ccp_alpha выполняет cost-complexity pruning (более обоснованную постобработку). В случайном лесу max_features и bootstrap добавляют регуляризацию через случайность. В градиентном бустинге критичны learning_rate и early_stopping (низкий LR + ранняя остановка + достаточное число деревьев обычно побеждают). Subsample и colsample_bytree добавляют регуляризацию через стохастичность.

machine-learning
from sklearn.ensemble import RandomForestClassifier
from sklearn.tree import DecisionTreeClassifier

# Decision tree regularization hyperparameters
tree = DecisionTreeClassifier(
    max_depth=5,             # limit tree depth (strongest lever)
    min_samples_split=20,    # min samples to split a node
    min_samples_leaf=10,     # min samples per leaf
    max_leaf_nodes=20,       # cap total leaves
    max_features="sqrt",     # features considered per split
    ccp_alpha=0.01,          # cost-complexity pruning
)

# Random forest adds more regularization via:
rf = RandomForestClassifier(
    n_estimators=200,
    max_depth=None,
    min_samples_leaf=5,
    max_features="sqrt",     # random feature subset per split
    bootstrap=True,          # bagging
    max_samples=0.8,         # subsample ratio
)

# For boosting (XGBoost), also use:
# - learning_rate (smaller = more regularization)
# - subsample, colsample_bytree (randomness)
# - reg_lambda, reg_alpha (L2/L1 on leaf weights)
# - gamma (minimum loss reduction to split)
# - early_stopping_rounds

Dropout и BatchNorm (глубокое обучение)

Dropout случайно обнуляет активации при обучении, вынуждая сеть учить избыточные представления — сильный регуляризатор. Обычно его больше в крупных слоях, меньше в мелких и часто ноль на выходе. BatchNorm нормирует активации по батчу, стабилизируя обучение и давая мягкий регуляризующий эффект (шум батчевой статистики). Помните: dropout и batchnorm ведут себя по-разному в train и eval — всегда вызывайте model.eval() для инференса и model.train() для продолжения обучения.

machine-learning
import torch.nn as nn

model = nn.Sequential(
    nn.Linear(784, 256),
    nn.BatchNorm1d(256),     # normalize activations -> faster, stable training
    nn.ReLU(),
    nn.Dropout(0.5),         # randomly zero 50% of activations during training

    nn.Linear(256, 128),
    nn.BatchNorm1d(128),
    nn.ReLU(),
    nn.Dropout(0.3),         # less dropout closer to output

    nn.Linear(128, 10),      # no dropout before output (or use very low)
)

# IMPORTANT: dropout is OFF during inference (model.eval())
# BatchNorm uses batch stats in training and running stats in eval

# Common patterns:
# - Higher dropout in big layers, lower in small layers
# - No dropout right after input or right before output
# - BatchNorm before activation (debated; try both)

Ранняя остановка

Ранняя остановка прекращает обучение, когда validation loss перестаёт улучшаться, предотвращая переобучение и экономя вычисления. Всегда сохраняйте лучшую модель (с минимальным val loss), а не последнюю — последняя может быть переобучена. patience задаёт, сколько эпох без улучшения терпеть. В градиентном бустинге early_stopping_rounds делает то же самое на уровне деревьев. Ранняя остановка — один из самых выгодных и дешёвых регуляризаторов; всегда используйте её в глубоком обучении.

machine-learning
import torch

best_val_loss = float("inf")
patience, counter = 5, 0
best_state = None

for epoch in range(max_epochs):
    train_loss = train_one_epoch(model, train_loader, optimizer, criterion)
    val_loss   = validate(model, val_loader, criterion)

    if val_loss < best_val_loss:
        best_val_loss = val_loss
        counter = 0
        best_state = {k: v.clone() for k, v in model.state_dict().items()}
    else:
        counter += 1
        if counter >= patience:
            print(f"Early stopping at epoch {epoch}")
            break

# Restore the best model
model.load_state_dict(best_state)

# For XGBoost/LightGBM, use early_stopping_rounds:
# model.fit(X_train, y_train,
#           eval_set=[(X_val, y_val)],
#           early_stopping_rounds=20)

Аугментация данных

Аугментация данных — сильнейший регуляризатор при ограниченной разметке: она синтетически расширяет набор сохраняющими метку преобразованиями. Для изображений: отражения, обрезка, изменение цвета, повороты (уместные для домена: не переворачивайте медицинские рентгеновские снимки, но переворачивайте обычные фотографии). Для текста: замена синонимами, обратный перевод, случайное удаление. Для табличных данных: SMOTE (дисбаланс) или mixup (регрессия). Аугментация по сути даёт бесплатные размеченные данные.

machine-learning
# Images (torchvision)
import torchvision.transforms as T

train_transform = T.Compose([
    T.RandomResizedCrop(224),
    T.RandomHorizontalFlip(),
    T.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2),
    T.RandomRotation(10),
    T.ToTensor(),
    T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])

# Text (NLPAug or simple Python)
import random
def augment_text(text):
    # Synonym replacement, random deletion, back-translation
    words = text.split()
    if random.random() < 0.3:
        idx = random.randrange(len(words))
        words[idx] = synonym(words[idx])
    if random.random() < 0.2:
        words = [w for w in words if random.random() > 0.1]
    return " ".join(words)

# Tabular (SMOTE for imbalance, mixup for regression)
# mixup: X_mix = alpha*X1 + (1-alpha)*X2, y_mix = alpha*y1 + (1-alpha)*y2

Was this helpful?

Learning path

Learn from scratch

Learn this language from the ground up with structured lessons.