Обратное распространение ошибки: от интуиции до кода

Простой

12 мин

364

Туториал

Введение.

Современные нейросети часто воспринимаются как черная магия. Вы закидываете в черный ящик датасет, ждете пару часов, и вот уже модель пишет за вас код, генерирует картины и безошибочно отличает собаку от выпечки. Но под капотом нет никаких заклинаний. Вся эта вычислительная мощь держится на одном элегантном алгоритме, основы которого были заложены еще в 1970-х годах — обратном распространении ошибки (Backpropagation).

Сейчас порог входа в машинное обучение низок как никогда. Чтобы заставить сеть учиться, достаточно написать loss.backward() в PyTorch или вызвать model.fit() в Keras. Фреймворки берут всю математическую рутину на себя. Это чертовски удобно, но порождает проблему: мы получаем разработчиков, которые умеют собирать архитектуры из готовых блоков-лего, но впадают в ступор, если спросить их, что именно происходит при вызове backward(). Как сеть понимает, какой конкретно вес в десятом слое виноват в том, что на выходе получилась ерунда?

В этой статье мы снимем покров тайны. Мы разберем backprop на пальцах и понятных аналогиях, сдуем пыль со школьного учебника алгебры (не пугайтесь, нам понадобится только база) и напишем этот алгоритм с полного нуля на чистом Python.

2. Интуиция: Заводской конвейер и поиск виноватых

Прежде чем лезть в математику, давайте разберемся со смыслом.

Как вообще учится нейросеть? Процесс начинается с прямого прохода (Forward Pass). Мы показываем сети фотографию кота. Сигнал бежит по слоям от входа к выходу, умножаясь на веса (текущие настройки сети), и в конце нейросеть гордо выдает результат: «Уверен на 90%, что это собака».

Мы сравниваем этот ответ с правильным (мы-то знаем, что это кот) и вычисляем ошибку — Loss. В нашем случае ошибка просто огромная. И вот тут возникает главная проблема: внутри современной модели могут быть миллионы и миллиарды параметров (весов). Как понять, какой конкретно нейрон в пятом слое недоработал, а какой в десятом — перестарался?

Здесь на сцену выходит обратное распространение (Backpropagation).

Представьте себе огромный заводской конвейер. На выходе получается бракованная деталь. Генеральный директор (функция потерь) смотрит на убыток и говорит: «Мы потеряли на этом 100 тысяч рублей».

Директор не бежит ругать конкретного токаря. Он вызывает своего заместителя (последний слой нейросети) и говорит: «Твой отдел виноват в 80% этого убытка». Заместитель идет к начальнику цеха: «Из-за настроек твоего конвейера мы получили 50% нашей доли брака». Начальник цеха спускается к бригадиру, а тот уже подходит к конкретному рабочему Ивану (наш вес в самом первом слое) и говорит: «Ваня, ты закрутил гайку на два оборота сильнее, чем нужно, и именно это запустило всю цепочку брака».

Сигнал об ошибке передается с конца в начало. Каждый уровень вычисляет, каков личный вклад его подчиненных в общий провал. Это и есть суть backprop — мы раскручиваем процесс вычислений в обратную сторону, чтобы найти долю вины каждого отдельного параметра. В математике эта «доля вины» называется градиентом.

Важное отличие, о котором часто забывают: Многие новички путают обратное распространение с градиентным спуском (Gradient Descent), считая это одним процессом. Это не так.

Backprop — это просто строгий аудитор. Он только считает градиенты. Он говорит: «Вес нужно уменьшить, а вес — сильно увеличить». Он ничего не меняет сам.
Градиентный спуск — это уже механик с гаечным ключом. Получив отчет от аудитора (градиенты), он идет и физически обновляет значения весов, делая шаг в сторону уменьшения ошибки.

Аудитор нашел виноватых, механик подкрутил гайки. Цикл повторяется, пока сеть не начнет безошибочно узнавать кота.

3. Математический фундамент (без боли)

Да, мы добрались до математики. Но уберите валерьянку — мы не будем лезть в дебри матанализа, нам понадобится только база.

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

«Если я чуть-чуть покручу ручку настройки (вес ), как сильно изменится итоговая ошибка ()?»

