Автоматическое дифференцирование

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

В прошлом уроке Value научился запоминать граф. Теперь научим его главному — самому считать производные. Мы напишем метод backward(). Вызовите его у результата, и в поле .grad каждого узла графа окажется $\partial L / \partial \text{узел}$. Это обратное распространение ошибкиобратное распространение ошибкиEN backpropagation из урока 3.1.2, но автоматический и для любого графа: хоть нейрон, хоть трансформер.

Механизм состоит из трёх идей. Каждая занимает несколько строк кода, и каждая встречается в PyTorch:

1. Локальная производная: каждая операция знает только свою производную.
2. Топологический порядок: узлы обходят от результата к листьям, причём каждый — только после всех его «потребителей».
3. Накопление (+=): если узел используется несколько раз, вклады складываются.

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

Возьмём выражение из видео Карпатого:

$$\begin{gathered} e = a \cdot b, \quad d = e + c, \quad L = d \cdot f, \\ a = 2,\ b = -3,\ c = 10,\ f = -2 \end{gathered}$$

Вперёд: $e = -6$, $d = 4$, $L = -8$. Назад идём от $L$, на каждом шаге умножая градиент сверху на локальную производную (цепное правилоцепное правилоEN chain ruleПроизводная композиции — произведение производных звеньев — (f(g(x)))′ = f′(g(x))·g′(x). Математическая основа backprop.):

Узел	Как считаем	grad
$L$	$\partial L / \partial L$	1
$f$	$\partial (d f) / \partial f = d$, умножить на 1	4
$d$	$\partial (d f) / \partial d = f$, умножить на 1	$-2$
$c$	сложение передаёт градиент как есть: $1 \cdot (-2)$	$-2$
$e$	то же самое	$-2$
$a$	$\partial (a b) / \partial a = b$, умножить на $-2$	6
$b$	$\partial (a b) / \partial b = a$, умножить на $-2$	$-4$

Проверим смысл одного числа. $a.\text{grad} = 6$ означает, что при $a = 2.001$ значение $L$ вырастет примерно на $0.006$. Так и есть: $L = (2.001 \cdot (-3) + 10) \cdot (-2) = -7.994$.

Локальная производная: каждый узел знает только себя

Заметьте: чтобы посчитать градиент узла, нужны только градиент результата (out.grad) и локальная производная операции. Остальной граф не важен. Поэтому каждая операция может сама сказать, как распределить градиент между своими входами:

Операция	Вперёд	Что добавить к градиентам входов
сложение	$a + b$	$a$: out.grad, $b$: out.grad
умножение	$a \cdot b$	$a$: b.data * out.grad, $b$: a.data * out.grad
степень	$x^k$	$k\, x^{k-1} \cdot$ out.grad
tanh	$t = \tanh x$	$(1 - t^2) \cdot$ out.grad
exp	$e^x$	$e^x \cdot$ out.grad (это уже out.data)
ReLU	$\max(0, x)$	out.grad, если $x > 0$, иначе 0

Полезные метафоры из курса CS231n: сложение раздаёт градиент обоим входам без изменений, умножение меняет местами: вход $a$ получает градиент, умноженный на $b$, и наоборот. ReLU — маршрутизатор: пропускает градиент только через активный вход.

Код: замыкание _backward

Каждая операция при создании результата кладёт в него маленькую функцию _backward. Она умеет передать out.grad своим детям — входам операции:

    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 tanh(self):
        t = math.tanh(self.data)
        out = Value(t, (self,), "tanh")

        def _backward():
            self.grad += (1 - t**2) * out.grad

        out._backward = _backward
        return out

_backward — это замыкание (closure) из урока 0.2.2: функция, которая «захватила» переменные self, other, out и t из места, где её создали. Вызовем её через сто строк кода, а она всё ещё будет знать, чьи градиенты обновлять. Обратите внимание: строка out._backward = _backward функцию не вызывает (скобок нет), а только кладёт её в поле узла — «на потом». У листьев _backward пустой (lambda: None — функция, которая ничего не делает): передавать градиент им некому.

