дорожка · 01.11.2026 · нормализация

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

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

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

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

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

Как это устроено. Возьмём слой без смещения: y = ReLU(x·W), где W — матрица d×d со случайными числами. Каждая координата y — сумма d произведений, и если веса имеют разброс (стандартное отклонение) σ, то разброс суммы примерно в σ·√d раз больше разброса входа. ReLU (выпрямитель: отрицательное заменяет нулём) обнуляет примерно половину значений и тем самым уменьшает средний квадрат вдвое. Получается множитель на слой: если веса взяты с разбросом k/√d, средний квадрат сигнала за слой умножается примерно на k²/2.

Отсюда правило. При k² = 2, то есть k = √2, множитель равен единице, и сигнал проходит любое число слоёв, не меняя размера. Это инициализация Хе (He initialization) из работы Каймина Хе и соавторов 2015 года: разброс весов √(2/d) для слоёв с ReLU. Для функций активации без «срезанной половины», например tanh, нужная константа другая — это инициализация Ксавье (Xavier, или Glorot), разброс около √(1/d). Если k чуть меньше нужного, сигнал убывает как геометрическая прогрессия; если чуть больше — растёт так же.

Ограничение. Правильная инициализация держит сигнал только в момент старта. Как только веса начинают меняться при обучении, их разброс уходит от расчётного, и через тысячи шагов исходный баланс уже ничего не гарантирует. Кроме того, это рассуждение про средний размер, а у отдельных примеров и отдельных координат разброс может быть совсем другим. Поэтому одной инициализации для глубоких трансформеров недостаточно, нужны механизмы, которые держат размер сигнала на каждом шаге обучения, — об этом следующие ступени. Соседнее понятие — затухание и взрыв градиента (vanishing / exploding gradients): обратный проход тоже цепочка умножений, только на транспонированные матрицы, и болеет тем же.

Подробный пример. Пропустим 64 случайных примера по 256 чисел через 50 слоёв ReLU и будем смотреть разброс активаций после 10, 30 и 50 слоёв при четырёх значениях k. Веса в каждом слое новые случайные.

import numpy as np
rng = np.random.default_rng(0)
d, L = 256, 50
x0 = rng.standard_normal((64, d))          # 64 примера по 256 чисел
for k in [0.8, 1.0, np.sqrt(2), 1.6]:
    x, row = x0, []
    for l in range(1, L + 1):
        W = rng.standard_normal((d, d)) * k / np.sqrt(d)   # разброс весов k/sqrt(d)
        x = np.maximum(x @ W, 0)                            # слой + ReLU
        if l in (10, 30, 50): row.append(f"{x.std():.2e}")
    print(f"k={k:.2f}: разброс после 10/30/50 слоёв:", " ".join(row))

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

k=0.80: разброс после 10/30/50 слоёв: 2.49e-03 2.21e-08 1.42e-13
k=1.00: разброс после 10/30/50 слоёв: 2.24e-02 2.27e-05 2.14e-08
k=1.41: разброс после 10/30/50 слоёв: 6.80e-01 4.46e-01 5.95e-01
k=1.60: разброс после 10/30/50 слоёв: 2.16e+00 2.00e+01 1.81e+02

При k = 0,8 разброс за 50 слоёв упал до 10−13: сигнал фактически исчез, и градиент до первых слоёв тоже не дойдёт. При k = 1 — это популярная «интуитивная» нормировка 1/√d — к 50-му слою осталось 2·10−8, потому что про половину, срезанную ReLU, забыли. При k = √2 сигнал держится около 0,5–0,7 на всей глубине. При k = 1,6 к 50-му слою разброс 181 и продолжает расти. Повтори: замени ReLU на np.tanh и найди k, при котором сигнал не гаснет; он окажется близко к единице.

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

  • Берут нормировку 1/√d для слоёв с ReLU или GELU и удивляются, что глубокая сеть «не учится». Для функций, срезающих отрицательную часть, нужен множитель около √2.
  • Смотрят только на потерю. Разброс активаций по слоям в первые шаги обучения показывает проблему сразу, а потеря может долго выглядеть просто «медленной».
  • Лечат взрыв активаций уменьшением скорости обучения. Это откладывает проблему: при неправильном масштабе на старте она возвращается на следующем росте весов.

