дорожка · 02.11.2026 · полносвязный блок

Полносвязный блок трансформера: что он делает, функции активации и SwiGLU

В прошлой дорожке мы разобрали обход и нормализацию, то есть «трубы» трансформера. Сегодня — то, что стоит между ними во второй половине каждого слоя: полносвязный блок (feed-forward network, FFN). Внимание перемешивает информацию между токенами, а этот блок думает над каждым токеном по отдельности, и в нём лежит большая часть весов модели. От того, какая в нём функция активации и есть ли гейт, зависит качество модели при том же бюджете, а от его ширины — сколько стоит каждый токен. Все примеры — маленькие расчёты на numpy; код мы запускали, выводы взяты из этих запусков. Остальное — формулы и опубликованные работы, и это сказано прямо.

Все дорожки — /put. Прошлая — нормализация.

1 Что делает полносвязный блок и почему в нём две трети параметров слоя

Зачем это в работе. Каждый слой трансформера состоит из двух половин: внимания, которое смешивает информацию между токенами, и полносвязного блока (feed-forward network, FFN, его ещё называют MLP — многослойный перцептрон), который обрабатывает каждый токен отдельно. Когда в описании модели пишут «ширина скрытого слоя 11008» или «эксперты заменяют FFN», речь именно о нём. Он занимает большую часть весов, поэтому от него зависят размер файла модели, объём памяти видеокарты и цена каждого токена.

Как это устроено. Блок получает вектор одного токена размера d (размер модели, hidden size) и делает три шага: умножает его на первую матрицу размера d×f и получает вектор шире исходного — f обычно в несколько раз больше d; к каждой координате применяет нелинейную функцию активации (activation function); умножает результат на вторую матрицу f×d и возвращает вектор прежнего размера, который прибавляется к остаточному потоку. Число f называют шириной блока или промежуточным размером (intermediate size). В исходном трансформере 2017 года было d = 512 и f = 2048, то есть f = 4d, и функция активации ReLU; это соотношение 4d потом повторили GPT-2 и многие другие модели.

Почему блок «думает над токеном отдельно». Обе матрицы применяются к каждому токену одинаково и независимо от соседей: в формуле нет ни одного слагаемого, где встречались бы два токена сразу. Значит, всё, что блок может использовать, уже должно быть в векторе токена, а туда это кладёт внимание предыдущих слоёв. Разделение труда такое: внимание собирает нужное из контекста, полносвязный блок перерабатывает собранное нелинейно. Без функции активации две матрицы подряд схлопнулись бы в одну матрицу d×d, и блок стал бы бесполезным; вся его выразительность — в нелинейности посередине.

Откуда две трети параметров. Внимание держит четыре матрицы d×d — для запросов, ключей, значений и выходной проекции, итого 4d². Обычный полносвязный блок с f = 4d держит две матрицы d×4d, итого 8d². Получается, что блок — две трети параметров слоя, без учёта таблицы эмбеддингов и мелких весов нормализации. Ограничение этого подсчёта: в моделях с группированным вниманием (grouped-query attention) матрицы ключей и значений меньше, и доля блока ещё выше.

Подробный пример. Посчитаем параметры одного слоя для двух опубликованных конфигураций — GPT-2 small (d = 768, f = 3072, обычный блок) и Llama-2 7B (d = 4096, f = 11008, гейтированный блок с тремя матрицами, о нём ступень 3) — и проверим на маленьком блоке, что он действительно обрабатывает токены независимо.

import numpy as np
def layer(d, f, gated):
    attn = 4 * d * d                      # Q, K, V и выходная проекция
    ffn = (3 if gated else 2) * d * f     # SwiGLU: три матрицы, обычный блок: две
    return attn, ffn
for name, d, f, g in [("GPT-2 small", 768, 3072, False), ("Llama-2 7B", 4096, 11008, True)]:
    a, m = layer(d, f, g)
    print(f"{name:12s} внимание {a/1e6:6.1f} млн  полносвязный {m/1e6:6.1f} млн  доля блока {m/(a+m):.2f}")
