SGD, Momentum и RMSProp: как веса спускаются по градиенту

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

Обучение нейросети — это поиск минимума функции потерь $L(\theta)$ по миллионам и миллиардам весов $\theta$. Готовой формулы для минимума нет: потери зависят от весов слишком сложно. Остаётся идти к минимуму шагами, и единственный ориентир на каждом шаге — градиент $\nabla L$: вектор, указывающий направление самого быстрого роста потерь. Шагаем в обратную сторону.

Эта страница — о трёх ступенях одного метода:

• SGD (stochastic gradient descent, стохастический градиентный спуск) — шаг против градиента, посчитанного на маленькой случайной пачке примеров, мини-батче;
• Momentum (инерция, метод тяжёлого шарика) — шаг против накопленной суммы прошлых градиентов: инерция гасит зигзаги и разгоняет спуск вдоль пологих направлений;
• RMSProp — шаг, поделённый на среднеквадратичную величину недавних градиентов: у каждого веса свой масштаб шага.

Сложите вторую и третью ступень, добавьте поправку смещения — получится Adam. А SGD с инерцией по-прежнему обучает многие свёрточные сети для изображений и нередко даёт на них лучшее обобщение, чем адаптивные методы.

Интуиция: шаг под гору

Представьте, что вы спускаетесь с холма в густом тумане. Видно только склон под ногами: куда и насколько круто он идёт вниз. Разумная стратегия — шагнуть в сторону самого крутого спуска, осмотреться и повторить. Длина шага задаётся темпом обучения (learning rate) $\eta$.

Короткие шаги надёжны, но медленны. Слишком длинный шаг перепрыгивает дно ямы и попадает на противоположный склон — и если там он выше, следующий шаг унесёт ещё дальше. Посмотрите, как это выглядит на простейшей потере $f(\theta)=L\theta^2/2$: её градиент $f'(\theta)=L\theta$, а кривизна (вторая производная) равна $L$.

Формула по косточкам

$\theta_{t-1}$

текущие веса — вектор всех параметров модели;

$g_t$

стохастический градиент: среднее градиентов потерь $\ell$ по мини-батчу $B_t$ из $B$ случайных примеров;

$\eta$

темп обучения, положительное число, обычно от $10^{-4}$ до $10^{-1}$;

$-\eta\,g_t$

шаг: против градиента, длиной $\eta\|g_t\|$ — тем длиннее, чем круче склон.

Почему это работает. Разложим потери в ряд Тейлора около текущей точки: $L(\theta-\eta g)\approx L(\theta)-\eta\,\|g\|^2$. Пока шаг мал, потери уменьшаются примерно на $\eta\|g\|^2$, и это самое быстрое убывание среди шагов той же длины: скалярное произведение $\langle\nabla L,\,d\rangle$ при фиксированной длине $\|d\|$ минимально, когда $d$ направлен против градиента.

Число обусловленности: почему спуск бывает медленным

Если кривизны по разным направлениям различаются, шаг обязан подстроиться под самую крутую: $\eta<2/\lambda_{\max}$. Тогда вдоль самого пологого направления координата за шаг уменьшается лишь на долю $\eta\lambda_{\min}<2/\kappa$, где $\kappa=\lambda_{\max}/\lambda_{\min}$ — число обусловленности (condition number). Даже при лучшем постоянном шаге $\eta=2/(\lambda_{\max}+\lambda_{\min})$ ошибка за шаг уменьшается лишь в $(\kappa-1)/(\kappa+1)$ раз:

При $\kappa=100$ множитель равен $0{,}980$, и чтобы уменьшить ошибку в тысячу раз, нужно около 345 шагов. Грубое правило: SGD тратит порядка $\kappa$ шагов на каждый порядок точности.

Стохастичность: мини-батчи и шум

Полный градиент — среднее по всем $N$ примерам обучающей выборки. При миллионах примеров один такой шаг стоил бы прохода по всем данным. SGD берёт случайный мини-батч из $B$ примеров. Его градиент — несмещённая оценка полного: в среднем совпадает с $\nabla L$, но каждый раз отклоняется на случайный шум.

$\Sigma$

ковариация градиентов отдельных примеров в текущей точке (с делением на $N$);

$\frac{N-B}{N-1}$

поправка за выбор без возвращения: при $B=N$ шум исчезает.

Дисперсия шума падает как $1/B$, а цена шага растёт как $B$. Поэтому за одну эпоху (один проход по данным) маленькие батчи делают много неточных шагов, а большие — мало точных. На рисунке — линейная регрессия $y\approx wx+b$ на 200 точках с потерей $L=\frac1{2N}\sum(wx_i+b-y_i)^2$: это квадратичная «миска» над плоскостью весов $(w;\,b)$.

Momentum: инерция тяжёлого шарика

Градиентный спуск — это точка без массы: в каждый момент она идёт ровно туда, куда показывает склон. Б. Т. Поляк (1964) предложил дать ей массу. Тяжёлый шарик катится, накапливая скорость, и не реагирует на каждую кочку. В формуле скорость — вектор $u$:

$u_t$

накопленное направление (буфер инерции), $u_0=0$;

$\beta$

коэффициент инерции, $0\le\beta<1$, обычно $0{,}9$; при $\beta=0$ — обычный SGD.

Раскроем рекурсию: $u_t=g_t+\beta g_{t-1}+\beta^2 g_{t-2}+\dots$ — взвешенная сумма всех прошлых градиентов с экспоненциально убывающими весами. Если градиенты из шага в шаг указывают в одну сторону, они складываются, и шаг растёт до $\eta/(1-\beta)$ — в 10 раз при $\beta=0{,}9$. Если знак скачет (зигзаг поперёк оврага), слагаемые гасят друг друга.

Почему инерция ускоряет: теория на квадратичной функции

Возьмём одно направление с кривизной $L$ и обозначим $h=\eta L$. Подставим $g_t=L\theta_{t-1}$ и исключим $u$ (из второй формулы $\eta u_{t-1}=\theta_{t-2}-\theta_{t-1}$). Получится линейная рекуррентность второго порядка:

Её поведение определяют корни характеристического уравнения $\lambda^2-(1+\beta-h)\lambda+\beta=0$. Скорость сходимости — наибольший модуль корня $\rho$: ошибка убывает примерно как $\rho^t$.

Нестеров: градиент там, куда несёт инерция

Ю. Е. Нестеров (1983) предложил считать градиент не в текущей точке, а там, куда шарик всё равно унесёт инерция. В форме PyTorch (nesterov=True) это поправка к шагу:

Характеристическое уравнение становится $\lambda^2-(1+\beta)(1-h)\lambda+\beta(1-h)=0$. На пологих направлениях колебания затухают быстрее ($\rho=\sqrt{\beta(1-h)}$ вместо $\sqrt\beta$), но область устойчивости уже: $\eta L<2(1+\beta)/(1+2\beta)$, при $\beta=0{,}9$ — всего $1{,}36$. Переключите рисунок 4 на «Нестеров», чтобы увидеть обе особенности.

RMSProp: свой шаг для каждого веса

У SGD и Momentum один темп $\eta$ на все веса. Но градиенты разных весов могут отличаться на порядки: эмбеддинги редких слов получают редкие крупные толчки, смещения последнего слоя — постоянные мелкие. Общий $\eta$ для одних слишком велик, для других слишком мал. RMSProp (Дж. Хинтон, лекции курса на Coursera, 2012) делит шаг каждого веса на его типичный размер градиента:

$g_t^2$

поэлементный квадрат: у каждого веса свой $v$;

$v_t$

экспоненциальное скользящее среднее квадрата градиента — оценка $\mathbb E[g^2]$ за последние $\sim1/(1-\beta)$ шагов, $v_0=0$;

$\sqrt{v_t}$

среднеквадратичное значение (root mean square, RMS) градиента — отсюда название;

$\epsilon$

маленькая добавка ($10^{-8}$) против деления на ноль.

Деление на $\sqrt{v_t}$ делает шаг безразмерным: если умножить все градиенты веса на 1000, то и $\sqrt v$ вырастет в 1000 раз, а шаг не изменится. Типичный шаг становится порядка $\eta$ — темп теперь задаёт длину шага прямо в единицах весов.

Траектории в 2D и 3D

Сравним три метода на одной задаче — вытянутой квадратичной долине $f=\tfrac12(a^2+\kappa b^2)$, где $a$ и $b$ — координаты вдоль и поперёк оврага: кривизна поперёк в $\kappa$ раз больше, чем вдоль. Старт — в точке $a=-3{,}4$, $b=0{,}9$, где $f=46{,}3$.

Вторая классика — функция Розенброка $f=(1-x)^2+100(y-x^2)^2$: узкий изогнутый «банан» с минимумом в $(1;\,1)$. Кривизна здесь меняется от точки к точке, и никакой постоянный шаг не идеален.

В коде: с нуля и в PyTorch

Все три метода помещаются в два маленьких класса. Обратите внимание: состояние ($u$ или $v$) — массив того же размера, что и веса, поэтому Momentum и RMSProp удваивают память под параметры, а Adam — утраивает.

pythonimport numpy as np

class SGD:
    """SGD с инерцией (momentum) и вариантом Нестерова — как в torch.optim.SGD."""
    def __init__(self, lr=0.01, momentum=0.0, nesterov=False):
        self.lr, self.beta, self.nesterov, self.u = lr, momentum, nesterov, None

    def step(self, theta, g):
        if self.beta == 0:
            return theta - self.lr * g
        self.u = g.copy() if self.u is None else self.beta * self.u + g
        d = g + self.beta * self.u if self.nesterov else self.u
        return theta - self.lr * d

