Частные производные и градиент

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

Loss языковой модели зависит не от одного числа, а от миллиардов. Значит, нужна производная по каждому из них. Все эти производные вместе — градиентградиентEN gradientВектор всех частных производных ∇f. Указывает направление наискорейшего роста функции; его длина — крутизна склона.. Это вектор, а для матрицы весов — матрица той же формы, что и сами веса. Каждый шаг оптимизатора — от простого градиентного спуска до AdamW и Muon — начинается с градиента.

В прошлом уроке мы прогнали обратный проход для скаляров. Теперь поднимемся на уровень векторов и матриц — именно в таком виде backprop работает в настоящих сетях. Главный результат урока — формула градиента линейного слоя, через который проходит почти вся «тяжёлая» работа модели. А в конце научимся проверять любой градиент численно: это главный инструмент отладки всего, что вы будете писать руками на ступенях 3–5.

Функции многих переменных

Функция $f(x, y) = x^2 + 3y^2$ принимает две переменные и возвращает одно число. Её удобно представлять как рельеф: точка $(x, y)$ — место на карте, $f(x, y)$ — высота. Как на топографической карте, рельеф рисуют линиями уровня — кривыми, вдоль которых высота одинакова. У нашей функции это вытянутые эллипсы вокруг минимума в точке $(0, 0)$.

Loss нейросети — такой же рельеф, только «карта» имеет не два измерения, а миллиарды. Обучение — это спуск в низину по этому рельефу. Нарисовать его нельзя, но вся математика работает так же, как на плоскости.

Частные производные

Как изменится высота, если шагнуть только вдоль оси $x$, не трогая $y$? Это частная производнаячастная производнаяEN partial derivative∂f/∂x — производная функции многих переменных по одной из них, когда остальные заморожены. по $x$: все остальные переменные замораживаем и дифференцируем как обычно.

$$\frac{\partial f}{\partial x} = \lim_{h \to 0} \frac{f(x + h, y) - f(x, y)}{h}$$

Значок $\partial$ («дэ круглое») напоминает, что переменных несколько. Пример: $f(x, y) = x^2 + 3xy$ в точке $(1, 2)$.

• По $x$ (считаем $y$ числом): $\frac{\partial f}{\partial x} = 2x + 3y = 2 + 6 = 8$. Почему $3y$: при замороженном $y = 2$ слагаемое $3xy$ — это просто $6x$, прямая с наклоном 6, то есть $3y$.
• По $y$ (считаем $x$ числом): $\frac{\partial f}{\partial y} = 3x = 3$. Слагаемое $x^2$ от $y$ не зависит — для $y$ это константа, её производная 0 (урок 1.2.1).

Численная проверка — та же центральная разность, только шевелим одну переменную:

f = lambda x, y: x ** 2 + 3 * x * y
h = 1e-5
print((f(1 + h, 2) - f(1 - h, 2)) / (2 * h))   # ≈ 8.000000000008 — двигаем только x
print((f(1, 2 + h) - f(1, 2 - h)) / (2 * h))   # ≈ 3.000000000064 — двигаем только y

Градиент: куда круче всего вверх

Соберём все частные производные в вектор — это и есть градиент:

$$\nabla f = \left( \frac{\partial f}{\partial x_1}, \; \frac{\partial f}{\partial x_2}, \; \dots, \; \frac{\partial f}{\partial x_n} \right)$$

Значок $\nabla$ называют «набла». Для $f(x, y) = x^2 + 3y^2$ градиент $\nabla f = (2x, 6y)$, в точке $(1, 1)$ это $(2, 6)$. У градиента та же форма, что у входа: если вход — матрица $4096 \times 4096$, градиент — тоже матрица $4096 \times 4096$. В PyTorch w.grad всегда имеет форму w.

Почему именно «наискорейший подъём»