Разброс (standard deviation). Типичное отклонение чисел от их среднего; здесь — мера «размера» сигнала в слое.

Активации (activations). Числа на выходе слоя для конкретного входа, промежуточные результаты прямого прохода.

ReLU. Функция активации, которая оставляет положительные числа и заменяет отрицательные нулём.

Инициализация Хе (He initialization). Выбор начальных весов с разбросом √(2/d), сохраняющий размер сигнала в слоях с ReLU.

Инициализация Ксавье (Xavier, Glorot). Выбор начальных весов с разбросом около √(1/d) для симметричных функций активации вроде tanh.

Затухание градиента (vanishing gradient). Уменьшение градиента в геометрической прогрессии по мере движения к первым слоям.

Взрыв градиента (exploding gradient). Обратная ситуация: градиент растёт от слоя к слою, пока не переполнит формат чисел.

NaN (not a number). Специальное значение «не-число», которое появляется при переполнении или делении нуля на ноль и дальше заражает все вычисления.

2 Остаточная связь: прямая дорога для сигнала и градиента

Зачем это в работе. Остаточная связь (residual connection, skip connection) — причина, по которой вообще можно строить сети на десятки и сотни слоёв. В трансформере вокруг каждого блока внимания и каждого полносвязного блока стоит такой обход, и вся модель устроена как один «поток», в который блоки по очереди дописывают поправки. Это понятие нужно, чтобы читать схемы архитектур, понимать, почему градиент доходит до первых слоёв, и откуда в остаточном потоке растут большие числа.

Как это устроено. Обычный слой заменяет вход: x → f(x). Слой с обходом прибавляет к входу поправку: x → x + f(x). Идея пришла из работы ResNet (He и соавторы, 2015) для распознавания изображений. Если блоку нечему научиться, ему достаточно выдавать ноль, и сигнал пройдёт без изменений, а без обхода для этого блоку пришлось бы выучить тождественное преобразование, что гораздо труднее.

Главное — обратный проход. Производная от x + f(x) по x равна единице плюс производная f. Градиент, пришедший сверху, проходит через блок двумя путями: через f, где он может уменьшиться, и напрямую, где он не меняется вовсе. Перемножая такие множители по слоям, мы получаем сумму, в которой всегда есть слагаемое «градиент сверху без изменений», поэтому полностью он не гаснет. Без обхода есть только произведение множителей через f, и если каждый меньше единицы, произведение быстро идёт к нулю.

Остаточный поток (residual stream). В трансформере выход модели можно записать как вход плюс сумма вкладов всех блоков: x_L = x_0 + f_1 + f_2 + … Каждый блок читает текущую сумму и дописывает свою поправку. Эта картина — основа работ по интерпретируемости: каждый вклад можно рассмотреть отдельно. Ограничение тоже видно из формулы: если ничем не сдерживать размеры f, сумма растёт с глубиной, и то же происходит с градиентом, только в обратную сторону. Обход спасает от затухания, но сам по себе может привести к росту. Поэтому его всегда сочетают с нормализацией и с уменьшенным масштабом весов в последних слоях блоков; например, в GPT-2 веса таких слоёв при инициализации делили на √N, где N — число остаточных слоёв, так описано в самой статье о GPT-2.

Подробный пример. Сеть из 48 блоков tanh на 64 числах. Посчитаем градиент суммы выхода по входу каждого блока вручную, обратным проходом, в двух вариантах: x → tanh(xW) и x → x + tanh(xW). Сравним размер градиента у последнего блока, в середине и у первого.

import numpy as np
rng = np.random.default_rng(1)
d, L = 64, 48
Ws = [rng.standard_normal((d, d)) / np.sqrt(d) for _ in range(L)]
x0 = rng.standard_normal(d)
def grad_at_input(residual):
    # прямой проход: h = tanh(x W); x_next = x + h (с обходом) или h (без)
    xs, x = [], x0
    for W in Ws:
        xs.append(x); h = np.tanh(x @ W)
        x = x + h if residual else h
    g = np.ones(d)                       # градиент суммы выхода
    norms = {}
    for l in reversed(range(L)):
        W, x = Ws[l], xs[l]
        dh = g * (1 - np.tanh(x @ W) ** 2)
        g = (g if residual else 0) + dh @ W.T
        if l in (47, 24, 0): norms[l] = np.linalg.norm(g)
    return norms
