Обратное распространение ошибки - алгоритм, который превращает нейронную сеть из набора случайных матриц в работающую модель. Без него невозможно обучение современных архитектур: от простых многослойных перцептронов до трансформеров. Алгоритм вычисляет, как каждый вес сети влияет на итоговую ошибку, и указывает направление для корректировки. В основе лежит цепное правило дифференцирования, знакомое из курса математического анализа. Эта статья - первая часть разбора, где мы строим интуитивное понимание механики обратного распространения на конкретных числах, без матричных обобщений и кода.
Если вы работаете с нейросетями, понимание этого алгоритма помогает диагностировать проблемы обучения: исчезающие градиенты, расходимость потерь, неэффективность оптимизаторов. Когда модель не сходится, вы не гадаете, а знаете, на каком слое градиент затухает и почему. Это практический навык, который отличает инженера, способного довести модель до production, от того, кто просто запускает скрипты.
Похожий подход к глубинному разбору архитектур мы применяем в материалах о парадоксе безопасности Anthropic и методологии оценки AI-агентов Databricks. Там мы тоже вскрываем внутренние механизмы, а не ограничиваемся поверхностным описанием.
Зачем разбираться в обратном распространении ошибки?
Информационный шум вокруг AI создаёт иллюзию, что достаточно знать API фреймворков: вызвал model.fit() и получил результат. Реальность сложнее. Когда обучение идёт не по плану, высокоуровневые абстракции PyTorch и TensorFlow перестают помогать. Вы остаётесь один на один с графиками потерь, которые не убывают, и градиентами, которые взрываются.
Прямая выгода от понимания обратного распространения:
- Диагностика проблем обучения. Градиенты на первых слоях близки к нулю? Сигнал не доходит - меняйте функцию активации или инициализацию весов. Градиенты растут экспоненциально? Нужно gradient clipping или нормализация.
- Осознанный выбор архитектур. ResNet с пропускными соединениями решает проблему затухающих градиентов. BatchNorm стабилизирует распределение активаций. Эти решения не магические трюки, а прямые следствия того, как работает обратное распространение.
- Эффективная отладка. Реализовали свой слой или функцию потерь? Без проверки градиентов через численное дифференцирование вы не узнаете, корректно ли работает backward-проход. Это стандартная практика, описанная в документации PyTorch.
Алгоритм обратного распространения - это не исторический артефакт 1986 года, а работающий механизм внутри каждой обученной модели. От линейной регрессии до GPT - принцип один: градиенты текут от выхода к входу, обновляя параметры. В этой статье мы разберём этот поток на простейшей архитектуре, чтобы интуиция закрепилась на уровне чисел.
От линейной регрессии к градиентам: базовая интуиция
Линейная регрессия - идеальная стартовая точка. Модель предсказывает значение ŷ = wx + b, где w - вес, b - смещение, x - входной признак. Цель обучения: найти такие w и b, чтобы ошибка между предсказанием ŷ и истинным значением y была минимальной. Функция потерь MSE (Mean Squared Error) формализует эту цель: L = (ŷ - y)².
Обучение сводится к поиску минимума функции потерь в пространстве параметров. Представьте холмистый ландшафт: высота в каждой точке - значение ошибки, координаты - значения весов. Градиентный спуск делает шаг в направлении наискорейшего убывания высоты. Направление указывает градиент - вектор из частных производных функции потерь по всем параметрам.
Производная функции потерь: что это и зачем?
Производная ∂L/∂w показывает скорость изменения ошибки при малом изменении веса w. Геометрически это наклон касательной к графику функции потерь в текущей точке. Если производная положительна, увеличение веса увеличит ошибку - вес нужно уменьшать. Если отрицательна - увеличение веса уменьшит ошибку - вес нужно увеличивать.
Для MSE с линейной моделью производная вычисляется аналитически. L = (wx + b - y)². По правилу дифференцирования сложной функции: ∂L/∂w = 2(wx + b - y) * x. Множитель 2 часто опускают, используя L = 0.5(ŷ - y)² для упрощения. Тогда ∂L/∂w = (ŷ - y) * x. Ошибка предсказания, умноженная на вход - вот и весь градиент для веса.
Эта формула интуитивно понятна: если модель недооценила (ŷ < y), ошибка положительна, и градиент ∂L/∂w положителен при положительном x. Вес увеличится, предсказание вырастет, ошибка уменьшится. Если модель переоценила - вес уменьшится. Корректировка пропорциональна входному сигналу: признаки с большими значениями получают большие обновления.
Градиентный спуск на примере одного нейрона
Возьмём конкретные числа. Датасет: x=2, y=4. Начальный вес w=1, смещение b=0, learning rate α=0.1. Функция потерь: L = 0.5(ŷ - y)².
Итерация 1. Прямой проход: ŷ = 1*2 + 0 = 2. Ошибка: 2 - 4 = -2. Потеря: 0.5 * (-2)² = 2. Градиент по w: ∂L/∂w = (ŷ - y) * x = (-2) * 2 = -4. Обновление: w := 1 - 0.1*(-4) = 1.4. Новый вес: 1.4.
Итерация 2. ŷ = 1.4*2 + 0 = 2.8. Ошибка: 2.8 - 4 = -1.2. Потеря: 0.5 * 1.44 = 0.72. Градиент: (-1.2) * 2 = -2.4. w := 1.4 - 0.1*(-2.4) = 1.64.
Итерация 3. ŷ = 1.64*2 = 3.28. Ошибка: -0.72. Потеря: 0.259. Градиент: -1.44. w := 1.64 + 0.144 = 1.784.
За три шага вес сдвинулся с 1.0 до 1.784, потеря упала с 2 до 0.259. Истинное оптимальное значение w=2 (при x=2, y=4, b=0). Модель движется к нему, замедляясь по мере приближения - градиент уменьшается вместе с ошибкой. Это и есть градиентный спуск в действии: без магии, чистая математика.
Цепное правило: ключ к многослойным сетям
В линейной регрессии ошибка напрямую зависит от веса: L = f(w). В нейросети с одним скрытым слоем зависимость опосредована: вес w₁ влияет на активацию скрытого слоя, та - на выход, выход - на потерю. L = f(g(h(w₁))). Чтобы вычислить ∂L/∂w₁, нужно перемножить производные всех промежуточных функций. Это цепное правило.
Формально: если y = f(u) и u = g(x), то dy/dx = (dy/du) * (du/dx). Для трёх функций: dy/dx = (dy/du) * (du/dv) * (dv/dx). В нейросети каждый слой - это функция. Прямой проход вычисляет композицию этих функций от входа к выходу. Обратный проход вычисляет производную этой композиции, перемножая локальные градиенты от выхода к входу.
Ключевое преимущество: каждое промежуточное значение вычисляется один раз и используется дважды. При прямом проходе - для расчёта выхода. При обратном - для расчёта градиента. Это даёт линейную сложность по числу параметров, а не квадратичную, как при наивном численном дифференцировании.
Пример цепного правила в действии
Разберём композицию трёх функций, типичную для нейросети. L = (ŷ - y)² - потеря. ŷ = σ(z) - сигмоида на выходе (для бинарной классификации). z = wx + b - линейная комбинация. Нужно найти ∂L/∂w.
По цепному правилу: ∂L/∂w = ∂L/∂ŷ * ∂ŷ/∂z * ∂z/∂w. Вычисляем каждый множитель:
- ∂L/∂ŷ = 2(ŷ - y) - производная квадратичной функции.
- ∂ŷ/∂z = σ(z)(1 - σ(z)) - производная сигмоиды.
- ∂z/∂w = x - производная линейной функции по весу.
Перемножаем: ∂L/∂w = 2(ŷ - y) * σ(z)(1 - σ(z)) * x. Градиент для веса - произведение ошибки выхода, чувствительности активации и входного сигнала. Ошибка модулируется двумя факторами: насколько круто меняется выход при изменении z (производная сигмоиды) и насколько сильно вес влиял на z (вход x).
Если сигмоида в насыщении (σ близка к 0 или 1), её производная близка к нулю. Градиент ∂L/∂w затухает, вес перестаёт обновляться. Это проблема исчезающих градиентов, из-за которой сигмоиду заменили на ReLU в скрытых слоях. Цепное правило объясняет причину: производная сигмоиды ≤ 0.25, и при перемножении многих слоёв градиент экспоненциально убывает.
Вывод градиента для скрытого слоя: пошаговый разбор
Переходим к нейросети с одним скрытым слоем. Архитектура: вход x, скрытый слой с одним нейроном (вес w₁, смещение b₁, активация ReLU), выходной слой (вес w₂, смещение b₂, линейная активация). Задача регрессии. Датасет: x=1, y=2. Начальные параметры: w₁=0.5, b₁=0, w₂=0.5, b₂=0. Learning rate α=0.1.
Прямой проход: от входа к ошибке
Вычисляем активации последовательно.
Скрытый слой: z₁ = w₁*x + b₁ = 0.5*1 + 0 = 0.5. ReLU: a₁ = max(0, z₁) = 0.5.
Выходной слой: z₂ = w₂*a₁ + b₂ = 0.5*0.5 + 0 = 0.25. ŷ = z₂ = 0.25 (линейная активация).
Потеря: L = 0.5*(ŷ - y)² = 0.5*(0.25 - 2)² = 0.5*(-1.75)² = 0.5*3.0625 = 1.53125.
Модель с текущими весами предсказывает 0.25 при истинном значении 2. Ошибка значительная, градиенты будут существенными.
Обратный проход: вычисление градиентов
Движемся от выхода к входу, применяя цепное правило на каждом шаге.
Шаг 1. Градиент по выходу. ∂L/∂ŷ = ŷ - y = 0.25 - 2 = -1.75. Производная 0.5(ŷ - y)² по ŷ даёт (ŷ - y).
Шаг 2. Градиенты выходного слоя. ŷ = w₂*a₁ + b₂. ∂ŷ/∂w₂ = a₁ = 0.5. ∂L/∂w₂ = ∂L/∂ŷ * ∂ŷ/∂w₂ = -1.75 * 0.5 = -0.875. ∂ŷ/∂b₂ = 1. ∂L/∂b₂ = -1.75 * 1 = -1.75.
Шаг 3. Градиент по активации скрытого слоя. ŷ = w₂*a₁ + b₂, значит ∂ŷ/∂a₁ = w₂ = 0.5. ∂L/∂a₁ = ∂L/∂ŷ * ∂ŷ/∂a₁ = -1.75 * 0.5 = -0.875.
Шаг 4. Градиенты скрытого слоя. a₁ = ReLU(z₁). Производная ReLU: 1 при z₁ > 0, 0 при z₁ ≤ 0. z₁ = 0.5 > 0, значит ∂a₁/∂z₁ = 1. ∂L/∂z₁ = ∂L/∂a₁ * ∂a₁/∂z₁ = -0.875 * 1 = -0.875.
z₁ = w₁*x + b₁. ∂z₁/∂w₁ = x = 1. ∂L/∂w₁ = ∂L/∂z₁ * ∂z₁/∂w₁ = -0.875 * 1 = -0.875. ∂z₁/∂b₁ = 1. ∂L/∂b₁ = -0.875 * 1 = -0.875.
Собрали все градиенты: ∂L/∂w₂ = -0.875, ∂L/∂b₂ = -1.75, ∂L/∂w₁ = -0.875, ∂L/∂b₁ = -0.875. Отрицательные значения означают, что увеличение любого параметра уменьшит потерю.
Обновление весов и следующий шаг
Применяем градиентный спуск: параметр := параметр - α * градиент.
- w₂ := 0.5 - 0.1*(-0.875) = 0.5 + 0.0875 = 0.5875
- b₂ := 0 - 0.1*(-1.75) = 0 + 0.175 = 0.175
- w₁ := 0.5 - 0.1*(-0.875) = 0.5 + 0.0875 = 0.5875
- b₁ := 0 - 0.1*(-0.875) = 0 + 0.0875 = 0.0875
Проверим новый прямой проход с обновлёнными весами. z₁ = 0.5875*1 + 0.0875 = 0.675. a₁ = 0.675. z₂ = 0.5875*0.675 + 0.175 = 0.3966 + 0.175 = 0.5716. ŷ = 0.5716. Потеря: 0.5*(0.5716 - 2)² = 0.5*2.040 = 1.020. Ошибка уменьшилась с 1.531 до 1.020 за одну итерацию.
В реальном обучении процесс повторяется для всех примеров в датасете. Пакетный градиентный спуск усредняет градиенты по всему набору данных. Стохастический - обновляет веса на каждом примере. Мини-пакетный - компромисс: батч из 32-256 примеров даёт баланс скорости и стабильности. Но механика обратного распространения неизменна: прямой проход, вычисление потери, обратный проход с цепным правилом, обновление весов.
Что дальше? От интуиции к практике
Мы разобрали обратное распространение ошибки на конкретных числах: от линейной регрессии до сети со скрытым слоем. Алгоритм вычисляет градиенты функции потерь по всем параметрам сети, последовательно применяя цепное правило от выхода к входу. Каждый вес получает сигнал: насколько его изменение повлияет на итоговую ошибку. Этот сигнал - произведение локальных градиентов вдоль пути от веса до функции потерь.
Интуиция, построенная на одном скрытом нейроне, масштабируется на любые архитектуры. В полносвязных сетях градиенты вычисляются в матричной форме. В свёрточных - те же операции, но с учётом пространственной структуры. В рекуррентных - градиенты текут не только сквозь слои, но и сквозь временные шаги. Принцип цепного правила остаётся неизменным.
Понимание этой механики помогает трезво оценивать новые архитектуры. Когда вы читаете о том, как нейросети формируют видимость брендов, или о провалах скрытого рассуждения в fine-tune моделях, вы можете связать наблюдаемое поведение с процессом обучения. Градиенты определяют, какие паттерны модель выучит, а какие проигнорирует.
Во второй части статьи мы перейдём к матричной форме обратного распространения для полносвязных сетей, разберём различные функции активации и их производные, реализуем алгоритм на Python с нуля. Практический код закрепит интуицию и даст инструмент для собственных экспериментов.