Шагнём из точки на маленькое расстояние $\varepsilon$ в направлении единичного вектора $\mathbf{u} = (u_1, u_2)$. Такой шаг — это сдвиг на $\varepsilon u_1$ по оси $x$ и на $\varepsilon u_2$ по оси $y$. Сдвиг по $x$ меняет высоту примерно на $\frac{\partial f}{\partial x} \cdot \varepsilon u_1$ (производная — «курс обмена» из урока 1.2.1), сдвиг по $y$ — на $\frac{\partial f}{\partial y} \cdot \varepsilon u_2$, а при маленьком шаге эти вклады просто складываются. Итого высота изменится примерно на $\varepsilon \cdot (\nabla f \cdot \mathbf{u})$ — скалярное произведение градиента на направление. Величину $\nabla f \cdot \mathbf{u}$ называют производной по направлениюпроизводная по направлениюEN directional derivativeСкорость изменения функции при движении в направлении единичного вектора u — равна скалярному произведению ∇f · u.. В точке $(1, 1)$ с $\nabla f = (2, 6)$ сравним несколько направлений. Единичный вектор вдоль градиента получаем нормировкой из урока 1.1.1: длина $(2, 6)$ равна $\sqrt{40} \approx 6.32$, и $(2, 6) / 6.32 \approx (0.316, 0.949)$.

Направление $\mathbf{u}$	$\nabla f \cdot \mathbf{u}$	Что происходит
вдоль оси $x$: $(1, 0)$	2	подъём, но пологий
вдоль градиента: $(0.316, 0.949)$	6.32	самый крутой подъём
перпендикулярно: $(-0.949, 0.316)$	0	идём по линии уровня — высота не меняется
против градиента: $(-0.316, -0.949)$	−6.32	самый крутой спуск

Объяснение — из урока 1.1.1: $\nabla f \cdot \mathbf{u} = \lVert \nabla f \rVert \cos\theta$. Косинус максимален, когда угол $\theta = 0$, то есть когда мы идём вдоль градиента. Отсюда три свойства:

1. Градиент указывает направление наискорейшего роста функции.
2. Его длина $\lVert \nabla f \rVert$ — крутизна склона в этом направлении (здесь $\sqrt{4 + 36} \approx 6.32$).
3. Градиент перпендикулярен линиям уровня: вдоль линии уровня высота не меняется, производная по направлению равна 0.

Карта высот f(x, y) = x² + 3y²: эллипсы — линии уровня (подписаны значения f). Градиент указывает «в гору» поперёк линий уровня; спуск идёт против него и быстрее всего гасит крутую координату y.

Градиентный спуск на плоскости

Чтобы спуститься, шагаем против градиента: $\boldsymbol{\theta} \leftarrow \boldsymbol{\theta} - \eta \nabla L(\boldsymbol{\theta})$. Для нашей функции с $\eta = 0.1$ шаг даёт $x \leftarrow x - 0.1 \cdot 2x = 0.8x$ и $y \leftarrow y - 0.1 \cdot 6y = 0.4y$. Крутая координата $y$ за шаг сжимается в 2.5 раза, а пологая $x$ — всего в 1.25 раза, и путь на рисунке сначала «падает» на дно оврага, а потом медленно ползёт вдоль него. На вытянутых «оврагах» простой спуск неэффективен — это мотивация для Momentum и Adam (урок 1.4.2).

Якобиан — интуитивно

До сих пор функция выдавала одно число. А слой нейросети превращает вектор в вектор: $\mathbf{y} = F(\mathbf{x})$, $\mathbf{x} \in \mathbb{R}^n$, $\mathbf{y} \in \mathbb{R}^m$. Теперь у каждого выхода есть производная по каждому входу — получается таблица $m \times n$. Это матрица Якобиматрица Якоби (якобиан)EN Jacobian matrixТаблица всех частных производных векторной функции — ∂yᵢ/∂xⱼ. Для y = Wx якобиан равен самой матрице W., или якобиан:

$$J_{ij} = \frac{\partial y_i}{\partial x_j}$$

