Алгоритм обратного распространения ошибки: как учится сеть

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

Что такое обратное распространение ошибки

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

Ключевая идея: ошибка, посчитанная на выходе, распространяется назад по слоям. Каждый слой получает от следующего «сколько он наошибался» и пересчитывает это в градиенты по своим весам и в сигнал ошибки для предыдущего слоя. Отсюда и название - обратное распространение.

Алгоритм состоит из двух проходов:

1. Прямой проход (forward pass) - данные идут от входа к выходу, сеть выдаёт предсказание и считается ошибка.
2. Обратный проход (backward pass) - ошибка идёт от выхода к входу, по дороге накапливая градиенты для каждого веса.

Прямой проход: от входа к предсказанию

Возьмём минимальную сеть: один вход $x$, один скрытый нейрон и один выход. Веса и смещения - $w_1, b_1, w_2, b_2$. Прямой проход выглядит так:

$$\begin{aligned} z &= w_1 x + b_1 \\ a &= \sigma(z) \\ \hat{y} &= w_2 a + b_2 \end{aligned}$$

Здесь $\sigma(z) = \dfrac{1}{1 + e^{-z}}$ - сигмоидная функция активации, которая вносит нелинейность. Без неё сеть из любого числа слоёв схлопнулась бы в одно линейное преобразование.

Ошибку измеряем квадратичной функцией потерь:

$$L = \tfrac{1}{2}\,(\hat{y} - y)^2,$$

где $y$ - правильный ответ (target). Множитель $\tfrac{1}{2}$ стоит ради удобства: он сократится при дифференцировании. Чем дальше предсказание $\hat{y}$ от цели, тем больше $L$.

Рассчитать для своей задачи

Цепное правило - сердце алгоритма

Чтобы обновить вес $w_1$, нужно знать $\dfrac{\partial L}{\partial w_1}$. Но $w_1$ влияет на $L$ не напрямую, а через цепочку $w_1 \to z \to a \to \hat{y} \to L$. Производная такой композиции считается по цепному правилу - перемножением частных производных вдоль цепочки:

$$\frac{\partial L}{\partial w_1} = \frac{\partial L}{\partial \hat{y}} \cdot \frac{\partial \hat{y}}{\partial a} \cdot \frac{\partial a}{\partial z} \cdot \frac{\partial z}{\partial w_1}.$$

Именно цепное правило позволяет переиспользовать уже посчитанные множители. Когда мы доходим до $w_1$, всё, что левее в цепочке (вклад выходного слоя), уже вычислено для $w_2$ - повторно его считать не нужно. В этом и состоит экономия: backpropagation вычисляет все градиенты за время, пропорциональное одному прямому проходу, а не отдельно для каждого веса.

Обратный проход по шагам

Пройдём цепочку справа налево, накапливая градиенты. Начинаем с выхода:

$$\frac{\partial L}{\partial \hat{y}} = \hat{y} - y.$$

Дальше - градиенты выходного слоя $w_2, b_2$. Поскольку $\hat{y} = w_2 a + b_2$:

$$\frac{\partial L}{\partial w_2} = (\hat{y} - y)\,a, \qquad \frac{\partial L}{\partial b_2} = \hat{y} - y.$$

Теперь передаём ошибку в скрытый слой. Сигнал, дошедший до активации $a$, равен $\dfrac{\partial L}{\partial a} = (\hat{y} - y)\,w_2$. Проходим через производную сигмоиды, у которой удобная форма $\sigma'(z) = a(1 - a)$:

$$\frac{\partial L}{\partial z} = (\hat{y} - y)\,w_2 \cdot a(1 - a).$$

И, наконец, градиенты первого слоя:

$$\frac{\partial L}{\partial w_1} = \frac{\partial L}{\partial z}\,x, \qquad \frac{\partial L}{\partial b_1} = \frac{\partial L}{\partial z}.$$

Обратите внимание: каждый следующий слой влево умножает накопленный сигнал ошибки на новый множитель. Эта «эстафета» множителей и есть распространение ошибки назад.

Рассчитать для своей задачи

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

Когда все градиенты собраны, обучение делает один шаг по антиградиенту. Для каждого параметра $\theta$:

$$\theta \leftarrow \theta - \eta\,\frac{\partial L}{\partial \theta},$$

где $\eta$ - скорость обучения (learning rate). Знак минус означает движение в сторону уменьшения ошибки. Один проход «forward + backward + шаг» по обучающему примеру (или батчу примеров) называется итерацией; полный проход по всему датасету - эпохой.