Сверим код с таблицей на примере $c = a \cdot b$ при $a = 5$, $b = -2$. Пусть к моменту вызова c._backward() в c.grad лежит 4. Тогда к a.grad прибавится b.data * c.grad $= -2 \cdot 4 = -8$, а к b.grad — a.data * c.grad $= 5 \cdot 4 = 20$.

Почему внутри +=, а не =, — главный вопрос урока. Ответим на него ниже.

В каком порядке обходить граф

У узла $n$ нельзя вызвать _backward, пока в n.grad не собрались вклады от всех узлов, которые используют $n$. Иначе узел передаст дальше неполный градиент.

Простой обход «в ширину» — по уровням: сначала корень, потом все его дети, потом дети детей и так далее — эту гарантию не даёт. Пример: $x = 3$, $a = x^2$ и

$$L = 3 \cdot (2a) + a = 7a, \qquad \frac{\partial L}{\partial a} = 7, \qquad \frac{\partial L}{\partial x} = 7 \cdot 2x = 42$$

flowchart LR
x["x = 3"] --> a(("a = x·x"))
a --> m2(("·2"))
m2 --> m3(("·3"))
m3 --> L(("+ = L"))
a --> L

Узел a нужен двум операциям: короткий путь в L напрямую и длинный — через ·2 и ·3

Обход в ширину от $L$ дойдёт до $a$ по короткому пути раньше, чем по длинному. В этот момент в $a$ лежит только вклад 1 из 7. Если сразу вызвать a._backward(), то $x$ получит $1 \cdot 2x = 6$ вместо $7 \cdot 2x = 42$, а поздний вклад 6 так и останется в a.grad, не дойдя до $x$.

Решение — топологическая сортировкатопологическая сортировкаEN topological sortПорядок узлов ориентированного графа без циклов, в котором каждый узел идёт после всех, от кого зависит. backward() обходит его в обратную сторону.: упорядочить узлы так, чтобы каждый шёл после всех своих детей. Бытовая аналогия — порядок одевания: носки раньше ботинок, рубашка раньше пиджака. Любой список, где каждая вещь стоит после всего, что надевается под неё, — топологический порядок. Если пройти такой список задом наперёд, получится «от результата к листьям, и потребители всегда раньше». Строится он тем же обходом в глубину, что trace из прошлого урока, с одним отличием: узел добавляется в список, только когда добавлены все его дети.

    def backward(self):
        topo, visited = [], set()

        def build(v):
            if v not in visited:
                visited.add(v)
                for child in v._prev:
                    build(child)
                topo.append(v)        # v попадает в список ПОСЛЕ всех своих детей

        build(self)
        self.grad = 1.0               # dL/dL = 1
        for v in reversed(topo):      # от корня к листьям
            v._backward()

Для примера выше (не считая листьев-констант 2 и 3) topo будет таким: [x, a, ·2, ·3, L]. Задом наперёд: $L$, $\cdot 3$, $\cdot 2$, $a$, $x$. Проследим градиенты по этому порядку:

Шаг	Вызываем _backward у	Что происходит	Градиенты после шага
1	$L = (\cdot 3) + a$	сложение раздаёт 1 обоим входам	(·3).grad = 1, a.grad = 1
2	$\cdot 3$	умножение на 3	(·2).grad = 3
3	$\cdot 2$	умножение на 2	a.grad = 1 + 6 = 7
4	$a = x \cdot x$	$x$ — оба входа умножения: $3 \cdot 7 + 3 \cdot 7$	x.grad = 42

К моменту обработки $a$ (шаг 4) оба вклада, 1 и 6, уже на месте, и $x$ получает правильные 42.

Глубокие графы и RecursionError (можно пропустить при первом чтении)

