Как читать математику в статьях по AI на arXiv: практическое руководство

Viacheslav Dubrov

2026-11-03 · 49 мин · Инженерия моделей

Автоматический перевод

Эта статья была автоматически переведена с оригинальной английской версии.

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

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

Начните с разбора аттеншна: в нём одно уравнение связывается с формами массивов, маленькими числами и работающим кодом на Python. Справочник по нотации объясняет выражения, которые встретятся в других статьях. В остальных частях серии тот же метод применяется к уравнениям из конкретных статей: уравнениям архитектуры, таким как RoPE, MLA и LoRA; целевым функциям обучения, таким как DPO и GRPO; генеративным моделям и метрикам, таким как ELBO, диффузия и pass@k. Эти части ещё не вышли, поэтому разборы, на которые ссылается эта часть, пока без ссылок. За более подробным изложением основ обратитесь к книге Tianhua Chen The Little Book of Generative AI Foundations: в ней развиваются линейная алгебра и теория вероятностей, лежащие в основе генеративных моделей.

Аттеншн: читаем по одному символу

Аттеншн получает выходной вектор как взвешенное среднее векторов значений (value). Веса он находит, сравнивая вектор запроса (query) для выходной позиции с вектором ключа (key) каждой доступной входной позиции. Матрицы $Q$, $K$ и $V$ собирают векторы запросов, ключей и значений. Scaled dot-product attention объединяет эти шаги в уравнении (1) из §3.2.1 (§ означает «раздел») статьи Attention Is All You Need:

Определения находятся в тексте, а не в уравнении. В абзаце перед уравнением (1) сказано, что у запросов и ключей размерность $d_k$, а у значений — $d_v$. Метод берёт скалярное произведение каждого запроса со всеми ключами, делит каждое на $\sqrt{d_k}$ и применяет softmax, «чтобы получить веса значений». Запросы «собраны в матрицу $Q$», а ключи и значения — в $K$ и $V$. Значит, каждая строка этих матриц — вектор одного токена, а softmax выдаёт по одному набору весов на каждый запрос. Обучаемые матрицы, которые превращают векторы токенов в $Q$, $K$ и $V$, появляются позже, в §3.2.2.

Формы и роли. Attention head (далее — head) выполняет одно такое вычисление со своими векторами запросов, ключей и значений. Прежде чем читать операторы, запишите их формы. Для одного head с $n$ запросами и $m$ ключами:

Форму в статьях задают, указывая множество, которому принадлежит матрица: $Q\in\mathbb R^{n\times d_k}$ означает матрицу вещественных чисел с $n$ строками и $d_k$ столбцами, то есть массив формы [n, dk].

Читайте изнутри наружу.

1. $QK^\top$ умножает матрицу $n\times d_k$ на матрицу $d_k\times m$. Общая размерность $d_k$ сворачивается суммой, и получается таблица оценок $n\times m$. Элемент $(i,j)$ — это скалярное произведение запроса $i$ и ключа $j$: перемножьте соответствующие элементы, затем сложите произведения. При фиксированных длинах векторов эта оценка тем больше, чем ближе направления векторов.

2. Деление на $\sqrt{d_k}$ не даёт оценкам расти вместе с шириной вектора. Почему ненормированные скалярные произведения растут, показывает сноска 4 статьи. Допустим, компоненты запроса и ключа независимы друг от друга (знание одних ничего не говорит о других), и у каждой среднее 0 и дисперсия 1 (средний квадрат отклонения от среднего). Тогда:

   $$\begin{aligned} \text{one product }q_ik_i:&\quad\text{variance }1\\ q^\top k=\textstyle\sum_{i=1}^{d_k}q_ik_i:&\quad\text{variance }d_k,\ \text{standard deviation }\sqrt{d_k}\\ q^\top k/\sqrt{d_k}:&\quad\text{standard deviation }1 \end{aligned}$$

   В этих строках использованы два правила про независимые числа. Первое: произведение двух независимых чисел, у каждого из которых среднее 0 и дисперсия 1, тоже имеет дисперсию 1. Второе: при сложении независимых чисел их дисперсии складываются, поэтому $d_k$ произведений дают дисперсию $d_k$. Стандартное отклонение — квадратный корень из дисперсии, $\sqrt{d_k}$. Деление каждой оценки на $\sqrt{d_k}$ уменьшает разброс в то же число раз, обратно до 1.

   Почему эти два правила верны

   Дисперсия при нулевом среднем. Дисперсия — это средний квадрат отклонения от среднего. Когда среднее равно 0, квадрат отклонения от среднего — просто квадрат самого числа, так что дисперсия равна среднему значению квадрата. Поэтому у компоненты $q_i$ со средним 0 и дисперсией 1 величина $q_i^2$ в среднем равна 1.

   Среднее произведения. Для независимых чисел среднее произведения равно произведению средних. Возьмём число $a$, которое с равной вероятностью равно 1 или 3, то есть в среднем 2, и число $b$, которое с равной вероятностью равно 1 или 5, то есть в среднем 3. Независимость означает, что $b$ принимает каждое из своих значений одинаково часто, каким бы ни оказалось $a$, поэтому все четыре пары равновероятны. При $a=1$ произведения равны 1 и 5, их среднее $3=1\times3$. При $a=3$ они равны 3 и 15, среднее $9=3\times3$. В обоих случаях среднее равно $a\times3$, поэтому по обоим значениям $a$ оно составляет $(3+9)/2=6$, то есть $2\times3$. Без независимости правило ломается: если бы $b$ равнялось 5 всякий раз, когда $a$ равно 3, и 1, когда $a$ равно 1, встречались бы только произведения 1 и 15, а их среднее — 8. Википедия формулирует это правило для любых независимых случайных величин, называя среднее «математическим ожиданием» («expected value»): independence and expectation.

   Правило 1: у одного произведения дисперсия 1. Возьмём одно произведение $q_ik_i$. Его среднее равно произведению средних, $0\times0=0$, поэтому его дисперсия — среднее значение $(q_ik_i)^2=q_i^2k_i^2$. Квадраты независимы, потому что независимы $q_i$ и $k_i$, и каждый в среднем равен 1, так что дисперсия равна $1\times1=1$. Общая формула — variance of a product of independent variables.

   Правило 2: дисперсии независимых слагаемых складываются. Обозначим произведения $x_i=q_ik_i$, тогда скалярное произведение — это сумма $x_1+\cdots+x_{d_k}$. Слагаемые независимы, потому что каждое использует свои компоненты, и у каждого среднее 0 и дисперсия 1. У суммы среднее тоже 0, поэтому её дисперсия — среднее значение её квадрата. Если умножить сумму саму на себя, получится по одному произведению $x_ix_j$ на каждую пару слагаемых, то есть сетка $d_k\times d_k$:

   

   Диагональные клетки — это квадраты $x_i^2$, и каждая в среднем равна 1. Любая другая клетка перемножает два разных независимых слагаемых, поэтому её среднее равно произведению их средних, $0\times0=0$: положительные и отрицательные значения взаимно сокращаются. Остаются только $d_k$ диагональных клеток, поэтому дисперсия суммы равна $d_k$, а стандартное отклонение — $\sqrt{d_k}$. Разброс растёт как квадратный корень из ширины, потому что почти вся сетка сокращается. Общую формулировку Википедия приводит как variance of a sum of uncorrelated variables; независимые величины всегда некоррелированы, поэтому правило охватывает и их.

   При $d_k=64$ сырые оценки обычно разбросаны примерно в пределах $\pm8$; после масштабирования — примерно в пределах $\pm1$ при любой ширине.

   Сильно разбросанные оценки насыщают softmax (шаг 3), и его градиенты исчезают. Если одна оценка в строке намного выше остальных, softmax даёт этому ключу вес, близкий к 1, а всем остальным — близкий к 0. Небольшое изменение любой оценки тогда почти не двигает веса, поэтому градиент, доходящий до запросов и ключей, близок к нулю, и обучению почти нечем их подстраивать. Статья предлагает это как вероятное объяснение более раннего результата: без масштабирования dot-product attention при большом $d_k$ работал хуже additive attention, более старой формы, где оценка запроса и ключа считается небольшой сетью (Britz et al., 2017). Сами градиенты статья не измеряет.