Пример с числами: $F(x_1, x_2) = (x_1 x_2, \; x_1 + 3x_2)$ в точке $(2, 1)$. Первая строка якобиана — частные производные первого выхода: $\frac{\partial (x_1 x_2)}{\partial x_1} = x_2 = 1$ и $\frac{\partial (x_1 x_2)}{\partial x_2} = x_1 = 2$. Вторая строка — производные второго выхода: 1 и 3. Итого $J = \begin{pmatrix} 1 & 2 \\ 1 & 3 \end{pmatrix}$: строка — выход, столбец — вход.

Два важных примера:

• Линейный слой $\mathbf{y} = W\mathbf{x}$. Поскольку $y_i = \sum_j W_{ij} x_j$, производная $\frac{\partial y_i}{\partial x_j} = W_{ij}$. Якобиан линейного преобразования — сама матрица $W$. Логично: линейная функция везде имеет один и тот же «наклон».
• Поэлементная функция, например ReLU. Выход $y_i$ зависит только от $x_i$, поэтому якобиан диагональный: на диагонали $1$ там, где $x_i > 0$, и $0$ в остальных местах.

Цепное правило для векторов звучит знакомо: якобиан композиции — произведение якобианов. Композиция функций ↔ умножение матриц — та же связь, что в уроке 1.1.2.

Почему якобиан никогда не строят целиком

Возьмём батч из 1000 токенов с векторами размерности 4096 — всего 4.1 млн чисел на входе и столько же на выходе слоя. Якобиан такого слоя — таблица $4.1\,\text{млн} \times 4.1\,\text{млн} \approx 1.7 \cdot 10^{13}$ чисел. Это десятки терабайт на один слой.

Спасает то, что loss — одно число. На обратном проходе к слою приходит не якобиан, а вектор $\mathbf{g} = \frac{\partial L}{\partial \mathbf{y}}$ той же формы, что $\mathbf{y}$. Слою нужно лишь вычислить $\mathbf{g}^\top J$ — произведение вектора на якобиан. Для ReLU это поэлементное умножение на маску из нулей и единиц, для линейного слоя — умножение на $W^\top$. Ни одна огромная матрица не появляется. Именно эту операцию — «вектор на якобиан» — реализует каждый узел autograd.

Градиент матричного умножения

Теперь главная формула урока. Линейный слой на батче (урок 1.1.2):

$$Y = XW + \mathbf{b}, \qquad X \in \mathbb{R}^{B \times n}, \; W \in \mathbb{R}^{n \times m}, \; Y \in \mathbb{R}^{B \times m}$$

Читаем: батч $X$ — $B$ примеров по $n$ признаков, матрица весов $W$ превращает $n$ входов в $m$ выходов, получается $Y$ — $B$ строк по $m$ чисел. Обратите внимание: здесь для простоты веса хранятся как $(n \times m)$, то есть (in, out), и транспонирования в формуле нет. В nn.Linear из урока 1.1.2 веса лежат наоборот, (out, in), — как это меняет формулы, покажем в конце раздела.

Сверху, из следующих слоёв, пришёл градиент $G = \frac{\partial L}{\partial Y}$ — матрица формы $B \times m$. Нужно найти градиенты по весам, по входу (чтобы передать дальше вниз) и по сдвигу:

$$\boxed{\;\frac{\partial L}{\partial W} = X^\top G, \qquad \frac{\partial L}{\partial X} = G\,W^\top, \qquad \frac{\partial L}{\partial \mathbf{b}} = \sum_{\text{строки}} G\;}$$

Что	Форма	Градиент	Как считается	Форма градиента
вход $X$	$B \times n$	$\partial L / \partial X$	$G W^\top$: $(B \times m)(m \times n)$	$B \times n$ — уходит в предыдущий слой
веса $W$	$n \times m$	$\partial L / \partial W$	$X^\top G$: $(n \times B)(B \times m)$	$n \times m$ — идёт в оптимизатор
сдвиг $\mathbf{b}$	$m$	$\partial L / \partial \mathbf{b}$	сумма строк $G$	$m$ — идёт в оптимизатор

Обратите внимание на последний столбец: форма каждого градиента совпадает с формой того, по чему его берут.

Вывод по элементам