Глубина рекурсии в build равна глубине графа. У Python предел около 1000 вложенных вызовов (урок 0.2.2), поэтому цепочка из 3000 операций упадёт с RecursionError. Настоящие сети с длинными графами (особенно скалярные, как наша) требуют обхода без рекурсии. Вместо того чтобы вызывать функцию из функции, держим список «дел» — стек: берём последнее дело, а новые кладём в конец. Для заданий этого модуля хватит рекурсивной версии, а эту прочитайте для общего развития:

def topo_order(root):
    topo, visited, stack = [], set(), [(root, False)]
    while stack:
        v, children_done = stack.pop()
        if children_done:
            topo.append(v)               # все дети уже в списке — можно добавить и узел
        elif v not in visited:
            visited.add(v)
            stack.append((v, True))      # вернёмся к v, когда обработаем детей
            for child in v._prev:
                stack.append((child, False))
    return topo

Порядок получается тот же — «узел после детей», но глубина ограничена только памятью. Другой способ без рекурсии — алгоритм Кана: очередь и счётчики входящих рёбер. Он заодно находит циклы в графе, и его часто просят написать на собеседовании (урок 11.3.5).

Накопление градиентов: почему +=

Вернёмся к +=. Возьмём самый короткий пример: $b = a + a$. Производная $\partial b / \partial a = 2$. Посмотрим, что делает _backward сложения, где self и other — один и тот же объект a:

self.grad = out.grad    # a.grad = 1
other.grad = out.grad   # a.grad = 1 — перезаписали! Ответ 1 вместо 2

С += получается $0 + 1 + 1 = 2$. Это не трюк, а многомерное цепное правило: если величина влияет на результат по нескольким путям, её производная — сумма производных по всем путям:

$$\frac{\partial L}{\partial a} = \sum_{\text{пути } a \to L} \prod_{\text{рёбра на пути}} (\text{локальная производная})$$

Читается так: перечислите все пути по стрелкам от $a$ до $L$; вдоль каждого пути перемножьте локальные производные ($\prod$ — знак произведения из урока 1.0.3); сложите результаты по всем путям ($\sum$).

Это то же правило ветвления, что в уроке 1.2.2: там вы складывали вклады двух веток руками, а теперь это делает +=. В примере с $x^2$ это $1 + 2 \cdot 3 = 7$. Карпатый в видео сначала пишет = и ловит ровно этот баг на a + a. Это хорошее напоминание: автоград из двадцати строк легко сделать почти правильным.

Накопление градиентовнакопление градиентовEN gradient accumulationГрадиенты складываются (+=), а не перезаписываются. Внутри графа так учитываются все пути к узлу; на уровне обучения — шаг оптимизатора делают раз в несколько микробатчей. — не экзотика. В нейросетях узлы, которые используются многократно, повсюду:

• Веса и батч. Одна матрица $W$ применяется к каждому примеру батча. Её градиент — сумма вкладов примеров. Поэтому в уроке 3.1.2 получилось $dW = X^\top dY$: матричное умножение суммирует по примерам.
• Позиции в трансформере. Одни и те же $W_Q$, $W_K$, $W_V$ и веса FFN применяются к каждому токену последовательности. Градиент собирается со всех позиций.
• Остаточные связи. В $y = x + \mathrm{Block}(x)$ вход $x$ идёт по двум путям, и градиент к нему приходит по обоим (урок 3.4).
• Общие эмбеддинги. Одна матрица служит и входным слоем, и выходным (китайский угол ниже).

Обратная сторона: градиенты надо обнулять

+= означает, что .grad копит всё, что в него когда-либо добавили. В PyTorch то же самое: .grad листьев накапливается от вызова к вызову. Посмотрим на это в PyTorch (подробно он будет в модуле 3.3; если он ещё не установлен, просто сверьте код с выводом под ним):

import torch

a = torch.tensor(3.0, requires_grad=True)
(a + a).backward()
print(a.grad.item())                 # 2.0 — PyTorch тоже складывает вклады