3. Softmax превращает каждую строку оценок в веса. Пусть $z=(z_1,\ldots,z_m)$ — одна строка масштабированных оценок. Экспонента $e^a$, которую пишут и как $\exp(a)$, использует константу $e\approx2.718$. Тогда $\operatorname{softmax}(z)_j=e^{z_j}/\sum_{j'}e^{z_{j'}}$, где $j'$ — просто второе имя индекса, так что сумма идёт по всем ключам строки. Веса положительны, и каждая строка в сумме даёт 1.

4. Умножение весов $n\times m$ на значения $m\times d_v$ сворачивает ось ключей. Строка $i$ выхода $n\times d_v$ — это взвешенное среднее строк значений, где вес показывает, насколько хорошо каждый ключ подошёл запросу $i$.

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

Проверьте на двух числах. Возьмём один запрос и два ключа с масштабированными оценками $(0,\log3)$, выбранными так, чтобы экспоненты получились 1 и 3, и значения $v_1=(2,0)$ и $v_2=(0,4)$. На рисунке это разобрано по одной операции на столбец:

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

Сравните с кодом. Функция на NumPy ниже реализует один head. k.T — транспонирование. axis=1 — ось ключей, поэтому строка каждого запроса нормируется отдельно. Максимум строки вычитается перед np.exp: если прибавить одно и то же число ко всем оценкам строки, оно сократится в отношении softmax, и результат не изменится, но большие оценки перестанут вызывать переполнение. Необязательная маска задаёт заблокированным оценкам значение $-\infty$, из-за чего их веса становятся ровно нулевыми. Декодер использует такую маску, чтобы каждый токен не смотрел на более поздние токены (§3.2.3 статьи).

Сохраните блок как attention_example.py и выполните uv run --with numpy python attention_example.py. Проверки проходят молча.

import numpy as np

def attention(q, k, v, allowed=None):
    """One head. q: [n, dk], k: [m, dk], v: [m, dv], allowed: bool [n, m]."""
    scores = q @ k.T / np.sqrt(q.shape[1])  # [n, m]
    if allowed is not None:
        if not allowed.any(axis=1).all():
            raise ValueError("every query needs at least one allowed key")
        scores = np.where(allowed, scores, -np.inf)
    scores = scores - scores.max(axis=1, keepdims=True)
    weights = np.exp(scores)
    weights = weights / weights.sum(axis=1, keepdims=True)  # rows sum to 1
    return weights @ v, weights  # [n, dv], [n, m]

# The two-key example from the text.
out, w = attention(
    np.array([[1.0]]),
    np.array([[0.0], [np.log(3.0)]]),
    np.array([[2.0, 0.0], [0.0, 4.0]]),
)
np.testing.assert_allclose(w, [[0.25, 0.75]])
np.testing.assert_allclose(out, [[0.5, 3.0]])

# A causal mask: query i may attend only to keys 0..i.
x = np.random.default_rng(0).normal(size=(3, 4))
out, w = attention(x, x, x, allowed=np.tril(np.ones((3, 3), dtype=bool)))
assert out.shape == (3, 4)
np.testing.assert_allclose(w.sum(axis=1), 1.0)
assert np.all(w[np.triu_indices(3, k=1)] == 0)

Запрос, у которого все ключи заблокированы, — случай, который уравнение оставляет открытым: каждый вес в его строке был бы равен $0/0$. Функция выбрасывает ошибку вместо того, чтобы вернуть NaN.

От одного head к нескольким. Базовый Transformer запускает параллельно восемь head, у каждого свои обучаемые матрицы для получения $Q$, $K$ и $V$ и $d_k=d_v=64$. Он конкатенирует их выходы и умножает результат на ещё одну обучаемую матрицу, $W^O$ (Attention Is All You Need, §3.2.2).

Реализация может также обрабатывать батч: несколько входных последовательностей сразу. Например, scaled dot-product attention в PyTorch принимает тензор запросов Q формы [batch, heads, n, d_k]. Первые два измерения выбирают последовательность и head; Q[b, h] — матрица [n, d_k] для этой пары. Формула аттеншна применяется к каждой паре отдельно. Функция на NumPy здесь обрабатывает только одну такую пару: её операции .T и axis=1 рассчитаны на двумерные входы.

Шесть вопросов к любому уравнению

Какое утверждение делает уравнение

Аттеншн — вычисление: оно говорит, как получить выход из входов. Но статьи записывают и уравнения с другими задачами:

Ограничение утверждает свойство, которым должен обладать результат. Для весов аттеншна это свойство такое: каждый вес неотрицателен, и каждая строка в сумме даёт 1. Softmax — вычисление, которое выдаёт веса с этим свойством. Одно требование ещё не говорит, что нужно использовать именно softmax.

$=$ утверждает, что два выражения равны. $:=$ означает «определяется как»: оно даёт имя выражению. Определением можно назвать метрику, функцию потерь или множество допустимых значений, поэтому по одному $:=$ нельзя сказать, какой вид уравнения из таблицы выше вы читаете.

Например, Evaluating Large Language Models Trained on Code, статья, в которой представили модель генерации кода Codex, использует $:=$ для определения оценщика pass@k (уравнение 1). Эта метрика измеряет вероятность того, что хотя бы одна из $k$ сгенерированных программ пройдёт тесты. В техническом отчёте DeepSeek-V4 уравнение (2) объединяет два утверждения: $\mathcal M:=\{\ldots\}$ определяет множество допустимых матриц, а $B_l\in\mathcal M$ требует, чтобы матрица смешивания модели $B_l$ принадлежала этому множеству. Определение использует $:=$, ограничение — $\in$, то есть «принадлежит». Разделы про pass@k и mHC разбирают эти примеры.