# полносвязный блок обрабатывает токены независимо: перестановка токенов переставляет выходы
rng = np.random.default_rng(0)
d, f, n = 16, 64, 5
W1, W2 = rng.normal(size=(d, f)) / 4, rng.normal(size=(f, d)) / 8
ffn = lambda X: np.maximum(X @ W1, 0) @ W2
X = rng.normal(size=(n, d)); perm = [3, 0, 4, 1, 2]
print("перестановка коммутирует:", np.allclose(ffn(X)[perm], ffn(X[perm])))
print("выход токена 0 зависит только от токена 0:", np.allclose(ffn(X)[0], ffn(X[:1])[0]))

У нас этот код напечатал:

GPT-2 small  внимание    2.4 млн  полносвязный    4.7 млн  доля блока 0.67
Llama-2 7B   внимание   67.1 млн  полносвязный  135.3 млн  доля блока 0.67
перестановка коммутирует: True
выход токена 0 зависит только от токена 0: True

В обеих моделях на полносвязный блок приходится 0,67 параметров слоя: 4,7 млн из 7,1 млн у GPT-2 small и 135,3 млн из 202,4 млн у Llama-2 7B (в Llama-2 7B ключи и значения ещё полного размера, поэтому совпадение точное). Проверка с перестановкой показала: если переставить токены на входе, выходы переставятся точно так же, а выход первого токена не меняется, если остальных токенов вообще нет. Повтори: замени ReLU на тождественную функцию (просто X @ W1) и проверь через np.allclose, что блок стал равен одной матрице W1 @ W2.

Где обычно ошибаются.

  • Считают, что «знания модели» лежат во внимании, потому что оно на схемах заметнее. По числу параметров основную часть весов несут полносвязные блоки.
  • Ждут, что полносвязный блок поможет связать слова между собой. Он не видит соседей, и если внимание не принесло нужное в вектор токена, блок это не восстановит.
  • Оценивают размер модели по d и числу слоёв, забывая ширину f. При одном и том же d модели с f = 4d и f = 8d отличаются по размеру почти в полтора раза.

Полносвязный блок (feed-forward network, FFN, MLP). Вторая половина слоя трансформера: две матрицы с нелинейностью между ними, применяемые к каждому токену отдельно.

Размер модели (hidden size, d). Длина вектора, которым представлен каждый токен в остаточном потоке.

Ширина блока (intermediate size, f). Размер промежуточного вектора внутри полносвязного блока, обычно в 2,7–4 раза больше d.

Функция активации (activation function). Нелинейная функция, которую применяют к каждой координате; без неё несколько матриц подряд равны одной.

Проекция вверх и вниз (up / down projection). Первая матрица, расширяющая вектор с d до f, и вторая, сжимающая обратно.

Группированное внимание (grouped-query attention). Вариант внимания, где несколько голов делят одни ключи и значения, из-за чего матрицы K и V меньше.

Перестановочная эквивариантность (permutation equivariance). Свойство: переставил входы — выходы переставились так же; у полносвязного блока оно есть по токенам.

2 ReLU, GELU и SiLU: чем отличаются функции активации и откуда мёртвые нейроны

Зачем это в работе. Функция активации — единственное нелинейное место полносвязного блока, и её выбор записан в конфигурации каждой открытой модели: «relu», «gelu», «silu». От неё зависит, как течёт градиент при обучении, сколько нейронов будут выдавать ноль и насколько разрежены (содержат много нулей) активации — а на разреженности строят ускорение вывода. Знать разницу нужно и для того, чтобы правильно переносить веса: модель, обученная с GELU, с ReLU работать не будет.

Как это устроено. ReLU (rectified linear unit, выпрямитель) оставляет положительное число и заменяет отрицательное нулём. Она дешёвая и даёт много точных нулей, но у неё излом в нуле и нулевая производная для всех отрицательных входов. GELU (Gaussian error linear unit, Hendrycks и Gimpel, 2016) умножает вход на вероятность того, что нормально распределённая случайная величина меньше этого входа: x·Φ(x). Для больших положительных x это почти x, для больших отрицательных — почти ноль, а около нуля функция гладкая и даже слегка уходит в минус. GELU используют BERT и GPT-2. SiLU (sigmoid linear unit, x·σ(x), где σ — сигмоида; та же функция под именем Swish описана у Ramachandran и соавторов, 2017) похожа на GELU, но с более глубоким «провалом» в минус; она стоит внутри SwiGLU в Llama.

