СправочникОбновлено · 07.2026

Алгоритмы оптимизации весов в нейронных сетях

13 июня 2024 · 9 минут чтения

Проверка фактов

Юлия Найпак

Методист по автоматизации. Сверяет паспорт инструмента с документацией вендора.

Автор Р

Редакция

Коллектив авторов, редакторов и иллюстраторов статей на сайте блога онлайн-университета «Зерокодер». Пишем…

Черновик готовит редакция с помощью ИИ. За стандарт издания отвечает главный редактор — Валерий Курземнек.

Обновлено в 2026 году. Автор: редакция «Я — Зерокодер», практикующие ML-инженеры.

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

Коротко: что нужно знать про оптимизацию весов в нейросетях

По данным ruder.io.

• Базовое правило одно: новый вес = старый вес − скорость обучения × градиент. Всё остальное — надстройки над ним.
• Моментум добавляет инерцию и гасит осцилляции в «оврагах» функции потерь.
• Adagrad, RMSprop и Adam делают шаг индивидуальным для каждого веса.
• Рабочий дефолт на 2026 год — AdamW со скоростью обучения около 3e-4 и расписанием её снижения.
• Застывший или расходящийся loss почти всегда лечится скоростью обучения, инициализацией и нормализацией — а не сменой оптимизатора.

Как обновляются веса: градиентный спуск

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

Базовая формула обновления одного веса:

θ = θ − η · ∇J(θ)

Здесь θ — вес (параметр), η (эта) — скорость обучения (learning rate), ∇J(θ) — градиент функции потерь по этому весу. Эта запись — общая для всех оптимизаторов ниже; они отличаются лишь тем, как считают шаг.

Batch, SGD и mini-batch: на скольких примерах считать градиент

• Batch (полный) градиентный спуск — градиент считается по всему датасету, затем один шаг. Точное направление, но медленно и требует много памяти.
• Стохастический градиентный спуск (SGD) — шаг после каждого отдельного примера: θ = θ − η · ∇J(θ; xᵢ, yᵢ). Быстро и шумно; шум иногда помогает выскочить из плохого минимума.
• Mini-batch — компромисс: шаг после группы примеров (обычно 32–512). Это стандарт для обучения нейросетей: устойчивее SGD и эффективно использует GPU.

В обиходе «SGD» в фреймворках почти всегда означает именно mini-batch версию. Мини-вывод: размер батча — это баланс между стабильностью направления и скоростью итераций.

Оптимизаторы весов: от моментума до AdamW

Momentum: инерция против осцилляций

Чистый SGD в вытянутых «оврагах» функции потерь виляет из стороны в сторону. Моментум добавляет инерцию: накапливает экспоненциальное скользящее среднее прошлых градиентов и движется по нему.

v = γ·v + η·∇J(θ)
θ = θ − v

Коэффициент γ обычно равен 0.9. Инерция ускоряет движение вдоль устойчивого направления и гасит поперечные колебания. Разновидность — Nesterov (NAG): градиент вычисляется в точке, куда моментум уже собирается сдвинуть веса, что даёт «взгляд вперёд» и более аккуратное торможение у минимума.

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

Adagrad первым сделал скорость обучения индивидуальной: он накапливает сумму квадратов градиентов и делит шаг на её корень.

G = G + (∇J(θ))²
θ = θ − (η / √(G + ε)) · ∇J(θ)

Редкие признаки получают большой шаг, частые — маленький. Дефолтная скорость обучения — около 0.01. Проблема: знаменатель только растёт, поэтому шаг со временем неизбежно затухает до нуля и обучение застревает. Именно это ограничение чинят RMSprop и Adam.

RMSprop: скользящее среднее вместо накопления

RMSprop заменяет бесконечное накопление на экспоненциальное скользящее среднее квадратов градиентов — знаменатель перестаёт бесконтрольно расти.

E[g²] = 0.9·E[g²] + 0.1·g²
θ = θ − (η / √(E[g²] + ε)) · g

Типичные значения: коэффициент сглаживания 0.9, скорость обучения 0.001, ε ≈ 1e-8. RMSprop хорошо ведёт себя на нестационарных задачах и в рекуррентных сетях.

Adam и AdamW: рабочий стандарт

Adam (Adaptive Moment Estimation) объединяет моментум и RMSprop: держит скользящее среднее и самих градиентов (первый момент), и их квадратов (второй момент), плюс поправку на смещение на первых шагах.

m = β₁·m + (1−β₁)·g
v = β₂·v + (1−β₂)·g²
m̂ = m / (1 − β₁ᵗ)
v̂ = v / (1 − β₂ᵗ)
θ = θ − η · m̂ / (√v̂ + ε)

Значения по умолчанию: η = 0.001, β₁ = 0.9, β₂ = 0.999, ε = 1e-8. Поправки m̂ и v̂ нужны потому, что на старте m и v инициализированы нулями и занижены.

AdamW — исправленная версия, где регуляризация весов (weight decay) отделена от градиента и применяется к весам напрямую. В классическом Adam L2-регуляризация «размазывалась» адаптивным знаменателем и работала слабее. AdamW стал дефолтом для обучения трансформеров и больших моделей. Мини-вывод: если сомневаетесь, с чего начать, — начинайте с AdamW.

Скорость обучения и её расписания