Как найти новое уравнение, его определения и его код

Раздел методов статьи описывает, как работает её модель или алгоритм обучения. Заголовок может быть «Method», «Architecture» или более конкретным. Авторы часто сначала объясняют существующий метод, а потом показывают, что изменили. Чтобы определить заявленный вклад, начните с описания новизны во введении. Например, DeepSeekMath, §1.1 называет Group Relative Policy Optimization (GRPO) — свой метод обучения моделей по оценённым ответам. Номера разделов и уравнений здесь относятся к статье по ссылке.

Затем сравните предлагаемый метод с более ранним, который он меняет. Это иллюстрируют две статьи:

• Изменение архитектуры. DeepSeek-V2 описывает стандартный multi-head attention в §2.1.1 и вводит multi-head latent attention (MLA) в §2.1.2. Стандартный аттеншн хранит ключи и значения каждого предыдущего токена. MLA хранит сжатый вектор, из которого их можно восстановить. Сравнение этих уравнений показывает, что модель хранит иначе; разбор MLA выводит выигрыш в памяти.
• Изменение обучения. DeepSeekMath, §4.1.1 приводит целевую функцию Proximal Policy Optimization (PPO) как уравнение (1), а GRPO — как уравнение (3). Обе используют преимущество (advantage): число, которое говорит, был ли ответ лучше или хуже ожидаемого. PPO оценивает его второй обучаемой сетью, value model, которая предсказывает награду, которую ещё предстоит получить после частичного ответа. GRPO вместо этого сравнивает награду за ответ с наградами за другие ответы на тот же вопрос. Разбор GRPO сравнивает эти слагаемые, используя нотацию целого ответа из DeepSeek-R1.

Найдите определения вокруг уравнения. Посмотрите предыдущий абзац, любое предложение вида «где …» после него, сноски и приложения. В Attention Is All You Need абзац перед уравнением (1) определяет размерности, а сноска 4 объясняет масштабирующий множитель. DeepSeek-V3 определяет большинство символов роутинга сразу после уравнения (15), а смещение $b_i$ — прямо перед уравнением (16). DeepSeek-V2 выводит MLA в уравнениях (9)–(19), а затем собирает вычисление в Приложении C.

Проверьте алгоритм и код. Блок алгоритма — это пронумерованный листинг псевдокода, задающий порядок операций. Algorithm 1 в DeepSeekMath показывает, когда генерировать ответы, а когда обновлять модель. Algorithm 1 в Denoising Diffusion Probabilistic Models (DDPM) определяет, как выбирать обучающее изображение, уровень шума и сам шум. Остальные детали решает реализация: по умолчанию np.std делит сумму квадратов отклонений на $n$, а torch.std — на $n-1$. Пример с GRPO показывает, как этот выбор меняет значения преимущества, вычисленные по одним и тем же наградам.

Версии arXiv могут переставлять разделы и повторять уравнения под новыми номерами, поэтому указывайте версию. В DeepSeek-R1 v1 целевая функция GRPO находится в §2.2.1, уравнения (1)–(3). В v2, опубликованной в январе 2026 года, это §2.1, а те же уравнения повторяются как (11)–(13) в Supplementary A.3. Ссылка без версии открывает последнюю, поэтому каждая ссылка на arXiv в этой серии содержит версию, по которой её проверяли.

Проверка прочтения с помощью LLM

Чат-модель может набросать таблицу символов, индекс каждой суммы и проверку на маленьких числах, если дать ей определения и попросить указать, чего не хватает. Текст, скопированный из PDF, сплющивает нижние и верхние индексы и дроби в одну строку; ссылки «HTML (experimental)» и «TeX Source» на странице аннотации arXiv дают чистый текст для вставки. Вставьте уравнение и окружающие его абзацы с таким промптом:

Below is equation (N) from <paper title, arXiv ID and version>, followed by
the paragraphs that define its symbols.

1. Make a table with one row per symbol: shape or type, meaning, and whether
   it is input data, a trained weight, a frozen model, a fixed setting or a
   random sample. Quote the sentence that defines it.
2. List every symbol the pasted text does not define. Do not guess them.
3. For every sum, mean, softmax, min or expectation, name the index or the
   distribution it runs over.
4. Work through the equation with the smallest numbers that use every term.
5. Say which kind of statement it is: a computation, definition, objective,
   update rule, constraint, bound, estimator or empirical fit.

Без шага 2 ничто не мешает модели заполнить недостающее определение привычным значением буквы, например прочесть $\sigma$ в DPO как стандартное отклонение вместо сигмоиды. Цитаты из шага 1 делают таблицу проверяемой: найдите в PDF каждую из них, а строку, цитату из которой найти не удаётся, считайте догадкой.

Та же процедура в виде agent skills. paper-math-skills упаковывает этот раздел и справочник по нотации ниже в два skills, написанных для Claude Code; другие агенты, которые загружают файлы SKILL.md, тоже могут ими пользоваться. read-paper-math берёт зафиксированную версию arXiv, цитирует предложение, определяющее каждый символ, читает уравнение изнутри наружу и запускает проверку на маленьких числах. check-paper-math проверяет такое прочтение по статье: ищет каждую цитату, перезапускает числа и отмечает утверждения сильнее или слабее, чем в статье. В paper-math-readings лежат прочтения этих skills для частей 2–4, по одному на каждый из 15 разделов со строкой Source:.

Справочник по нотации

Если греческая буква незнакома, откройте справочник греческих букв в этой статье (Приложение A): там её название и типичные значения. Для дальнейшей практики с математикой в Stanford CS229 есть обзоры по теории вероятностей и линейной алгебре с упражнениями; Preliminaries в Dive into Deep Learning объясняют основы вместе с кодом.

Индексы, пометки и знаки отношений

Буквы — локальные имена переменных: каждая статья определяет свои. Нижние индексы обычно обозначают номера. $x_i$ может быть координатой $i$ вектора или примером $i$ в датасете, а $h_t$ — вектор модели для токена $t$, его скрытое состояние (hidden state).

Верхние индексы в статьях о моделях часто служат метками. В $h_t^{(\ell)}$ верхний индекс в скобках — это, как правило, номер слоя, а не степень; в $\operatorname{FFN}^{(s)}_i$ и $\operatorname{FFN}^{(r)}_i$ из DeepSeek-V3 он отмечает общих и маршрутизируемых экспертов: тех, которыми пользуется каждый токен, и тех, которых выбирает роутер (см. пример роутинга в MoE). В DeepSeek-V2 $W^{DKV}$ и $k_t^C$ несут метки, а не показатели степени; пример с MLA определяет эти метки. $W^\top$ — транспонирование, а $x^2$ — квадрат.