Мёртвые нейроны (dead neurons). У ReLU, если сумма на входе нейрона отрицательна для всех примеров, выход всегда ноль и производная всегда ноль, поэтому веса этого нейрона никогда не обновятся: он выпал навсегда. Так бывает, когда большой шаг обучения сдвигает смещение (bias) сильно в минус. У GELU и SiLU производная для отрицательных входов маленькая, но не нулевая, и нейрон может вернуться. Цена — меньше точных нулей, то есть меньше разреженности.

Чем это отличается от соседнего понятия. Функция активации в полносвязном блоке — не то же самое, что softmax во внимании или на выходе модели: softmax превращает целый вектор в распределение вероятностей, а функция активации действует на каждую координату отдельно. И это не нормализация: она не приводит размер вектора к стандарту, а гнёт каждое число по одной и той же кривой.

Подробный пример. Посчитаем значения трёх функций в нескольких точках, а потом возьмём 512 нейронов на 1000 случайных входах и будем сдвигать их смещение в минус, как это делает неудачный шаг обучения. Смотрим долю нулей у ReLU, долю нейронов, которые выдают ноль на всех 1000 входах, и средний модуль производной SiLU.

import numpy as np
from math import erf, sqrt
relu = lambda x: np.maximum(x, 0)
gelu = lambda x: 0.5 * x * (1 + np.vectorize(erf)(x / sqrt(2)))
silu = lambda x: x / (1 + np.exp(-x))
xs = np.array([-3.0, -1.0, -0.5, 0.0, 0.5, 1.0, 3.0])
for name, f in [("ReLU", relu), ("GELU", gelu), ("SiLU", silu)]:
    print(f"{name:5s}", " ".join(f"{v:6.3f}" for v in f(xs)))
# «мёртвые» нейроны: смещение уехало в минус, ReLU выдаёт ноль на всех входах
rng = np.random.default_rng(0)
X = rng.normal(size=(1000, 64)); W = rng.normal(size=(64, 512)) / 8
for shift in [0.0, -1.5, -3.0]:
    H = X @ W + shift
    dead_relu = np.mean((relu(H) == 0).all(axis=0))
    zeros = np.mean(relu(H) == 0)
    s = 1 / (1 + np.exp(-H))
    grad_silu = np.abs(s * (1 + H * (1 - s))).mean()   # производная SiLU
    print(f"сдвиг {shift:4.1f}: нулей ReLU {zeros:.2f}, мёртвых нейронов ReLU {dead_relu:.2f}, "
          f"средний модуль производной SiLU {grad_silu:.3f}")

У нас этот код напечатал:

ReLU   0.000  0.000  0.000  0.000  0.500  1.000  3.000
GELU  -0.004 -0.159 -0.154  0.000  0.346  0.841  2.996
SiLU  -0.142 -0.269 -0.189  0.000  0.311  0.731  2.858
сдвиг  0.0: нулей ReLU 0.50, мёртвых нейронов ReLU 0.00, средний модуль производной SiLU 0.511
сдвиг -1.5: нулей ReLU 0.93, мёртвых нейронов ReLU 0.00, средний модуль производной SiLU 0.150
сдвиг -3.0: нулей ReLU 1.00, мёртвых нейронов ReLU 0.34, средний модуль производной SiLU 0.076

В точке −1 ReLU даёт 0, GELU −0,159, SiLU −0,269: гладкие функции пропускают немного отрицательного сигнала. Без сдвига у ReLU нулей ровно половина, мёртвых нейронов нет. При сдвиге −1,5 нулей уже 93%, а при сдвиге −3 — практически все выходы нулевые и треть нейронов (0,34) мертва: на всех входах ноль, градиент до них не дойдёт. У SiLU средняя производная при этом уменьшилась с 0,511 до 0,076, то есть обучение замедлилось, но не остановилось. Повтори: посчитай для сдвига −3 долю нейронов SiLU, у которых производная меньше 0,01 на всех входах, и сравни с 0,34 у ReLU.

