Ускорение Нестерова и Adam

Нестеров смотрит на шаг вперёд, Adam подбирает свой шаг каждой координате — два столпа современной оптимизации.

Adam — адаптивный метод, хранящий скользящие средние градиента ($m$) и его квадрата ($v$) и масштабирующий шаг каждой координаты на $1/\sqrt{v}$.

Нестеров: посмотреть, прежде чем прыгнуть

Обычный момент считает градиент в текущей точке, а потом прыгает по инерции. Ускоренный градиент Нестерова делает иначе: сначала мысленно делает инерционный шаг $x_k+\beta v_k$, и градиент считает уже там — «заглядывает вперёд». Это позволяет вовремя притормозить перед минимумом:

$$v_{k+1}=\beta v_k-\alpha\nabla f(x_k+\beta v_k),\qquad x_{k+1}=x_k+v_{k+1}.$$

Для выпуклых функций Нестеров даёт сходимость $O(1/k^2)$ против $O(1/k)$ у обычного спуска — теоретически оптимально для методов первого порядка.

Adam: свой шаг каждому

Главная боль оврагов — единый шаг на все координаты. Adam лечит её, ведя для каждой координаты две оценки: $m$ — сглаженный градиент (как момент), $v$ — сглаженный квадрат градиента (мера «активности» координаты). Шаг по координате делится на $\sqrt{v}$: где градиенты бурные, шаг ужимается; где вялые, шаг растёт. Формулы:

$$m_k=\beta_1 m_{k-1}+(1-\beta_1)g_k,\qquad v_k=\beta_2 v_{k-1}+(1-\beta_2)g_k^2,$$

$$\hat m_k=\frac{m_k}{1-\beta_1^k},\quad \hat v_k=\frac{v_k}{1-\beta_2^k},\qquad x_{k+1}=x_k-\alpha\frac{\hat m_k}{\sqrt{\hat v_k}+\varepsilon}.$$

Деление на $(1-\beta^k)$ — коррекция смещения: в начале $m,v$ стартуют с нуля и занижены, поправка это компенсирует. Типичные значения: $\beta_1=0.9$, $\beta_2=0.999$, $\varepsilon=10^{-8}$.

Реализация Adam

Запустим Adam на нашем овраге $f=x^2+100y^2$ и сравним с обычным спуском.

import math

def grad(v):
    return [2 * v[0], 200 * v[1]]

def f(v):
    return v[0] ** 2 + 100 * v[1] ** 2

def adam(alpha=0.2, b1=0.9, b2=0.999, eps=1e-8, steps=200):
    x = [10.0, 1.0]
    m = [0.0, 0.0]
    v = [0.0, 0.0]
    for k in range(1, steps + 1):
        g = grad(x)
        for i in range(2):
            m[i] = b1 * m[i] + (1 - b1) * g[i]
            v[i] = b2 * v[i] + (1 - b2) * g[i] ** 2
            mhat = m[i] / (1 - b1 ** k)
            vhat = v[i] / (1 - b2 ** k)
            x[i] -= alpha * mhat / (math.sqrt(vhat) + eps)
        if k in (1, 50, 100, 150, 200):
            print(f"шаг {k:3d}: x=({x[0]:.4f}, {x[1]:.4f}) f={f(x):.5f}")
    return x

adam()

Вывод:

шаг   1: x=(9.8000, 0.8000) f=160.04000
шаг  50: x=(1.8022, 0.0546) f=3.54654
шаг 100: x=(-0.0780, -0.0045) f=0.00810
шаг 150: x=(0.0024, -0.0001) f=0.00001
шаг 200: x=(-0.0002, -0.0000) f=0.00000

Adam добил овраг почти до нуля, причём заметьте: координата $y$ (бурная) и $x$ (вялая) подошли к нулю согласованно — адаптивный шаг автоматически уравнял их «скорости». Чистому спуску на это потребовались бы тысячи итераций.

Сравнение методов

Как работает под капотом

Adam можно читать как «грубое приближение Ньютона на коленке»: деление на $\sqrt{v}$ имитирует деление на корень из диагонали гессиана, выравнивая масштабы координат без дорогого вычисления и обращения матрицы. Это объясняет и его силу (дёшево лечит овраги), и слабости: диагональное приближение игнорирует взаимодействие осей, а агрессивная адаптация иногда ухудшает обобщение моделей по сравнению с честным SGD+momentum. Поэтому Adam — рабочий выбор по умолчанию, но не всегда лучший финальный.

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

• Забыть коррекцию смещения. Без деления на $(1-\beta^k)$ первые шаги Adam занижены и метод стартует вяло.
• $\varepsilon$ не там. $\varepsilon$ добавляют к $\sqrt{\hat v}$ в знаменателе, а не к $\hat v$ под корнем.
• Считать Adam всегда лучшим. Для финальной точности часто выигрывает SGD с моментом и расписанием шага.

Итоги

• Нестеров считает градиент после инерционного шага («взгляд вперёд»), даёт $O(1/k^2)$ на выпуклых задачах.
• Adam ведёт $m$ (момент) и $v$ (квадрат градиента), делает шаг $\propto \hat m/\sqrt{\hat v}$ — свой для каждой координаты.
• Adam дёшево лечит овраги, имитируя диагональ Ньютона; коррекция смещения обязательна.