Self-attention

Предыдущая заметка позволила декодеру рекуррентного переводчика оценивать каждое состояние энкодера и считывать их взвешенное среднее. Сам энкодер по-прежнему рекуррентный: $n$ токенов требуют $n$ последовательных шагов, а связь между двумя далёкими словами проходит через каждый шаг между ними. В этой заметке тот же поиск применяется внутри одной последовательности: каждая позиция оценивает каждую позицию, включая себя, и считывает взвешенное среднее по всем ним — одним матричным произведением. Эта операция называется self-attention (внимание последовательности к самой себе); в виде нескольких параллельных голов (heads) это единственная операция трансформера, которая смешивает позиции (Vaswani et al., 2017). Матричные иллюстрации того же вычисления есть у Alammar (2018) и Jurafsky and Martin.

Обозначения. Последовательность из $n$ токенов с $d$-мерными векторами — это матрица $X \in \mathbb R^{n \times d}$; её строка $x_i$ — вектор токена $i$: эмбеддинг (embedding) или выход предыдущего слоя. Векторы — строки, как в PyTorch. Обучаемые матрицы $W_Q, W_K \in \mathbb R^{d \times d_k}$ и $W_V \in \mathbb R^{d \times d_v}$ дают запрос (query) $q_i = x_i W_Q$, ключ (key) $k_i = x_i W_K$ и значение (value) $v_i = x_i W_V$. Оценки внимания (attention scores) обозначаются $s_{ij}$, веса внимания — $\alpha_{ij}$, выходы — $y_i$; $h$ — число голов. Softmax от матрицы берётся по строкам.

Задача: смысл слова зависит от других слов#

В предложении «Кубок не помещается в коричневый чемодан, потому что он слишком большой» он — это кубок; если заменить большой на маленький, то он — это чемодан. В этой схеме Винограда (Winograd schema) (Levesque, Davis and Morgenstern, 2012) статический эмбеддинг даёт слову он один и тот же вектор в обоих предложениях. Нам нужен слой, который переписывает вектор каждого токена с учётом связанных с ним токенов, выбранных по их содержанию и стоящих в любом месте предложения.

Базовый подход: рекуррентность и внимание поверх неё#

Рекуррентный энкодер (заметка об LSTM) смешивает контекст, передавая состояние вдоль последовательности в одном или в обоих направлениях. Внимание (attention) из предыдущей заметки стоит между декодером и энкодером; энкодер остаётся рекуррентным.

Где этот подход не справляется:

• Последовательные вычисления. Шагу $t$ нужно состояние шага $t-1$, поэтому $n$ шагов нельзя выполнить параллельно.
• Длинные пути. Сигнал и градиент между позициями $i$ и $j$ проходят через $|i - j|$ нелинейных обновлений одного состояния фиксированной ширины. Вентили (gates) делают этот путь обучаемым, но не коротким.
• Смешивание — не сравнение. Сколько от токена $j$ доходит до токена $i$, решают гейты по мере продвижения состояния, а не сравнение $i$ с $j$.

Внимание как мягкий поиск по словарю#

Словарь сравнивает запрос с хранимыми ключами и возвращает значение того ключа, который совпал в точности. Внимание делает совпадение мягким: softmax превращает оценки совпадения в веса, дающие в сумме единицу, а результат — взвешенное среднее всех значений. Поскольку веса гладко зависят от оценок, все три проекции обучаются обратным распространением ошибки.

В предыдущей заметке запросом служит состояние декодера, а состояния энкодера — одновременно ключами и значениями (Bahdanau, Cho and Bengio, 2015). Self-attention берёт все три из одной и той же последовательности (Cheng, Dong and Lapata, 2016, ещё до трансформера). Cross-attention (внимание к выходам энкодера) берёт запросы из одной последовательности, а ключи и значения — из другой, с матрицей весов $m \times n$ для $m$ запросов и $n$ ключей; заметка о трансформере помещает его в декодер.

От эмбеддингов к Q, K и V#

Для одного токена $i$ слой делает четыре вещи (пошаговый разбор в этом же порядке — у Starmer, 2023):

