Как читать формулы

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

Формула — это сжатый код. Строчка $\mathrm{softmax}(QK^\top / \sqrt{d_k})\,V$ заменяет полстраницы текста. На этом языке написана вся литература по LLM — от статьи «Attention Is All You Need» до техотчётов DeepSeek и Qwen. Пока формулы выглядят как шифр, статьи закрыты, и приходится верить пересказам.

Хорошая новость: словарь небольшой. Полтора десятка греческих букв, несколько значков ($\Sigma$, $\Pi$, $\nabla$, $\in$) и правила индексов — этого хватает, чтобы читать почти все формулы этого курса. Главное правило урока: каждую формулу переводим в код. Если вы смогли написать формулу циклом for, значит, вы её поняли.

Греческие буквы ML

Греческие буквы в формулах — просто имена переменных, как lr или theta в коде. Но у многих есть устойчивые значения, и их полезно знать заранее:

Буква	Читается	Что обычно значит в ML	Где встретится
$\alpha$	альфа	коэффициент; показатель степени в scaling laws	1.0.2, 5.1
$\beta$	бета	$\beta_1, \beta_2$ в Adam; сила KL-штрафа в DPO и GRPO	1.4.2, ступень 6
$\gamma$	гамма	масштаб в нормализации; дисконт в RL	4.5, ступень 6
$\delta, \Delta$	дельта	малое изменение, разность: $\Delta x$	модуль 1.2
$\varepsilon$	эпсилон	крошечное число против деления на ноль (1e-8 в Adam); порог клиппинга в PPO и GRPO	1.4.2, ступень 6
$\eta$	эта	learning rate	модуль 1.4
$\theta$	тета	все параметры модели разом	везде
$\lambda$	лямбда	коэффициент регуляризации (weight decay)	2.1, 1.4.2
$\mu$	мю	среднее	этот урок, 1.3
$\sigma$	сигма	стандартное отклонение; сигмоида $\sigma(x)$	1.0.1, этот урок
$\pi$	пи	число 3.14…, а в RL — политика, то есть сама модель $\pi_\theta$	ступень 6
$\tau$	тау	температура (часто пишут и $T$)	4.1.3
$\Sigma$	сигма заглавная	сумма	этот урок
$\Pi$	пи заглавная	произведение	этот урок
$\nabla$	набла	градиент	1.2.3
$\partial$	«дэ круглое»	частная производная	1.2.3

Одна буква — разные смыслы

$\sigma$ — это и сигмоида, и стандартное отклонение. $\pi$ — и 3.14, и политика в RL. $V$ — и размер словаря, и матрица значений в attention. Смысл задаёт контекст, и хорошая статья объясняет его прямо под формулой: «where $\sigma$ denotes…». Всегда читайте этот абзац «where…» — это словарь к формуле.

Латинские буквы тоже имеют привычные роли: $x$ — вход, $y$ — правильный ответ, $\hat y$ — предсказание, $w$ и $W$ — веса, $b$ — смещение, $\mathcal{L}$ или $L$ — loss, $n$ или $N$ — число примеров, $d$ — размерность, $t$ — позиция токена или шаг обучения, $T$ — длина последовательности.

Индексы: нижние и верхние

Нижний индекснижний индексEN subscript (index)x_i — i-й элемент. В формулах счёт обычно с 1, в Python — с 0. Индекс бывает и просто названием, как k в d_k. $x_i$ означает «$i$-й элемент $x$». Пусть $x = (5, 8, 2, 7)$. В математике счёт обычно идёт с единицы: $x_1 = 5$, $x_3 = 2$. В Python — с нуля: x[0] == 5, x[2] == 2. Это главный источник ошибок при переводе формул в код:

В формуле	В Python
$x_1, x_2, \ldots, x_n$	x[0], x[1], …, x[n-1]
$i = 1, \ldots, n$	for i in range(n)
$W_{ij}$ — строка $i$, столбец $j$	W[i][j] или в NumPy W[i, j] (с тем же сдвигом: $W_{11}$ — это W[0, 0])