for r in (False, True):
    n = grad_at_input(r)
    print("с обходом " if r else "без обхода", {f"слой {k}": f"{v:.2e}" for k, v in sorted(n.items())})

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

без обхода {'слой 0': '3.70e-01', 'слой 24': '3.14e+00', 'слой 47': '8.41e+00'}
с обходом  {'слой 0': '2.07e+02', 'слой 24': '2.22e+01', 'слой 47': '8.31e+00'}

Без обхода градиент от последнего блока к первому уменьшился с 8,4 до 0,37, примерно в 23 раза: первые слои учатся гораздо медленнее последних. С обходом градиент у первого блока не только не исчез, но вырос до 207, в 25 раз больше, чем наверху: прямые пути и пути через блоки складываются. Это и есть обратная сторона обхода, и это прямой довод в пользу нормализации и уменьшенного масштаба блоков. Повтори: умножь tanh(xW) на 0,1 в варианте с обходом и посмотри, как размер градиента на всех слоях выравнивается.

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

  • Считают, что остаточная связь «решает проблему глубины» сама по себе. Она устраняет затухание, но без нормализации и масштаба блоков создаёт рост сигнала и градиента.
  • Ставят между блоком и сложением что-то, что меняет размер прямого пути, например dropout или масштаб на самой ветке обхода. Прямой путь должен оставаться тождественным, иначе его главное свойство пропадает.
  • Путают остаточную связь с плотными связями (dense connections), где выходы всех прошлых слоёв склеиваются, а не складываются. Это другая архитектура, она дороже по памяти.

Остаточная связь (residual connection). Обход вокруг блока, при котором выход равен входу плюс поправка блока.

ResNet. Сеть для изображений 2015 года, где остаточные связи впервые позволили обучать очень глубокие модели.

Тождественное преобразование (identity). Преобразование, которое возвращает вход без изменений.

Остаточный поток (residual stream). Сумма входа и вкладов всех блоков, которая идёт через трансформер от первого слоя к последнему.

Ветка блока (residual branch). Часть вычисления, которая считает поправку f(x) и прибавляется к потоку.

Масштаб ветки. Множитель на выходе блока, чаще всего заданный через уменьшенные начальные веса, чтобы сумма вкладов не росла с глубиной.

Интерпретируемость (interpretability). Направление исследований, которое разбирает, какие вычисления выполняют отдельные части модели.

3 LayerNorm, RMSNorm и BatchNorm: что именно нормализуют и почему в языковых моделях не BatchNorm

Зачем это в работе. Нормализация (normalization) — операция, которая приводит вектор активаций к стандартному размеру перед следующим вычислением. Она стоит в каждом блоке трансформера по одному-два раза, и в описании любой открытой модели указано, какая именно: LayerNorm или RMSNorm. От выбора зависит, что модель «видит» во входе, сколько стоит вычисление и как она ведёт себя на коротких батчах при генерации текста.

Как устроена нормализация слоя (LayerNorm, Ba и соавторы, 2016). Для одного вектора одного токена считают среднее его координат и разброс, вычитают среднее и делят на разброс; к знаменателю добавляют маленькое число эпсилон (epsilon), чтобы не делить на ноль. Потом каждую координату умножают на свой обучаемый масштаб (gain) и прибавляют обучаемый сдвиг (bias). Результат не зависит ни от того, на сколько умножили вход, ни от того, какое число прибавили ко всем координатам.

RMSNorm (Zhang и Sennrich, 2019) упрощает это: среднее не вычитают, а делят на корень из среднего квадрата координат (root mean square), и сдвига обычно нет. Остаётся независимость от умножения входа, но пропадает независимость от общего сдвига. Авторы показали, что качество при этом практически не страдает, а считать меньше; в итоге RMSNorm стоит, например, в семействе Llama. LayerNorm используется в GPT-2 и многих других моделях; оба варианта нормализуют каждый токен отдельно.

Пакетная нормализация (BatchNorm, Ioffe и Szegedy, 2015) устроена по-другому: среднее и разброс считают для каждой координаты по всем примерам батча. Это хорошо работает в свёрточных сетях для изображений, но результат для одного примера зависит от того, какие ещё примеры оказались рядом в батче. Для языковых моделей это неудобно: последовательности разной длины, батчи при генерации маленькие, а при обучении и при работе модели приходится держать разные статистики. Поэтому в трансформерах нормализуют по координатам одного токена, а не по батчу.