Если производная положительная, значит увеличение веса приведет к росту ошибки (нам это не нужно, значит, будем вес уменьшать). Если отрицательная — увеличение веса ошибку снизит. Величина производной говорит нам, насколько резко изменится результат. Это наш компас.

Вычислительный граф (Computational Graph)

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

Весь процесс вычислений представляют в виде вычислительного графа. Это схема, где узлы — это простые операции (например, + или *), а стрелки — числа, которые между ними передаются.

Прямой проход (forward pass) — это движение по графу слева направо: мы берем входы, прогоняем через операции и получаем ответ. А обратное распространение — это движение справа налево, где по тем же самым маршрутам мы протаскиваем назад значения производных.

Секретное оружие: Цепное правило (Chain Rule)

Но как протащить значение ошибки от самого конца графа к самому первому входу? Ведь между ними лежат десятки операций! Здесь на сцену выходит главное оружие backprop’а — цепное правило дифференцирования сложной функции. Вы наверняка проходили его в школе.

Суть правила гениально проста: производная сложной функции равна произведению производных ее частей. В виде формулы для одного веса это выглядит так:

$\frac{\partial L}{\partial w} = \frac{\partial L}{\partial a} \cdot \frac{\partial a}{\partial z} \cdot \frac{\partial z}{\partial w}$

Выглядит пугающе? Давайте переведем с математического на человеческий:

Влияние веса на ошибку = (влияние выхода нейрона на ошибку) $\times$ (влияние суммы на выход) $\times$ (влияние веса на сумму).

Возвращаясь к нашей метафоре с заводом, если мы хотим узнать, насколько сильно действия рабочего Ивана () виноваты в убытках компании (), мы просто перемножаем три вещи:

Как готовая деталь повлияла на убытки директора ( $\frac{\partial L}{\partial a}$ ).
Как работа цеха повлияла на готовую деталь ( $\frac{\partial a}{\partial z}$ ).
Как конкретное движение Ивана повлияло на работу всего цеха ( $\frac{\partial z}{\partial w}$ ).

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

4. Шаг за шагом: Разбираем один нейрон

Хватит теории, давайте запачкаем руки. Возьмем самую примитивную нейросеть в мире. В ней будет всего один вход, один вес, одна функция активации (возьмем популярную ReLU) и функция потерь (будем считать квадрат ошибки).

Наш граф вычислений выглядит так: Вход () $\rightarrow$ Умножение на Вес () $\rightarrow$ Сумма () $\rightarrow$ ReLU $\rightarrow$ Выход () $\rightarrow$ Ошибка ()

Прямой проход (Forward Pass): считаем ошибку

Дадим нашей микро-сети конкретные числа:

Входное значение:
Текущий вес (взят из головы, сеть же не обучена):
Правильный ответ, который мы хотим получить:

Погнали по графу слева направо:

Умножение: $z = x \cdot w = 2 \cdot 3 = 6$
Активация (ReLU): Эта функция пропускает положительные числа без изменений, а отрицательные превращает в ноль. У нас , поэтому выход нейрона .
Функция потерь (Loss): Считаем квадрат разности между тем, что получилось, и тем, что хотели. .

Итак, наш прямой проход завершен. Мы получили ошибку . Директор завода недоволен.

Обратный проход (Backward Pass): ищем виноватых

Наша цель — найти $\frac{\partial L}{\partial w}$ . То есть ответить на вопрос: «Как изменение веса повлияет на ошибку ?».

Берем цепное правило из предыдущего раздела и идем по нашему графу строго в обратном направлении, справа налево. Нам нужно посчитать три локальные производные.

Шаг 1: Как выход сети повлиял на ошибку? ( $\frac{\partial L}{\partial a}$ ) Наша функция потерь: . Вспоминаем школу: производная от равна . Значит, производная нашей ошибки:

$\frac{\partial L}{\partial a} = 2 \cdot (a - 10)$

Подставляем наше текущее значение :

$\frac{\partial L}{\partial a} = 2 \cdot (6 - 10) = -8$

Что это значит? Градиент равен -8 . Минус означает обратную зависимость. Если мы чуть-чуть увеличим выход сети , наша ошибка уменьшится.

