Градиентный спуск: как нейросеть находит минимум ошибки

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

Опираемся на курс машинного обучения Google, математический учебник Яндекса, обзор Себастьяна Рудера и статью про оптимизатор Adam. Расчёты проверены запуском на Python 3.13, данные на октябрь 2026 года.

Цель обучения — получить модель с наименьшей ошибкой. Ошибку записывают функцией потерь $L(w)$, где $w$ — веса модели. Нужно найти такие веса, при которых $L$ минимальна. В учебнике Яндекса замечено: в большинстве случаев аналитического решения нет, а если оно есть, то может быть нестабильным или вычисляться долго. Поэтому используют итерационный подход: за несколько шагов можно найти решение с хорошей точностью.

Что такое градиент

Для функции одной переменной производная показывает, как быстро и в какую сторону растёт функция. Для функции многих переменных такую роль играет градиент: вектор частных производных по каждому параметру. По учебнику Яндекса, градиент показывает направление наискорейшего роста функции. Значит, чтобы уменьшать ошибку, нужно двигаться в противоположную сторону — по антиградиенту.

Шаг 1. Выберите начальные параметры

Начните с некоторой точки: случайных или нулевых значений весов.

Шаг 2. Посчитайте ошибку и градиент

Вычислите значение функции потерь и градиент в текущей точке.

Шаг 3. Сдвиньте параметры против градиента

Новые значения получаются по формуле:

$w_{t+1} = w_t - \eta \,\nabla L(w_t)$

Расшифровка: $w_t$ — веса на шаге $t$, $\nabla L(w_t)$ — градиент функции потерь в этой точке, $\eta$ (эта) — скорость обучения, то есть размер шага. Минус означает движение против градиента.

Шаг 4. Повторяйте

Вернитесь к шагу 2 и продолжайте, пока ошибка заметно уменьшается.

Шаг 5. Остановитесь

В учебнике Яндекса сказано: когда градиент около нуля, метод останавливают, и получившиеся веса считают искомыми. В курсе Google говорят, что модель сошлась (сошёлся процесс обучения), когда дальнейшие итерации существенно не уменьшают потери.

Пример с числами

Возьмём самую простую функцию $f(x)=x^2$ с минимумом в нуле. Её производная равна $2x$, значит, шаг метода: $x_{t+1} = x_t - \eta \cdot 2x_t$. Начнём с $x=4$ и сравним три значения шага.

def спуск(шаг, x=4.0, итераций=6):
    путь = [x]
    for _ in range(итераций):
        градиент = 2 * x          # производная функции f(x) = x**2
        x = x - шаг * градиент    # шаг против градиента
        путь.append(x)
    return путь

шаги = [0.05, 0.4, 1.1]
пути = [спуск(шаг) for шаг in шаги]
print("итерация   шаг 0.05   шаг 0.4   шаг 1.1")
for i in range(7):
    print(f"{i:^9}" + "".join(f"{путь[i]:>10.3f}" for путь in пути))
print("ошибка f(x)=x² на 6-й итерации:", *(f"{путь[-1] ** 2:.3f}" for путь in пути))

Вывод при запуске на Python 3.13.12:

итерация   шаг 0.05   шаг 0.4   шаг 1.1
    0         4.000     4.000     4.000
    1         3.600     0.800    -4.800
    2         3.240     0.160     5.760
    3         2.916     0.032    -6.912
    4         2.624     0.006     8.294
    5         2.362     0.001    -9.953
    6         2.126     0.000    11.944
ошибка f(x)=x² на 6-й итерации: 4.519 0.000 142.658

В таблице видны три сценария. Шаг 0,05 безопасен, но за шесть итераций точка прошла лишь половину пути. Шаг 0,4 за те же шесть итераций почти точно попал в минимум. Шаг 1,1 каждый раз перелетает через ноль и оказывается дальше, чем был: ошибка растёт с каждой итерацией. Это соответствует тому, что пишет учебник Яндекса: слишком большой шаг заставляет модель перескакивать минимум и блуждать, слишком малый — затягивает обучение.

Варианты метода

В учебнике Яндекса разобраны три способа считать градиент.

Поверх этих вариантов строят оптимизаторы. Их разбирает обзор Рудера, а Кингма и Ба в статье 2014 года предложили Adam — метод стохастической оптимизации. Подробности смотрите в первоисточниках.

Применение стохастического градиентного спуска не гарантирует попадания в минимум функции потерь. Возможны два плохих сценария. Первый: метод попадает в локальный, но не глобальный минимум, где градиент тоже равен нулю, и останавливается. Второй: метод не доходит до минимума из-за сложности ландшафта функции потерь. Для линейных моделей картина лучше: в курсе Google сказано, что у них функция потерь выпуклая, и градиентный спуск всегда находит глобальный минимум.

Условия и ограничения

Версия

Октябрь 2026 — данные приведены на дату написания; расчёт проверен на Python 3.13.12.

Функция

Дифференцируемость — метод требует, чтобы функцию потерь можно было дифференцировать по параметрам.

Шаг

Подбирается опытным путём — значения шага в примере учебные и не подходят для настоящих моделей.

Гарантии

Выпуклость — для линейных моделей метод находит глобальный минимум, для нейросетей такой гарантии нет.

Пример

Одна переменная — на одной переменной показана идея; в нейросетях параметров миллионы и больше.

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

• Берут шаг «на глаз» и не смотрят на график ошибки по итерациям.
• Не смотрят на график ошибки: расходящийся спуск по цифрам в начале легко принять за обучение.
• Останавливаются слишком рано, пока ошибка ещё заметно падает.
• Путают минимум на обучающих данных и на проверочных: хорошая обучающая ошибка ещё не значит хорошую модель.
• Считают, что спуск всегда находит глобальный минимум.
• Путают понятия: градиентный спуск вычисляет сдвиг весов, а градиенты по слоям нейросети получают методом обратного распространения.

Короткий вывод

Градиентный спуск движет параметры против градиента функции потерь с шагом, который задаёт скорость обучения. Шаг определяет, сойдётся ли метод: слишком малый и слишком большой одинаково плохи. Для нейросетей применяют мини-батч-вариант, а гарантий глобального минимума там нет. Дальше стоит изучить обратное распространение ошибки и оптимизаторы вроде Adam.