$x_{1:T}$ означает позиции с 1 по $T$, включая $T$, в отличие от среза в Python; статьи обычно считают с 1. $x_{<t}$ означает все позиции до $t$. $X_{t,:}$ выбирает строку $t$, как срез в NumPy.

Пометки над буквой обычно меняют её смысл одним из следующих способов:

Некоторые символы, кроме греческих букв, тоже выполняют несколько ролей:

Пять знаков показывают, как соотносятся две стороны. $:=$, иногда $\triangleq$, определяет новое имя. $\approx$ отмечает приближение, как среднее по выборке в разделе Математическое ожидание и откуда берутся сэмплы. $\propto$ означает «пропорционально», с опущенной нормировочной константой: $p_i\propto e^{z_i}$ становится распределением только после деления на $\sum_j e^{z_j}$. $\ll$ означает «намного меньше», как в $d_c\ll d_hn_h$ из DeepSeek-V2: сжатая ширина намного меньше суммарной ширины всех head. $\leftarrow$ — присваивание, как в правиле обновления.

Суммы, подсчёты, интервалы и логарифмы

Крупный $\sum$ складывает слагаемые, а $\prod$ перемножает их. Индекс под оператором здесь начинается с 1 и идёт до верхней границы $N$:

Индекс принадлежит оператору, как переменная цикла принадлежит своему циклу. В $y_i=\sum_{j=1}^{d}W_{ij}x_j$ сумма идёт по $j$, а $i$ определяет элемент выхода. Результат — вектор с одним элементом на каждое $i$: записанное в развёрнутом виде произведение матрицы на вектор $Wx$. Индексы в левой части говорят, какой формы выход.

Множитель перед суммой решает, что получает равный вес. Батч с ответом из 2 токенов и ответом из 8 токенов, где $\ell_{it}$ — потери на токене $t$ ответа $i$ (в GRPO $\ell$ — слагаемое, которое нужно максимизировать), можно усреднить двумя способами:

В первом каждый ответ получает вес $\tfrac12$, который делится между его токенами:

Во втором у каждого токена вес $1/10$. GRPO выбирает $G$ ответов $o_1,\ldots,o_G$ на каждый вопрос, а $\vert o_i\vert$ — число токенов в ответе $i$. Тогда два усреднения записываются так, для GRPO из DeepSeekMath и для DAPO, более позднего варианта GRPO:

При $G=2$ это $L_{\text{answers}}$ и $L_{\text{tokens}}$ выше. DAPO перешёл на усреднение по токенам (§3.3), потому что усреднение по ответам придавало токенам длинных ответов слишком малый вес: модель слишком мало училась на длинных хороших ответах и недостаточно штрафовала длинные повторяющиеся плохие.

Сумма может и считать. Статьи делают это с помощью индикатора: жирной единицы с условием, $\mathbf 1[C]$, которая равна 1, когда условие $C$ истинно, и 0, когда ложно. Некоторые статьи ставят условие в скобки или печатают вместо жирной единицы двойную; смысл тот же. Поэтому сумма индикаторов считает, сколько раз условие выполнилось. Типичный пример — accuracy. Если $\hat y_i$ — предсказанный класс, а $y_i$ — правильный класс для примера $i$, то $\sum_i\mathbf 1[\hat y_i=y_i]$ — число верных предсказаний. Предсказания (кошка, собака, собака) при правильных метках (кошка, кошка, собака) дают индикаторы 1, 0 и 1, так что счёт равен 2, а accuracy — 2/3. В слое mixture-of-experts (MoE) роутер отправляет каждый токен в несколько из множества feed-forward подсетей, которые называют экспертами. В балансирующей функции потерь DeepSeek-V3 (уравнение 18) индикатор равен 1, когда оценка эксперта для токена входит в $K_r$ наибольших оценок для этого токена, где $K_r$ — число экспертов, в которые направляется каждый токен. Его сумма по токенам последовательности считает, как часто это случалось. Оценка здесь не включает смещение, которое добавляет роутинг, поэтому счёт может отличаться от экспертов, которых роутер выбирает на самом деле (роутинг в MoE).

Биномиальный коэффициент $\binom nk$, читается «$n$ по $k$», считает способы выбрать $k$ различных элементов из $n$ без учёта порядка. Для целых $0\leq k\leq n$ он равен $n!/(k!\,(n-k)!)$. Восклицательный знак означает факториал: $n!=1\times2\times\cdots\times n$, при $0!=1$. Например, $\binom52=5!/(2!\,3!)=10$: из пяти элементов получается десять различных пар. DeepSeekMoE использует биномиальные коэффициенты для подсчёта комбинаций экспертов, а оценщик pass@k — для подсчёта наборов сэмплов.

Интервалы используют скобки для включённых концов: $[a,b]$ включает оба, $(a,b)$ — ни одного. В Gated DeltaNet $\alpha_t\in(0,1)$ означает строго между 0 и 1. В других местах $(a,b)$ — пара.

Натуральный логарифм обращает возведение в степень: $\log(e^a)=a$. Логарифмы превращают произведения в суммы, а частные — в разности: $\log(ab)=\log a+\log b$ и $\log(a/b)=\log a-\log b$, но $\log(a+b)$ не раскладывается. Поэтому статьи работают с лог-вероятностями. Логарифм произведения вероятностей токенов — сумма, а логарифм отношения вероятностей двух моделей — разность, именно такая форма используется в целевых функциях DPO и GRPO. Статьи по ML подразумевают натуральный логарифм, если не сказано иное; результат измеряется в натах (nats), а логарифмы по основанию 2 дают биты. Для вероятности $p\leq1$ величина $-\log p\geq0$ и неограниченно растёт по мере приближения $p$ к 0, поэтому уверенное неверное предсказание обходится дорого.

Log-sum-exp означает: возведите в экспоненту каждую оценку $z_i$, сложите результаты, затем возьмите логарифм. Прямое вычисление $\log\sum_i e^{z_i}$ может переполниться, если оценка велика. Вместо этого найдите наибольшую оценку и назовите её $m$. Запись $m=\max_i z_i$ означает «сравнить все элементы $z_i$ и взять наибольший»; в NumPy это m = z.max().

Вычтите $m$ из каждой оценки перед возведением в экспоненту, а после взятия логарифма прибавьте обратно:

Для $z=(1000,1001)$ наибольшая оценка $m=1001$. Сдвинутые оценки равны $(-1,0)$, так что вычисление превращается в $1001+\log(e^{-1}+1)\approx1001.313$. Ни одна экспонента не больше 1. Код аттеншна делает то же вычитание перед softmax; там общий множитель сокращается при делении, поэтому ничего прибавлять обратно не нужно.

Условная вероятность и вероятность текста