1. Проекция. $q_i = x_i W_Q$, и для каждого токена $j$: $k_j = x_j W_K$, $v_j = x_j W_V$. Каждая из них — линейный слой без смещения.
2. Оценка. $s_{ij} = q_i \cdot k_j / \sqrt{d_k}$ для каждого $j$, включая $j = i$.
3. Нормировка. $\alpha_{ij} = \exp(s_{ij}) / \sum_{l=1}^{n} \exp(s_{il})$. Веса положительны и $\sum_j \alpha_{ij} = 1$.
4. Смешивание. $y_i = \sum_{j=1}^{n} \alpha_{ij} v_j$.

Одни и те же $W_Q$, $W_K$ и $W_V$ используются в каждой позиции, поэтому один слой обрабатывает последовательности любой длины. Строки $Y$ — контекстные эмбеддинги: одно и то же слово получает разные векторы в разных предложениях; на них опираются заметка о BERT и семантический поиск.

Зачем разделять запросы и ключи#

Оценка через $x_i \cdot x_j$ не работает по двум причинам. Она симметрична, поэтому «местоимение ищет свой антецедент» и обратное отношение были бы одним и тем же. И сам токен обычно побеждает в своей строке: по неравенству Коши–Буняковского $x_i \cdot x_j \le \lVert x_i \rVert \lVert x_j \rVert \le \lVert x_i \rVert^2$, если $\lVert x_j \rVert \le \lVert x_i \rVert$, поэтому при равных нормах диагональный элемент — наибольшая оценка в каждой строке.

С проекциями оценка равна

$$s_{ij} = \frac{x_i\, W_Q W_K^\top\, x_j^\top}{\sqrt{d_k}},$$

то есть обучаемой билинейной форме. Она не обязана быть симметричной, а большая оценка для самого себя становится выученным выбором, а не заложенным заранее предпочтением. Ранг матрицы $W_Q W_K^\top$ не больше $d_k$: голова сравнивает токены вдоль $d_k$ выученных направлений. Отдельная $W_V$ разделяет то, что сопоставляется, и то, что передаётся дальше.

Почему скалярное произведение#

Предыдущая заметка сравнила аддитивную, билинейную и скалярную функции оценки (Luong, Pham and Manning, 2015). Здесь скалярное произведение делает всю матрицу оценок одним произведением $QK^\top$, а нормы несут информацию: запрос с большей нормой даёт более острый softmax, ключ с большей нормой забирает больше веса. Контролировать нужно только типичную величину оценок, которая растёт с $d_k$.

Внимание на основе масштабированного скалярного произведения#

Составив из строк матрицы, получаем матричную форму внимания на основе масштабированного скалярного произведения (scaled dot-product attention):

$$\begin{gathered} Q = X W_Q \in \mathbb R^{n \times d_k}, \\ K = X W_K \in \mathbb R^{n \times d_k}, \\ V = X W_V \in \mathbb R^{n \times d_v}, \end{gathered}$$ $$\begin{aligned} &\operatorname{Attention}(Q, K, V) \\ &\qquad = \operatorname{softmax}\!\Big(\frac{Q K^\top}{\sqrt{d_k}}\Big) V . \end{aligned}$$

Элемент $(i, j)$ матрицы $QK^\top$ равен $q_i \cdot k_j$; деление на $\sqrt{d_k}$ удерживает оценки в масштабе, с которым softmax может работать (ниже); softmax даёт $\alpha_{ij}$, а строка $i$ произведения с $V$ равна $y_i$: это четыре шага выше, выполненные сразу для всех токенов.

Матрица	Размер	Смысл
$X$	$n \times d$	представления токенов
$Q, K$	$n \times d_k$	запросы, ключи
$V$	$n \times d_v$	значения
$QK^\top$	$n \times n$	оценки «токен — токен»
$A = \operatorname{softmax}(QK^\top/\sqrt{d_k})$	$n \times n$	веса внимания, каждая строка даёт в сумме 1
$AV$	$n \times d_v$	по одному вектору с учётом контекста на каждый токен

Рисунок

Размеры матриц в self-attention и путь одной строки

