Цепное правило и вычислительный граф

Зачем это нужно

В прошлом уроке мы научились находить производную одной функции. Но нейросеть — это композиция сотен функций: эмбеддинг → слой → активация → слой → … → softmax → loss. Вес из первого слоя влияет на loss через все последующие. Как узнать, насколько loss чувствителен к этому весу?

Ответ даёт цепное правилоцепное правилоEN chain ruleПроизводная композиции — произведение производных звеньев — (f(g(x)))′ = f′(g(x))·g′(x). Математическая основа backprop. — главная формула всего глубокого обучения. А чтобы применять его к миллиардам параметров без хаоса, вычисления раскладывают на вычислительный графвычислительный графEN computational graphСхема вычисления — узлы-операции и рёбра-значения. По нему идёт прямой проход (значения) и обратный (градиенты). и проходят по нему дважды: вперёд, чтобы посчитать значения, и назад, чтобы посчитать производные. Это и есть обратное распространение ошибкиобратное распространение ошибкиEN backpropagation (backpropagation), которое запускает строчка loss.backward(). Сегодня мы сделаем всё это руками на маленьком примере, а в модуле 3.2 напишем свой автоград.

Цепное правило

Возьмём $h(x) = (3x + 1)^2$. Это композиция (урок 1.0.1): внутреннее звено $u = g(x) = 3x + 1$, внешнее — $f(u) = u^2$.

Интуиция: шестерёнки. Пусть шестерёнка $u$ крутится в 3 раза быстрее шестерёнки $x$, а шестерёнка $y$ — в 8 раз быстрее $u$. Тогда $y$ крутится в $3 \cdot 8 = 24$ раза быстрее $x$. Скорости звеньев перемножаются:

$$\big(f(g(x))\big)' = f'(g(x)) \cdot g'(x), \qquad \text{или} \qquad \frac{dy}{dx} = \frac{dy}{du} \cdot \frac{du}{dx}$$

Запись Лейбница справа удобна для запоминания: кажется, будто $du$ «сокращается» (это не строгое доказательство, но мнемоника работает). Обратите внимание: внешнюю производную $f'$ вычисляют в точке $g(x)$, а не в $x$.

Посчитаем в точке $x = 1$. Внутреннее звено: $u = 4$, $\frac{du}{dx} = 3$. Внешнее: $\frac{dy}{du} = 2u = 8$. Итого $\frac{dy}{dx} = 8 \cdot 3 = 24$. Центральная разность из прошлого урока даёт 24.000 — сходится.

Ещё три примера

Экспонента с минусом. $\frac{d}{dx} e^{-x}$: внешнее звено $e^u$ с производной $e^u$, внутреннее $u = -x$ с производной $-1$. Ответ: $-e^{-x}$. В точке $x = 0$ это $-1$: при росте $x$ функция $e^{-x}$ убывает, поэтому производная отрицательна.

Сигмоида — ещё раз. $\sigma(x) = (1 + e^{-x})^{-1}$ (степень $-1$ — это «единица, делённая на», урок 1.0.2). Внешнее звено $u^{-1}$ по правилу $(x^n)' = n x^{n-1}$ при $n = -1$ даёт $-u^{-2}$, внутреннее $1 + e^{-x}$ — по предыдущему примеру — даёт $-e^{-x}$:

$$\sigma'(x) = -\frac{1}{(1 + e^{-x})^2} \cdot (-e^{-x}) = \frac{e^{-x}}{(1 + e^{-x})^2} = \sigma(x)\,(1 - \sigma(x))$$

Тот же ответ, что и по правилу частного в прошлом уроке, — хороший знак.