Индекс-название. Не каждый нижний индекс — номер. В $d_k$ буква $k$ значит «keys»: это просто имя «размерность ключей». Точно так же $\beta_1$ — «первая бета», $\pi_\theta$ — «политика с параметрами $\theta$», $\nabla_\theta$ — «градиент по $\theta$». Подсказка: если по букве в индексе нет суммы и она не меняется в цикле, скорее всего, это название.

Верхние индексы бывают четырёх видов:

Запись	Читается	Что значит
$x^2$	икс в квадрате	степень (урок 1.0.2)
$x^{(i)}$	икс с индексом i в скобках	$i$-й пример датасета, а не степень
$W^\top$ или $W^T$	W транспонированная	строки и столбцы меняются местами (урок 1.1.2)
$W^Q$, $\theta^*$	W с индексом Q, тета со звёздочкой	метки: «матрица для запросов», «лучшие параметры»

Значки над буквой тоже несут смысл: $\hat y$ («с крышкой») — предсказание или оценка, $\bar x$ («с чертой») — среднее, $\tilde x$ («с тильдой») — изменённая или приближённая версия, $x'$ («штрих») — другое значение $x$ или производная.

Знак суммы Σ — это цикл for

Знак суммызнак суммы (Σ)EN summation notation (sigma notation)Σ_{i=1}^{n} x_i — «сложить x_i для i от 1 до n»; в коде — цикл for с накоплением суммы от 0. — самый частый значок в ML:

$$\sum_{i=1}^{n} x_i = x_1 + x_2 + \ldots + x_n$$

Читается: «сумма по $i$ от 1 до $n$ икс-итых». Под знаком записаны переменная цикла и начало ($i = 1$), над ним — конец ($n$), справа — что складываем (тело цикла). Перевод в Python один к одному:

x = [5, 8, 2, 7]
n = len(x)

total = 0                  # сумма начинается с нуля
for i in range(n):         # i = 0, 1, …, n−1 (в формуле 1, …, n)
    total += x[i]          # тело суммы: x_i
print(total)               # 22
print(sum(x))              # 22 — то же самое встроенной функцией

Справа от $\Sigma$ может стоять любое выражение. Например, $\sum_{i=1}^{n} x_i^2 = 25 + 64 + 4 + 49 = 142$, в коде sum(xi ** 2 for xi in x).

Среднее и дисперсия. Две формулы, которые встретятся сотни раз:

$$\mu = \frac{1}{n} \sum_{i=1}^{n} x_i, \qquad \sigma^2 = \frac{1}{n} \sum_{i=1}^{n} (x_i - \mu)^2$$

Среднее $\mu$ — сумма, делённая на количество: $22 / 4 = 5.5$. Дисперсия $\sigma^2$ — средний квадрат отклонения от среднего. Отклонения равны $-0.5, 2.5, -3.5, 1.5$, их квадраты — $0.25, 6.25, 12.25, 2.25$, сумма — 21, а $\sigma^2 = 21 / 4 = 5.25$. Стандартное отклонение — корень из дисперсии: $\sigma = \sqrt{5.25} \approx 2.29$. Обратите внимание: формула дисперсии использует результат формулы среднего. В коде сначала считаем mu, потом дисперсию.

Сокращённые записи. Часто пределы суммы не пишут: $\sum_i x_i$ значит «по всем $i$». Запись $\sum_{i \in S}$ значит «по всем $i$ из множества $S$». Двойная сумма $\sum_{i=1}^{m} \sum_{j=1}^{n} W_{ij}$ — это два вложенных цикла: сумма всех элементов матрицы.

Взвешенная сумма — это нейрон. Нейрон из урока 1.0.1 с $n$ входами записывают так:

$$z = \sum_{i=1}^{n} w_i x_i + b$$