Подробный пример. Реализуем обе нормализации токена в две строки и проверим их свойства на векторе [3, 5, 7, 9]: что будет, если умножить его на 100 и если прибавить 50. Затем возьмём один и тот же пример a = [1, 2] в двух разных батчах и посмотрим, что делает с ним BatchNorm.

import numpy as np
def layernorm(x, eps=1e-5): return (x - x.mean(-1, keepdims=True)) / np.sqrt(x.var(-1, keepdims=True) + eps)
def rmsnorm(x, eps=1e-6):   return x / np.sqrt((x ** 2).mean(-1, keepdims=True) + eps)
x = np.array([3.0, 5.0, 7.0, 9.0])
np.set_printoptions(precision=3, suppress=True)
print("LayerNorm(x)     ", layernorm(x))
print("RMSNorm(x)       ", rmsnorm(x))
print("RMSNorm(100*x)   ", rmsnorm(100 * x), " <- масштаб входа не важен")
print("LayerNorm(x+50)  ", layernorm(x + 50), " <- сдвиг убран")
print("RMSNorm(x+50)    ", rmsnorm(x + 50), " <- сдвиг не убран")
# пакетная нормализация: один и тот же пример в двух разных батчах
def batchnorm(B, eps=1e-5): return (B - B.mean(0)) / np.sqrt(B.var(0) + eps)
a = np.array([[1.0, 2.0]])
b1 = np.vstack([a, [[3.0, 4.0]], [[5.0, 0.0]]])
b2 = np.vstack([a, [[1.5, 2.5]], [[0.0, 9.0]]])
print("BatchNorm, пример a в батче 1:", batchnorm(b1)[0])
print("BatchNorm, пример a в батче 2:", batchnorm(b2)[0])
print("RMSNorm, пример a в любом батче:", rmsnorm(a)[0])

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

LayerNorm(x)      [-1.342 -0.447  0.447  1.342]
RMSNorm(x)        [0.469 0.781 1.093 1.406]
RMSNorm(100*x)    [0.469 0.781 1.093 1.406]  <- масштаб входа не важен
LayerNorm(x+50)   [-1.342 -0.447  0.447  1.342]  <- сдвиг убран
RMSNorm(x+50)     [0.946 0.981 1.017 1.053]  <- сдвиг не убран
BatchNorm, пример a в батче 1: [-1.225  0.   ]
BatchNorm, пример a в батче 2: [ 0.267 -0.784]
RMSNorm, пример a в любом батче: [0.632 1.265]

Умножение на 100 не изменило результат RMSNorm ни в одном знаке. Прибавление 50 LayerNorm полностью убрал, а RMSNorm — нет: вектор превратился почти в постоянный около единицы, и различия между координатами сжались почти в девять раз. BatchNorm выдал для одного и того же примера a два разных ответа, [−1,225, 0] и [0,267, −0,784], только потому, что соседи в батче были разные; RMSNorm от соседей не зависит. Повтори: добавь в rmsnorm обучаемый масштаб g = [2, 1, 1, 1] и посмотри, как он восстанавливает размер нужной координаты.

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

  • Считают нормализацию в коротком формате. Среднее квадратов — сумма тысяч чисел, и в fp16 или bf16 она теряет точность; фреймворки делают её в fp32, и в собственной реализации это нужно повторить.
  • Ставят слишком маленький эпсилон для fp16: 10−8 в этом формате округляется до нуля, и деление на почти нулевой разброс даёт бесконечность.
  • Применяют уменьшение весов к обучаемым масштабам нормализации. Тогда они тянутся к нулю и глушат сигнал; обычно их исключают из уменьшения весов.

Нормализация (normalization). Приведение вектора активаций к стандартному размеру перед следующим вычислением.

LayerNorm. Нормализация одного токена: вычесть среднее его координат и разделить на их разброс.

RMSNorm. Упрощённая нормализация токена: разделить на корень из среднего квадрата координат, без вычитания среднего.

BatchNorm. Нормализация каждой координаты по всем примерам батча; результат зависит от соседей по батчу.

Эпсилон (epsilon). Маленькое число в знаменателе, которое защищает от деления на ноль.