Выход содержит по одной строке на каждый входной токен, поэтому слои можно ставить друг на друга. В батче, дополненном паддингом (padding), тензоры имеют размер $[B, n, d]$, а оценки — $[B, n, n]$.

Разобранный пример#

Три токена, «dogs chase cats» («собаки гонятся за кошками»), $d = 4$, $d_k = d_v = 2$, игрушечные числа:

$$X = \begin{pmatrix} 1&0&1&0 \\ 0&1&0&1 \\ 1&0&0&1 \end{pmatrix},$$ $$\begin{gathered} W_Q = \begin{pmatrix} 1&0 \\ 0&1 \\ 1&0 \\ 0&0 \end{pmatrix}, \qquad W_K = \begin{pmatrix} 0&1 \\ 1&0 \\ 0&0 \\ 1&1 \end{pmatrix}, \\[4pt] W_V = \begin{pmatrix} 1&0 \\ 0&2 \\ 1&1 \\ 0&1 \end{pmatrix}. \end{gathered}$$

Проекции:

$$\begin{gathered} Q = \begin{pmatrix} 2&0 \\ 0&1 \\ 1&0 \end{pmatrix}, \qquad K = \begin{pmatrix} 0&1 \\ 2&1 \\ 1&2 \end{pmatrix}, \\[4pt] V = \begin{pmatrix} 2&1 \\ 0&3 \\ 1&1 \end{pmatrix}. \end{gathered}$$

Оценки и масштабированные оценки ($\sqrt 2 \approx 1.414$):

$$\begin{gathered} QK^\top = \begin{pmatrix} 0&4&2 \\ 1&1&2 \\ 0&2&1 \end{pmatrix}, \\[4pt] \frac{QK^\top}{\sqrt 2} = \begin{pmatrix} 0&2.828&1.414 \\ 0.707&0.707&1.414 \\ 0&1.414&0.707 \end{pmatrix}. \end{gathered}$$

Softmax по строкам и выход:

$$\begin{gathered} A = \begin{pmatrix} 0.045&0.768&0.187 \\ 0.248&0.248&0.503 \\ 0.140&0.576&0.284 \end{pmatrix}, \\[4pt] Y = AV = \begin{pmatrix} 0.277&2.536 \\ 1.000&1.497 \\ 0.564&2.152 \end{pmatrix}. \end{gathered}$$

Проверим вторую строку вручную: $y_2 = 0.248\,(2, 1) + 0.248\,(0, 3) + 0.503\,(1, 1) = (1.000, 1.497)$ с точностью до округления. Dogs берёт 77% своего нового вектора от chase и лишь 4.5% от себя; chase берёт половину из cats. Каждая строка даёт в сумме единицу, столбцы — не обязательно.

Рисунок

Self-attention для одного токена: что куда идёт

Рисунок проводит строку chase через четыре шага раздела От эмбеддингов к Q, K и V: спроецировать (1), оценить (2), нормировать (3), смешать (4). Если положить его рядом с шагом внимания переводчика, это то же вычисление: запрос играет роль состояния декодера, ключи и значения — роль состояний энкодера. Нового две вещи, в янтарной рамке: все три берутся из одной последовательности обучаемыми проекциями, и каждый токен проходит те же четыре шага одновременно с остальными — это и вычисляет матричная форма выше.

Рисунок

Один запрос: от оценок к выходу

Те же входы без проекций, $A_0 = \operatorname{softmax}(XX^\top/\sqrt 4)$, делают мысль предыдущего подраздела наглядной:

$$\begin{gathered} XX^\top = \begin{pmatrix} 2&0&1 \\ 0&2&1 \\ 1&1&2 \end{pmatrix}, \\[4pt] A_0 = \begin{pmatrix} 0.506&0.186&0.307 \\ 0.186&0.506&0.307 \\ 0.274&0.274&0.452 \end{pmatrix}: \end{gathered}$$

оценки $XX^\top$ симметричны и диагональ побеждает в каждой строке, но сами веса не симметричны: у каждой строки свой знаменатель softmax, поэтому $\alpha_{13} = e^{0.5}/5.367 = 0.307$, а $\alpha_{31} = e^{0.5}/6.016 = 0.274$. При симметричных оценках влияние dogs на cats и cats на dogs по-прежнему задаётся одним числом, с точностью до нормировки строк. Выученные $W_Q \ne W_K$ делают несимметричными сами оценки, а большая оценка токена для самого себя становится выученным выбором.