w = [0.5, -1.0, 2.0]
x = [4.0, 1.0, 0.5]
b = 0.1
z = sum(wi * xi for wi, xi in zip(w, x)) + b    # 0.5·4 − 1·1 + 2·0.5 + 0.1
print(z)                                        # 2.1

Знак произведения Π

Знак произведениязнак произведения (Π)EN product notation (capital pi)Π_{i=1}^{n} x_i — «перемножить все x_i»; накопление начинается с 1. устроен так же, только числа перемножаются, и накопление начинается с единицы (с нуля всё обнулится):

$$\prod_{i=1}^{n} x_i = x_1 \cdot x_2 \cdot \ldots \cdot x_n$$

Главная формула языкового моделирования (урок 4.1.1) — как раз произведение:

$$p(x_1, \ldots, x_T) = \prod_{t=1}^{T} p(x_t \mid x_{<t})$$

Читаем по символам: «вероятность всей последовательности от $x_1$ до $x_T$ равна произведению по $t$ от 1 до $T$ вероятностей токена $x_t$ при условии всех предыдущих токенов». Вертикальная черта $\mid$ читается «при условии» (урок 1.3.1). Запись $x_{<t}$ означает «все $x$ с номерами меньше $t$», то есть префикс текста.

Из прошлого урока мы знаем, что логарифм превращает произведение в сумму: $\log \prod_t p_t = \sum_t \log p_t$. Поэтому в коде вы почти никогда не увидите $\Pi$ — только сумму логарифмов:

import math
probs = [0.5, 0.2, 0.9]       # p(x_t | x_<t) для трёх токенов

p = 1.0                       # произведение начинается с 1
for q in probs:
    p *= q
print(p)                                  # 0.09000000000000001
print(math.log(p))                        # -2.407945608651872
print(sum(math.log(q) for q in probs))    # -2.407945608651872 — то же через сумму

Векторы и матрицы в формулах

Во многих учебниках (например, в d2l) шрифт подсказывает тип объекта:

• $x$ — курсив, строчная буква: скаляр (одно число);
• $\mathbf{x}$ — жирная строчная: вектор (список чисел);
• $\mathbf{W}$ или $W$ — заглавная: матрица (таблица чисел).

Многие статьи жирный шрифт не используют, и тип приходится угадывать по контексту. Здесь выручает запись с $\in$ — самая полезная строчка в любой статье, потому что она сообщает формы (shape) массивов:

Формула	Читается	В NumPy
$\mathbf{x} \in \mathbb{R}^{d}$	x принадлежит эр в степени d	x.shape == (d,)
$W \in \mathbb{R}^{m \times n}$	W — матрица m на n из вещественных чисел	W.shape == (m, n)
$\mathbf{w}^\top \mathbf{x}$	w транспонированное на x	w @ x — то же, что $\sum_i w_i x_i$
$W\mathbf{x}$	W на x	W @ x
$\mathbf{a} \odot \mathbf{b}$	поэлементное произведение	a * b

Буквой $\mathbb{R}$ обозначают множество вещественных (обычных дробных) чисел. Запись $\mathbf{w}^\top \mathbf{x}$ — это сумма $\sum_i w_i x_i$ из раздела про нейрон, только короче. Так что нейрон пишут ещё и так: $z = \mathbf{w}^\top \mathbf{x} + b$. Как устроены векторы и матрицы, разберём в модуле 1.1, а пока достаточно уметь их узнавать.

Другие значки