Скорость обучения (learning rate) — самый чувствительный гиперпараметр оптимизации весов в нейросетях. Слишком маленькая — модель ползёт и застревает; слишком большая — loss скачет или уходит в бесконечность. Одного фиксированного значения на всё обучение обычно мало, поэтому применяют расписания (schedules):

• Step decay — снижение скорости в несколько раз каждые N эпох.
• ReduceOnPlateau — уменьшать скорость, когда loss на валидации перестал падать.
• Cosine / linear decay — плавное снижение к концу обучения.
• Warmup — первые шаги с очень малой скоростью, затем разгон; почти обязателен для трансформеров.

Практический порядок: сначала подберите базовую скорость без расписания, затем добавьте затухание, и только потом — warmup и перезапуски. Расписание настраивают после того, как найдена рабочая базовая скорость, а не вместо неё.

Что делать, если loss застыл или расходится

Прежде чем менять оптимизатор, пройдите по диагностике — в большинстве случаев проблема не в нём.

Loss стоит на месте (застыл)

• Скорость обучения слишком мала. Поднимите её в 5–10 раз и посмотрите, стал ли график круче на первых эпохах. Это первое, что проверяют.
• Плохая инициализация. Неудачные стартовые веса загоняют модель на плато. Используйте He-инициализацию для ReLU и Xavier (Glorot) для tanh/sigmoid.
• Затухающие градиенты (vanishing). В глубоких сетях градиент по пути назад умножается на малые числа и гаснет — ранние слои не учатся. Лечится ReLU-подобными активациями, нормализацией (BatchNorm/LayerNorm) и остаточными связями (residual).
• Мёртвые нейроны и насыщение. При sigmoid/tanh в зоне насыщения производная близка к нулю — отсюда нулевой градиент.

Loss растёт или скачет (расходится)

• Скорость обучения слишком велика — самая частая причина. Уменьшите её на порядок.
• Взрывающиеся градиенты (exploding). Градиент разрастается и веса улетают в NaN. Помогает обрезка градиента (gradient clipping) по норме и нормализация слоёв.
• Не масштабированы входные данные. Признаки разного порядка ломают обучение — нормализуйте вход.
• Ошибка в данных или лоссе. Перепутанные метки, неверная функция потерь под задачу, деление на ноль.

Мини-вывод: сначала — скорость обучения и инициализация, затем — нормализация и градиентные патологии, и лишь в последнюю очередь смена самого оптимизатора.

Сравнение оптимизаторов: когда что выбирать

Правило по умолчанию: берите AdamW для быстрого рабочего результата; переходите на SGD с моментумом и расписанием, если боретесь за последние проценты точности на зрении.

Как выбрать оптимизатор: короткий алгоритм

1. Стартуйте с AdamW, скорость обучения 3e-4, включите нормализацию слоёв.
2. Смотрите на loss в первые эпохи: застыл — поднимите скорость и проверьте инициализацию; расходится — снизьте скорость и добавьте clipping.
3. Когда обучение стабильно идёт — добавьте расписание снижения скорости (cosine или ReduceOnPlateau).
4. Нужна максимальная генерализация (особенно в CV) — попробуйте SGD + Momentum с тем же расписанием и сравните на валидации.

Пример: обучение с оптимизатором в Keras

Классификация рукописных цифр MNIST — минимальный пример, где виден вызов оптимизатора. Здесь используется Adam; заменить его на AdamW или SGD — одна строка.

import tensorflow as tf
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras.optimizers import Adam

# Загрузка и нормализация данных
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

# Создание модели
model = Sequential([
    Flatten(input_shape=(28, 28)),
    Dense(128, activation='relu'),
    Dense(10, activation='softmax')
])

# Компиляция с оптимизатором Adam
model.compile(optimizer=Adam(learning_rate=0.001),
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# Обучение и оценка
model.fit(x_train, y_train, epochs=5)
test_loss, test_acc = model.evaluate(x_test, y_test)
print('Test accuracy:', test_acc)

Нормализация входа (деление на 255) здесь не косметика: без неё градиенты крупнее и обучение менее устойчиво — тот самый случай масштабирования данных из раздела про расходящийся loss.

Часто задаваемые вопросы

Какой оптимизатор лучший для нейросети?

Универсального нет. Для быстрого рабочего результата берут AdamW — он адаптивен и хорошо работает из коробки. Для максимальной точности на задачах компьютерного зрения часто выигрывает SGD с моментумом и расписанием скорости обучения.

Почему loss не уменьшается при обучении?

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

Чем Adam отличается от SGD?

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

Что такое learning rate и как его подбирать?

Learning rate — множитель шага обновления весов. Подбирают эмпирически: начинают с типового значения (0.001 для Adam), при застывшем loss повышают, при расходящемся — понижают, затем добавляют расписание снижения.

Чем AdamW лучше обычного Adam?

В AdamW регуляризация весов (weight decay) отделена от градиента и применяется к весам напрямую, тогда как в Adam она искажалась адаптивным знаменателем. Поэтому AdamW стабильнее регуляризует и стал стандартом для больших моделей и трансформеров.

Итог

Оптимизация весов — это градиентный спуск и его надстройки. SGD с моментумом даёт контроль и хорошую генерализацию, адаптивные методы (Adagrad, RMSprop, Adam, AdamW) экономят время на подборе шага. Начинайте с AdamW и расписания скорости обучения, а застывший или расходящийся loss чините диагностикой — скоростью, инициализацией и нормализацией, а не слепой сменой оптимизатора.