Здесь много индексов. Если при первом чтении они пугают, перейдите к «Мнемонике» и «Примеру с числами» ниже, а сюда вернитесь потом: вывод нужен, чтобы понять, откуда формула, а пользоваться ей можно и без него.

Запишем один элемент выхода: $Y_{bj} = \sum_i X_{bi} W_{ij} + b_j$. Индексы: $b$ — номер примера в батче, $i$ — номер входа, $j$ — номер выхода. (Буква $b$ здесь работает дважды: в индексе это номер примера, а $b_j$ — сдвиг $j$-го выхода. Так пишут во многих статьях — смысл подсказывает место буквы.) Вес $W_{ij}$ участвует в элементах $Y_{bj}$ всех примеров батча $b$ (с тем же $j$), и каждый раз с множителем $X_{bi}$. Это ветвление из прошлого урока: вклады всех путей складываются:

$$\frac{\partial L}{\partial W_{ij}} = \sum_{b} \frac{\partial L}{\partial Y_{bj}} \cdot \frac{\partial Y_{bj}}{\partial W_{ij}} = \sum_b G_{bj} X_{bi} = (X^\top G)_{ij}$$

Так же для входа: $X_{bi}$ участвует во всех $Y_{bj}$ своей строки с множителями $W_{ij}$, поэтому $\frac{\partial L}{\partial X_{bi}} = \sum_j G_{bj} W_{ij} = (G W^\top)_{bi}$. А сдвиг $b_j$ прибавляется к каждой строке — его градиент равен сумме столбца $j$ матрицы $G$ по всему батчу.

Мнемоника «по формам»

Формулу легко восстановить, даже если вы её забыли. Градиент по $W$ обязан иметь форму $W$, то есть $n \times m$. Под рукой есть $X$ ($B \times n$) и $G$ ($B \times m$). Перемножить их так, чтобы получилось $n \times m$, можно единственным способом: $X^\top G$. Для $\frac{\partial L}{\partial X}$ ($B \times n$) из $G$ ($B \times m$) и $W$ ($n \times m$) получается только $G W^\top$.

Где мнемоника врёт

Если все размеры одинаковые (квадратные матрицы, $B = n = m$), «подходят по формам» сразу несколько неверных вариантов: $G X^\top$, $X G^\top$, $G^\top X$. Ошибки не будет — будет неверный градиент и модель, которая плохо учится. Поэтому в тестах всегда берите разные размеры, а любой написанный руками backward проверяйте численно (ниже).

Пример с числами

Пусть $X = \begin{pmatrix} 1 & 2 \\ 3 & 4 \end{pmatrix}$ (2 примера по 2 признака), $W = \begin{pmatrix} 1 & 0 & -1 \\ 2 & 1 & 0 \end{pmatrix}$, а $L$ — просто сумма всех элементов $Y$. Тогда каждый элемент $Y$ входит в $L$ с коэффициентом 1, и $G$ — матрица из единиц формы $2 \times 3$:

$$\frac{\partial L}{\partial W} = X^\top G = \begin{pmatrix} 4 & 4 & 4 \\ 6 & 6 & 6 \end{pmatrix}, \quad \frac{\partial L}{\partial X} = G W^\top = \begin{pmatrix} 0 & 3 \\ 0 & 3 \end{pmatrix}, \quad \frac{\partial L}{\partial \mathbf{b}} = (2, 2, 2)$$

Смысл каждого числа можно проверить «на пальцах». Вес $W_{1j}$ умножается на первый признак обоих примеров, $1 + 3 = 4$. Признак $X_{b1}$ умножается на первую строку $W$, сумма которой $1 + 0 - 1 = 0$. Сдвиг прибавлен к двум строкам — отсюда 2.

Градиент одного примера — матрица ранга 1

Если в батче один пример ($B = 1$), то $X$ — это одна строка $\mathbf{x}$ ($1 \times n$), а $G$ — строка $\mathbf{g}$ ($1 \times m$). Тогда $X^\top G = \mathbf{x}^\top \mathbf{g}$ — столбец на строку, внешнее произведение. По уроку 1.1.3 это матрица ранга 1. Градиент по батчу из $B$ примеров — сумма $B$ таких слоёв, его ранг не больше $B$.