$p_\theta(y\mid x)$ — вероятность, которую модель с параметрами $\theta$ назначает выходу $y$ при входе $x$. Нижний индекс называет параметры; некоторые статьи пишут $p(y\mid x;\theta)$, где точка с запятой тоже отмечает параметры, а не условие. Если вместо выхода поставить точку, $p_\theta(\cdot\mid x)$ — это всё распределение по выходам, а не одно число. В статьях по RL тот же объект записывают как $\pi_\theta(o\mid q)$, вероятность того, что модель напишет ответ $o$ на вопрос $q$, и называют модель политикой (policy).

Если поменять местами событие и условие, получится другое число. Допустим, есть 100 ответов модели: 60 верны, 50 являются корректным JSON и 40 — и то и другое. Тогда

Пусть $A$ означает «ответ верен», а $B$ — «ответ является корректным JSON». Условная вероятность ограничивает подсчёт ответами, удовлетворяющими условию: $P(A\mid B)=P(A\cap B)/P(B)$, при условии $P(B)>0$. Символ $\cap$ означает «происходят оба события». Здесь дробь равна $0.4/0.5=0.8$, то же самое, что 40 верных ответов среди 50 с корректным JSON.

Два события независимы, когда знание о том, что одно из них произошло, не меняет вероятность другого. Для этого требуется $P(A\cap B)=P(A)P(B)$. В этой выборке $P(\text{both})=0.4$, тогда как $P(\text{correct})P(\text{valid JSON})=0.6\times0.5=0.3$, так что в наблюдаемых долях независимости нет.

Теорема Байеса, или правило Байеса, связывает два направления условия: $P(A\mid B)=P(B\mid A)P(A)/P(B)$. Она позволяет вычислить вероятность $A$ при $B$ по вероятности $B$ при $A$ и вероятностям двух событий. Пример с ELBO использует её, чтобы найти вероятность скрытого кода при наблюдаемом изображении.

Языковая модель оценивает последовательность по одному токену. По цепному правилу вероятности

Каждый множитель зависит от всех предыдущих токенов, поэтому формула не предполагает независимости токенов. Если у трёх токенов условные вероятности 0.5, 0.2 и 0.1:

Обычные потери при обучении — это эта сумма с обратным знаком, делённая на длину:

Во время обучения предыдущие токены $y_{<t}$ берутся из датасета. Во время генерации это собственные предыдущие выборы модели.

Математическое ожидание и откуда берутся сэмплы

Математическое ожидание — это среднее, взвешенное вероятностями:

Читайте $\mathbb E_{x\sim p}[f(x)]$ как «среднее значение $f(x)$, когда $x$ берётся из $p$». Запись $\sum_x$ суммирует по всем возможным дискретным значениям $x$. Без нижнего индекса $\mathbb E[X]$ усредняет случайную величину $X$ по её собственному распределению: если $X$ равно 1 с вероятностью 0.75 и 3 с вероятностью 0.25, то $\mathbb E[X]=1\times0.75+3\times0.25=1.5$.

Когда у переменной есть плотность $p(x)$, то есть вероятность на единицу $x$, взвешенное среднее становится интегралом, $\int f(x)p(x)\,dx$. Символ $dx$ показывает, что интегрируется по $x$; если пределы не записаны, интеграл берётся по всему диапазону. Пример с плотностью объясняет вероятность на единицу и показывает интеграл как площадь под кривой.

Код обучения не может суммировать по всем возможным входам, поэтому он берёт выборку и усредняет: $\mathbb E_{x\sim p}[f(x)]\approx\frac1N\sum_{i=1}^{N}f(x_i)$, где каждый $x_i$ независимо берётся из $p$, что статьи пишут как $x_i\overset{\text{iid}}{\sim}p$. Статьи называют это оценкой Монте-Карло (Monte Carlo estimate), а в коде это loss.mean() по батчу. Среднее по батчу оценивает математическое ожидание, только если батч берётся из распределения, указанного в нижнем индексе $\mathbb E$, поэтому нижний индекс говорит, как порождаются обучающие данные:

• DPO усредняет по сохранённым примерам $(x,y_w,y_l)\sim\mathcal D$: промпту, предпочтённому ответу и отвергнутому ответу. Ответы собирают и размечают до этого этапа обучения; они могут происходить из более ранней генерации модели. На каждом шаге обучения модель вычисляет вероятности для этих готовых ответов и обновляет веса. Свежих ответов для этого шага она не генерирует.
• GRPO в DeepSeek-R1: сгенерировать ответы, затем сравнить их награды. Обучение берёт вопрос из датасета, генерирует несколько ответов и оценивает их функцией награды, например проверкой математического результата или запуском юнит-тестов. Обновление поощряет ответы, получившие оценку выше среднего по группе. Запись $q\sim P(Q)$ означает «выбрать вопрос $q$ из распределения вопросов». Запись $\{o_i\}\sim\pi_{\theta_{old}}(O\mid q)$ означает «выбрать ответы $o_i$ на этот вопрос из копии модели $\pi_{\theta_{old}}$». Нижний индекс old отмечает копию, сгенерировавшую эти ответы; она остаётся фиксированной, пока батч используется для обновлений. Разбор GRPO объясняет сравнение наград и обновления.
• On-policy distillation в MiniLLM и DeepSeek-V4: сгенерировать текст, затем учиться по вероятностям учителя. Обучаемая модель — студент (student). Он генерирует текст; замороженный учитель (teacher) выдаёт вероятности следующего токена для тех же префиксов, и обучение подстраивает вероятности студента под вероятности учителя. Именно эти вероятности служат сигналом обучения, а не оценка награды за ответ, как в GRPO. MiniLLM записывает текст, сгенерированный студентом, как $y\sim q_\theta$: $y$ — это текст, а $q_\theta$ называет модель-студента. DeepSeek-V4 называет своего студента $\pi_\theta$ и использует нескольких специализированных учителей. Реальная процедура выборки в MiniLLM к тому же подмешивает токены, взятые у учителя. Разбор дистилляции объясняет целевые функции и это различие в выборке.

Порядок показывает, что оптимизирует обучение. Допустим, модель назначает вероятности 0.9 и 0.1 правильным выходам двух равновзвешенных обучающих примеров. Усреднить их лог-вероятности значит сначала взять каждый логарифм, а потом усреднить: np.log(probs).mean(). Взять логарифм их среднего — np.log(probs.mean()). Если $X$ — вероятность, назначенная правильному выходу случайно выбранного примера:

Если поменять знак, получатся потери 1.20 и 0.69. Вторая модель, которая назначает 0.5 каждому правильному выходу, получает 0.69 при любом из двух вычислений. Значит, усреднение вероятностей до логарифма считает две модели одинаково хорошими, а обычное среднее отрицательных лог-вероятностей сильнее штрафует первую модель за низкую вероятность на втором правильном выходе. Переводя функцию потерь в код, сохраняйте порядок логарифма и усреднения.

