Градиентный спуск и оптимизаторы

В обучении нейронных сетей градиентный спуск и его вариации — это сердце процесса оптимизации. Неправильный выбор оптимизатора может привести к провалу обучения: либо застреванию в локальных минимумах, либо нестабильности, либо запредельно долгому обучению. Давайте разберемся в механике работы SGD, Adam и их модификаций, а также рассмотрим практические аспекты их применения.

Механика градиентного спуска

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

Базовый алгоритм SGD (Stochastic Gradient Descent) выглядит так:

Инициализировать веса модели случайными значениями
Для каждого батча данных:
- Вычислить градиенты функции потерь по отношению к весам
- Обновить веса: w = w - learning_rate * gradient

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

Вариации SGD и их реализация

SGD с моментом (Momentum)

SGD с моментом добавляет “инерцию” к процессу оптимизации. Это помогает преодолеть локальные минимумы и ускорить движение в направлении основного тренда градиента.

# Инициализация
velocity = 0
momentum = 0.9

# На каждом шаге
gradient = compute_gradient(parameters)
velocity = momentum * velocity + learning_rate * gradient
parameters = parameters - velocity

Nesterov Accelerated Gradient (NAG)

NAG — это улучшенная версия Momentum, которая вычисляет градиент “предсказанной” позиции, а не текущей:

# Инициализация
velocity = 0
momentum = 0.9

# На каждом шаге
gradient = compute_gradient(parameters - momentum * velocity)
velocity = momentum * velocity + learning_rate * gradient
parameters = parameters - velocity

Адаптивные методы: AdaGrad, RMSprop, Adam

Адаптивные методы подстраивают скорость обучения для каждого параметра individually, основываясь на истории градиентов.

AdaGrad накапливает квадраты градиентов:

# Инициализация
grad_squared = 0
epsilon = 1e-8

# На каждом шаге
gradient = compute_gradient(parameters)
grad_squared += gradient^2
parameters = parameters - learning_rate * gradient / (sqrt(grad_squared) + epsilon)

RMSprop исправляет проблему возрастания шага в AdaGram, используя экспоненциальное сглаживание:

# Инициализация
grad_squared = 0
decay_rate = 0.9
epsilon = 1e-8

# На каждом шаге
gradient = compute_gradient(parameters)
grad_squared = decay_rate * grad_squared + (1 - decay_rate) * gradient^2
parameters = parameters - learning_rate * gradient / (sqrt(grad_squared) + epsilon)

Adam (Adaptive Moment Estimation) сочетает идеи Momentum и RMSprop, используя экспоненциально сглаженные оценки градиентов и их квадратов:

# Инициализация
m = 0  # Первый момент (аналог скорости)
v = 0  # Второй момент (аналог квадрата градиента)
beta1 = 0.9  # Скорость сглаживания первого момента
beta2 = 0.999  # Скорость сглаживания второго момента
epsilon = 1e-8

# На каждом шаге
gradient = compute_gradient(parameters)
m = beta1 * m + (1 - beta1) * gradient
v = beta2 * v + (1 - beta2) * (gradient^2)

# Скорректированные оценки
m_hat = m / (1 - beta1^t)  # t - номер шага
v_hat = v / (1 - beta2^t)

parameters = parameters - learning_rate * m_hat / (sqrt(v_hat) + epsilon)

Практические аспекты и узкие места

Learning Rate Schedules

Статичная скорость обучения часто неоптимальна. Более эффективны стратегии изменения скорости обучения в процессе обучения:

Step Decay: Уменьшение скорости обучения через фиксированные интервалы
Exponential Decay: Экспоненциальное уменьшение скорости обучения
Cosine Annealing: Плавное уменьшение по косинусоидальной функции
One Cycle Policy: Сначала увеличение, затем уменьшение скорости обучения

# Пример реализации Cosine Annealing
def cosine_annealing_lr(optimizer, epoch, max_epochs, lr_min, lr_max):
    lr = lr_min + 0.5 * (lr_max - lr_min) * (1 + math.cos(math.pi * epoch / max_epochs))
    for param_group in optimizer.param_groups:
        param_group['lr'] = lr
    return lr

Узкие места и компромиссы

Adam vs SGD:
- Adam сходится быстрее на большинстве задач
- SGD часто достигает лучшей финальной точности, особенно с правильным подбором скорости обучения
- Adam требует больше памяти (хранит два момента на параметр)
Локальные минимумы:
- Momentum и его вариации помогают преодолевать мелкие локальные минимумы
- Adam более устойчив к выбору начальной скорости обучения
Плато и седловые точки:
- Adam эффективен на плато, так как адаптивно подстраивает скорость обучения
- Седловые точки особенно проблематичны для базового SGD
Общая производительность:
- Adam требует больше вычислений на шаг (из-за вычисления второго момента)
- Для небольших моделей или датасетов разница может быть незначительной

Когда что использовать

Adam:
- Хороший выбор для большинства задач, особенно если у вас ограниченное время на эксперименты
- Рекомендуется для глубоких сетей и задач с зашумленными градиентами
- Идеален для трансферного обучения
SGD с Momentum/NAG:
- Когда требуется максимальная точность
- Когда у вас достаточно времени для подбора скорости обучения и ее расписания
- Для небольших моделей, где разница в вычислительной эффективности существенна
RMSprop:
- Хорош для рекуррентных нейронных сетей (LSTM, GRU)
- Эффективен для последовательных данных с разными масштабами градиентов
AdaGrad:
- Редко используется сегодня самостоятельно, но как база для других методов
- Может быть полезен для задач с разреженными данными

В конечном счете, выбор оптимизатора — это компромисс между скоростью сходимости, финальной точностью и вычислительными затратами. Начинайте с Adam как с хорошего универсального решения, но не бойтесь экспериментировать с SGD и его вариациями, если вам нужна максимальная производительность. Всегда учитывайте специфику вашей задачи, архитектуры модели и доступных вычислительных ресурсов.