a = torch.tensor(3.0, requires_grad=True)
y = a * a
y.backward(retain_graph=True)
y.backward()
print(a.grad.item())                 # 6 + 6 = 12, а не 6

try:                                 # try/except ловит ошибку (урок 0.2.4), чтобы показать её текст
    z = torch.tanh(a)
    z.backward()
    z.backward()                     # граф уже освобождён
except RuntimeError as err:
    print(str(err).split("(")[0].strip())   # печатаем только начало длинного сообщения

2.0
12.0
Trying to backward through the graph a second time

Поэтому в цикле обучения перед каждым backward() градиенты обнуляют (zero_grad). Иначе шаг делается по сумме градиентов всех прошлых шагов. Этим займёмся в следующем уроке. Заодно видно отличие от micrograd: PyTorch после backward() освобождает граф. Хотите пройти его второй раз — попросите retain_graph=True.

Проверяем автоград

Соберём сигмоиду из примитивов — exp, +, ** и умножения на $-1$ — и сверим автоград с формулой $\sigma'(z) = \sigma(z)(1 - \sigma(z))$ из уроков 1.2.1 и 2.2. Для этого кода нужен класс Value с методом backward() — его вы допишете в задании ниже, так что вернитесь сюда после практики:

w, x, b = Value(1.5), Value(-2.0), Value(0.5)
z = w * x + b                     # z = −2.5
s = 1 / (1 + (-z).exp())          # сигмоида, собранная из примитивов
s.backward()
print(f"s = {s.data:.4f}")
print(f"autograd: ds/dw = {w.grad:.4f}")
print(f"формула σ(1 − σ)·x = {s.data * (1 - s.data) * x.data:.4f}")

s = 0.0759
autograd: ds/dw = -0.1402
формула σ(1 − σ)·x = -0.1402

Автоград прошёл через семь операций (умножение, сложение, минус — то есть умножение на $-1$, exp, ещё сложение, степень $-1$ и умножение на 1 из __rtruediv__) и получил то же число, что аналитическая формула. Мы не писали правило для сигмоиды: оно само сложилось из локальных правил. В этом сила автограда. Сверка с PyTorch на нейроне из прошлого урока:

import torch

x1 = torch.tensor(2.0, dtype=torch.float64, requires_grad=True)
x2 = torch.tensor(0.0, dtype=torch.float64, requires_grad=True)
w1 = torch.tensor(-3.0, dtype=torch.float64, requires_grad=True)
w2 = torch.tensor(1.0, dtype=torch.float64, requires_grad=True)
b = torch.tensor(6.8813735870195432, dtype=torch.float64, requires_grad=True)
o = torch.tanh(x1 * w1 + x2 * w2 + b)
o.backward()
print([round(t.grad.item(), 4) for t in (x1, w1, x2, w2, b)])

[-1.5, 1.0, 0.5, 0.0, 0.5]

Ровно те числа, которые даст ваш Value после задания. Сверьте: $1 - o^2 = 1 - 0.5 = 0.5$ — это градиент $n$ и $b$. Дальше умножения меняют местами: $x_1$ получает $w_1 \cdot 0.5 = -1.5$, а $w_1$ получает $x_1 \cdot 0.5 = 1$. У $w_2$ градиент ноль, потому что $x_2 = 0$: вес, умноженный на нулевой вход, на выход не влияет.

Практика

Допишите локальные производные для *, **, tanh, exp, relu и метод backward(). Сложение дано как образец. Тесты проверят нейрон из урока, повторное использование узлов, порядок обхода на примере с $x^2$, численные производные и длинную цепочку из 200 операций.

Каждое _backward — одна-две строки по таблице «Локальная производная». Шаблон всегда один: вход.grad += (локальная производная) * out.grad. Кнопка «Запустить» печатает градиенты нейрона из урока; правильный ответ: x1 -1.5, w1 1.0, x2 0.5, w2 0.0, b 0.5.