Неравенство Йенсена формулирует общее соотношение для положительного $X$: $\mathbb E[\log X]\leq\log\mathbb E[X]$. Оно же помогает строить альтернативные целевые функции обучения. Когда вероятность данных в модели требует дорогого усреднения по скрытым переменным, среднее логарифмических слагаемых может дать нижнюю границу, которую легче оценить. Разбор ELBO объясняет эту задачу обучения; ELBO расшифровывается как evidence lower bound. В разделе 2.4 книги Tianhua Chen The Little Book of Generative AI Foundations граница выводится с помощью неравенства Йенсена.

Плотности, дисперсия и планки погрешностей

У $p(x)$ два распространённых смысла. Для дискретных исходов, таких как токены или классы, оно даёт вероятность исхода $x$: число от 0 до 1, причём вероятности по всем исходам в сумме дают 1.

Чтобы понять другой смысл, допустим, что $X$ выбирается равномерно между 0 и 0.5. Интервалы одинаковой длины имеют одинаковые вероятности. Интервал от 0.1 до 0.2 занимает одну пятую всего диапазона, поэтому

В этом диапазоне вероятность — это ширина интервала, умноженная на 2. Этот множитель и есть плотность вероятности: $p(x)=2$ при $0\leq x\leq0.5$ и ноль вне этого отрезка. Плотность описывает вероятность на единицу переменной, а не вероятность одного точного значения.

Нулевая вероятность точки не означает, что ничего не выбирается. Сужайте интервал вокруг 0.15: его вероятность вдвое больше его ширины, поэтому она стремится к нулю вместе с шириной. Значит, у одной точной точки вероятность нулевая. Но выборка всё равно даёт какое-то значение в $[0,0.5]$, а вероятность всего этого интервала равна 1. Если записать результат, округлив до двух знаков после запятой, записанное значение 0.15 представляет интервал от 0.145 до 0.155, вероятность которого $2\times0.01=0.02$.

Для неравномерной плотности множитель меняется с $x$. Интеграл складывает вклады по интервалу:

Геометрически это площадь под кривой плотности между $a$ и $b$; площадь по всему диапазону равна 1. В равномерном примере площадь — это просто высота 2, умноженная на ширину 0.5. Поэтому плотность может превышать 1, а её логарифм — быть положительным, как здесь $\log2\approx0.69$. Вероятность никогда не превышает 1.

Гауссово распределение, которое в DDPM используется для шума, имеет плотность такого рода. Не у каждого непрерывного распределения есть обычная плотность: распределение Кантора — математический контрпример, не относящийся к обсуждаемым здесь моделям. Хранение вещественных значений тоже не означает непрерывного распределения: переменная, ограниченная значениями 0.0 и 1.0, по-прежнему имеет два дискретных исхода.

Статьи часто обозначают вероятности и плотности одной и той же буквой. Проверьте, как статья определяет распределение переменной и по какой переменной ведётся суммирование или интегрирование. Интеграл по скрытой переменной $z$, такой как латентный код в ELBO в части 4, не говорит, дискретна наблюдаемая $x$ или непрерывна. Некоторые статьи пишут заглавное $P$ для вероятностей и строчное $p$ для плотностей, но во многих $p$ используют для обеих.

Чтобы описать, насколько распределение разбросано вокруг среднего, статьи используют дисперсию (variance): средний квадрат отклонения от среднего, $\operatorname{Var}(X)=\mathbb E[(X-\mu)^2]$, где $\mu=\mathbb E[X]$. Стандартное отклонение (standard deviation) — её квадратный корень, поэтому оно измеряется в тех же единицах, что и $X$.

Эти величины присутствуют и в названиях распределений. Гауссово распределение, или нормальное, записывается $\mathcal N(\mu,\sigma^2)$: $\mu$ — его среднее, а $\sigma^2$ — дисперсия. Для вектора $\mathcal N(\mu,\Sigma)$ использует ковариационную матрицу $\Sigma$: элемент $(i,j)$ измеряет, как вместе меняются координаты $i$ и $j$, а на диагонали стоят их дисперсии. $\mathcal N(0,I)$ описывает вектор независимых стандартных нормальных чисел, у каждого из которых среднее 0 и дисперсия 1; $I$ — единичная матрица.

Таблицы бенчмарков часто приводят средний результат вместе с мерой изменчивости. Разброс отдельных запусков отличается от неопределённости их среднего: для $N$ независимых запусков со стандартным отклонением $\sigma$ стандартная ошибка среднего равна $\sigma/\sqrt N$.

Прежде чем сравнивать две записи вроде $82.3\pm0.4$ и $81.5\pm0.4$, выясните по подписи, является ли 0.4 стандартным отклонением по запускам, стандартной ошибкой или полушириной доверительного интервала. Чтобы сравнить средние, вычислите интервал для их разности. Процедура 95%-го доверительного интервала даёт диапазоны, которые содержат истинную разность в 95% повторных экспериментов при своих допущениях.

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

Для независимых средних дисперсия их разности равна сумме их дисперсий. Стандартная нормальная величина попадает между $-1.96$ и $1.96$ с вероятностью около 0.95, что даёт множитель для нормального приближения 95%-го интервала. Если 0.4 — стандартное отклонение по четырём запускам, то первый расчёт даёт:

Множитель 1.96 считает оценённый разброс известным. При всего четырёх запусках на модель используйте t-распределение Стьюдента, чтобы учесть неопределённость разброса. При перечисленных допущениях число степеней свободы равно $4+4-2=6$ (восемь запусков минус две оценённые средние). scipy.stats.t.ppf(0.975, 6) даёт около 2.447 вместо 1.96; 0.975 оставляет по 2.5% за каждым концом 95%-го интервала. Если допущение о равных дисперсиях не подходит, используйте интервал Уэлча (Welch), у которого степени свободы считаются иначе.

Теперь рассмотрим другое прочтение подписи: 0.4 — уже стандартная ошибка каждого среднего, оценённая по этим четырём запускам. Делить на $\sqrt4$ ничего не нужно, и стандартная ошибка разности равна примерно 0.566. Множитель Стьюдента по-прежнему нужен. Два прочтения дают:

На рисунке начальное нормальное приближение сравнивается с двумя t-интервалами:

Когда 0.4 — стандартное отклонение, t-интервал исключает ноль: при этих допущениях результаты поддерживают положительную разность. Когда 0.4 — оценённая стандартная ошибка, интервал содержит ноль, поэтому результаты не позволяют установить, у какой модели средний результат выше.

Кросс-энтропия и KL-дивергенция

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

Здесь исходы дискретны, например токены или классы. Обозначим целевое распределение $p$, а предсказанное моделью распределение по тем же исходам — $q$. Начнём с одного наблюдаемого исхода $i$: если модель дала ему вероятность $q_i$, потери равны $-\log q_i$. Они равны 0 при $q_i=1$, около 0.69 при $q_i=0.5$, около 2.3 при $q_i=0.1$ и бесконечны при $q_i=0$.