Рисунок

Веса внимания с обучаемыми проекциями и без них

Зачем делить на $\sqrt{d_k}$#

Предположим, что компоненты $q$ и $k$ независимы, имеют среднее 0 и дисперсию 1 — примерно это дают инициализация и нормализация. Тогда $q \cdot k = \sum_{c=1}^{d_k} q_c k_c$ — сумма $d_k$ независимых слагаемых, у каждого из которых среднее $\mathbb E[q_c]\,\mathbb E[k_c] = 0$ и дисперсия $\mathbb E[q_c^2]\,\mathbb E[k_c^2] = 1$. Дисперсии независимых слагаемых складываются, поэтому

$$\operatorname{Var}(q \cdot k) = d_k, \qquad \operatorname{Var}\!\Big(\frac{q \cdot k}{\sqrt{d_k}}\Big) = 1 .$$

(Vaswani et al., 2017, §3.2.1, сноска 4.) Делитель — размер одной головы $d_k$ (64 в базовом трансформере), а не ширина модели $d$ (512).

Почему величина важна: якобиан softmax равен $\partial \alpha_j / \partial s_l = \alpha_j(\delta_{jl} - \alpha_l)$. Когда одна оценка доминирует, $\alpha$ близок к one-hot-вектору, все элементы якобиана близки к нулю, и $W_Q$ и $W_K$ перестают получать градиент. Сводка одним числом — след $\sum_j \alpha_j(1 - \alpha_j) = 1 - \sum_j \alpha_j^2$: $1 - 1/n$ для равномерных весов и $0$ для весов в виде one-hot-вектора.

Игрушечная симуляция: $n = 16$ ключей, $q, k \sim \mathcal N(0, I_{d_k})$, 2000 испытаний на каждое значение $d_k$, начальное значение генератора (seed) 0.

$d_k$	ст. откл. $q \cdot k$	наибольший вес, без масштаба	наибольший вес, с масштабом	$1 - \sum \alpha_j^2$, без масштаба	$1 - \sum \alpha_j^2$, с масштабом
1	0.99	0.21	0.21	0.87	0.87
4	1.99	0.43	0.23	0.71	0.87
16	4.01	0.69	0.25	0.43	0.87
64	8.02	0.84	0.25	0.22	0.87
512	22.49	0.94	0.25	0.08	0.87

Без масштабирования при $d_k = 64$ один ключ уже на инициализации забирает большую часть веса, а мера градиента падает до четверти. В разобранном примере без $\sqrt 2$ первая строка была бы $(0.016, 0.867, 0.117)$ вместо $(0.045, 0.768, 0.187)$. Масштаб задаёт только начальную точку: обучение по-прежнему может сделать внимание острым, увеличивая нормы запросов и ключей.

Рисунок

Зачем оценки делят на √d_k

Маски#

Исключаемым оценкам до softmax присваивается $-\infty$: поскольку $e^{-\infty} = 0$, их веса в точности равны нулю, а остальные веса строки по-прежнему дают в сумме единицу.

• Маска паддинга (padding mask). Столбцы [PAD] маскируются во всех строках: маска размера $[B, 1, n]$ распространяется (broadcasting) на все запросы. Выходы запросов-паддингов отбрасываются позже.
• Каузальная маска (causal mask). Языковая модель, предсказывающая токен $t + 1$, не должна давать позиции $t$ видеть более поздние позиции. Маскирование $j > i$ (верхний треугольник, размер $[n, n]$) делает это сразу для всех позиций, поэтому декодер обучается на всей последовательности за один проход; на это опирается заметка о GPT.

В разобранном примере, если считать cats паддингом, строки становятся $(0.056, 0.944, 0)$, $(0.5, 0.5, 0)$ и $(0.196, 0.804, 0)$; с каузальной маской — $(1, 0, 0)$, $(0.5, 0.5, 0)$ и $(0.140, 0.576, 0.284)$.

Рисунок

Маска паддинга и каузальная маска на одних и тех же оценках