Значок	Читается	Пример	В коде
$:=$	«по определению равно»	$\mathrm{ReLU}(x) := \max(0, x)$	def relu(x): …
$\leftarrow$	«присвоить»	$\theta \leftarrow \theta - \eta g$	theta = theta - lr * g
$\approx$	приблизительно равно	$\ln 152\,000 \approx 11.9$	math.isclose(a, b)
$\propto$	пропорционально	$p_i \propto e^{z_i}$	равно с точностью до общего множителя
$\in$	принадлежит	$i \in \{1, \ldots, n\}$	i in range(n), форма массива
$\ll$	много меньше	$d_c \ll d_h n_h$	—
$\max_i z_i$	максимум	$\max(3, 7, 5) = 7$	max(z)
$\arg\max_i z_i$	аргмакс: номер максимума	$\arg\max(3, 7, 5) = 2$	np.argmax(z) вернёт 1
$\lvert x \rvert$	модуль или размер множества	$\lvert V \rvert$ — число токенов в словаре	abs(x), len(V)
$\lVert \mathbf{x} \rVert$	норма (длина) вектора	$\lVert \mathbf{x} \rVert_2$	np.linalg.norm(x) (урок 1.1.1)
$\mathbb{E}$	математическое ожидание	$\mathbb{E}_{x \sim D}[\mathcal{L}]$	среднее по батчу (урок 1.3.1)
$\sim$	«выбрано из распределения»	$x \sim D$	сэмплирование

Обратите внимание на $\arg\max$. В математике счёт идёт с единицы, и аргмакс $(3, 7, 5)$ равен 2. np.argmax считает с нуля и вернёт 1. Это тот же сдвиг на единицу, что и с индексами. Аргмакс понадобится в «жадной» генерации: модель берёт токен с наибольшей вероятностью (урок 4.1.3).

Разбираем настоящие формулы

Теперь словаря хватает, чтобы прочитать пять формул, на которых держится весь курс. Для каждой — чтение по символам, пример с числами и код.

1. Среднеквадратичная ошибка (MSE)

$$\mathrm{MSE} = \frac{1}{n} \sum_{i=1}^{n} \left(\hat y_i - y_i\right)^2$$

Читаем: «одна $n$-я суммы по $i$ от 1 до $n$ квадратов разностей предсказания $\hat y_i$ и ответа $y_i$». По частям: $\frac{1}{n}$ — усреднение, $\Sigma$ — цикл по примерам, $(\hat y_i - y_i)$ — ошибка на $i$-м примере, квадрат — штраф, который растёт быстрее ошибки (урок 1.0.1). Это MSEсреднеквадратичная ошибка (MSE)EN mean squared error (MSE)Корень из MSE — RMSE (root mean squared error), измеряется в тех же единицах, что и целевая переменная., среднеквадратичная ошибка.

Числа: $y = (3, 5, 2)$, $\hat y = (2.5, 5, 4)$. Ошибки равны $-0.5, 0, 2$, квадраты — $0.25, 0, 4$. Сумма 4.25, делим на 3 и получаем MSE $\approx 1.417$.

y_true = [3.0, 5.0, 2.0]
y_pred = [2.5, 5.0, 4.0]
n = len(y_true)

total = 0.0
for i in range(n):
    total += (y_pred[i] - y_true[i]) ** 2    # (ŷ_i − y_i)²
print(total / n)                             # 1.4166666666666667

2. Softmax

$$\mathrm{softmax}(\mathbf{z})_i = \frac{e^{z_i}}{\sum_{j=1}^{V} e^{z_j}}$$

Читаем: «$i$-я компонента softmax от вектора $\mathbf{z}$ равна $e$ в степени $z_i$, делённому на сумму по $j$ от 1 до $V$ экспонент $z_j$». Здесь $\mathbf{z}$ — логиты: «сырые» оценки, которые модель выдаёт для каждого токена словаря. Это любые числа, в том числе отрицательные. $V$ — размер словаря (не матрица значений!). Softmax превращает логиты в вероятности: все положительные, в сумме 1.

Главное наблюдение — в формуле два разных индекса. Индекс $i$ свободный: формула верна для каждого $i$, поэтому результат — целый вектор. Индекс $j$ связанный: он живёт только внутри $\Sigma$ и «исчезает» после суммирования. В коде сумма по $j$ считается один раз, а потом используется для каждого $i$. Эту же формулу часто пишут короче: $p_i \propto e^{z_i}$ — «вероятность пропорциональна экспоненте логита».