Кросс-энтропия усредняет эти потери по исходам, выбранным из цели:

Для one-hot метки $p$, равной 1 для правильного класса $y$ и 0 для остальных, считается только правильный класс, и $H(p,q)=-\log q_y$: обычные потери классификации. nn.CrossEntropyLoss в PyTorch вычисляет это по сырым оценкам модели, логитам (logits), и сам применяет log-softmax; на вход ему подаётся не вектор вероятностей $q$. Если $p$ — мягкое распределение модели-учителя, каждый класс учитывается пропорционально вероятности учителя. Классическая дистилляция обучает небольшую модель на вероятностях большой именно так. Для цели $p=(0.9,0.1)$ у двух моделей такие кросс-энтропии $H(p,q)$:

Вторая модель совпадает с целью, и лучше не может быть ни одна модель. Этот минимум, здесь 0.325, равен $H(p)=-\sum_ip_i\log p_i$, энтропии (entropy) $p$. Он равен 0 только для one-hot цели: когда сама цель неопределённа, остаются потери, которые не может убрать никакая модель.

KL-дивергенция вычитает этот минимум и оставляет только потери, вызванные отличием $q$ от $p$. Её записывают с двойной чертой $\Vert$, которая лишь разделяет два аргумента; это не вертикальная черта условной вероятности $\mid$ из раздела Условная вероятность и вероятность текста и не знак длины $\Vert x\Vert$ из справочника по векторам. Статьи используют её вместо запятой, чтобы показать, что порядок важен: усреднение идёт по исходам, выбранным из первого аргумента.

Для первой модели выше $0.693-0.325\approx0.37$. KL равна 0, когда два распределения совпадают, и положительна в остальных случаях.

Порядок меняет то, какие несовпадения штрафуются. Слагаемое с $p_i>0$ и $q_i=0$ бесконечен, поэтому $D_{\mathrm{KL}}(p\Vert q)$ штрафует $q$ за нулевую вероятность чего-либо, что может выдать $p$. Исходы с $p_i=0$ ничего не добавляют (по соглашению $0\log0=0$), поэтому прямого штрафа они не несут, даже если $q_i>0$. Если поменять аргументы местами, получится $D_{\mathrm{KL}}(q\Vert p)$, которая бесконечна всюду, где $q_i>0$ и $p_i=0$. Исходы с $q_i=0$ теперь ничего не добавляют, даже если $p_i>0$. Если $p$ — цель, то $D_{\mathrm{KL}}(p\Vert q)$ называют прямой (forward) KL, а $D_{\mathrm{KL}}(q\Vert p)$ — обратной (reverse) KL.

Для $p=(0.5,0.5)$ и $q=(1,0)$ прямая KL бесконечна, потому что $q$ упускает исход, который выдаёт $p$, а обратная KL равна всего $1\times\log(1/0.5)+0=\log2$: исход, который $q$ пропускает, ничего не добавляет. Для $p=(0.9,0.1)$ и $q=(0.5,0.5)$ прямая KL — это найденные выше 0.37, здесь вычисленные по слагаемым, а обратная KL отличается:

Из-за этой асимметрии KL называют дивергенцией, а не расстоянием.

Поскольку $H(p,q)=H(p)+D_{\mathrm{KL}}(p\Vert q)$, а энтропия фиксированного учителя $H(p)$ не зависит от студента, кросс-энтропия относительно фиксированного учителя даёт студенту те же градиенты, что и $D_{\mathrm{KL}}(p\Vert q)$. Изменение параметра студента меняет обе функции потерь на одну и ту же величину, поэтому их производные, используемые при обучении, равны; вычисление объясняет раздел Градиенты и оптимизация. Благодаря этому код классификации и классической дистилляции может использовать кросс-энтропию. Такая замена работает только при учителе на первом месте. Если студент стоит первым, $D_{\mathrm{KL}}(q\Vert p)=H(q,p)-H(q)$, а собственная энтропия студента $H(q)$ меняется по ходу обучения, поэтому градиенты у них уже не совпадают.

Векторы и матрицы

Уравнения архитектуры описывают вычисления над массивами чисел. Форма (shape) массива говорит, как расположены его числа, какие операции допустимы и что они дают. Вектор — упорядоченный список чисел. Матрица располагает числа по строкам и столбцам. В коде ML тензор (tensor) — общий термин для таких числовых массивов, в том числе с более чем двумя осями. Ось (axis) — измерение, по которому индексируется массив: у матрицы есть ось строк и ось столбцов.

Скрытое состояние (hidden state) токена — вектор чисел, вычисленный внутри модели для представления этого токена. Допустим, мы обрабатываем вместе батч из $B$ последовательностей, в каждой $T$ позиций токенов, а каждое скрытое состояние содержит $d$ чисел. Массив скрытых состояний имеет форму [B, T, d], которую статьи пишут и как $B\times T\times d$. Его три оси выбирают последовательность, позицию токена и число внутри вектора этого токена. Например, [2, 3, 4] содержит две последовательности, по три вектора токенов в каждой и по четыре числа в векторе: всего 24 числа. Здесь $d$ — ширина вектора. Форма перечисляет три размера; их произведение даёт число элементов.

Статьи часто записывают формы как принадлежность множеству: $a\in\mathbb R^d$ означает, что $a$ — вектор из $d$ вещественных чисел, а $A\in\mathbb R^{m\times n}$ — что $A$ — матрица с $m$ строками и $n$ столбцами. Жирные буквы иногда отмечают векторы или тензоры, но форму определяет определение в статье.

В таблице ниже $a$ и $b$ — векторы-столбцы: их числа расположены вертикально. Верхний индекс $\top$ означает транспонирование: обмен строк и столбцов. Так $a^\top$ — строка с теми же числами, что и столбец $a$. Заглавные $A$ и $B$ здесь называют матрицы; $B$ больше не означает размер батча.

Для конкретного сравнения возьмём $a=\begin{pmatrix}1\\2\end{pmatrix}$ и $b=\begin{pmatrix}3\\4\end{pmatrix}$. Перенос транспонирования меняет и вычисление, и результат:

Скалярное произведение даёт одну оценку, как при сравнении запроса и ключа в аттеншне. Внешнее произведение сохраняет отдельное значение для каждой пары элементов; обновление в Gated DeltaNet использует его, чтобы построить матричное обновление из двух векторов.

Матричное произведение можно перегруппировать, $(AB)C=A(BC)$, но нельзя переставить множители; вывод MLA использует перегруппировку, чтобы не восстанавливать ключи. NumPy записывает матричное умножение как @, а поэлементное произведение как *. Статьи не наследуют правила broadcasting из NumPy: чтобы прибавить вектор к матрице, нужно указать ось. Статьи расходятся и в том, строка вектор или столбец: аттеншн складывает токены в строки $Q$, тогда как MLA, Gated DeltaNet и LoRA пишут $Wh$ с векторами-столбцами, а nn.Linear в PyTorch вычисляет x @ W.T над строками.

