Dropout и регуляризация: как спасти модель от переобучения

🎯 Зачем это нужно?

Представь: ты готовишься к экзамену, заучивая наизусть все задачи из одного сборника 📚. На тренировке решаешь всё идеально! Но на реальном экзамене с новыми задачами проваливаешься… Знакомо?

Точно так же нейросети могут “зазубрить” тренировочные данные, но плохо работать на новых примерах. Это называется переобучение (overfitting). А dropout и регуляризация - это наши спасители от этой беды!

💼 Где используется:

• Instagram/TikTok: алгоритмы рекомендаций не должны показывать одинаковый контент всем
• Яндекс.Переводчик: модель должна переводить новые тексты, а не только те, на которых училась
• Autonomous driving: Tesla не может “запомнить” все дороги - нужно обобщать на новые маршруты

📚 История вопроса

В 2012 году команда Джеффри Хинтона из Торонто придумала dropout почти случайно! 🎲 Они заметили, что если во время обучения “выключать” случайные нейроны, модель становится более устойчивой.

Идея пришла из биологии: в мозге нейроны тоже иногда “молчат”, и это делает мышление более гибким. Dropout стал революцией - почти все современные нейросети его используют!

Забавный факт: название “dropout” придумали по аналогии со школой - как ученики “выпадают” из класса, так и нейроны “выпадают” из сети 🎓

💡 Интуиция

Что такое переобучение?

Imagine твоя нейросеть как студент, который зубрит экзамен:

🟢 Хорошо обученная модель = студент понимает принципы, может решить похожие задачи 🔴 Переобученная модель = студент выучил ответы наизусть, но не понимает логику

[МЕДИА: image_01] Описание: График showing training vs validation loss curves, overfitting visualization with diverging lines Промпт: “educational graph showing overfitting in machine learning, training loss decreasing while validation loss increases, two curved lines diverging, clean mathematical style, blue and red colors”

Как работает Dropout?

Dropout = “отключаем” случайные нейроны во время обучения:

1. Во время тренировки: 50% нейронов случайно “засыпают” 😴
2. При инференсе: все нейроны работают, но их выходы масштабируются

Это заставляет сеть не полагаться на конкретные нейроны и искать более общие закономерности!

[МЕДИА: image_02] Описание: Neural network diagram with some neurons grayed out (dropped), showing before and after dropout application Промпт: “neural network illustration showing dropout technique, some neurons colored gray (inactive), arrows showing information flow, educational style, clear visualization of concept”

📐 Формальное определение

Dropout

Во время обучения каждый нейрон “выживает” с вероятностью p:

output = {
  0,           с вероятностью (1-p)  
  input/p,     с вероятностью p
}

Типичные значения: p = 0.5 для полносвязных слоев, p = 0.8 для входного слоя

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

L2 регуляризация (Ridge): L = L₀ + λ∑ᵢwᵢ²

• Штрафует за большие веса
• Делает веса “гладкими”

L1 регуляризация (Lasso): L = L₀ + λ∑ᵢ|wᵢ|

• Зануляет неважные веса
• Создает “разреженные” модели

где L₀ - основная функция потерь, λ - коэффициент регуляризации

🔍 Примеры с разбором

Пример 1: Классификация изображений котиков 🐱

import torch.nn as nn

class CatClassifier(nn.Module):
    def __init__(self):
        super().__init__()
        self.features = nn.Sequential(
            nn.Linear(784, 512),
            nn.ReLU(),
            nn.Dropout(0.5),      # 50% нейронов отключаем!
            nn.Linear(512, 256),
            nn.ReLU(), 
            nn.Dropout(0.3),      # Меньше dropout в глубоких слоях
            nn.Linear(256, 2)     # кот/не кот
        )
    
    def forward(self, x):
        return self.features(x)

Что происходит:

• На тренировке: случайно “убираем” половину связей
• На тесте: используем все связи, но уменьшаем выходы в 2 раза

Пример 2: L2-регуляризация в PyTorch

# Обычный оптимизатор
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

# С L2-регуляризацией (weight decay)
optimizer = torch.optim.Adam(
    model.parameters(), 
    lr=0.001,
    weight_decay=1e-4  # λ = 0.0001
)

Теперь веса автоматически “сжимаются” к нулю!

Пример 3: Early Stopping

best_val_loss = float('inf')
patience = 10
counter = 0

for epoch in range(1000):
    train_loss = train_one_epoch()
    val_loss = validate()
    
    if val_loss < best_val_loss:
        best_val_loss = val_loss
        counter = 0
        save_model()  # Сохраняем лучшую модель
    else:
        counter += 1
        if counter >= patience:
            print("Stopping early!")
            break

Останавливаемся, когда модель перестает улучшаться на валидации.

[МЕДИА: image_03] Описание: Comparison chart showing model performance with and without regularization techniques Промпт: “comparison chart showing training curves with and without regularization, multiple lines representing different techniques, clear legends, educational visualization style”