Числа: $\mathbf{z} = (2, 1, 0.1)$. Экспоненты равны $(7.389, 2.718, 1.105)$, их сумма — 11.213. Делим каждую на сумму и получаем $(0.659, 0.242, 0.099)$.

import math
z = [2.0, 1.0, 0.1]
exps = [math.exp(zj) for zj in z]          # e^{z_j} для всех j
s = sum(exps)                              # Σ_j e^{z_j} — считаем один раз
p = [e / s for e in exps]                  # для каждого i: e^{z_i} / s
print([round(pi, 3) for pi in p])          # [0.659, 0.242, 0.099]

Это «школьная» версия. На логитах вроде 1000 она переполнится. Устойчивую версию вы напишете в уроке 1.3.2.

3. Cross-entropy

$$H(p, q) = -\sum_{i=1}^{V} p_i \log q_i$$

Читаем: «аш от $p$ и $q$ равно минус сумме по $i$ от 1 до $V$ произведений $p_i$ на логарифм $q_i$». Здесь $p$ и $q$ — два распределения, то есть наборы вероятностей по всем токенам словаря с суммой 1. $p$ — правильный ответ, $q$ — предсказание модели (выход softmax), $\log$ — натуральный логарифм (урок 1.0.2). В языковой модели правильный ответ один — токен $t$. Поэтому $p_t = 1$, а остальные $p_i = 0$ (такой вектор называют one-hot). В сумме выживает одно слагаемое:

$$H = -\log q_t$$

Числа: берём $q = (0.659, 0.242, 0.099)$ из softmax выше и правильный токен $t = 1$ (первый). Тогда $H = -\ln 0.659 \approx 0.417$.

import math
q = [0.659, 0.242, 0.099]                          # из softmax
p = [1, 0, 0]                                      # one-hot: правильный — первый токен
full = -sum(pi * math.log(qi) for pi, qi in zip(p, q))
short = -math.log(q[0])                            # индекс 0 в Python = t = 1 в формуле
print(round(full, 3), round(short, 3))             # 0.417 0.417

Это cross-entropyперекрёстная энтропияEN cross-entropy — функция потерь каждой LLM. Почему она именно такая, подробно разобрано в уроке 1.3.2.

4. Шаг градиентного спуска

$$\theta \leftarrow \theta - \eta \, \nabla_\theta \mathcal{L}(\theta)$$

Читаем: «тета присвоить тета минус эта, умноженное на градиент эл по тета». Здесь $\theta$ — все параметры, $\eta$ — learning rateскорость обученияEN learning rate, а $\nabla_\theta \mathcal{L}$ — градиент функции потерь, то есть направление её самого быстрого роста (урок 1.2.3). Минус означает «идём в обратную сторону», вниз по склону. Стрелка $\leftarrow$ — это присваивание, как = в коде.

Числа: вернёмся к «чаше» $\mathcal{L}(w) = (2w - 6)^2$ из урока 1.0.1. Её производная равна $8w - 24$ (как её найти, узнаете в модуле 1.2). Начнём с $w = 2$ и $\eta = 0.1$:

w, lr = 2.0, 0.1
for step in range(4):
    grad = 8 * w - 24           # ∇L(w)
    w = w - lr * grad           # θ ← θ − η·∇L
    print(step, round(w, 4))

0 2.8
1 2.96
2 2.992
3 2.9984

С каждым шагом $w$ подходит к дну чаши $w = 3$. Именно этот цикл в разных обличьях крутится при обучении любой нейросети (градиентный спускградиентный спускEN gradient descent, модуль 1.4).

5. Attention

$$\mathrm{Attention}(Q, K, V) = \mathrm{softmax}\!\left(\frac{QK^\top}{\sqrt{d_k}}\right) V$$