Шаг 2: Как сумма повлияла на выход? ( $\frac{\partial a}{\partial z}$ ) Наш выход: $a = \text{ReLU}(z)$ . Производная ReLU элементарна: если число больше нуля, градиент равен (каждое изменение входа напрямую меняет выход). Если меньше нуля — градиент (вентиль закрыт). У нас , значит:

$\frac{\partial a}{\partial z} = 1$

Что это значит? Сигнал проходит через этот узел без искажений. Начальник цеха передает приказ бригадиру слово в слово.

Шаг 3: Как вес повлиял на сумму? ( $\frac{\partial z}{\partial w}$ ) Наша сумма: $z = x \cdot w$ . Если мы берем производную по , то выступает как константа. Производная равна . У нас , значит:

$\frac{\partial z}{\partial w}=2$

Что это значит? Чем больше был входной сигнал , тем сильнее текущий вес влияет на результат.

Шаг 4: Собираем комбо (Chain Rule) Теперь просто перемножаем все, что нашли:

$\frac{\partial L}{\partial w} = -8 \cdot 1 \cdot 2 = -16$

Бинго! Градиент нашего веса равен -16.

Магия сработала. Что нам говорит это число? Оно кричит: «Эй, если ты увеличишь вес , ошибка резко пойдет вниз!».

Давайте проверим это руками (сымитируем шаг градиентного спуска). Пусть мы послушались градиента и увеличили вес с до . Делаем новый прямой проход: $z = 2 \cdot 4 = 8$ $a = \text{ReLU}(8) =8$

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

5. Масштабируем до полноценной сети: Добро пожаловать в Матрицу

Один нейрон — это прекрасно для понимания базы. Но в современных моделях вроде GPT счет параметров идет на сотни миллиардов. Если мы будем считать производную для каждого веса отдельно, используя циклы for в Python, наша сеть будет обучаться до смерти Вселенной.

Что происходит, когда нейронов много? Представьте, что на нашем заводе работает не один токарь Иван, а целых 1000 рабочих, которые передают детали 500 менеджерам. Писать 500 000 отдельных уравнений для каждого взаимодействия — форменное безумие. Нам нужен способ автоматизировать этот бюрократический ад.

Здесь на помощь приходит линейная алгебра. Мы просто берем наши одиночные числа (скаляры) и аккуратно упаковываем их в списки (векторы) и таблицы (матрицы).

Все входы в слой сети мы записываем в один длинный вектор .
Все веса между текущим и следующим слоем мы упаковываем в огромную таблицу — матрицу весов .

Теперь прямой проход для целого слоя с тысячами нейронов записывается одной элегантной формулой: $Z = W \cdot X$ . Вместо тысяч операций мы делаем одно матричное умножение.

Страшное слово на букву «Я» (Якобиан)

Когда мы переходим к обратному распространению (backward pass), логика остается абсолютно такой же. Работает все то же самое цепное правило из предыдущего раздела: мы умножаем производную ошибки на локальную производную узла.

Разница лишь в том, что теперь мы берем производную не от одного числа по другому числу, а от вектора по вектору. И результатом такой операции становится Матрица Якоби (или Якобиан).

В академических статьях тензорный анализ и Якобианы часто описывают так, что хочется закрыть страницу. Но на деле, Якобиан — это просто эксель-табличка. Если скалярная производная говорит: «Как этот один вес влияет на этот один выход», то Якобиан говорит: «Вот тебе таблица, где на пересечении строк и столбцов записано, как каждый конкретный вход повлиял на каждый конкретный выход этого слоя».

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

Зачем нам эти таблицы? Секрет видеокарт (GPU)

Может показаться, что мы просто усложнили себе жизнь новой формой записи. Но упаковка градиентов в матрицы — это главный секрет современного Deep Learning. И вот почему.

Центральный процессор (CPU) вашего компьютера — это гениальный профессор. Он решает задачи по очереди, очень быстро, но строго одну за другой. Если дать ему 10 миллионов градиентов, он будет считать их последовательно.

Видеокарта (GPU) — это армия из десятков тысяч не очень умных, но исполнительных школьников. По отдельности они медленнее профессора, но они могут работать одновременно. Видеокарты аппаратно созданы для того, чтобы умножать огромные матрицы.