scores = q @ k.transpose(-2, -1) / math.sqrt(d_k)          # [B, n, n]
scores = scores.masked_fill(mask, float("-inf"))           # mask: True там, где ключ запрещён
weights = scores.softmax(dim=-1)                           # каждая строка даёт в сумме 1 по разрешённым ключам
output = weights @ v                                       # [B, n, d_v]

causal = torch.triu(torch.ones(n, n, dtype=torch.bool), diagonal=1)   # True над диагональю

Phuong and Hutter (2022) приводят точный псевдокод для обеих масок. Строка, в которой замаскированы все ключи, даёт $0/0$, то есть NaN. Каузальная маска такого не допускает (диагональ разрешена), маска паддинга — тоже, пока в каждой последовательности есть настоящий токен; но при обеих масках и паддинге слева, как при генерации батчами, у запроса-паддинга могут быть замаскированы все ключи, поэтому реализации используют вместо $-\infty$ большое конечное отрицательное число.

Self-attention не видит порядка слов#

Без информации о позициях «cats chase dogs» переставляет строки $X$ и выхода, а у весов — строки и столбцы: dogs получает $(0.277, 2.536)$ в обоих предложениях. В общем случае $\operatorname{Attention}(\Pi X) = \Pi\,\operatorname{Attention}(X)$ для любой матрицы перестановки $\Pi$, если маски нет (каузальная маска привязана к позициям и это нарушает); доказательство — в заметке о позиционных представлениях. Порядок нужно передать извне: прибавить к $X$ (абсолютные позиции) или встроить в оценки (относительные и ротационные позиции).

Рисунок

Перестановка двух слов лишь переставляет результат

Многоголовое внимание#

Токену часто нужны сразу несколько отношений: его синтаксическая вершина, антецедент, предыдущий токен. Один softmax может распределить вес по ним, но тогда их значения усредняются в один вектор. Многоголовое внимание (multi-head attention) запускает $h$ вычислений внимания параллельно, каждое со своими проекциями меньшего размера, и объединяет их выходы:

$$\begin{gathered} H_r = \operatorname{Attention}\big(Q^{(r)}, K^{(r)}, V^{(r)}\big), \\ \operatorname{MultiHead}(X) = \big[H_1; \dots; H_h\big]\, W_O , \end{gathered}$$

где $Q^{(r)} = X W_Q^{(r)}$, $K^{(r)} = X W_K^{(r)}$, $V^{(r)} = X W_V^{(r)}$ для $r = 1, \dots, h$, выход $H_r$ головы $r$ лежит в $\mathbb R^{n \times d_v}$, $[\,\cdot\,;\,\cdot\,]$ — конкатенация по оси признаков, а $W_O \in \mathbb R^{h d_v \times d}$.

При $d_k = d_v = d/h$ все $3h$ матриц проекций содержат $3h \cdot d \cdot d/h = 3d^2$ весов, а $W_O$ — ещё $d^2$: $4d^2$ на слой при любом $h$, как у одной головы полной ширины. В небольшом энкодере для AG News из заметки о трансформере ($d = 32$, $h = 4$, $d_k = 8$) это $3 \cdot 4 \cdot 32 \cdot 8 + 32^2 = 4\,096$. Базовый трансформер использует $d = 512$, $h = 8$, $d_k = d_v = 64$; у BERT-base ($d = 768$, $h = 12$) — $4 \cdot 768^2 \approx 2.36$ млн весов внимания на слой.

Конкатенация, за которой следует $W_O$, — это сумма по головам. Разобьём $W_O$ на $h$ блоков по $d_v$ строк, $W_O^{(r)}$; тогда, обозначив через $A^{(r)}$ матрицу весов головы $r$, получаем

$$\operatorname{MultiHead}(X) = \sum_{r=1}^{h} A^{(r)}\, X\, W_V^{(r)} W_O^{(r)} .$$

Каждая голова добавляет свой вклад, со своим шаблоном внимания и своим отображением $W_V^{(r)} W_O^{(r)}$ ранга не выше $d_v$ из прочитанного в записываемое (Elhage et al., 2021). В коде головы — одна проекция, у которой затем меняется форма; это быстрее, чем цикл по головам:

# W_Q: [d, h*d_k], h матриц W_Q^(r), поставленных рядом; так же для W_K и W_V
q = (x @ W_Q).view(B, n, h, d_k).transpose(1, 2)    # [B, h, n, d_k]; так же для k и v
out = attention(q, k, v, mask)                      # mask: [B, 1, n, n] или [B, 1, 1, n], распространяется на все головы; out: [B, h, n, d_k]
out = out.transpose(1, 2).reshape(B, n, h * d_k)    # конкатенация голов
y = out @ W_O                                       # [B, n, d]

Рисунок

Многоголовое внимание: четыре головы размера 8 в модели ширины 32

Головы работают бок о бок, и их вклады суммируются; слои ставятся друг на друга, поэтому запросы слоя уже несут контекст из нижних слоёв. Обученные головы смотрят на предыдущий или следующий токен либо следуют синтаксису или кореференции (Clark et al., 2019; Voita et al., 2019), и многие из них можно удалить после обучения с небольшой потерей качества (Michel, Levy and Neubig, 2019).

Вычислительная сложность#

В матрице оценок $n^2$ элементов на голову, каждый вычисляется за $d_k$ умножений, и произведение с $V$ стоит столько же:

Операция	Время	Память	Последовательные шаги	Самый длинный путь
Проекции $XW_Q, XW_K, XW_V$	$O(n d^2)$	$O(nd)$	$O(1)$	—
Оценки $QK^\top$ и веса $\times V$	$O(n^2 d)$	$O(n^2)$ на голову	$O(1)$	$O(1)$
Рекуррентный слой, для сравнения	$O(n d^2)$	$O(nd)$	$O(n)$	$O(n)$

Последние два столбца взяты из таблицы 1 в Vaswani et al. (2017). Внимание начинает доминировать, как только $n$ становится небольшим кратным $d$: $n = 2d$ по сравнению с проекциями и около $6d$ по сравнению с целым блоком, где ширина полносвязного блока (feed-forward) равна $4d$. В этом небольшом энкодере ($n = 128$, $d = 32$) матрицы оценок содержат $16\,384$ элемента на голову на пример, а $2n^2 d \approx 1.0 \times 10^6$ умножений со сложением (multiply-adds) для $QK^\top$ и $AV$ уже больше, чем $4nd^2 \approx 5.2 \times 10^5$ для $W_Q$, $W_K$, $W_V$ и $W_O$. Взамен все $n$ строк получаются одним матричным произведением. Системы с длинным контекстом борются с квадратичным членом: кэширование ключей и значений, точные ядра (kernels), которые никогда не хранят матрицу $n \times n$ (Dao et al., 2022), и разреженные, оконные или линеаризованные варианты.

Рисунок

Рекуррентность и self-attention: длина пути и стоимость

Как выглядят головы обученной модели#

Обучим 4-слойный энкодер с 4 головами из заметки о трансформере на AG News и посмотрим на все 16 голов на одном обучающем примере из 49 токенов:

• Слой 1. Строки близки к one-hot-векторам на нескольких содержательных токенах; в голове 4 большинство строк выбирают injured, travel, southern или baghdad.
• Слой 2. Веса распределены по многим ключам.
• Слои 3 и 4. Вертикальные полосы: почти каждый запрос читает одни и те же немногие ключи (некоторые головы слоя 3, все головы слоя 4).

Карты показывают, откуда голова читает, а не на что опирается классификатор.

Что изменилось#

	Внимание декодера к энкодеру	Self-attention
Откуда запросы	Состояние декодера	Каждый токен последовательности
Откуда ключи и значения	Состояния энкодера (один вектор для обоих)	Каждый токен, через отдельные проекции
Путь между двумя позициями	Через рекуррентность, $O(n)$	Один шаг
Последовательная зависимость	Через обе рекуррентности	Отсутствует между позициями внутри слоя (генерация по-прежнему выдаёт по одному токену за раз)
Вычисление	Один softmax на шаг декодера	Один softmax $n \times n$ на голову и слой
Стоимость	$O(nd)$ на шаг декодера	$O(n^2 d)$ на слой
Порядок слов	Из рекуррентности	Потерян; его нужно передать
Головы	Одна	$h$ параллельно