Где обычно ошибаются.

  • Подменяют функцию активации при загрузке весов: GELU в точной форме и в приближении через tanh дают немного разные числа, и смешение вариантов заметно портит выход больших моделей. Вариант берут из конфигурации модели.
  • Считают, что гладкая активация «лучше всегда». Она избавляет от мёртвых нейронов, но убирает точные нули, на которых держатся приёмы ускорения с пропуском нулевых нейронов.
  • Принимают долю нулей у ReLU за признак проблемы. Половина нулей при нулевом сдвиге — норма; тревожна именно доля нейронов, которые молчат на всех входах.

GELU. Гладкая функция активации x·Φ(x), почти x для больших входов и почти ноль для больших отрицательных.

SiLU, или Swish. Функция x·σ(x): похожа на GELU, но глубже уходит в минус около нуля.

Сигмоида (sigmoid, σ). Функция 1/(1+e−x), плавно переводящая любое число в интервал от 0 до 1.

Мёртвый нейрон (dead neuron). Нейрон ReLU, выдающий ноль на всех входах; его веса больше не обучаются.

Смещение (bias). Число, прибавляемое к взвешенной сумме перед функцией активации.

Разреженность активаций (activation sparsity). Доля точных нулей в промежуточном векторе блока.

Нормальное распределение, функция Φ. Φ(x) — вероятность того, что случайная величина со стандартным нормальным распределением меньше x.

3 Гейтированный блок SwiGLU: зачем третья матрица и почему ширина 8/3 от размера модели

Зачем это в работе. В большинстве современных открытых языковых моделей — Llama, Mistral, Qwen и других — полносвязный блок не «две матрицы и активация», а гейтированный вариант SwiGLU с тремя матрицами. Из-за этого ширины в конфигурациях выглядят странно, например 11008 при d = 4096 вместо ожидаемых 16384, а при квантовании и разбиении модели по видеокартам приходится учитывать три матрицы вместо двух.

Как это устроено. Гейтированный линейный блок (gated linear unit, GLU, Dauphin и соавторы, 2016) считает из входа два вектора одинаковой ширины: значение (value) v = x·Wup и гейт (gate) g = x·Wgate. К гейту применяют функцию активации, затем два вектора поэлементно перемножают: h = act(g) ⊙ v, где ⊙ — умножение координат с одинаковыми номерами. Третья матрица Wdown сжимает h обратно до размера d. Если активация — SiLU, получается SwiGLU; если GELU — GeGLU; без активации — билинейный блок. Эти варианты сравнивал Ноам Шазир в работе «GLU Variants Improve Transformer» (2020) и получил лучшую перплексию у гейтированных вариантов при равном числе параметров.

Почему гейт помогает. В обычном блоке нейрон выдаёт функцию от одной взвешенной суммы входа. В гейтированном — произведение двух разных сумм: одна решает, «открыт ли» нейрон, другая — что он пропускает. Произведение двух линейных функций уже даёт квадратичные выражения вроде x1·x2, которые обычному блоку приходится собирать из многих изломов ReLU. Почему именно это улучшает языковые модели, в работе Шазира не объяснено: результат там экспериментальный, и автор прямо об этом пишет.

Откуда 8/3. Чтобы сравнение было честным, число параметров держат равным обычному блоку: 3·d·f = 2·d·4d, откуда f = 8d/3. Для d = 4096 это 10923; Llama округлила ширину вверх до кратного 256 и получила 11008. Отсюда «странные» числа в конфигурациях. Отличие от соседнего понятия: гейт здесь — поэлементный множитель внутри одного блока, а не маршрутизатор (router) в смеси экспертов, который выбирает, какие блоки целиком считать для токена; о нём дорожка про смесь экспертов.

Подробный пример. Возьмём цель y = x1·x2 на 2000 случайных точках. Билинейный гейтированный блок с двумя нейронами решает её точно, потому что x1x2 = ((x1+x2)² − (x1−x2)²)/4, а квадрат суммы — это и есть произведение гейта на значение с одинаковыми весами. Для обычного блока ReLU возьмём случайный первый слой и подберём выходной слой методом наименьших квадратов. В конце проверим подсчёт параметров для d = 4096.