Обучаемый масштаб (gain, weight). Множитель на каждую координату после нормализации, который модель подбирает при обучении.

Корень из среднего квадрата (RMS, root mean square). Мера размера вектора: квадраты координат усредняют и извлекают корень.

4 Нормализация до блока или после: pre-norm, post-norm и зачем нужен разогрев

Зачем это в работе. Один и тот же набор деталей можно собрать двумя способами, и от этого зависит, обучится ли глубокая модель без разогрева скорости обучения и без всплесков потери. Почти все современные языковые модели используют схему pre-norm, но в исходном трансформере 2017 года стояла post-norm, и в литературе встречаются обе. Эту разницу полезно видеть на схеме сразу.

Как это устроено. В схеме post-norm нормализация стоит после сложения: x → Norm(x + f(x)). Так сделано в статье «Attention Is All You Need». В схеме pre-norm нормализуют только вход блока, а поток не трогают: x → x + f(Norm(x)). В GPT-2 нормализацию перенесли на вход каждого блока и добавили ещё одну после последнего блока; эта финальная нормализация нужна, потому что сам поток в pre-norm нигде не нормализован.

Почему это важно для обучения. В post-norm прямой путь обхода каждый раз проходит через нормализацию, и чистого тождественного пути от выхода к входу нет. Ксионг и соавторы (Xiong et al., 2020) показали анализом и опытами, что в post-norm на старте градиенты у параметров близких к выходу слоёв большие, поэтому без разогрева скорости обучения такая модель легко срывается; в pre-norm градиенты ведут себя ровнее, и разогрев можно сократить или убрать. Разогрев (warmup) — это первые шаги обучения, в течение которых скорость обучения плавно растёт от нуля.

Цена pre-norm. Поток в pre-norm — это сумма входа и вкладов всех блоков без нормализации, и его размер растёт с глубиной. Каждый следующий блок дописывает поправку примерно постоянного размера, потому что видит нормализованный вход, а поток при этом становится всё больше. Значит, относительный вклад глубоких блоков падает; ряд работ связывает с этим наблюдение, что глубокие слои многих pre-norm моделей можно убрать с небольшой потерей качества. Отличие от post-norm: там размер потока постоянный, но вход быстро «растворяется» в потоке и прямой дороги для градиента нет.

Подробный пример. Сеть из 48 блоков с полносвязной веткой relu(xW₁)W₂ на 32 числах. Соберём её двумя способами, посмотрим размер потока после 1, 12, 24 и 48 блоков и сходство итогового вектора с исходным входом — косинус угла между ними: 1 значит «то же направление», 0 — «никакой связи».

import numpy as np
rng = np.random.default_rng(2)
d, L = 32, 48
W1 = [rng.standard_normal((d, 4*d)) / np.sqrt(d) for _ in range(L)]
W2 = [rng.standard_normal((4*d, d)) / np.sqrt(4*d) for _ in range(L)]
def rms(x): return np.sqrt((x**2).mean())
def block(h, l):                      # f(h) = relu(h W1) W2
    return np.maximum(h @ W1[l], 0) @ W2[l]
def run(pre):
    x0 = np.random.default_rng(3).standard_normal(d); x = x0
    sizes = []
    for l in range(L):
        if pre:   # x + f(norm(x))
            n = x / rms(x); f = block(n, l)
            x = x + f
        else:     # norm(x + f(x))
            f = block(x, l); z = x + f
            x = z / rms(z)
        if l + 1 in (1, 12, 24, 48): sizes.append(f"{rms(x):.2f}")
    cos = x @ x0 / np.linalg.norm(x) / np.linalg.norm(x0)
    return sizes, cos
for pre in (False, True):
    s, g = run(pre)
    print("pre-norm " if pre else "post-norm", "размер потока после 1/12/24/48 блоков:", s, "| сходство выхода со входом:", f"{g:.2f}")

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

post-norm размер потока после 1/12/24/48 блоков: ['1.00', '1.00', '1.00', '1.00'] | сходство выхода со входом: 0.01
pre-norm  размер потока после 1/12/24/48 блоков: ['1.29', '2.63', '3.90', '5.77'] | сходство выхода со входом: 0.28