backward(): автоматическое дифференцирование8 тестов

import math


class Value:
    def __init__(self, data, _children=(), _op=""):
        self.data = data
        self.grad = 0.0
        self._backward = lambda: None   # у листьев нечего распространять
        self._prev = set(_children)
        self._op = _op

    def __repr__(self):
        return f"Value(data={self.data}, grad={self.grad})"

    def __add__(self, other):
        other = other if isinstance(other, Value) else Value(other)
        out = Value(self.data + other.data, (self, other), "+")

        def _backward():
            # готовый образец: сложение «раздаёт» out.grad обоим слагаемым.
            # Обратите внимание: +=, а не = (узел может участвовать в графе несколько раз)
            self.grad += out.grad
            other.grad += 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():
            # TODO: d(a·b)/da = b, d(a·b)/db = a; умножьте на out.grad и накопите в self.grad и other.grad
            pass

        out._backward = _backward
        return out

    def __pow__(self, k):
        out = Value(self.data**k, (self,), f"**{k}")

        def _backward():
            # TODO: d(x^k)/dx = k · x^(k−1)
            pass

        out._backward = _backward
        return out

    def tanh(self):
        t = math.tanh(self.data)
        out = Value(t, (self,), "tanh")

        def _backward():
            # TODO: d tanh(x)/dx = 1 − tanh(x)², значение tanh уже лежит в t
            pass

        out._backward = _backward
        return out

    def exp(self):
        out = Value(math.exp(self.data), (self,), "exp")

        def _backward():
            # TODO: (e^x)' = e^x — и оно уже посчитано в out.data
            pass

        out._backward = _backward
        return out

    def relu(self):
        out = Value(self.data if self.data > 0 else 0.0, (self,), "relu")

        def _backward():
            # TODO: градиент проходит, только если вход был > 0
            pass

        out._backward = _backward
        return out

    def backward(self):
        """Обратный проход от этого узла (корня, обычно loss).

        1) Постройте топологический порядок: рекурсивно обойдите детей (v._prev)
           и добавляйте узел в список ПОСЛЕ всех его детей; посещённые храните в set.
        2) Положите self.grad = 1.0.
        3) Пройдите список в обратном порядке и у каждого узла вызовите v._backward().
        """
        # TODO: ваш код
        pass

    # Производные операции — через уже готовые (здесь ничего менять не нужно)
    def __neg__(self):
        return self * -1

    def __radd__(self, other):
        return self + other

    def __sub__(self, other):
        return self + (-other)

    def __rsub__(self, other):
        return other + (-self)

    def __rmul__(self, other):
        return self * other

    def __truediv__(self, other):
        return self * other**-1

    def __rtruediv__(self, other):
        return other * self**-1


# Проверьте себя кнопкой «Запустить». Ожидается: x1 -1.5, w1 1.0, x2 0.5, w2 0.0, b 0.5
x1, x2, w1, w2 = Value(2.0), Value(0.0), Value(-3.0), Value(1.0)
b = Value(6.8813735870195432)
o = (x1 * w1 + x2 * w2 + b).tanh()
o.backward()
print(f"o = {o.data:.4f}")
for name, v in [("x1", x1), ("w1", w1), ("x2", x2), ("w2", w2), ("b", b)]:
    print(name, round(v.grad, 4))

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

Китайский угол: += в настоящих моделях

Правило «узел используется дважды — градиенты складываются» работает в китайских LLM в полный рост.