Ограничения#

• Нет понятия порядка. Его вводит заметка о позиционных представлениях.
• Квадратичность по $n$. Удвоение контекста учетверяет работу и память: $65\,536$ весов на последовательность на слой при $n = 128$, $h = 4$; около $10^9$ на голову при $n = 32\,000$. Точные ядра экономят память, но не работу.
• Веса должны давать в сумме единицу. Голова, которой нечего читать, «паркует» вес на разделителях, пунктуации или первом токене (Clark et al., 2019; Xiao et al., 2024).
• Только взвешенные средние. Выходы — выпуклые комбинации значений, линейно отображённые через $W_O$, без преобразования каждого токена по отдельности. Заметка о трансформере добавляет полносвязный слой, остаточные связи (residual connections) и нормализацию.
• Веса — не объяснения. Разные шаблоны весов могут давать одно и то же предсказание (Jain and Wallace, 2019; более аккуратный взгляд — у Wiegreffe and Pinter, 2019), а веса не учитывают величину значений, на которые они умножаются (Kobayashi et al., 2020).

Что нужно запомнить#

• $\operatorname{Attention}(Q, K, V) = \operatorname{softmax}(QK^\top/\sqrt{d_k})\,V$, где $Q = XW_Q$, $K = XW_K$, $V = XW_V$: строка $i$ выхода — взвешенное среднее строк значений с весами по тому, насколько запрос $i$ совпадает с каждым ключом.
• Размеры: $X$ — $n \times d$, оценки — $n \times n$ ($m \times n$ для cross-attention), выход — $n \times d_v$.
• Отдельные $W_Q$ и $W_K$ позволяют оценкам $s_{ij}$ и $s_{ji}$ различаться и не дают совпадению токена с самим собой доминировать. Оценки через обычное скалярное произведение симметричны; веса softmax, построенные из них, уже немного различаются, потому что у каждой строки свой знаменатель.
• Делим на $\sqrt{d_k}$ одной головы, потому что $\operatorname{Var}(q \cdot k) = d_k$; иначе softmax насыщается и его градиент исчезает.
• Маски присваивают оценкам $-\infty$: маска паддинга закрывает столбцы ключей, каузальная маска — верхний треугольник.
• Self-attention без маски эквивариантен относительно перестановок (permutation-equivariant): порядок нужно передать во входе или в оценках.
• $h$ голов размера $d/h$ стоят $4d^2$ весов на слой при любом $h$ и складываются как сумма вкладов отдельных голов.
• Один шаг между любыми двумя позициями, никакой последовательной зависимости, память $O(n^2)$ на голову.

Ноутбук#

week05_transformer.ipynb. Ячейки нумеруются с 1, считая все ячейки, включая текстовые. Приведённые числа взяты из прогона, сохранённого в курсе; у ячеек, изменённых с тех пор под текущие версии библиотек, сохранённого выхода нет.