В post-norm размер потока ровно 1 на любой глубине, но к 48-му блоку от входа почти ничего не осталось: косинус 0,01. В pre-norm поток вырос с 1,29 до 5,77, примерно как корень из числа блоков, а исходный вход по-прежнему заметен в выходе: косинус 0,28, потому что он лежит в сумме без изменений. Это наглядно показывает обе стороны: у pre-norm есть прямая дорога от входа к выходу, но каждый следующий блок меняет растущий поток всё слабее. Повтори: в pre-norm умножь вклад f на 1/√(2·48) — так делают многие инициализации — и посмотри, как перестаёт расти поток.

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

  • Убирают финальную нормализацию в pre-norm модели «для простоты». Поток не нормализован, и слой выдачи слов получает вход, размер которого зависит от глубины и обучения.
  • Переносят расписание с разогревом из pre-norm статьи на post-norm модель с сокращённым разогревом и получают всплески потери в первые тысячи шагов.
  • Читают «Norm» на схеме, не проверяя, где он стоит относительно сложения. Одни и те же слова в описании архитектуры могут означать обе схемы.

Post-norm. Схема, где нормализация стоит после сложения потока с выходом блока.

Pre-norm. Схема, где нормализуют только вход блока, а поток идёт без нормализации.

Финальная нормализация (final norm). Нормализация после последнего блока pre-norm модели, перед слоем выдачи слов.

Разогрев (warmup). Плавный рост скорости обучения от нуля в первые шаги, защищающий от срыва на старте.

Косинусное сходство (cosine similarity). Косинус угла между векторами: 1 — одно направление, 0 — независимые направления.

Слой выдачи слов (unembedding, LM head). Последняя матрица, которая превращает вектор потока в оценки для каждого токена словаря.

5 Где нормализация не спасает: выбросы в активациях, рост логитов внимания и QK-norm

Зачем это в работе. Даже правильно собранная модель с pre-norm и RMSNorm в больших масштабах встречает две известные неприятности. Первая — редкие координаты потока с огромными значениями, которые мешают сжимать модель до int8. Вторая — рост логитов внимания, из-за которого внимание схлопывается на один токен и обучение срывается. Обе проблемы видны в отчётах о больших обучениях, и обе лечатся конкретными, понятными приёмами.

Выбросы в активациях (outlier features). Деттмерс и соавторы в работе LLM.int8() (2022) описали, что в больших моделях появляются отдельные координаты потока, значения которых намного больше остальных, и что они систематически встречаются в одних и тех же координатах. Нормализация делит весь вектор на один общий размер, поэтому такой выброс она не убирает, а лишь масштабирует вместе с остальными. Позднее работа о «массивных активациях» (Sun и соавторы, 2024) описала ещё более крупные отдельные значения, которые связаны с определёнными токенами.

Почему это бьёт по квантованию. При простом квантовании в int8 по наибольшему значению (absmax) весь диапазон делят на 255 уровней так, чтобы поместилось самое большое число. Один выброс растягивает сетку, и все обычные значения попадают на несколько уровней около нуля. Поэтому LLM.int8() обрабатывает координаты-выбросы отдельно в 16 битах, а другие методы переносят масштаб из активаций в веса или квантуют маленькими блоками, у каждого свой масштаб.

Рост логитов внимания. Логит внимания — скалярное произведение запроса (query) и ключа (key), делённое на √d. Если при обучении размеры векторов q и k растут, логиты растут как произведение их размеров, softmax превращается почти в «один токен получает всё», а градиенты через внимание почти исчезают. В работе о ViT-22B (Dehghani и соавторы, 2023) именно такой рост логитов приводил к срыву обучения, и его устранили нормализацией q и k перед скалярным произведением (QK-norm, QK-layernorm). Мера «размазанности» внимания — энтропия (entropy): у равномерного распределения по n токенам она равна ln n, у внимания на один токен — нулю.

Подробный пример. Две части. Сначала квантуем в int8 вектор из 4096 обычных чисел и тот же вектор, где одна координата равна 60, и сравниваем ошибку на всех остальных координатах. Затем берём запрос и 16 ключей, умножаем q и k на 1, 4 и 16 и смотрим максимальный логит и энтропию внимания; после этого повторяем с RMSNorm на q и k.

import numpy as np
rng = np.random.default_rng(4)
def int8_absmax(v):
    s = np.abs(v).max() / 127
    return np.round(v / s) * s