import numpy as np
rng = np.random.default_rng(1)
X = rng.uniform(-2, 2, size=(2000, 2)); y = X[:, 0] * X[:, 1]       # цель: произведение двух входов
# 1) гейтированный блок без активации (билинейный GLU), два скрытых нейрона, веса заданы вручную:
#    x1*x2 = ((x1+x2)^2 - (x1-x2)^2) / 4,  а (w·x)*(w·x) — это и есть поэлементное произведение гейта и значения
Wg = np.array([[1, 1], [1, -1]]).T; Wv = Wg.copy(); Wo = np.array([0.25, -0.25])
glu = ((X @ Wg) * (X @ Wv)) @ Wo
print(f"GLU, 2 нейрона: средняя ошибка {np.abs(glu - y).mean():.1e}")
# 2) обычный блок ReLU: случайный первый слой, выходной слой подобран методом наименьших квадратов
for h in [2, 8, 32, 128]:
    W = rng.normal(size=(2, h)); b = rng.uniform(-2, 2, size=h)
    H = np.maximum(X @ W + b, 0); H = np.c_[H, np.ones(len(X))]
    w, *_ = np.linalg.lstsq(H, y, rcond=None)
    print(f"ReLU, {h:3d} нейронов: средняя ошибка {np.abs(H @ w - y).mean():.3f}")