В настоящем обучении в батче миллионы токенов, и граница «ранг не больше $B$» уже ничего не ограничивает: формально градиент может иметь полный ранг. Но на практике в градиенте матрицы весов обычно доминируют немногие направления: несколько первых сингулярных чисел (урок 1.1.3) намного больше остальных. Поэтому к градиенту полезно относиться именно как к матрице — так делает, например, оптимизатор Muon (о нём — в «Китайском угле» ниже).

В PyTorch: веса хранятся транспонированными

nn.Linear хранит веса в форме (out, in) и считает $Y = XW^\top + \mathbf{b}$ (урок 1.1.2). Тогда та же логика даёт weight.grad $= G^\top X$ формы (out, in). Проверим:

import torch

torch.manual_seed(0)
layer = torch.nn.Linear(3, 2)                 # веса (out, in) = (2, 3)
X = torch.randn(4, 3)                         # батч из 4 примеров
Y = layer(X)                                  # Y = X @ W.T + b, форма (4, 2)
G = torch.randn(4, 2)                         # пусть dL/dY = G (как будто пришло сверху)
L = (Y * G).sum()                             # такая L даёт ровно dL/dY = G
L.backward()

print(torch.allclose(layer.weight.grad, G.T @ X))   # True: для весов (out, in) это Gᵀ X
print(torch.allclose(layer.bias.grad, G.sum(0)))    # True: сумма по батчу

Трюк L = (Y * G).sum() полезно запомнить: он позволяет «подать сверху» любой градиент $G$ и проверить обратный проход одного слоя отдельно от всей сети.

Проверка градиента

Ручной backward ошибается тихо: код работает, loss даже немного падает, а градиент неверен. Самый надёжный способ поймать такую ошибку — проверка градиентапроверка градиентаEN gradient checkСравнение аналитического градиента с численным (центральные разности) по относительной ошибке. Главный способ найти баг в backward. (gradient check): посчитать градиент численно и сравнить с аналитическим.

1. Для каждого элемента параметра сдвиньте его на $+h$ и на $-h$, посчитайте loss и возьмите центральную разность (урок 1.2.1). Верните элемент на место.
2. Сравните с аналитическим градиентом по относительной ошибке (формула ниже) — абсолютная ничего не скажет, если градиенты порядка $10^{-6}$ или $10^{3}$.
3. Прочитайте результат по таблице.

Относительная ошибка для аналитического градиента $a$ и численного $n$ считается по каждому элементу, и берётся наибольшая:

$$\text{rel} = \max \frac{\lvert a - n \rvert}{\max(10^{-8}, \lvert a \rvert + \lvert n \rvert)}$$

Числитель — обычная разница, знаменатель приводит её к масштабу самих чисел, а $10^{-8}$ спасает от деления на ноль, когда оба градиента нулевые. Например, $a = 1$ и $n = 1.01$ дают $0.01 / 2.01 \approx 0.005$.

Относительная ошибка (float64)	Вердикт
меньше $10^{-7}$	отлично, градиент верен
от $10^{-7}$ до $10^{-4}$	подозрительно; допустимо, если в функции есть изломы (ReLU, max)
от $10^{-4}$ до $10^{-2}$	скорее всего, ошибка
больше $10^{-2}$	ошибка почти наверняка

Проверим на $L = \sum \tanh(XW)$. Аналитически $\frac{\partial L}{\partial Y} = 1 - \tanh^2(Y)$, и по формуле урока $\frac{\partial L}{\partial W} = X^\top (1 - \tanh^2(Y))$. Добавим и вариант с типичным багом — «забыли» производную tanh:

import numpy as np

rng = np.random.default_rng(0)
X = rng.standard_normal((4, 3))
W = rng.standard_normal((3, 2))

def loss(W):
    return np.tanh(X @ W).sum()                 # L = сумма tanh(XW)

# аналитический градиент: dL/dY = 1 − tanh²(Y), затем dL/dW = Xᵀ · dL/dY
Y = X @ W
dW = X.T @ (1 - np.tanh(Y) ** 2)
dW_bug = X.T @ np.ones_like(Y)                  # «забыли» производную tanh