Скорость обучения критична. Слишком маленькая $\eta$ - сеть учится мучительно медленно. Слишком большая - шаг перелетает минимум, и ошибка не падает, а растёт: обучение расходится. В интерактивном калькуляторе выше это видно сразу: поднимите learning rate до предела, и кривая loss вместо спуска уйдёт вверх. Тот же градиент потом используют более умные оптимизаторы вроде Adam, которые подбирают эффективный шаг автоматически.

Почему алгоритм так эффективен

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

Backpropagation вычисляет все частные производные за один обратный проход, по стоимости сопоставимый с одним прямым проходом. Достигается это динамическим программированием: промежуточные множители цепного правила вычисляются один раз и переиспользуются для всех весов, лежащих ниже по цепочке. Именно эта эффективность в 1986 году (работа Румельхарта, Хинтона и Уильямса) сделала обучение многослойных сетей практичным и запустила всю современную глубокую нейронную сеть как технологию.

Проблема исчезающего градиента

У обратного прохода есть встроенная слабость. Сигнал ошибки, идущий к ранним слоям, на каждом шаге умножается на производную активации. У сигмоиды $\sigma'(z) = a(1-a)$ максимум равен $0{,}25$ и резко падает к нулю на краях. В глубокой сети таких множителей много, и они перемножаются:

$$\frac{\partial L}{\partial w_{\text{первый слой}}} \sim \prod_{k} \sigma'(z_k)\,w_k.$$

Если каждый множитель меньше единицы, произведение многих из них стремится к нулю - градиент до первых слоёв доходит исчезающе малым, и они почти не обучаются. Это и есть проблема исчезающего градиента (vanishing gradient).

Частичные решения: активация ReLU вместо сигмоиды (её производная равна $1$ для положительных значений, не затухает), нормализация по батчам, остаточные связи (residual connections), которые дают градиенту короткий путь в обход слоёв.

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

• Путают backpropagation и градиентный спуск. Backpropagation только считает градиенты; спуск делает шаг по ним. Это разные вещи, работающие в паре.
• Забывают про производную активации в скрытых слоях. Градиент в скрытом слое - это не просто «ошибка с выхода», а ошибка, умноженная на $\sigma'(z)$. Без этого множителя выкладки неверны.
• Считают, что большой learning rate ускоряет обучение. До какого-то предела - да, но за ним шаг перелетает минимум и loss расходится. Скорость обучения подбирают, а не «выкручивают на максимум».
• Не сохраняют активации прямого прохода. Обратному проходу нужны значения $a, z$, посчитанные на forward. Если их не закэшировать, backward придётся пересчитывать forward - теряется вся экономия.
• Применяют сигмоиду в глубоких сетях и удивляются, что ранние слои не учатся. Это и есть исчезающий градиент; в современных архитектурах в скрытых слоях используют ReLU и её варианты.

FAQ

Чем обратное распространение отличается от прямого прохода? Прямой проход (forward) идёт от входа к выходу и вычисляет предсказание и ошибку. Обратный проход (backward) идёт от выхода к входу и вычисляет градиенты - насколько каждый вес повлиял на ошибку. Сначала всегда forward (нужны активации), затем backward по тем же связям в обратном порядке.

Можно ли обучать сеть без backpropagation? Технически да - есть численная оценка градиента, эволюционные методы, методы без градиента. Но для глубоких сетей они на порядки дороже: backpropagation даёт точный градиент по всем параметрам почти бесплатно, поэтому он остаётся стандартом обучения нейросетей.

Почему градиент иногда «исчезает» или «взрывается»? Потому что при обратном проходе градиент перемножается на множители каждого слоя. Если они систематически меньше единицы - градиент исчезает (затухает к нулю); если больше единицы - взрывается (растёт лавинообразно). Лечится выбором активаций, нормализацией и остаточными связями.

Коротко

Алгоритм обратного распространения ошибки вычисляет градиент функции потерь по всем весам сети за один обратный проход, применяя цепное правило к композиции слоёв. Прямой проход даёт предсказание и ошибку; обратный - гонит эту ошибку назад, на каждом слое умножая её на производную активации и пересчитывая в градиенты по весам. Полученные градиенты использует градиентный спуск, делая шаг $\theta \leftarrow \theta - \eta\,\partial L/\partial\theta$. Эффективность алгоритма (переиспользование множителей) сделала глубокое обучение практичным, а его врождённая слабость - исчезающий градиент в глубоких сигмоидных сетях - породила ReLU, нормализацию и остаточные связи.