Читаем: «attention от $Q$, $K$, $V$ равно softmax от $Q$, умноженного на $K$ транспонированное и делённого на корень из $d_k$, и всё это умножить на $V$». Это формула (1) из статьи «Attention Is All You Need», сердце трансформера (механизм вниманиямеханизм вниманияEN attention). Разберём каждый символ. Пусть в тексте $T$ токенов:

Символ	Форма	Смысл
$Q$ (queries, запросы)	$T \times d_k$	что ищет каждый токен
$K$ (keys, ключи)	$T \times d_k$	что предлагает каждый токен
$V$ (values, значения)	$T \times d_v$	какую информацию токен передаёт
$QK^\top$	$T \times T$	все попарные сходства: элемент $(i, j)$ равен $\sum_c Q_{ic} K_{jc}$
$\sqrt{d_k}$	число	масштаб, чтобы числа не росли с размерностью (урок 4.4.2)
$\mathrm{softmax}(\cdot)$	$T \times T$	каждую строку превращает в веса с суммой 1
$(\ldots)\,V$	$T \times d_v$	каждая строка ответа — взвешенная сумма строк $V$

Здесь $V$ — матрица значений, а не размер словаря, как в softmax выше. Снова решает контекст.

flowchart LR
Q["Q (T×d_k)"] --> S["Q·Kᵀ / √d_k<br/>(T×T)"]
K["K (T×d_k)"] --> S
S --> W["softmax по строкам<br/>веса (T×T)"]
W --> O["веса · V<br/>ответ (T×d_v)"]
V["V (T×d_v)"] --> O

Путь данных в формуле attention

Числа: возьмём один запрос $\mathbf{q} = (1, 0)$ и три токена с ключами $(1, 0)$, $(0, 1)$, $(-1, 0)$ и значениями $(10, 0)$, $(0, 10)$, $(0, 0)$; $d_k = 2$. Сначала распишем формулу циклами — каждое умножение матриц превращается в $\Sigma$:

import math

q = [1.0, 0.0]                                   # запрос одного токена
K = [[1.0, 0.0], [0.0, 1.0], [-1.0, 0.0]]        # ключи трёх токенов
V = [[10.0, 0.0], [0.0, 10.0], [0.0, 0.0]]       # значения трёх токенов
d_k = len(q)

scores = []
for j in range(len(K)):                          # для каждого токена j
    s = sum(q[c] * K[j][c] for c in range(d_k))  # Σ_c q_c · K_jc — сходство запроса с ключом j
    scores.append(s / math.sqrt(d_k))            # делим на √d_k
print([round(s, 3) for s in scores])             # [0.707, 0.0, -0.707]

exps = [math.exp(s) for s in scores]
weights = [e / sum(exps) for e in exps]          # softmax
print([round(w, 3) for w in weights])            # [0.576, 0.284, 0.14]

out = [sum(weights[j] * V[j][c] for j in range(len(V))) for c in range(2)]   # Σ_j w_j · v_j
print([round(o, 3) for o in out])                # [5.76, 2.84]

Запрос больше всего похож на первый ключ, поэтому первый токен получил наибольший вес 0.576 и в ответе преобладает его значение. А теперь та же формула для трёх запросов сразу, на NumPy — одна строка на символ:

import numpy as np

Q = np.array([[1.0, 0.0], [0.0, 1.0], [-1.0, 0.0]])    # (T=3, d_k=2)
K = np.array([[1.0, 0.0], [0.0, 1.0], [-1.0, 0.0]])    # (3, 2)
V = np.array([[10.0, 0.0], [0.0, 10.0], [0.0, 0.0]])   # (3, 2)
d_k = Q.shape[1]

scores = Q @ K.T / np.sqrt(d_k)                                         # QKᵀ/√d_k → (3, 3)
weights = np.exp(scores) / np.exp(scores).sum(axis=1, keepdims=True)   # softmax по строкам
out = weights @ V                                                       # · V → (3, 2)
print(out.round(3))