# численный градиент: шевелим каждый элемент W по очереди
num = np.zeros_like(W)                          # массив нулей той же формы, что W
h = 1e-5
for idx in np.ndindex(W.shape):                 # перебирает все индексы: (0, 0), (0, 1), (1, 0), …
    old = W[idx]
    W[idx] = old + h                            # сдвинули элемент вверх
    up = loss(W)
    W[idx] = old - h                            # и вниз
    down = loss(W)
    W[idx] = old                                # обязательно вернуть на место!
    num[idx] = (up - down) / (2 * h)            # центральная разность из урока 1.2.1

def rel_error(a, b):
    return np.max(np.abs(a - b) / np.maximum(1e-8, np.abs(a) + np.abs(b)))

print(f"верный градиент:  {rel_error(dW, num):.1e}")
print(f"градиент с багом: {rel_error(dW_bug, num):.1e}")

верный градиент:  1.0e-11
градиент с багом: 4.3e-01

Практические правила.

• Проверяйте во float64: во float32 численная производная сама ошибается на $10^{-3}$ и маскирует баги.
• Численный градиент стоит два вычисления loss на каждый элемент. Проверяйте на крошечных размерах (батч 3–5, слой 4×3) или на нескольких случайных элементах большого тензора.
• В точке излома (ReLU ровно в нуле) численная и аналитическая производные законно расходятся — не пугайтесь одиночных выбросов, если вход оказался рядом с нулём.

В PyTorch для этого есть готовая функция torch.autograd.gradcheck — она делает то же самое и требует float64:

import torch
from torch.autograd import gradcheck

def f(X, W):
    return torch.tanh(X @ W).sum()

X = torch.randn(4, 3, dtype=torch.float64, requires_grad=True)   # gradcheck требует float64
W = torch.randn(3, 2, dtype=torch.float64, requires_grad=True)
print(gradcheck(f, (X, W), eps=1e-6, atol=1e-4))                 # True

Практика

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

Gradient check для линейного слояnumpy · нужен интернет6 тестов

import numpy as np


def numerical_gradient(f, X, h=1e-5):
    """Численный градиент скалярной функции f по массиву X (любой формы).

    Для каждого элемента X[idx]: сдвиньте его на +h и на −h, посчитайте f,
    возьмите центральную разность и ОБЯЗАТЕЛЬНО верните элемент на место.
    Перебрать все индексы удобно так: for idx in np.ndindex(X.shape).
    """
    # TODO: ваш код
    ...


def linear_backward(X, W, G):
    """Обратный проход линейного слоя Y = X @ W + b.

    X — (B, n), W — (n, m), G = dL/dY — (B, m).
    Верните кортеж (dX, dW, db) формы (B, n), (n, m), (m,).
    """
    # TODO: ваш код
    ...


def rel_error(a, b):
    """Относительная ошибка: max |a − b| / max(1e-8, |a| + |b|) по всем элементам."""
    # TODO: ваш код
    ...


# Проверьте себя кнопкой «Запустить»:
rng = np.random.default_rng(0)
X = rng.standard_normal((4, 3))
W = rng.standard_normal((3, 5))
b = rng.standard_normal(5)
R = rng.standard_normal((4, 5))            # L = sum(Y * R), поэтому dL/dY = R


def loss_of_W(W_):
    return np.sum((X @ W_ + b) * R)


grads = linear_backward(X, W, R)
if grads is not None:                      # пока функция не написана, она возвращает None
    dX, dW, db = grads
    print(rel_error(dW, numerical_gradient(loss_of_W, W)))   # меньше 1e-7 — градиент верен

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

Задание для Jupyter (по желанию). Возьмите двухслойную сеть $L = \sum (\mathrm{ReLU}(XW_1) W_2 - Y)^2$ на батче 5×4 со скрытым слоем 6 и выходом 3. Напишите обратный проход руками по формулам урока (не забудьте маску ReLU) и проверьте все градиенты через numerical_gradient. Это ровно та задача, которую вы будете решать в уроке 3.1.2.