class RMSProp:
    """RMSProp: свой масштаб шага для каждого веса."""
    def __init__(self, lr=0.01, beta=0.99, eps=1e-8):
        self.lr, self.beta, self.eps, self.v = lr, beta, eps, None

    def step(self, theta, g):
        if self.v is None:
            self.v = np.zeros_like(theta)
        self.v = self.beta * self.v + (1 - self.beta) * g * g
        return theta - self.lr * g / (np.sqrt(self.v) + self.eps)

# Вытянутая долина f = (a² + 100·b²)/2, как на рисунке 6
H = np.diag([1.0, 100.0])
f = lambda th: 0.5 * th @ H @ th
grad = lambda th: H @ th

for name, opt in [("SGD", SGD(lr=0.018)),
                  ("Momentum", SGD(lr=0.018, momentum=0.9)),
                  ("Nesterov", SGD(lr=0.018, momentum=0.9, nesterov=True)),
                  ("RMSProp", RMSProp(lr=0.1, beta=0.9))]:
    th = np.array([-3.4, 0.9])
    for t in range(100):
        th = opt.step(th, grad(th))
    print(f"{name:9s} f = {f(th):.2e}")
# SGD       f = 1.53e-01
# Momentum  f = 2.23e-04
# Nesterov  f = 3.14e+57   ← расходится: ηλ_max = 1.8 > 2(1+β)/(1+2β) ≈ 1.36
# RMSProp   f = 2.60e-02

Числа в комментариях совпадают с рисунком 6, а torch.optim.SGD и torch.optim.RMSprop на той же задаче дают те же значения. Нестеров с тем же $\eta$ расходится — ровно по условию устойчивости из раздела про инерцию.

pythonimport torch
import torch.nn.functional as F

model = torch.nn.Linear(10, 1)

# SGD с инерцией и затуханием весов — классика для свёрточных сетей
opt = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9,
                      nesterov=True, weight_decay=1e-4)
# RMSProp: коэффициент сглаживания в PyTorch называется alpha (по умолчанию 0.99)
# opt = torch.optim.RMSprop(model.parameters(), lr=1e-3, alpha=0.99, eps=1e-8)

for x, y in loader:                  # мини-батчи из DataLoader
    opt.zero_grad()                  # градиенты накапливаются — обнуляем
    loss = F.mse_loss(model(x), y)
    loss.backward()                  # g_t в param.grad
    opt.step()                       # θ ← θ − η·(…)

Гиперпараметры и практика

• Расписание темпа. Ступенчатое (умножение на $0{,}1$ на 30-й и 60-й эпохах из 90 — классика ResNet), косинусное или «один цикл». Постоянный $\eta$ оставляет шумовое облако у минимума.
• Разогрев (warmup). Первые сотни–тысячи шагов $\eta$ растёт линейно от малого значения — особенно важно при большом батче.
• Обрезка градиента (gradient clipping) по норме защищает от редких огромных градиентов в RNN и трансформерах.
• Поиск темпа (LR range test, Л. Смит): короткая прогонка с экспоненциально растущим $\eta$; берут значение заметно меньше того, где потери начинают расти.
• Нормализация входов, батч-нормализация и разумная инициализация уменьшают число обусловленности и позволяют брать больший $\eta$.

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

1. Забытый zero_grad(). В PyTorch градиенты накапливаются в .grad; без обнуления $g_t$ превращается в сумму всех прошлых градиентов — это не инерция, а ошибка.
2. Слишком большой темп: потери растут или становятся NaN. По рисунку 1 нужно $\eta<2/\lambda_{\max}$; первым делом уменьшите $\eta$ в 3–10 раз.
3. Перенос $\eta$ между оптимизаторами. С инерцией $\beta=0{,}9$ установившийся шаг в 10 раз больше, чем у SGD с тем же $\eta$. У RMSProp и Adam $\eta$ вообще в других единицах: $10^{-3}$ для них нормально, для SGD обычно мало.
4. Смена батча без смены темпа. Увеличили $B$ в 8 раз и оставили $\eta$ — сеть учится медленнее за эпоху; уменьшили $B$ — шум может раскачать обучение.
5. $\epsilon=10^{-8}$ в низкой точности. В float16 это число округляется до нуля, и при $v\approx0$ шаг RMSProp взрывается; в смешанной точности $v$ держат в float32 или берут $\epsilon$ больше.
6. Постоянный темп до конца обучения. Без снижения $\eta$ SGD дрожит у минимума, и последние эпохи почти ничего не дают.

Связи с другими формулами

• Adam: числитель — EMA-инерция, знаменатель — $\sqrt{v}$ из RMSProp, плюс поправка смещения.
• MSE: её градиент $\frac2n\sum_i(\hat y_i-y_i)\,x_i$ — с точностью до множителя 2 тот же $g_t$, что в линейной регрессии на рисунке 2 (там потеря — половина MSE).
• BCE и кросс-энтропия: градиент по логитам $\hat y-y$ — простейший сигнал для спуска.
• Сигмоида: насыщение даёт крошечные градиенты — SGD на них почти стоит, а RMSProp растягивает шаг.
• Huber: ограничивает градиент выбросов — родственник обрезки градиента.

Итоги

Проверь себя