[[5.76  2.84 ]
 [2.483 5.035]
 [1.4   2.84 ]]

Первая строка совпала с ответом циклов. Подробно attention разберём в модуле 4.4, а сейчас важно, что вы можете прочитать эту формулу символ за символом.

Шпаргалка: как прочитать незнакомую формулу

Пять разборов выше шли по одному и тому же плану. Он работает и для формулы из любой новой статьи:

1. Что вычисляем? Посмотрите на левую часть: число, вектор или матрица получится в итоге.
2. Прочитайте абзац «where…» под формулой и выпишите, что значит каждая буква.
3. Найдите формы. Записи вида $\in \mathbb{R}^{m \times n}$ подскажут shape каждого массива.
4. Разберите индексы. Индекс под $\Sigma$ или $\Pi$ — переменная цикла, свободный индекс — «для каждого», индекс-название — просто имя.
5. Подставьте маленькие числа — два-три элемента, как в наших примерах, — и посчитайте руками.
6. Напишите циклами, сверьте с ручным счётом и только потом переходите на NumPy.

Если на каком-то шаге застряли, значит, не хватает одного обозначения. Найдите его в таблицах этого урока или в разделе обозначений книги d2l (ссылка в источниках).

Практика

Переведите шесть формул в код: среднее, дисперсию, MSE, произведение $\Pi$, скалярное произведение и аргмакс. Формула каждой функции записана в её docstring.

Формулы с Σ и Π → код на Python6 тестов

# Переведите каждую формулу в код. Можно циклом for (так нагляднее),
# можно встроенными sum(...) и генераторами. NumPy здесь не нужен.
# Помните: в формулах индексы идут с 1 до n, а в Python — с 0 до n−1.


def mean(xs):
    """Среднее: μ = (1/n) · Σ_{i=1}^{n} x_i

    mean([2, 4, 6]) → 4.0
    """
    # TODO
    ...


def variance(xs):
    """Дисперсия: σ² = (1/n) · Σ_{i=1}^{n} (x_i − μ)², где μ — среднее.

    variance([2, 4, 4, 4, 5, 5, 7, 9]) → 4.0
    """
    # TODO: сначала посчитайте μ через mean(xs)
    ...


def mse(y_pred, y_true):
    """Среднеквадратичная ошибка: MSE = (1/n) · Σ_{i=1}^{n} (ŷ_i − y_i)²

    mse([2.5, 5.0, 4.0], [3.0, 5.0, 2.0]) → 1.4166…
    """
    # TODO
    ...


def product(xs):
    """Произведение: Π_{i=1}^{n} x_i = x_1 · x_2 · … · x_n

    product([1, 2, 3, 4]) → 24.  Произведение пустого списка равно 1.
    """
    # TODO: с какого числа начинать накопление — с 0 или с 1?
    ...


def dot(w, x):
    """Скалярное произведение: wᵀx = Σ_{i=1}^{n} w_i · x_i

    dot([0.5, -1.0, 2.0], [4.0, 1.0, 0.5]) → 2.0
    """
    # TODO
    ...


def argmax(xs):
    """argmax_i x_i — НОМЕР (индекс с нуля) самого большого элемента, а не сам элемент.

    argmax([0.1, 0.7, 0.2]) → 1.  При равенстве — первый из максимальных.
    """
    # TODO
    ...


print(mean([2, 4, 6]), variance([2, 4, 4, 4, 5, 5, 7, 9]))
print(mse([2.5, 5.0, 4.0], [3.0, 5.0, 2.0]))
print(product([1, 2, 3, 4]), dot([0.5, -1.0, 2.0], [4.0, 1.0, 0.5]))
print(argmax([0.1, 0.7, 0.2]))

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

Китайский угол: читаем формулу из статьи DeepSeek