Китайский угол: градиент как матрица — Muon в Kimi

Слова. Китайское слово «градиент» складывается из слогов «лестница» и «мера», то есть буквально значит «крутизна лестницы». Остальные термины урока — градиентный спуск, частная производная, якобиан, проверка градиента — переводятся дословно.

Muon. Обычные оптимизаторы — SGD, Adam — обращаются с градиентом весов как с длинным списком независимых чисел. Оптимизатор Muon (Келлер Джордан, 2024) смотрит на градиент матрицы весов как на матрицу. Мы только что увидели, что такой градиент — сумма внешних произведений, и обычно в нём доминируют немногие направления. Muon «выравнивает» обновление: заменяет $G = U\Sigma V^\top$ на $UV^\top$, делая все сингулярные числа (урок 1.1.3) равными 1, чтобы редкие направления тоже получали заметный шаг. Дорогое SVD при этом не считают — его приближают несколькими итерациями Ньютона — Шульца из одних матричных умножений.

Пекинская компания Moonshot AI (китайское название — «Тёмная сторона Луны», чат-бот Kimi) показала, что Muon работает и в масштабе больших моделей. В работе Moonlight (arXiv:2502.16982) Muon дал примерно двукратный выигрыш в вычислительной эффективности по сравнению с AdamW. Kimi K2 (1T параметров) обучили на 15.5T токенов с модификацией MuonClip — без единого всплеска loss. Подробно — в уроке 5.4.4.

Что почитать. В «Погружении в глубокое обучение» раздел 2.4 «Математический анализ» вводит частные производные и градиент и даёт правила дифференцирования по векторам, а раздел 2.5 «Автоматическое дифференцирование» показывает, как это делает PyTorch.

Проверь себя

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

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

2 Чему равна длина градиента $f(x, y) = x^2 + 3y^2$ в точке $(1, 1)$? Округлите до двух знаков.

3 Куда указывает градиент функции в точке?

В сторону минимума функцииВдоль линии уровняВ сторону наискорейшего роста функции, перпендикулярно линии уровняВсегда вдоль оси $x$

4 $Y = XW$, где $X$ — $(32 \times 768)$, $W$ — $(768 \times 3072)$, $G = \partial L / \partial Y$. Как вычислить $\partial L / \partial W$?

$G X^\top$$X^\top G$$G W^\top$$X G^\top$

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

Градиент по сдвигу $\mathbf{b}$ — сумма строк $G$ по батчуЯкобиан функции $\mathbf{y} = W\mathbf{x}$ равен $W$Градиент $\partial L / \partial W$ линейного слоя для одного примера — матрица ранга 1Относительная ошибка 0.3 в gradient check — нормальный результат

6 $Y = XW$, $L$ — сумма всех элементов $Y$, $X = \begin{pmatrix} 1 & 2 \\ 3 & 4 \end{pmatrix}$. Чему равен $\partial L / \partial W_{11}$?

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

Итоги

• Частная производная — производная по одной переменной при замороженных остальных. Градиент $\nabla f$ — вектор всех частных производных той же формы, что и вход.
• Градиент указывает направление наискорейшего роста, его длина — крутизна, он перпендикулярен линиям уровня. Спуск: $\theta \leftarrow \theta - \eta \nabla L$.
• Якобиан — таблица производных вектор-функции; для $W\mathbf{x}$ это $W$. Backprop не строит якобианы, а умножает на них вектор градиента.
• Линейный слой: $\frac{\partial L}{\partial W} = X^\top G$, $\frac{\partial L}{\partial X} = G W^\top$, $\frac{\partial L}{\partial \mathbf{b}} = \sum G$. Градиент одного примера — ранг 1.
• Любой ручной backward проверяйте численно во float64: относительная ошибка меньше $10^{-7}$ — отлично, больше $10^{-2}$ — баг.

Дальше: модуль 1.3 — вероятность и теория информации: случайные величины, распределения и то, как языковая модель выдаёт вероятности следующего токена.