🎮 Практика

Базовый уровень 🟢

Задание 1: В каком случае dropout НЕ поможет от переобучения? a) Модель слишком сложная для данных b) Слишком мало данных для обучения
c) Модель недообучена (underfitting) d) Данные очень зашумлены

Задание 2: Какой dropout лучше использовать для входного слоя? a) 0.9 b) 0.5 c) 0.2 d) 0.0

Задание 3: Что происходит с нейронами во время inference при dropout=0.5?

Задание 4: Напиши код добавления L1-регуляризации к функции потерь:

loss = criterion(outputs, targets)
# Твой код здесь
l1_reg = 0
for param in model.parameters():
    l1_reg += torch.sum(torch.abs(param))
total_loss = loss + lambda_l1 * l1_reg

Продвинутый уровень 🟡

Задание 5: Объясни, почему dropout работает только во время обучения:

Задание 6: Реализуй Batch Normalization + Dropout в правильном порядке:

class RegularizedBlock(nn.Module):
    def __init__(self, in_features, out_features, dropout_p=0.5):
        super().__init__()
        # Твоя реализация
        self.linear = nn.Linear(in_features, out_features)
        self.bn = nn.BatchNorm1d(out_features)
        self.dropout = nn.Dropout(dropout_p)
        self.relu = nn.ReLU()
    
    def forward(self, x):
        # Правильный порядок: Linear → BatchNorm → ReLU → Dropout
        return self.dropout(self.relu(self.bn(self.linear(x))))

Задание 7: Почему L1-регуляризация создает разреженные модели?

Задание 8: Настрой learning rate schedule с регуляризацией:

# Подбери параметры для стабильного обучения
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(
    optimizer, 
    mode='min',
    factor=0.5,      # Уменьшаем LR в 2 раза
    patience=5,      # Ждем 5 эпох без улучшения
    min_lr=1e-6      # Минимальный LR
)

Челлендж 🔴

Задание 9: Реализуй DropConnect (более продвинутая версия Dropout):

class DropConnect(nn.Module):
    def __init__(self, in_features, out_features, drop_prob=0.5):
        super().__init__()
        # Отключаем связи, а не нейроны!
        self.in_features = in_features
        self.out_features = out_features
        self.drop_prob = drop_prob
        self.weight = nn.Parameter(torch.randn(out_features, in_features))
        
    def forward(self, x):
        if self.training:
            # Создаем маску для весов
            mask = torch.bernoulli(torch.ones_like(self.weight) * (1 - self.drop_prob))
            masked_weight = self.weight * mask / (1 - self.drop_prob)
            return F.linear(x, masked_weight)
        return F.linear(x, self.weight)

Задание 10: Создай адаптивную регуляризацию:

class AdaptiveRegularization:
    def __init__(self, base_lambda=0.01):
        self.base_lambda = base_lambda
        self.val_losses = []
        
    def get_lambda(self, val_loss):
        self.val_losses.append(val_loss)
        if len(self.val_losses) < 5:
            return self.base_lambda
            
        # Если validation loss растет - усиливаем регуляризацию
        recent_trend = sum(self.val_losses[-3:]) / 3 - sum(self.val_losses[-5:-2]) / 3
        if recent_trend > 0:  # Loss растет
            return self.base_lambda * 2
        else:
            return self.base_lambda * 0.8

⚠️ Частые ошибки

❌ Ошибка: Использовать dropout во время inference ✅ Правильно: model.eval() автоматически отключает dropout 💡 Почему: При inference нужна детерминированная работа модели

❌ Ошибка: Слишком большой dropout (0.8-0.9) везде ✅ Правильно: Входной слой: 0.1-0.2, скрытые: 0.3-0.5 💡 Почему: Большой dropout может привести к недообучению

❌ Ошибка: Применять все техники регуляризации сразу ✅ Правильно: Начать с одной техники, потом добавлять 💡 Почему: Избыток регуляризации = недообучение

❌ Ошибка: Одинаковый λ для всех слоев при L2-регуляризации ✅ Правильно: Больший λ для более глубоких слоев 💡 Почему: Глубокие слои более склонны к переобучению

🎓 Главное запомнить

✅ Dropout = случайно “выключаем” нейроны при обучении для лучшего обобщения ✅ L1/L2 регуляризация = штрафуем модель за сложность через функцию потерь
✅ Early Stopping = останавливаем обучение по росту validation loss ✅ Цель всех техник = борьба с переобучением и улучшение обобщающей способности

🔗 Связь с другими темами

Откуда пришли: Урок 332 заложил основы архитектуры нейросетей Куда ведет: Далее изучим конкретные архитектуры (CNN, RNN, Transformers) где эти техники критически важны Связь с математикой: Регуляризация связана с байесовской статистикой и теорией вероятности