• Внимание (ячейки 38–40). Одна голова, причём головы слоя вычисляются в цикле Python, а не одной проекцией с изменением формы: проекции nn.Linear(embed_dim, embed_dim // num_heads) без смещения, оценки через torch.bmm, делённые на $\sqrt{d_k}$, masked_fill с $-\infty$, softmax, дропаут, bmm с $V$. MultiHeadAttention конкатенирует головы из nn.ModuleList и применяет nn.Linear(embed_dim, embed_dim) без смещения в роли $W_O$. Маска паддинга tokens == pad_idx повторяется по строкам запросов до размера $[B, n, n]$.
• Модель (ячейки 42–45). Четыре слоя, описанные в заметке о трансформере. Сохранённый выход ячейки 45 показывает Linear(32 → 8) для каждой головы и Linear(32 → 32) для $W_O$: $4\,096$ весов внимания на слой.
• Карты внимания (ячейки 51–62). 16 матриц весов одного примера из 49 токенов (ячейка 59, у каждой панели своя цветовая шкала) и слой 1, голова 4 с подписями токенов (ячейка 62); они описаны выше и сохранены только как изображения.
• Подводные камни. Комментарии о размерах неверны для $W_V$ в ячейке 39 (она отображает 32 в 8) и для attention_scores в ячейке 42 (размер $[B, n, n, h, L]$).
• Cross-attention. week04_lstm_attention_transformer.ipynb, ячейки 71–79, сохраняет усреднённые по головам веса однослойного трансформера для перевода, размер $[32, 31, 32]$ (батч, целевая, исходная последовательность); они обсуждаются в предыдущей заметке.

Дальше#

Self-attention смешивает позиции и больше ничего не делает: у него нет нелинейности для отдельного токена, нет понятия о порядке, а глубокий стек голых слоёв внимания трудно обучать. Заметка о трансформере оборачивает многоголовое внимание остаточными связями и нормализацией слоя (layer normalization), добавляет полносвязную сеть, применяемую к каждой позиции отдельно (position-wise feed-forward), и собирает из блоков энкодер, декодер с каузальным self-attention или энкодер–декодер с cross-attention.

Литература#

• A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, Ł. Kaiser, I. Polosukhin. Attention Is All You Need. NeurIPS, 2017. §3.2.1 (внимание на основе масштабированного скалярного произведения и сноска о дисперсии), §3.2.2 (многоголовое внимание), таблица 1 (сложность, последовательные операции, длина пути).
• H. J. Levesque, E. Davis, L. Morgenstern. The Winograd Schema Challenge. KR, 2012. Пример с кубком и чемоданом.
• D. Bahdanau, K. Cho, Y. Bengio. Neural Machine Translation by Jointly Learning to Align and Translate. ICLR, 2015.
• M.-T. Luong, H. Pham, C. D. Manning. Effective Approaches to Attention-based Neural Machine Translation. EMNLP, 2015.
• J. Cheng, L. Dong, M. Lapata. Long Short-Term Memory-Networks for Machine Reading. EMNLP, 2016. Внимание внутри одной последовательности до трансформера.
• N. Elhage, N. Nanda, C. Olsson, et al. A Mathematical Framework for Transformer Circuits. Transformer Circuits Thread, 2021. Многоголовое внимание как сумма вкладов отдельных голов.
• M. Phuong, M. Hutter. Formal Algorithms for Transformers. arXiv, 2022. Точный псевдокод внимания и масок.
• K. Clark, U. Khandelwal, O. Levy, C. D. Manning. What Does BERT Look At? An Analysis of BERT’s Attention. BlackboxNLP, 2019.
• E. Voita, D. Talbot, F. Moiseev, R. Sennrich, I. Titov. Analyzing Multi-Head Self-Attention: Specialized Heads Do the Heavy Lifting, the Rest Can Be Pruned. ACL, 2019.
• P. Michel, O. Levy, G. Neubig. Are Sixteen Heads Really Better than One? NeurIPS, 2019.
• S. Jain, B. C. Wallace. Attention is not Explanation. NAACL, 2019.
• S. Wiegreffe, Y. Pinter. Attention is not not Explanation. EMNLP, 2019.
• G. Kobayashi, T. Kuribayashi, S. Yokoi, K. Inui. Attention is Not Only a Weight: Analyzing Transformers with Vector Norms. EMNLP, 2020.
• G. Xiao, Y. Tian, B. Chen, S. Han, M. Lewis. Efficient Streaming Language Models with Attention Sinks. ICLR, 2024.
• T. Dao, D. Y. Fu, S. Ermon, A. Rudra, C. Ré. FlashAttention: Fast and Memory-Efficient Exact Attention with IO-Awareness. NeurIPS, 2022.
• J. Starmer (StatQuest). Transformer Neural Networks, ChatGPT’s foundation, Clearly Explained!!! Видео, 2023. Пошаговый разбор запросов, ключей, значений и взвешенной суммы для одного слова — в том порядке, которому следует эта заметка.
• J. Alammar. The Illustrated Transformer. 2018. Матричные иллюстрации self-attention.
• D. Jurafsky, J. H. Martin. Speech and Language Processing, 3-е изд., черновик от 19 августа 2026 г. Глава 7, Transformers and Pretraining (self-attention, многоголовое внимание, маски).