Когда мы упаковываем наши локальные производные в Якобианы и перемножаем эти матрицы между собой, GPU берет эту огромную таблицу и вычисляет градиенты для миллионов весов одновременно за доли секунды. Именно поэтому алгоритм из 70-х годов “выстрелил” только в 2010-х, когда появились мощные видеокарты.

6. Продвинутые концепции: Глухие менеджеры и паникеры

Когда компьютеры стали мощнее, исследователи решили: «А давайте добавим не два слоя, а двадцать! Сеть станет умнее». Собрали, запустили… и ничего не произошло. Сеть упорно отказывалась учиться. Оказалось, что у алгоритма обратного распространения есть две фатальные проблемы, связанные с тем самым цепным правилом умножения.

Затухание градиентов (Vanishing Gradients)

Представьте, что наш генеральный директор передает приказ: «Нужно срочно исправить ошибку на 100 пунктов!». Он говорит это заместителю. Заместитель немного ленив и передает начальнику цеха только 25% от этой срочности. Начальник цеха передает бригадиру 25% от того, что услышал. К тому моменту, когда сигнал доходит до рабочего Ивана в самом первом цехе, приказ звучит так: «Нужно исправить ошибку на 0.0001 пункта». Иван пожимает плечами и ничего не меняет в своей работе. Первые слои сети не учатся.

В математике это происходит из-за функций активации. Исторически самой популярной была Сигмоида (Sigmoid), которая сжимает любые числа в диапазон от до . Проблема в том, что максимальное значение производной сигмоиды равно .

Помните цепное правило? Мы перемножаем локальные производные. Если у вас 10 слоев, вы умножаете градиент на десять раз подряд. $0.25^{10} \approx 0.0000009$ . Градиент буквально «испаряется» по пути к начальным слоям. Сеть остается глупой.

Взрыв градиентов (Exploding Gradients)

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

Директор говорит: «Ошибка на 1 рубль». Заместитель кричит: «Ошибка на 5 рублей!». Начальник цеха: «На 25!». До Ивана доходит приказ: «Мы потеряли 10 миллионов, срочно крути все гайки в обратную сторону!».

В математике, если вы многократно умножаете число больше единицы само на себя, оно улетает в бесконечность. Градиенты становятся настолько огромными, что веса обновляются гигантскими скачками, значения превращаются в NaN (Not a Number), и сеть ломается.

ReLU: Герой, который спас Deep Learning

Почему сегодня мы можем обучать сети из сотен слоев (как GPT) и градиенты не затухают? Все благодаря одному простому, но гениальному решению — функции активации ReLU (Rectified Linear Unit).

Формула ReLU примитивна: если число отрицательное — выдай , если положительное — выдай само это число. Ее производная (градиент) также элементарна:

Если вход был , производная равна .
Если вход был $\le 0$ , производная равна .

В чем магия? Умножение на единицу не меняет число! Если сигнал об ошибке проходит через узел ReLU, он передается дальше на 100% мощности, не затухая. Директор крикнул «100 пунктов!», и менеджер передал ровно «100 пунктов!». Сигнал спокойно долетает до самых первых слоев даже в очень глубоких сетях. Именно этот трюк стал одним из главных ключей к революции глубокого обучения.

7. Практика: Пишем свой PyTorch с нуля (на чистом Python)

Теория — это отлично, но ничто так не проясняет голову, как написание кода своими руками. Чтобы окончательно развеять туман, мы не будем копаться в исходниках PyTorch на C++. Вместо этого мы напишем свой собственный микро-фреймворк для автоматического дифференцирования на чистом Python (идея вдохновлена гениальным проектом micrograd Андрея Карпатого).

Нам нужен объект, который будет не просто хранить число, но и «помнить», откуда это число взялось (своих родителей в графе вычислений) и уметь вычислять свою локальную производную. Назовем его Value.

Вот полный код нашего движка, который помещается в несколько десятков строк:

class Value:
    def __init__(self, data, _children=()):
        self.data = data
        self.grad = 0.0 # Изначально мы считаем, что вес ни на что не влияет
        self._backward = lambda: None # Функция для расчета градиента текущего узла
        self._prev = set(_children)   # Ссылки на "родителей" (предыдущие узлы в графе)

    def __add__(self, other):
        # Оборачиваем обычные числа в объекты Value
        other = other if isinstance(other, Value) else Value(other)
        out = Value(self.data + other.data, (self, other))

        def _backward():
            # Производная сложения равна 1.0. 
            # Градиент просто "протекает" к обоим родителям без изменений (цепное правило: 1.0 * out.grad)
            self.grad += 1.0 * out.grad
            other.grad += 1.0 * out.grad
            
        out._backward = _backward
        return out

    def __mul__(self, other):
        other = other if isinstance(other, Value) else Value(other)
        out = Value(self.data * other.data, (self, other))

        def _backward():
            # Производная умножения — это значение "другого" множителя.
            self.grad += other.data * out.grad
            other.grad += self.data * out.grad
            
        out._backward = _backward
        return out

    def relu(self):
        out = Value(0 if self.data < 0 else self.data, (self,))

        def _backward():
            # Производная ReLU: 1, если число положительное, иначе 0.
            self.grad += (out.data > 0) * out.grad
            
        out._backward = _backward
        return out

    def backward(self):
        # Топологическая сортировка графа. 
        # Нам нужно убедиться, что мы идем строго с конца в начало, 
        # и ни один узел не посчитает свой backward до того, как получит градиент от "потомков".
        topo = []
        visited = set()
        def build_topo(v):
            if v not in visited:
                visited.add(v)
                for child in v._prev:
                    build_topo(child)
                topo.append(v)
        build_topo(self)

        # Градиент самой функции потерь (самого конца) всегда равен 1
        self.grad = 1.0
        
        # Идем по графу в обратном порядке и вызываем локальные производные
        for node in reversed(topo):
            node._backward()

Разбираем магию по косточкам

Что здесь происходит? Когда мы выполняем математические операции (сложение, умножение), мы не просто получаем ответ. Мы динамически строим граф вычислений.

Каждый раз, создавая новую переменную out, мы «зашиваем» внутрь нее функцию _backward. Эта функция — математическое воплощение цепного правила. Она берет градиент, пришедший сверху (out.grad), умножает его на локальную производную текущей операции и записывает результат в .grad родителей. Обратите внимание на +=: если один вес используется в сети несколько раз (например, в RNN), его градиенты должны суммироваться.

Проверяем в бою

Давайте воспроизведем пример из 4-го раздела (где мы считали один нейрон руками) с помощью нашего нового класса:

# Задаем начальные значения
x = Value(2.0)
w = Value(3.0)
y_true = Value(10.0)

# Прямой проход (Forward pass)
z = x * w
a = z.relu()

# Считаем MSE (квадрат ошибки)
# Так как мы не написали возведение в степень и вычитание,
# запишем (a - 10)^2 как (a + (-10)) * (a + (-10))
diff = a + Value(-10.0)
loss = diff * diff

print(f"Ошибка (Loss) после прямого прохода: {loss.data}") 
# Вывод: 16.0

# ОБРАТНОЕ РАСПРОСТРАНЕНИЕ!
loss.backward()

print(f"Градиент веса w: {w.grad}") 
# Вывод: -16.0

Сходится! Алгоритм выдал ровно те же , что мы мучительно вычисляли на листочке. Только теперь наш движок может автоматически посчитать градиенты для графа любой глубины и сложности. Если мы соберем из этих Value многослойный перцептрон, вызов loss.backward() за долю секунды найдет виноватых на всех этапах конвейера.

Заключение

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

Что посмотреть дальше:

3Blue1Brown (YouTube): Плейлист про нейросети с гениальными визуализациями математики.
Стрим Андрея Карпатого : Видео, где он с нуля пишет движок, на котором основан наш код.

Анонсы новых статей, полезные материалы, а так же если в процессе у вас возникнут сложности, обсудить их или задать вопрос по этой статье можно в моём Telegram-сообществе. Смело заходите, если что-то пойдет не так, — постараемся разобраться вместе.

此内容由惯性聚合(RSS阅读器)自动聚合整理，仅供阅读参考。原文来自 — 版权归原作者所有。

推荐订阅源

Все публикации подряд на Хабре