# равенство параметров: SwiGLU с шириной 8/3·d против обычного блока с шириной 4·d
d = 4096
print("обычный 4d:", 2 * d * 4 * d, " SwiGLU 8/3·d:", 3 * d * (8 * d // 3), " SwiGLU 11008:", 3 * d * 11008)

У нас этот код напечатал:

GLU, 2 нейрона: средняя ошибка 5.0e-17
ReLU,   2 нейронов: средняя ошибка 0.911
ReLU,   8 нейронов: средняя ошибка 0.208
ReLU,  32 нейронов: средняя ошибка 0.081
ReLU, 128 нейронов: средняя ошибка 0.014
обычный 4d: 134217728  SwiGLU 8/3·d: 134209536  SwiGLU 11008: 135266304

Гейтированный блок с двумя нейронами дал ошибку 5·10−17, то есть ноль с точностью вычислений. Обычному блоку ReLU с двумя нейронами не хватило (ошибка 0,911), с 32 нейронами ошибка 0,081, с 128 — 0,014: точное произведение он может только приближать изломами. Подсчёт для d = 4096 показывает, что ширина 8d/3 даёт почти столько же параметров, сколько обычный блок 4d (134,2 млн против 134,2 млн), а округление до 11008 добавляет около 0,8%. Пример игрушечный: он показывает, какие функции гейт даёт «бесплатно», а не доказывает, что SwiGLU лучше на тексте. Повтори: замени в GLU произведение на SiLU гейта, умноженную на значение, и подбери выходные веса методом наименьших квадратов при 8 нейронах со случайными Wgate и Wup.

Где обычно ошибаются.

  • Сравнивают модели по ширине f напрямую. Гейтированный блок с f = 11008 и обычный с f = 16384 при d = 4096 имеют почти одинаковое число параметров.
  • Путают местами Wgate и Wup при конвертации весов. Функция активации применяется только к гейту, поэтому перестановка двух матриц тихо ломает модель без ошибки при загрузке.
  • Делят матрицу гейта и матрицу значения между видеокартами по-разному. При тензорном параллелизме обе нужно резать одинаково по ширине f, иначе поэлементное произведение соединит чужие координаты.

Гейтированный линейный блок (GLU). Блок, в котором один вектор поэлементно умножается на другой, пропущенный через функцию активации.

SwiGLU. GLU с функцией SiLU (Swish) на гейте; стандартный полносвязный блок в Llama и похожих моделях.

Гейт (gate). Вектор, который решает, насколько пропустить каждую координату другого вектора.

Поэлементное произведение (⊙, Hadamard product). Умножение двух векторов координата на координату.

Билинейный блок (bilinear). GLU без функции активации: произведение двух линейных функций входа.

Перплексия (perplexity). Мера того, насколько модель «удивлена» правильным текстом; чем ниже, тем лучше она его предсказывает.

Метод наименьших квадратов (least squares). Способ подобрать линейные веса так, чтобы сумма квадратов ошибок была минимальной.

4 Полносвязный блок как память «ключ — значение»

Зачем это в работе. Если спросить, где в модели хранится факт «столица Франции — Париж», лучший на сегодня ответ из исследований — в основном в полносвязных блоках средних слоёв. На этом строят методы точечного редактирования знаний и анализ того, почему модель ошибается в фактах. Взгляд на блок как на память помогает понять, почему факты «смешиваются» и почему модель увереннее в частых фактах, чем в редких.

Как это устроено. Посмотрим на блок по-другому. Каждый столбец первой матрицы — это ключ (key): нейрон считает скалярное произведение вектора токена с ключом, то есть меру похожести, и после функции активации выдаёт «насколько этот ключ узнан». Каждая строка второй матрицы — значение (value): то, что нейрон дописывает в остаточный поток, умноженное на силу узнавания. Выход блока — сумма значений узнанных ключей. Такую трактовку проверили Гева и соавторы в работе «Transformer Feed-Forward Layers Are Key-Value Memories» (2021): ключи нижних слоёв срабатывали на поверхностные шаблоны текста, верхних — на смысловые, а значения сдвигали вероятность определённых следующих слов.

Где это видно на практике. Мэн и соавторы (метод ROME, 2022) искали, какие части GPT-модели влияют на вспоминание фактов, и нашли решающую роль полносвязных блоков средних слоёв на последнем токене имени субъекта; потом меняли один такой блок формулой ранга один и «переписывали» факт. Это результат конкретной работы на конкретных моделях, а не закон для всех: последующие работы показали, что место, где факт «находится» по такому анализу, не всегда совпадает с местом, где его лучше всего редактировать.

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

Подробный пример. Соберём блок вручную. Размер вектора d = 64; храним n пар «ключ — значение» из случайных единичных векторов, по одному нейрону на пару. Первая матрица — ключи, смещение задаёт порог, функция ReLU; вторая матрица — значения. Запрос — ключ с шумом. Считаем, верно ли блок возвращает нужное значение (ближайшее из всех хранимых), и сколько нейронов в среднем срабатывает.

import numpy as np
rng = np.random.default_rng(2)
d = 64
def run(n, noise, thr=0.5):
    K = rng.normal(size=(n, d)); K /= np.linalg.norm(K, axis=1, keepdims=True)   # ключи: строки первой матрицы
    V = rng.normal(size=(n, d)); V /= np.linalg.norm(V, axis=1, keepdims=True)   # значения: строки второй матрицы
    q = K + noise * rng.normal(size=(n, d)) / np.sqrt(d)                         # запросы: ключ с шумом
    q /= np.linalg.norm(q, axis=1, keepdims=True)
    H = np.maximum(q @ K.T - thr, 0)       # первая матрица + смещение -thr + ReLU: какие ключи «узнаны»
    out = H @ V                            # вторая матрица: сумма значений узнанных ключей
    hit = np.argmax(out @ V.T, axis=1) == np.arange(n)
    active = (H > 0).sum(axis=1).mean()
    return hit.mean(), active
for thr in [0.5, 0.2, 0.0]:
    for n in [50, 500, 5000]:
        for noise in [1.0, 2.0]:
            acc, act = run(n, noise, thr)
            print(f"порог {thr}, пар {n:5d}, шум {noise}: верно {acc:.2f}, активных нейронов {act:7.1f}")

У нас этот код напечатал:

порог 0.5, пар    50, шум 1.0: верно 1.00, активных нейронов     1.0
порог 0.5, пар    50, шум 2.0: верно 0.38, активных нейронов     0.4
порог 0.5, пар   500, шум 1.0: верно 1.00, активных нейронов     1.0
порог 0.5, пар   500, шум 2.0: верно 0.29, активных нейронов     0.3
порог 0.5, пар  5000, шум 1.0: верно 1.00, активных нейронов     1.1
порог 0.5, пар  5000, шум 2.0: верно 0.29, активных нейронов     0.3
порог 0.2, пар    50, шум 1.0: верно 1.00, активных нейронов     3.9
порог 0.2, пар    50, шум 2.0: верно 0.94, активных нейронов     3.6
порог 0.2, пар   500, шум 1.0: верно 1.00, активных нейронов    28.0
порог 0.2, пар   500, шум 2.0: верно 0.70, активных нейронов    28.6
порог 0.2, пар  5000, шум 1.0: верно 0.39, активных нейронов   276.4
порог 0.2, пар  5000, шум 2.0: верно 0.04, активных нейронов   276.6
порог 0.0, пар    50, шум 1.0: верно 1.00, активных нейронов    24.8
порог 0.0, пар    50, шум 2.0: верно 0.92, активных нейронов    25.1
порог 0.0, пар   500, шум 1.0: верно 0.33, активных нейронов   250.1
порог 0.0, пар   500, шум 2.0: верно 0.08, активных нейронов   250.7
порог 0.0, пар  5000, шум 1.0: верно 0.00, активных нейронов  2501.2
порог 0.0, пар  5000, шум 2.0: верно 0.00, активных нейронов  2499.9

Видны оба способа сломать память. При высоком пороге 0,5 срабатывает в среднем один нейрон, и даже 5000 пар в 64 измерениях вспоминаются без ошибок при умеренном шуме — но при сильном шуме верно лишь 0,29–0,38, потому что искажённый запрос не дотягивает до порога и не включает ничего (активных нейронов 0,3–0,4). При нулевом пороге на 5000 парах срабатывает половина нейронов, около 2500, и точность падает до нуля: значения соседей заглушают нужное. Порог 0,2 — компромисс: на 500 парах при сильном шуме 0,70, но на 5000 уже 0,04. Это игрушка с ручными весами, а не обученная модель; она показывает механику помех, а не реальную ёмкость. Повтори: сделай ключи частично похожими (прибавь ко всем один и тот же общий вектор) и посмотри, как падает точность при пороге 0,5.

Где обычно ошибаются.

  • Думают, что каждый факт хранится в одном нейроне. На деле один нейрон участвует во многих ассоциациях, а одна ассоциация — во многих нейронах; ручной пример с «нейроном на пару» — упрощение.
  • Считают, что раз факт можно отредактировать в одном блоке, модель потом будет последовательно его использовать. Работы по редактированию отмечают, что связанные выводы и перефразировки часто не обновляются.
  • Объясняют выдумки модели только «нехваткой памяти». Помехи между похожими ключами дают уверенный, но чужой ответ даже тогда, когда нужный факт в весах есть.

Ключ (key) в полносвязном блоке. Столбец первой матрицы; нейрон срабатывает, когда вектор токена на него похож.

Значение (value) в полносвязном блоке. Строка второй матрицы, которую нейрон дописывает в поток пропорционально силе срабатывания.

Скалярное произведение (dot product). Сумма произведений координат двух векторов; для единичных векторов — мера их похожести.

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

Помехи (interference). Искажение ответа, когда на запрос откликаются чужие ключи и их значения складываются с нужным.

ROME (rank-one model editing). Метод 2022 года: правит веса одного полносвязного блока поправкой ранга один, чтобы изменить конкретный факт.

Редактирование знаний (knowledge editing). Изменение отдельных фактов в обученной модели без полного дообучения.

5 Сколько полносвязный блок стоит в вычислениях и что с этим делают

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

Как это устроено. Умножение вектора на матрицу a×b — это a·b умножений и примерно столько же сложений, то есть около 2ab операций с плавающей точкой (FLOP). На один токен в одном слое гейтированный блок тратит 2·3·d·f, проекции внимания — 2·4·d², и обе величины не зависят от длины контекста. Сами оценки внимания — сравнение запроса со всеми n ключами и сумма значений — дают около 2·2·n·d операций и растут линейно с контекстом. Это оценочная формула из учебных расчётов (такой же счёт приведён у Каплана и соавторов, 2020), а не измерение: реальная скорость зависит ещё и от того, упирается ли вычисление в арифметику или в чтение памяти.

Что делают с ценой блока. Первый путь — смесь экспертов: блок заменяют несколькими блоками-экспертами, и маршрутизатор отправляет токен лишь в немногие из них, так что параметров много, а операций на токен мало. Второй путь — разреженность активаций: если большинство нейронов на данном токене выдают ноль, соответствующие строки второй матрицы можно не читать. Ли и соавторы (2022, «The Lazy Neuron Phenomenon») сообщили о высокой разреженности активаций в обученных трансформерах с ReLU; для SiLU и GELU точных нулей мало, и такие методы сначала заменяют активацию на ReLU с дообучением. Третий путь — квантование: веса блока — основной объём модели, поэтому именно их сжатие в 4–8 бит сильнее всего уменьшает память; об этом дорожка про квантование.

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

Подробный пример. Посчитаем по формуле долю операций на токен в одном слое конфигурации Llama-2 7B при контексте от 512 до 131072 токенов. Это расчёт по формуле, не замер на видеокарте.

# операции на один токен в одном слое модели размера Llama-2 7B (d=4096, ширина блока 11008, SwiGLU)
d, f = 4096, 11008
proj = 2 * 4 * d * d          # Q, K, V, выход: умножение-сложение = 2 операции
ffn = 2 * 3 * d * f
for n in [512, 4096, 32768, 131072]:
    scores = 2 * 2 * n * d    # QK^T и умножение на V при контексте n (в среднем вдвое меньше из-за маски)
    tot = proj + ffn + scores
    print(f"контекст {n:6d}: полносвязный {ffn/tot:.2f}, проекции внимания {proj/tot:.2f}, сами оценки внимания {scores/tot:.2f}")

У нас этот код напечатал:

контекст    512: полносвязный 0.65, проекции внимания 0.32, сами оценки внимания 0.02
контекст   4096: полносвязный 0.57, проекции внимания 0.28, сами оценки внимания 0.14
контекст  32768: полносвязный 0.29, проекции внимания 0.14, сами оценки внимания 0.57
контекст 131072: полносвязный 0.11, проекции внимания 0.05, сами оценки внимания 0.84

При контексте 512 полносвязный блок — 0,65 всех операций слоя, а оценки внимания всего 0,02. При 4096 доля блока ещё 0,57. Где-то между 4096 и 32768 оценки внимания обгоняют все матричные умножения: при 32768 их 0,57, при 131072 — 0,84, а блок падает до 0,11. Вывод для работы: в чате с коротким контекстом ускорять надо полносвязный блок (эксперты, разреженность, квантование весов), в работе с длинными документами — внимание и кэш ключей и значений. Повтори: поставь параметры смеси экспертов — пусть на токен считаются 2 эксперта из 8, каждый шириной 14336 при d = 4096 — и посчитай долю блока на тех же контекстах.

Где обычно ошибаются.

  • Считают, что смесь экспертов делает модель «в 4 раза дешевле» во всём. Операций на токен меньше, но памяти на веса нужно на всех экспертов, и при чтении памяти выигрыш меньше.
  • Оценивают цену длинного контекста по числу параметров. Начиная с десятков тысяч токенов главные расходы — внимание, и размер полносвязного блока там почти не влияет.
  • Переносят выводы о разреженности ReLU-моделей на модели с SwiGLU. Без замены активации и дообучения точных нулей там мало, и пропуск нейронов портит выход.

FLOP (floating point operation). Одна операция с плавающей точкой; умножение вектора на матрицу a×b стоит около 2ab.

Ограничение по памяти (memory-bound). Режим, когда время уходит на чтение данных из памяти, а не на арифметику.

Смесь экспертов (mixture of experts, MoE). Замена одного полносвязного блока несколькими, из которых для токена считаются лишь немногие.

Маршрутизатор (router). Маленький слой, который выбирает, в каких экспертов отправить токен.

Пропуск нулевых нейронов. Приём ускорения: не читать строки второй матрицы для нейронов, выдавших ноль.

Длина контекста (n). Число токенов, которые внимание видит при обработке текущего токена.

Кэш ключей и значений (KV cache). Сохранённые ключи и значения прошлых токенов, чтобы не пересчитывать их на каждом шаге генерации.

Словарь целиком — /slovar, новости — /novosti. Все дорожки — /put.