Общие эмбеддинги в маленьких Qwen. Матрица эмбеддингов $V \times d$ огромна: у Qwen3-0.6B это 152 тыс. × 1024 ≈ 156 млн параметров — четверть модели. Поэтому в маленьких моделях её используют дважды: на входе (токен → вектор) и на выходе как LM head (вектор → логиты). Это связывание весовсвязывание весов (общие эмбеддинги входа и выхода)EN weight tying (tied embeddings)Одна и та же матрица служит эмбеддингом токенов и LM head. Её градиент — сумма вкладов от обоих мест. В Hugging Face — флаг tie_word_embeddings., в конфиге Qwen3-0.6B стоит tie_word_embeddings: true. Её градиент — сумма вкладов от входа и от выхода, ровно += из этого урока. В больших моделях семейства матрицы раздельные: там лишние сотни миллионов параметров не так заметны.

Общая голова MTP в DeepSeek-V3. В V3 (arXiv:2412.19437) к основной модели добавлен модуль Multi-Token Prediction: он учится предсказывать токен на шаг дальше. Эмбеддинги и выходная голова у MTP-модуля и основной модели общие. В разделе об экономии памяти авторы пишут, что размещают их на одном и том же этапе конвейерного параллелизма, чтобы физически делить и параметры, и градиенты. Градиент общей головы складывается из двух loss — основного и MTP.

Накопление на уровне обучения. Тот же += используют, когда батч не помещается в память. Батч режут на несколько маленьких кусков — микробатчей. Делают прямой и обратный проход по каждому из них, не обнуляя градиенты, и только потом один шаг оптимизатора. В LLaMA-Factory (китайский фреймворк дообучения, ступень 6) это параметр gradient_accumulation_steps. В скриптах MiniMind — тоже накопление на несколько шагов перед optimizer.step(). На вашей машине с 4 × RTX 4080 это будет главный способ получить «большой» батч при дообучении моделей на 7–14B.

Термины. Автоматическое дифференцирование, обратный режим, топологическая сортировка и накопление градиентов по-китайски называются дословно. Для общих весов есть два слова: «разделяемые веса» и «связывание весов» (weight tying).

Проверь себя

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

1 c = a * b, где a.data = 4, b.data = −2, и к моменту вызова c._backward() в c.grad лежит 3. Что добавится к a.grad?

2 o = n.tanh(), o.data = 0.6, o.grad = 2. На сколько увеличится n.grad?

3 $x = 3$, y = x * x + x. Чему равен x.grad после y.backward()?

4 Почему _backward узлов нельзя вызывать в произвольном порядке?

Узел должен получить вклады от всех своих потребителей, прежде чем передавать градиент дальшеPython запрещает вызывать замыкания не в порядке созданияИначе граф станет циклическимПорядок влияет только на скорость, а не на результат

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

backward() кладёт в корень grad = 1, потому что $\partial L / \partial L = 1$Если в _backward написать = вместо +=, ошибка проявится только там, где узел используется больше одного разаПовторный backward() в PyTorch без обнуления перезаписывает .grad листьев новым значениемГрадиент весов по батчу — сумма вкладов примеров, потому что один вес используется в каждом примере

6 Почему рекурсивная топологическая сортировка падает на цепочке из 3000 операций?

Глубина рекурсии равна глубине графа и превышает предел Python (около 1000)В графе появляется циклНе хватает памяти под градиентыТопологическая сортировка не определена для длинных цепочек

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

Итоги

• Каждая операция знает только свою локальную производную и хранит её в замыкании _backward. Сложение раздаёт градиент, умножение меняет местами, tanh масштабирует на $1 - t^2$.
• backward(): топологическая сортировка, затем grad = 1 в корне и _backward() у узлов в обратном порядке. Так каждый узел передаёт дальше полный градиент.
• += — это многомерное цепное правило: вклады всех путей складываются. Отсюда суммы по батчу, по позициям, по двум ветвям остаточной связи и по двум ролям общих эмбеддингов.
• Обратная сторона +=: .grad копит всё, поэтому перед каждым обратным проходом его обнуляют. PyTorch ведёт себя так же.

Дальше: соберём из Value нейрон, слой и MLP, напишем цикл обучения с zero_grad и научим сеть различать две «луны» с точностью выше 95%.