x = rng.standard_normal(4096)
x_out = x.copy(); x_out[7] = 60.0          # одна «огромная» координата
for name, v in (("без выброса", x), ("с выбросом 60", x_out)):
    err = np.delete(np.abs(int8_absmax(v) - v), 7)   # ошибка на всех, кроме координаты 7
    print(f"{name:14s} шаг сетки {np.abs(v).max()/127:.4f}  средняя ошибка остальных {err.mean():.4f}")
# рост логитов внимания и QK-norm
q = rng.standard_normal((1, 64)); k = rng.standard_normal((16, 64))
def entropy(logits):
    p = np.exp(logits - logits.max()); p /= p.sum(); return -(p * np.log(p)).sum()
for s in (1, 4, 16):
    lg = (s*q) @ (s*k).T / np.sqrt(64)
    print(f"q,k умножены на {s:2d}: макс. логит {lg.max():7.1f}, энтропия внимания {entropy(lg):.3f} (максимум {np.log(16):.3f})")
for s in (1, 16):
    lg = ((s*q)/np.sqrt(((s*q)**2).mean())) @ ((s*k)/np.sqrt(((s*k)**2).mean(-1, keepdims=True))).T / np.sqrt(64)
    print(f"с QK-norm, множитель {s:2d}: макс. логит {lg.max():7.1f}, энтропия {entropy(lg):.3f}")

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

без выброса    шаг сетки 0.0319  средняя ошибка остальных 0.0080
с выбросом 60  шаг сетки 0.4724  средняя ошибка остальных 0.1191
q,k умножены на  1: макс. логит     1.1, энтропия внимания 2.557 (максимум 2.773)
q,k умножены на  4: макс. логит    17.9, энтропия внимания 0.432 (максимум 2.773)
q,k умножены на 16: макс. логит   286.5, энтропия внимания 0.000 (максимум 2.773)
с QK-norm, множитель  1: макс. логит     1.3, энтропия 2.483
с QK-norm, множитель 16: макс. логит     1.3, энтропия 2.483

Один выброс увеличил шаг сетки int8 с 0,032 до 0,47 и среднюю ошибку на остальных 4095 координатах с 0,008 до 0,119, почти в 15 раз, хотя сами эти координаты не изменились. Во второй части умножение q и k на 4 подняло максимальный логит с 1,1 до 17,9 и уронило энтропию с 2,56 до 0,43 при возможном максимуме 2,77; при множителе 16 логит 286, энтропия 0 — всё внимание на одном токене. С нормализацией q и k логит и энтропия одинаковые при любом множителе: рост размеров просто не доходит до softmax. Повтори: квантуй вектор с выбросом блоками по 64 числа, каждый со своим масштабом, и сравни ошибку.

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

  • Считают, что после RMSNorm все координаты одного порядка. Нормализация делит вектор целиком и сохраняет выбросы, она лишь меняет общий масштаб.
  • Квантуют активации большой модели в int8 одним масштабом на весь тензор и списывают падение качества на «плохое квантование» вообще, а не на конкретные координаты-выбросы.
  • Пытаются лечить схлопывание внимания только уменьшением скорости обучения или обрезкой градиента, не посмотрев на размер логитов внимания по слоям. Если логиты растут, точечное средство — нормализация q и k.

Выбросы в активациях (outlier features). Отдельные координаты потока с намного большими значениями, чем у остальных, повторяющиеся от токена к токену.

Массивные активации (massive activations). Особенно крупные одиночные значения в потоке, связанные с определёнными токенами.

Квантование absmax. Квантование, при котором шаг сетки выбирают по самому большому по модулю значению тензора.

Квантование блоками (block-wise quantization). Квантование, в котором каждый небольшой кусок тензора получает свой масштаб.

Логит внимания (attention logit). Скалярное произведение запроса и ключа до softmax; от него зависит, сколько внимания получит токен.

Энтропия внимания (attention entropy). Мера того, насколько внимание распределено по токенам: ноль значит, что оно всё на одном.

QK-norm. Нормализация векторов запроса и ключа перед скалярным произведением, которая не даёт логитам расти.

Схлопывание внимания (attention collapse). Состояние, когда внимание почти целиком уходит на один токен и градиенты через него почти пропадают.

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