Какие знаешь типы регуляризации?

Типы регуляризации в машинном обучении

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

1. L1 и L2 регуляризация

L2 регуляризация (Ridge)

Добавляет штраф на сумму квадратов весов:

Loss = MSE(y_true, y_pred) + lambda * sum(weights ** 2)

Эффект: веса остаются маленькими и "гладкими", но редко становятся ровно нулю. Все признаки остаются в модели.

from sklearn.linear_model import Ridge
model = Ridge(alpha=1.0)  # alpha = lambda
model.fit(X, y)

Когда использовать: когда все признаки потенциально полезны, многоколинеарность.

L1 регуляризация (Lasso)

Шраф на сумму абсолютных значений весов:

Loss = MSE(y_true, y_pred) + lambda * sum(|weights|)

Эффект: некоторые веса обнуляются (feature selection), модель становится разреженной (sparse).

from sklearn.linear_model import Lasso
model = Lasso(alpha=0.1)
model.fit(X, y)

Когда использовать: нужна интерпретируемость, селекция признаков, много неполезных признаков.

ElasticNet (L1 + L2)

Лучшее из обоих миров:

Loss = MSE + lambda1 * sum(|w|) + lambda2 * sum(w**2)

from sklearn.linear_model import ElasticNet
model = ElasticNet(alpha=0.1, l1_ratio=0.5)

2. Dropout

Случайно отключает (обнуляет) часть нейронов во время обучения:

import torch.nn as nn

model = nn.Sequential(
    nn.Linear(784, 256),
    nn.ReLU(),
    nn.Dropout(p=0.5),  # отключает 50% нейронов
    nn.Linear(256, 128),
    nn.Dropout(p=0.5),
    nn.Linear(128, 10)
)

Механизм: интерпретируется как обучение ансамбля экспоненциально большого количества моделей с общими весами.

Практическое правило: dropout = 0.2-0.5, не больше. На вход не ставим!

Когда использовать: нейросети, переобучение, данных мало.

3. Batch Normalization

Нормализует входы для каждого слоя, добавляет небольшой noise:

model = nn.Sequential(
    nn.Linear(784, 256),
    nn.BatchNorm1d(256),
    nn.ReLU(),
    nn.Dropout(0.5),
    nn.Linear(256, 128),
    nn.BatchNorm1d(128),
    nn.ReLU()
)

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

Минусы: усложняет код, train/test разные (в train используется статистика батча, в test — накопленная).

4. Early Stopping

Прерываем обучение когда validation loss начинает расти:

best_val_loss = float(inf)
patience = 10
waits = 0

for epoch in range(num_epochs):
    train_loss = train_one_epoch()
    val_loss = validate()
    
    if val_loss < best_val_loss:
        best_val_loss = val_loss
        waits = 0
        save_checkpoint(model)  # сохраняем лучшую версию
    else:
        waits += 1
        if waits >= patience:
            break  # останавливаем обучение

load_checkpoint(model)  # загружаем лучшую версию

Очень важно: это не просто трюк, а принципиально важный компонент. Validation set должен быть отдельным от train!

5. Data Augmentation

Искусственно увеличиваем dataset, применяя трансформации:

from torchvision import transforms

augmentation = transforms.Compose([
    transforms.RandomHorizontalFlip(p=0.5),
    transforms.RandomRotation(15),
    transforms.RandomAffine(degrees=0, translate=(0.1, 0.1)),
    transforms.ColorJitter(brightness=0.2),
    transforms.RandomCrop(size=(224, 224)),
    transforms.RandomErasing(p=0.5),  # Random erasing
])

Идея: модель учится на разных версиях одного объекта, становится более robust.

Для текста: back-translation, замена синонимов, deletion, shuffling. Для цифр: noise, rotation, elastic distortion.

6. Weight Decay

Это другое название для L2 регуляризации в контексте оптимизаторов:

# Правильно (AdamW)
optimizer = torch.optim.AdamW(model.parameters(), 
                               lr=0.001,
                               weight_decay=0.01)

# Неправильно (обычный Adam)
optimizer = torch.optim.Adam(model.parameters(),
                             lr=0.001)
loss += 0.01 * sum(p.pow(2).sum() for p in model.parameters())

Важно: в AdamW weight decay работает корректнее, чем добавление L2 в loss!

7. Mixup и Cutmix

Mixup — интерполируем образцы в input space:

lambda = random_beta(0.1, 0.1)
x_mixed = lambda * x_i + (1 - lambda) * x_j
y_mixed = lambda * y_i + (1 - lambda) * y_j

Cutmix — режем кусок из одного изображения и вставляем из другого:

# Вырезаем random box из одного изображения
# Вставляем на его место из другого
# Label становится weighted mix

8. Label Smoothing

Вместо hard target (0, 1) используем мягкие:

# Вместо [0, 0, 1, 0]
smooth_target = [0.1/3, 0.1/3, 0.9, 0.1/3]  # epsilon=0.1

from torch.nn import CrossEntropyLoss
loss = CrossEntropyLoss(label_smoothing=0.1)

Эффект: модель становится менее уверенной, лучше обобщает.

9. Ensemble Methods

Не одна модель, а несколько с голосованием:

ensemble = [
    train_model(random_seed=1),
    train_model(random_seed=2),
    train_model(random_seed=3),
]

prediction = voting(ensemble_predictions)  # или averaging

Работает потому что: разные модели переобучаются на разных паттернах, в среднем это дает меньше переобучения.

10. Stochastic Depth

В нейросетях случайно пропускаем слои во время обучения:

# Используется в EfficientNets, Vision Transformers
if training and random() < drop_rate:
    x = input  # пропускаем слой
else:
    x = layer(input) + input  # residual connection

Сравнительная таблица

Практические рекомендации

1. Начни с простого: L2 регуляризация + early stopping
2. Добавь dropout если видишь переобучение
3. Data augmentation работает почти всегда
4. Ensemble для production моделей
5. НЕ комбинируй L1/L2 и weight decay одновременно
6. Всегда используй separate validation set

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