Обещанный tanh. Можно проверить, что $\tanh x = 2\sigma(2x) - 1$. Например, при $x = 0.5$: $\tanh 0.5 \approx 0.4621$, а $\sigma(1) \approx 0.7311$ и $2 \cdot 0.7311 - 1 = 0.4621$. Тогда по цепному правилу, обозначив $s = \sigma(2x)$ (внешнее звено $2\sigma(u) - 1$ даёт $2\sigma'(u)$, внутреннее $u = 2x$ даёт 2):

$$\begin{gathered} \tanh'(x) = 2 \cdot \sigma'(2x) \cdot 2 = 4s(1 - s), \\ 1 - \tanh^2 x = 1 - (2s - 1)^2 = 4s - 4s^2 = 4s(1 - s) \end{gathered}$$

Совпало: $\tanh' = 1 - \tanh^2$. Численно при $x = 0.7$ обе формулы дают 0.63474.

Длинные цепочки и исчезающий градиент

Для цепочки из многих звеньев $y = f_3(f_2(f_1(x)))$ правило применяется многократно: производная — произведение всех локальных производных вдоль пути. Отсюда важное следствие. Производная сигмоиды не больше 0.25, поэтому у цепочки из десяти сигмоид производная не больше $0.25^{10} \approx 10^{-6}$. Сигнал об ошибке почти не доходит до первых звеньев — это исчезающий градиент. Если же множители больше 1, произведение взрывается.

Современные сети борются с этим двумя приёмами, которые вы встретите на ступени 3. У ReLU производная равна 1 на положительной половине. А остаточная связь $y = x + F(x)$ имеет производную $1 + F'(x)$: даже если $F'$ мала, единица пропускает сигнал напрямую (урок 3.4.2).

Вычислительный граф

Цепное правило для формулы на бумаге — одно дело. Нейросеть же — программа из тысяч операций. Чтобы не запутаться, её представляют вычислительным графом: узлы — элементарные операции (+, ×, σ, …), рёбра — числа, которые текут между ними.

Возьмём один нейрон с сигмоидой и квадратичной ошибкой — модель на одном примере:

$$L = \big(\sigma(w \cdot x + b) - y\big)^2, \qquad x = 1.5, \; w = 2, \; b = -1, \; y = 1$$

Здесь $w$ и $b$ — параметры, которые мы хотим обучать, $x$ — вход, $y$ — правильный ответ.

Прямой проход

Прямой проходпрямой проходEN forward passВычисление выхода и loss по графу от входов к выходу с запоминанием промежуточных значений для обратного прохода. — считаем слева направо и запоминаем каждое промежуточное значение:

flowchart LR
X["x = 1.5"] --> M("×")
W["w = 2"] --> M
M -- "u = 3" --> P("+")
B["b = −1"] --> P
P -- "z = 2" --> S("σ")
S -- "a = 0.8808" --> D("− y")
D -- "d = −0.1192" --> Q("( )²")
Q --> L["L = 0.01421"]

Прямой проход: значения текут от входов к loss

Узел	Формула	Значение
умножение	$u = w \cdot x$	3
сложение	$z = u + b$	2
сигмоида	$a = \sigma(z)$	0.8808
вычитание	$d = a - y$	−0.1192
квадрат	$L = d^2$	0.01421

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

Теперь идём справа налево. (Не путайте промежуточную переменную $d$ с буквой d в записи производной: $\frac{dL}{dd}$ читается «производная $L$ по $d$».)

Слово «градиент»

В ML градиентом коротко называют производную loss по какой-нибудь величине: «градиент по $w$» — это $\frac{dL}{dw}$, «градиент по выходу узла» — производная $L$ по этому выходу. Строгое определение для функций многих переменных (градиент — это вектор всех таких производных) — в следующем уроке.

Начинаем с $\frac{dL}{dL} = 1$: loss по самому себе меняется один к одному. Каждый узел получает сверху «градиент по своему выходу» и умножает его на свою локальную производную — производную выхода узла по его входу. Так по цепному правилу получается градиент по входу узла, и он передаётся дальше влево. Например, у узла «квадрат» $L = d^2$ локальная производная равна $2d = 2 \cdot (-0.1192) = -0.2384$ — ровно по таблице производных из прошлого урока.

Шаг	Градиент сверху	Локальная производная	Результат
квадрат	$\frac{dL}{dL} = 1$	$\frac{dL}{dd} = 2d = -0.2384$	$\frac{dL}{dd} = -0.2384$
вычитание	$-0.2384$	$\frac{dd}{da} = 1$	$\frac{dL}{da} = -0.2384$
сигмоида	$-0.2384$	$\frac{da}{dz} = a(1 - a) = 0.1050$	$\frac{dL}{dz} = -0.02503$
сложение	$-0.02503$	$\frac{dz}{du} = 1$, $\frac{dz}{db} = 1$	$\frac{dL}{du} = \frac{dL}{db} = -0.02503$
умножение	$-0.02503$	$\frac{du}{dw} = x = 1.5$, $\frac{du}{dx} = w = 2$	$\frac{dL}{dw} = -0.03755$, $\frac{dL}{dx} = -0.05006$

flowchart RL
L["dL/dL = 1"] --> Q("( )²")
Q -- "−0.2384" --> D("− y")
D -- "−0.2384" --> S("σ")
S -- "−0.02503" --> P("+")
P -- "dL/db = −0.02503" --> B["b"]
P -- "−0.02503" --> M("×")
M -- "dL/dw = −0.03755" --> W["w"]
M -- "dL/dx = −0.05006" --> X["x"]

Обратный проход: градиенты текут от loss к параметрам

Что означают ответы. $\frac{dL}{dw} = -0.0375 < 0$: если чуть увеличить $w$, loss уменьшится. И правда: больший $w$ даёт больший $z$, сигмоида ближе к 1, а правильный ответ $y = 1$. Шаг градиентного спуска сдвинет $w$ вверх, $b$ — тоже.

Заметьте, что для сигмоиды мы использовали сохранённое значение $a$, а не пересчитывали $\sigma(z)$. Именно поэтому прямой проход запоминает промежуточные значения — они нужны для локальных производных.

Шаблоны узлов

Обратный проход собирается из нескольких повторяющихся «кирпичиков». Запомните их — и любой граф будет вам по силам.

Узел	Что делает с градиентом сверху $g$	Пример из таблицы
$z = u + b$ (сложение)	отдаёт $g$ всем входам без изменений — «распределитель»	$\frac{dL}{db} = \frac{dL}{du} = \frac{dL}{dz}$
$u = w \cdot x$ (умножение)	отдаёт каждому входу $g$, умноженный на другой вход — «перестановка»	$\frac{dL}{dw} = g \cdot x$, $\frac{dL}{dx} = g \cdot w$
$L = d^2$	умножает на $2d$	$-0.2384 = 1 \cdot 2 \cdot (-0.1192)$
$a = \sigma(z)$	умножает на $a(1 - a)$	$-0.02503 = -0.2384 \cdot 0.105$
$\max(0, z)$ (ReLU)	пропускает $g$, если $z > 0$, иначе отдаёт 0 — «маршрутизатор»

Ветвление: градиенты складываются

Что если одна и та же переменная используется в графе дважды? Возьмём $f(x, y) = (x + y) \cdot x$ в точке $x = 3$, $y = -1$. Граф: $q = x + y = 2$, затем $f = q \cdot x = 6$. Переменная $x$ входит в граф двумя путями: напрямую в умножение и через $q$.

flowchart LR
X["x = 3"] --> P("+")
Y["y = −1"] --> P
P -- "q = 2" --> M("×")
X --> M
M --> F["f = 6"]

x используется дважды: в сумме и в произведении

Обратный проход. Узел «×»: градиент по $q$ равен $x = 3$, по «прямому» входу $x$ — равен $q = 2$. Узел «+» передаёт градиент 3 дальше к $x$ и $y$ без изменений. В итоге к $x$ пришли два вклада: 2 по прямому пути и 3 через $q$. Их нужно сложить: $\frac{\partial f}{\partial x} = 2 + 3 = 5$, а $\frac{\partial f}{\partial y} = 3$.

Проверим без графа: $f = x^2 + xy$, производная по $x$ при замороженном $y$ — это $2x + y = 6 - 1 = 5$. Сошлось. (Значок $\partial$ — «частная производная»: производная по одной переменной, когда остальные заморожены. Подробно — в следующем уроке.)

Почему складываются? Маленькое изменение $x$ «растекается» по обоим путям, и их влияния на $f$ суммируются. В нейросетях ветвление повсюду: один вектор токена идёт и в attention, и в остаточную связь; в GPT матрица эмбеддингов часто используется и на входе, и на выходе (weight tying, урок 4.6.2).

Классический баг: = вместо +=

Если в коде обратного прохода написать x.grad = … вместо x.grad += …, второй путь перезапишет первый, и вы получите 2 или 3 вместо 5 — смотря какой путь посчитается последним. Ошибки не будет — просто модель станет учиться хуже. Этот баг вы специально поймаете, когда будете писать свой автоград в уроке 3.2.2. Отсюда же правило PyTorch: перед каждым шагом обучения градиенты нужно обнулять (optimizer.zero_grad()), иначе они накопятся с прошлого шага.

Почему проход «обратный»

Можно было бы идти и вперёд: для каждого входа протащить через граф «скорость изменения» вместе со значениями. Это прямой режим дифференцирования. Но за один такой проход вы получаете производные всего графа по одному входу. Для модели с 7 млрд параметров понадобилось бы 7 млрд проходов.

Обратный режим устроен наоборот: за один проход получаются производные одного выхода по всем входам. А у нас как раз один выход — число loss — и миллиарды параметров. Обратный проход стоит примерно вдвое дороже прямого, поэтому шаг обучения обходится примерно в три прямых прохода. Из этого соотношения в уроке 5.1.1 вырастет знаменитая оценка стоимости обучения $\approx 6ND$ операций.

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

Проверка в PyTorch

PyTorch строит граф автоматически во время прямого прохода и проходит его в обратную сторону по backward() (о PyTorch — заметка в уроке 1.1.2):

import torch

x = torch.tensor(1.5, requires_grad=True)   # requires_grad=True: «нужна производная по этой величине»
w = torch.tensor(2.0, requires_grad=True)
b = torch.tensor(-1.0, requires_grad=True)
y = torch.tensor(1.0)                       # правильный ответ — производная по нему не нужна

z = w * x + b              # прямой проход строит граф
a = torch.sigmoid(z)
L = (a - y) ** 2
L.backward()               # обратный проход по тому же графу; результаты — в w.grad, b.grad, x.grad

print(f"L = {L.item():.5f}")
print(f"dL/dw = {w.grad.item():.5f}, dL/db = {b.grad.item():.5f}, dL/dx = {x.grad.item():.5f}")

# Необязательная часть: печатаем имена узлов графа. Досконально понимать эти строки не нужно.
node = L.grad_fn                             # узел, который создал L (последняя операция)
while node is not None:                      # идём по графу от loss к входам
    print(type(node).__name__)               # имя узла
    # next_functions — узлы, из которых пришли входы; служебные узлы AccumulateGrad пропускаем
    nxt = [n for n, _ in node.next_functions if n is not None and type(n).__name__ != "AccumulateGrad"]
    node = nxt[0] if nxt else None

L = 0.01421
dL/dw = -0.03755, dL/db = -0.02503, dL/dx = -0.05006
PowBackward0
SubBackward0
SigmoidBackward0
AddBackward0
MulBackward0

Те же числа, что в нашей таблице. А имена узлов — это наш граф, прочитанный от loss к входам: квадрат, вычитание, сигмоида, сложение, умножение. У каждого такого узла PyTorch хранит свою локальную производную — ровно как мы.

Практика

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

Обратный проход по графу вручную5 тестов

import math


def sigmoid(z):
    """Устойчивая сигмоида (уже готова)."""
    if z >= 0:
        return 1 / (1 + math.exp(-z))
    e = math.exp(z)
    return e / (1 + e)


# ── Часть 1: нейрон  L = (σ(w·x + b) − y)² ────────────────────────────────

def forward(x, w, b, y):
    """Прямой проход. Верните словарь со ВСЕМИ промежуточными значениями:
    {"x": x, "w": w, "b": b, "y": y, "z": ..., "a": ..., "L": ...},
    где z = w·x + b, a = σ(z), L = (a − y)².
    """
    # TODO: ваш код
    ...


def backward(cache):
    """Обратный проход по графу: верните {"w": dL/dw, "b": dL/db, "x": dL/dx}.

    Идите от конца к началу: dL/da → dL/dz → dL/dw, dL/db, dL/dx.
    Каждый шаг — «градиент сверху» × локальная производная.
    """
    # TODO: ваш код
    ...


# ── Часть 2: ветвление  f(x, y) = (x + y) · x ─────────────────────────────

def grad_branch(x, y):
    """Верните (df/dx, df/dy) для f = q · x, где q = x + y.

    x используется в графе ДВАЖДЫ — градиенты по двум путям нужно СЛОЖИТЬ.
    """
    # TODO: ваш код
    ...


# ── Часть 3: два «слоя»  h = tanh(w1·x + b1),  out = w2·h + b2,  L = (out − y)² ──

def backward_two_layers(x, y, w1, b1, w2, b2):
    """Сделайте прямой проход, затем обратный. Верните {"w1": ..., "b1": ..., "w2": ..., "b2": ...}.

    Подсказка: tanh′(t) = 1 − tanh²(t).
    """
    # TODO: ваш код
    ...


# Проверьте себя кнопкой «Запустить»:
cache = forward(1.5, 2.0, -1.0, 1.0)
print(cache)                        # z = 2.0, a ≈ 0.8808, L ≈ 0.0142
print(backward(cache))              # w ≈ -0.03755, b ≈ -0.02503, x ≈ -0.05006
print(grad_branch(3.0, -1.0))       # (5.0, 3.0)
print(backward_two_layers(0.5, 1.0, 0.8, 0.1, 1.5, -0.2))

ЗапуститьПроверитьПодсказкаСбросить

Задание на бумаге (очень советуем). Нарисуйте граф для $L = (w_2 \cdot \mathrm{ReLU}(w_1 x + b_1) - y)^2$ при $x = 2$, $w_1 = -1$, $b_1 = 3$, $w_2 = 0.5$, $y = 2$. Выполните прямой и обратный проход и найдите производные по трём параметрам $w_1$, $b_1$ и $w_2$. Потом проверьте себя в PyTorch. Ответы для самопроверки: $L = 2.25$, $\frac{dL}{dw_2} = -3$, $\frac{dL}{dw_1} = -3$, $\frac{dL}{db_1} = -1.5$. А что случится с градиентами по $w_1$ и $b_1$, если взять $b_1 = 1$?

Китайский угол: динамический и статический граф

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

Два способа строить граф. В китайской документации и на форумах разработчиков постоянно встречаются слова «динамический граф» и «статический граф». PyTorch строит граф на лету, во время прямого прохода, как в нашем примере: удобно отлаживать и писать обычный Python с if и циклами. Статический граф сначала описывают целиком, а потом выполняют — его проще оптимизировать и переносить на специальное железо.

Китайские фреймворки глубокого обучения поддерживают оба режима. PaddlePaddle от Baidu, открытый в 2016 году, со второй версии по умолчанию работает в динамическом режиме и умеет переводить такой код в статический граф («из динамики в статику»). MindSpore от Huawei, открытый в 2020 году, имеет режимы PyNative (динамический) и Graph (статический); на нём обучают модели на китайских ускорителях Ascend. Сама математика внутри у всех одинаковая — цепное правило по графу из этого урока.

Что посмотреть. В «Погружении в глубокое обучение» раздел 4.7 «Прямое распространение, обратное распространение и вычислительные графы» рисует граф однослойной сети и объясняет, почему при обучении приходится хранить промежуточные значения. У Ли Хунъи в курсе машинного обучения 2016 года есть отдельная лекция «Backpropagation» (на китайском, на его YouTube-канале): тот же граф и то же правило «градиент сверху × локальная производная», хороший второй взгляд на тему.

Проверь себя

Проверь себя6 вопросов·

1 Найдите производную $h(x) = (2x + 1)^3$ в точке $x = 1$.

2 Узел умножения $u = w \cdot x$ при $w = 4$, $x = -2$ получил сверху градиент $\frac{dL}{du} = 0.5$. Чему равен $\frac{dL}{dw}$?

0.52−1−4

3 Для $f(x, y) = x \cdot y + x$ найдите $\frac{\partial f}{\partial x}$ в точке $x = 2$, $y = 5$.

4 Какие утверждения верны?Можно выбрать несколько ответов

Узел сложения передаёт градиент сверху всем своим входам без измененийОбратный проход даёт производные loss по всем параметрам за один проходДля обратного прохода промежуточные значения прямого прохода не нужныЕсли переменная используется в графе дважды, её градиенты по двум путям складываются

5 Производная сигмоиды не больше 0.25. Какова наибольшая возможная производная цепочки из 5 последовательных сигмоид? Ответ дайте десятичной дробью, округлив до пяти знаков после запятой.

6 Почему нейросети учат обратным, а не прямым режимом дифференцирования?

Прямой режим даёт неверные ответыВыход один (loss), а параметров миллиарды; обратный режим получает все производные за один проходОбратный режим не требует памятиТак исторически сложилось, разницы нет

Проверить ответы

Итоги

• Цепное правило: производная композиции — произведение производных звеньев, $\frac{dy}{dx} = \frac{dy}{du} \cdot \frac{du}{dx}$. В длинных цепочках множители меньше 1 дают исчезающий градиент.
• Вычислительный граф раскладывает функцию на элементарные операции. Прямой проход считает и запоминает значения, обратный идёт от loss к параметрам: градиент сверху × локальная производная.
• Шаблоны: «+» распределяет градиент, «×» умножает на другой вход, σ — на $a(1 - a)$, ReLU пропускает или блокирует.
• При ветвлении градиенты складываются (+=). Обратный режим даёт все производные за один проход ценой памяти на промежуточные значения.

Дальше: частные производные и градиент — как всё это выглядит для функций многих переменных и матриц, и откуда берётся формула $\frac{\partial L}{\partial W} = X^\top \frac{\partial L}{\partial Y}$.