С чего начать
Что такое машинное обучение?
Машинное обучение строит системы, которые обобщают данные, а не следуют вручную написанным правилам. Три парадигмы (обучение с учителем, без учителя и с подкреплением) покрывают большинство реальных задач. Соблюдение структурного рабочего процесса — особенно выделение чистого тестового набора — помогает избежать главного греха: переобучения под собственную оценку.
# 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 (удобен для продакшена) — оба покрывают один и тот же круг задач.
# 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 вместо фиксированного валидационного набора.
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 при несбалансированных задачах.
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) требует ещё детерминированных алгоритмов и переменных окружения — это полезно при отладке результатов, которые «должны» совпадать, но не совпадают.
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"Подготовка данных
Обработка пропущенных значений
Обучение импутера на всём наборе данных переносит статистику теста в обучение — всегда обучайте только на train. Медиана устойчивее к выбросам, чем среднее. Для категориальных признаков используйте 'most_frequent' или 'constant'. KNN-импутация умеет улавливать многомерную структуру, но дорога на больших данных. Подумайте, информативен ли сам факт пропуска (добавьте индикатор 'is_missing').
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 на тесте.
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-кодирование, чтобы не раздувать размерность.
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 на несбалансированных данных.
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 справляется с высокой размерностью и нелинейными границами. Решите, удалять, ограничивать (винзоризация) или сохранять выбросы, исходя из предметной области — иногда выбросы и есть те случаи, которые вас интересуют (мошенничество, аномалии).
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]Инженерия признаков
Полиномиальные признаки и взаимодействия
PolynomialFeatures позволяет линейным моделям улавливать нелинейные связи, добавляя x^2, x*y и т. п. как новые признаки. interaction_only исключает чистые квадраты — полезно, когда нужны только перекрёстные члены. Число признаков растёт комбинаторно, поэтому всегда сочетайте это с регуляризацией (Ridge/Lasso), чтобы избежать переобучения, или применяйте после снижения размерности.
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, чтобы модель воспринимала их как отдельные категории.
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, чтобы контролировать размер словаря и шум.
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 — простая трендовая фича для временных рядов.
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.
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)Обучение с учителем
Линейная и логистическая регрессия
Линейные модели быстры, интерпретируемы и служат сильным базовым уровнем. LogisticRegression по умолчанию использует L2-регуляризацию; меньшее C означает более сильную регуляризацию. Для многих классов применяется softmax. Коэффициенты показывают важность признаков, но только после масштабирования: без него коэффициенты несопоставимы. Всегда начинайте с линейного бейзлайна, прежде чем пробовать сложные модели.
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.
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 с валидационным набором, чтобы найти оптимальное число деревьев.
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 или ансамбль деревьев.
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).
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}")Обучение без учителя
Кластеризация K-Means
K-Means разбивает данные на k сферических кластеров, минимизируя внутрикластерную дисперсию. n_init=10 запускает алгоритм из 10 случайных инициализаций и оставляет лучшую (значение по умолчанию изменилось в sklearn 1.4). Выбирайте k по локтю (инерции) или силуэту (силуэт более обоснован). K-Means предполагает сферические кластеры равного размера — для несферических используйте DBSCAN или смесь гауссиан.
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.
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.
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 также умеет генерировать новые примеры — полезно для аугментации данных.
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 задаёт ожидаемую долю аномалий; настраивайте её по знаниям о предметной области.
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)Регрессия
Линейная регрессия и регуляризованные варианты
OLS минимизирует квадратичную ошибку без регуляризации — высокая дисперсия при мультиколлинеарности. Ridge (L2) плавно сжимает коэффициенты, хорошо подходит, когда важно много признаков. Lasso (L1) обнуляет часть коэффициентов, выполняя отбор признаков. ElasticNet смешивает оба подхода и полезен при коррелированных признаках. Всегда масштабируйте признаки перед регуляризованной регрессией, чтобы штраф был справедлив для всех признаков.
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.
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') предсказывает процентиль, а не среднее — комбинируйте модели нижнего и верхнего квантилей для интервалов предсказания, когда нужны оценки неопределённости.
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 перед кросс-валидацией.
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). Нормальность остатков важна для вывода (доверительных интервалов), но не для точности предсказаний.
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Классификация
Основы бинарной классификации
predict возвращает жёсткие метки классов (порог 0.5), predict_proba — вероятности, что обычно полезнее. Порог 0.5 по умолчанию редко оптимален: снижайте его ради большего recall (ловить больше положительных случаев, например при скрининге рака), повышайте ради precision (меньше ложных тревог, например в спам-фильтре). ROC-AUC измеряет, насколько хорошо вероятности ранжируют положительные объекты выше отрицательных, независимо от порога.
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 — когда важен их частотный вклад.
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.
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 измеряет качество предсказанных вероятностей (меньше — лучше).
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 исправляет это, подгоняя изотоническую регрессию или сигмоиду на отложенном наборе. Калибровка важна везде, где вы действуете по вероятностям (оценка риска, выбор порога), и не нужна, если используются только жёсткие метки классов.