Уравнение архитектуры может также описывать размер вектора, ограничивать допустимые матрицы или перестраивать произведение:

Градиенты и оптимизация

Обучение использует производные, чтобы решить, как менять параметры модели. Пусть $\mathcal L$ — одна скалярная функция потерь, а $\theta$ — вектор всех параметров; $\theta_i$ — один элемент этого вектора.

Частная производная $\partial\mathcal L/\partial\theta_i$ — одно число, вычисленное при текущих значениях параметров. Она измеряет скорость изменения потерь, когда меняется только $\theta_i$, а остальные параметры остаются фиксированными. Читайте её как «частная производная потерь по параметру $\theta_i$».

Градиент $\nabla_\theta\mathcal L$ собирает эти числа для всех параметров в один вектор. Его $i$-й элемент равен $\partial\mathcal L/\partial\theta_i$. Символ $\nabla$ называется набла; здесь он означает «взять градиент». При единственном параметре у градиента один элемент, равный обычной производной.

Например, возьмём $\mathcal L(\theta_1,\theta_2)=\theta_1^2+3\theta_2^2$. При $\theta_1=2$ и $\theta_2=1$:

Первая частная производная, 4, означает, что увеличение $\theta_1$ на 0.01 повышает потери примерно на 0.04, пока $\theta_2$ фиксировано. Градиент содержит эту информацию для обоих параметров. Градиентный спуск вычитает производную каждого параметра, умноженную на положительную скорость обучения (learning rate) $\eta$, которая задаёт размер шага:

При $\eta=0.1$ пример переходит от $(2,1)$ к $(1.6,0.4)$, а потери падают с 7 до 3.04. Для дифференцируемой функции потерь с ненулевым градиентом достаточно малый шаг уменьшает потери. Нулевой градиент обновления не даёт.

Нижний индекс у $\nabla$ говорит, что меняется. $\nabla_\theta\log p_\theta(x)$ варьирует параметры; $\nabla_x\log p_\theta(x)$ варьирует вход, и в статьях по диффузии его называют score, что не имеет отношения к оценке на бенчмарке.

Якобиан записывает производные для нескольких выходов. Слой нейросети может выдавать много чисел, например компоненты скрытого состояния токена. Чтобы описать, как каждый выход реагирует на каждый вход, частные производные собирают в матрицу, которую называют якобианом (Jacobian). Для $y=f(x)$ с $n$ входными и $m$ выходными числами его форма $m\times n$: строки соответствуют выходам, столбцы — входам, а элемент $J_{ij}=\partial y_i/\partial x_j$ измеряет, как меняется выход $i$ при изменении входа $j$.

Например, пусть функция принимает два числа и возвращает $y_1=x_1+2x_2$ и $y_2=3x_1-x_2$. Её якобиан равен

Второй столбец говорит, что увеличение $x_2$ на 0.1 при фиксированном $x_1$ увеличивает $y_1$ на 0.2 и уменьшает $y_2$ на 0.1. Этот пример линеен, поэтому его якобиан постоянен. У нелинейной функции элементы могут зависеть от текущего входа и описывают малые изменения локально. При единственном скалярном выходе у якобиана одна строка: те же производные, что и в градиенте, только транспонированные при нашем соглашении о векторах-столбцах. Общие определения даёт Deep Learning, §4.3.

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

В обучении производные описывают локальные изменения; оптимизационная цель говорит, что обновления должны минимизировать или максимизировать. Статьи различают наилучшее значение цели и параметры, которые его достигают: $\min_\theta f(\theta)$ — наименьшее значение $f$, а $\operatorname*{arg\,min}_\theta f(\theta)$ даёт значения параметров, при которых оно достигается. Для $f(\theta)=(\theta-3)^2$ минимум равен 0, а argmin равен 3. Argmin задаёт желаемый результат, но не определяет алгоритм обновления.

Например, MiniLLM записывает свою цель как $\theta=\operatorname*{arg\,min}_\theta D_{\mathrm{KL}}(q_\theta\Vert p)$ (уравнение 1), где $q_\theta$ — модель-студент, а $p$ — учитель, у которого она учится. Затем в разделе 2.2 выводится градиент, который затем изменяется, чтобы сделать обучение устойчивее; уравнение (7) — градиент, который используется для обновлений. Пример с on-policy distillation объясняет эти изменения. Если прочесть только argmin, их можно пропустить.

Stop-gradient, $\operatorname{sg}(x)$, пропускает $x$ вперёд без изменений, но блокирует градиенты через себя, как .detach() в PyTorch. Два выражения с одинаковым значением в прямом проходе могут обучаться по-разному, если одно из них отсоединено. В примере с GRPO Hugging Face TRL считает лог-вероятность старой модели фиксированной. В упрощении дистилляции, которое обсуждает DeepSeek-V4, отсоединённое лог-отношение учителя и студента даёт фиксированный вес для обновления.

Множества и ограничения

Ограничение (constraint) говорит, какие значения допустимы. Статьи часто выражают ограничения через множества: наборы различных элементов, записываемые в фигурных скобках, например $\{1,2,3\}$. Порядок не важен, поэтому $\{3,1,2\}$ — то же множество. Повторяющиеся элементы считаются один раз. Для сравнения, круглые скобки в векторе вроде $(1,2,3)$ описывают упорядоченный список: $(3,1,2)$ — уже другой вектор.

Когда статья определила множество, она может проверять принадлежность, объединять множества, считать их элементы или формулировать на них условие. Возьмём $A=\{1,2,3\}$ и $B=\{3,4\}$:

Нотация форм из раздела Векторы и матрицы тоже называет множества: $\mathbb R^d$ — множество всех векторов из $d$ вещественных чисел, а $\mathbb R^{n\times d}$ — множество всех вещественных матриц с $n$ строками и $d$ столбцами. Таким образом, $Q\in\mathbb R^{n\times d_k}$ указывает, какую форму должна иметь $Q$.

Set-builder-нотация задаёт множество условием: $\{x\in S\mid\text{condition}\}$ читается «элементы $S$, удовлетворяющие условию», как set comprehension в Python {x for x in S if condition(x)}. Черта здесь означает «такой, что», а не условную вероятность; некоторые статьи вместо неё используют двоеточие. Примеры в этой серии — допустимые матрицы в mHC, выбранные эксперты в MoE и выбранные токены в разреженном аттеншне.

DAPO, метод обучения, фильтрующий группы сгенерированных ответов, оставляет вопрос, только если часть ответов верна, а часть неверна. Для $G$ выбранных ответов $o_1,\ldots,o_G$ и эталонного ответа $a$ запишем множество индексов верных ответов как