Проверим словарь урока на настоящей формуле 2024 года. В статье DeepSeek-V2 (раздел 2.1.2) описано многоголовое латентное внимание (MLA)многоголовое латентное внимание (MLA)EN multi-head latent attention (MLA)Предложено DeepSeek в DeepSeek-V2 (2024).. Это главная причина, по которой DeepSeek хранит намного меньший KV-кэшKV-кэшEN KV cache:

$$\mathbf{c}_t^{KV} = W^{DKV} \mathbf{h}_t, \qquad \mathbf{k}_t^{C} = W^{UK} \mathbf{c}_t^{KV}, \qquad \mathbf{v}_t^{C} = W^{UV} \mathbf{c}_t^{KV}$$

Читаем по символам:

• $\mathbf{h}_t$ — жирная строчная, значит, вектор: скрытое состояние токена (вектор, которым модель представляет токен внутри слоя); нижний индекс $t$ — номер позиции.
• $W^{DKV}$ — матрица, а верхний индекс — метка, не степень: D = down-projection (сжатие), KV = «для ключей и значений».
• $\mathbf{c}_t^{KV} \in \mathbb{R}^{d_c}$ — сжатый (compressed) вектор длины $d_c$.
• $W^{UK}$ и $W^{UV}$ — матрицы up-projection, которые восстанавливают из сжатого вектора ключи $\mathbf{k}_t^{C}$ и значения $\mathbf{v}_t^{C}$.

В статье под формулой стоит $d_c \ll d_h n_h$ — «много меньше». В DeepSeek-V2 $d_c = 512$, а $d_h n_h = 128 \cdot 128 = 16\,384$, то есть в 32 раза больше. В кэше хранится в основном короткий $\mathbf{c}_t^{KV}$ (плюс небольшой ключ для позиционного кодирования), а не полные ключи и значения. Как это работает целиком, разберём в модуле 5.2. А читать такие строчки вы умеете уже сейчас.

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

Проверь себя

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

1 Как перевести $\sum_{i=1}^{n} x_i^2$ в Python для списка x длины n?

sum(x) ** 2sum(xi ** 2 for xi in x)sum(x[i] ** 2 for i in range(1, n + 1))x ** 2

2 Дано $x = (4, 1, 9, 2)$, счёт с единицы. Чему равен $\arg\max_i x_i$?

3 В каких записях верхний индекс НЕ означает возведение в степень?Можно выбрать несколько ответов

$x^{(i)}$ — пример датасета$W^\top$$W^{Q}$ в attention$(\hat y_i - y_i)^2$ в MSE

4 Шаг $\theta \leftarrow \theta - \eta \nabla_\theta \mathcal{L}$ при $\theta = 1.0$, $\eta = 0.5$ и градиенте $0.4$. Каким станет $\theta$?

5 В attention матрица $Q$ имеет форму $10 \times 64$ (10 токенов, $d_k = 64$). Какой формы $QK^\top$?

$10 \times 10$$64 \times 64$$10 \times 64$$64 \times 10$

6 Как называется значок $\nabla$, которым обозначают градиент?

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

Итоги

• Греческие буквы — просто имена переменных с устойчивыми ролями: $\theta$ — параметры, $\eta$ — learning rate, $\mu$ и $\sigma$ — среднее и разброс, $\varepsilon$ — крошечное число. Смысл уточняйте в абзаце «where…» под формулой.
• $\Sigma$ — цикл со сложением, начатым с 0, $\Pi$ — цикл с умножением, начатым с 1. В формулах счёт с 1, в Python — с 0.
• Верхний индекс бывает степенью ($x^2$), номером примера ($x^{(i)}$), транспонированием ($W^\top$) или меткой ($W^Q$). Запись $\in \mathbb{R}^{m \times n}$ сообщает форму массива.
• Вы прочитали и перевели в код MSE, softmax, cross-entropy, шаг градиентного спуска, attention и даже формулу MLA из статьи DeepSeek.

Дальше: тригонометрия для ML — радианы, синус и косинус как координаты точки на окружности и повороты векторов. На этом стоят позиционные кодировки трансформера и RoPE.