В прошлой дорожке мы посчитали, что состояние оптимизатора Adam занимает больше памяти, чем сами веса, и мимоходом сказали «16 байт на параметр». Сегодня разберём, откуда эти байты и как их экономят. Каждое число в модели хранится в каком-то формате: на него уходит 4, 2 или 1 байт, и от формата зависит, насколько большие и насколько мелкие числа он вмещает и как точно. Обучение в смешанной точности (mixed precision) считает основную работу в коротких форматах, а самые чувствительные места оставляет в длинном. Разберём по порядку: устройство числа, главную копию весов, масштабирование потери, точные суммы и восьмибитное обучение. Все примеры — маленькие расчёты на numpy, где короткие форматы имитируются округлением; код на странице мы запускали, выводы взяты из этих запусков. Числа из чужих работ помечены, откуда они.
Все дорожки — /put. Прошлая — оптимизатор.
Зачем это в работе. Почти каждое решение о памяти и скорости обучения — это выбор формата чисел. Ускорители считают короткие форматы в разы быстрее длинных, а память под веса, градиенты и состояние оптимизатора прямо пропорциональна числу байт на значение. Но короткий формат может молча превратить маленькое число в ноль, большое — в бесконечность, а прибавку к весу — в ничто. Чтобы понимать, где это случится, нужно знать, из каких частей состоит число.
Как это устроено. Число с плавающей точкой (floating point) хранится как три поля битов. Первый бит — знак. Следующие биты — порядок (exponent): он говорит, на какую степень двойки умножить число, то есть задаёт масштаб — тысячи это или тысячные. Оставшиеся биты — мантисса (mantissa): это значащие цифры внутри выбранного масштаба. Получается что-то вроде записи 1,0110 × 2−3 в двоичной системе. Название формата обычно говорит, сколько всего бит: fp32 — 32 бита, то есть 4 байта, fp16 и bf16 — по 2 байта, fp8 — 1 байт.
Главное ограничение: биты порядка и биты мантиссы делят между собой одну и ту же длину. Больше бит в порядке — шире диапазон (range), от самого мелкого до самого крупного представимого числа. Больше бит в мантиссе — выше точность (precision): ближе друг к другу соседние представимые числа. Удобная мера точности — шаг после единицы (machine epsilon): расстояние от 1 до следующего представимого числа. Он равен 2 в степени минус число бит мантиссы, поэтому считается по формуле, а не измеряется.
Отсюда разница между двумя двухбайтовыми форматами. У fp16 (стандарт IEEE half precision) 5 бит порядка и 10 бит мантиссы: точность неплохая, но наибольшее число всего 65 504. У bf16 (brain floating point, формат придумали в Google Brain для ускорителей TPU) 8 бит порядка, как у fp32, и только 7 бит мантиссы: диапазон тот же, что у fp32, а точность грубее. По сути bf16 — это fp32 с отрезанными младшими 16 битами мантиссы, поэтому переводить одно в другое просто и безопасно для диапазона. Для fp8 есть два формата: E4M3 (4 бита порядка, 3 бита мантиссы) точнее, но вмещает числа лишь до 448; E5M2 (5 и 2) грубее, но доходит до 57 344.
Ниже наименьшего «обычного» числа формат ещё может хранить так называемые субнормальные числа (subnormal numbers): там шаг сетки перестаёт уменьшаться, и относительная точность быстро падает, пока число не станет нулём. Это не то же самое, что округление: округление теряет младшие цифры, а уход ниже диапазона теряет всё число. Переполнение (overflow) — обратная беда: число больше наибольшего превращается в бесконечность, и одна бесконечность заражает все следующие вычисления.
Подробный пример. В numpy нет bf16 и fp8, поэтому сымитируем их округлением. Функция bf16 берёт число fp32 и округляет его до старших 16 бит, функция fp8 округляет к сетке с нужным числом бит мантиссы. Эти функции используются во всех примерах дорожки, сохрани их в файл lp.py.
# общие функции: имитация bf16 и fp8 средствами numpy
import numpy as np
def bf16(x):
"""Округлить float32 до bfloat16 (к ближайшему, при равенстве — к чётному)."""
a = np.asarray(x, dtype=np.float32).copy()
u = a.view(np.uint32)
u += 0x7FFF + ((u >> 16) & 1)
u &= 0xFFFF0000
return a
def fp8(x, man, emin, vmax):
"""Округлить к сетке fp8: man бит мантиссы, emin — наименьший порядок нормальных чисел."""
x = np.asarray(x, dtype=np.float64)
e = np.floor(np.log2(np.maximum(np.abs(x), 1e-300)))
e = np.maximum(e, emin) # ниже emin — равномерная сетка (субнормальные)
step = 2.0 ** (e - man)
return np.clip(np.round(x / step) * step, -vmax, vmax)
e4m3 = lambda x: fp8(x, 3, -6, 448.0)
e5m2 = lambda x: fp8(x, 2, -14, 57344.0)
Теперь посчитаем свойства форматов по формулам и проверим несколько чисел:
import warnings; warnings.filterwarnings('ignore')
import numpy as np
from lp import bf16, e4m3, e5m2
# порядок (бит), мантисса (бит), наибольший порядок нормальных чисел, наименьший
fmt = {"fp32": (8, 23, 127, -126), "fp16": (5, 10, 15, -14), "bf16": (8, 7, 127, -126),
"fp8 E5M2": (5, 2, 15, -14), "fp8 E4M3": (4, 3, 8, -6)}
print(f"{'формат':9} {'байт':>4} {'наибольшее':>10} {'наим. обычное':>13} {'шаг после 1':>11}")
for name, (E, M, emax, emin) in fmt.items():
big = (2 - 2.0**-M) * 2.0**emax if name != "fp8 E4M3" else 448.0 # у E4M3 нет бесконечности
print(f"{name:9} {(1+E+M)//8:>4} {big:>10.3g} {2.0**emin:>13.3g} {2.0**-M:>11.3g}")
print("1 + 0.001 в bf16:", bf16(1 + 0.001)[()], " в fp16:", np.float16(1 + 0.001))
print("70000 в fp16:", np.float16(70000), " в bf16:", bf16(70000)[()])
print("0.1 в bf16:", f"{bf16(0.1)[()]:.6f}", " в E4M3:", e4m3(0.1)[()], " в E5M2:", e5m2(0.1)[()])
У нас этот код напечатал:
формат байт наибольшее наим. обычное шаг после 1
fp32 4 3.4e+38 1.18e-38 1.19e-07
fp16 2 6.55e+04 6.1e-05 0.000977
bf16 2 3.39e+38 1.18e-38 0.00781
fp8 E5M2 1 5.73e+04 6.1e-05 0.25
fp8 E4M3 1 448 0.0156 0.125
1 + 0.001 в bf16: 1.0 в fp16: 1.001
70000 в fp16: inf в bf16: 70144.0
0.1 в bf16: 0.100098 в E4M3: 0.1015625 в E5M2: 0.09375
Таблица показывает обмен «диапазон против точности» в чистом виде. У bf16 наибольшее число такое же, как у fp32, но шаг после единицы 0,0078: прибавка 0,001 к единице в нём просто исчезает, а fp16 её сохраняет. Зато 70 000 в fp16 уже бесконечность, а bf16 хранит его как 70 144 — с ошибкой, но без катастрофы. Число 0,1 в bf16 превращается в 0,100098, в fp8 E4M3 — в 0,1016, в E5M2 — в 0,094. Повтори: подставь свои значения, например 1e-6 и 1e-8, и посмотри, где fp16 начинает возвращать ноль.
Где обычно ошибаются.
Число с плавающей точкой (floating point). Запись числа как знака, порядка и мантиссы, позволяющая хранить и очень большие, и очень малые значения.
Порядок (exponent). Часть битов, задающая степень двойки, то есть масштаб числа; от неё зависит диапазон.
Мантисса (mantissa). Часть битов со значащими цифрами числа; от неё зависит точность.
Диапазон (range). Промежуток от самого малого до самого большого числа, которое формат хранит без обнуления и бесконечности.
Шаг после единицы (machine epsilon). Расстояние от 1 до следующего представимого числа; равен 2 в степени минус число бит мантиссы.
bf16 (brain floating point). Двухбайтовый формат с диапазоном fp32 и грубой точностью, основной формат вычислений при обучении больших моделей.
Субнормальные числа (subnormal numbers). Числа ниже наименьшего обычного, которые формат ещё хранит, но со всё меньшим числом верных цифр.
Переполнение (overflow). Ситуация, когда результат больше наибольшего числа формата и превращается в бесконечность.
Зачем это в работе. Почти все большие модели сегодня учат в смешанной точности: основные умножения матриц идут в bf16, потому что так быстрее и меньше памяти, но кое-что держат в fp32. Если не понимать, что именно и почему, легко «сэкономить» на неправильном месте — и модель перестанет учиться, причём без всякой ошибки в журнале. Это же объясняет, почему на обучение модели нужно в несколько раз больше памяти, чем на её запуск.
Как это устроено. Схему описали Микикевичюс и соавторы из NVIDIA и Baidu в работе «Mixed Precision Training» (2017). Оптимизатор хранит главную копию весов (master weights) в fp32. Перед каждым шагом из неё делается рабочая копия в коротком формате, сейчас обычно bf16. На рабочей копии считаются прямой проход и градиенты: это самая тяжёлая часть, и она идёт в быстром формате. Затем градиенты переводятся в fp32, оптимизатор обновляет главную копию — и цикл повторяется.
Зачем главная копия, если веса всё равно используются в bf16? Из-за прибавки к большому числу. Обновление веса за один шаг — это скорость обучения, умноженная на шаг Adam; оно часто в тысячи раз меньше самого веса. Мы видели на прошлой ступени, что в bf16 соседние числа около единицы отстоят на 0,0078. Если прибавка меньше половины этого шага, результат округляется обратно к старому значению — обновление теряется полностью. Это явление называют застоем (stagnation). В fp32 шаг около единицы примерно 10−7, и мелкие прибавки накапливаются; рабочая копия bf16 просто берёт округлённое текущее значение.
Цена схемы — память. Работа ZeRO (Раджбхандари и соавторы, Microsoft, 2019) считает так для Adam в смешанной точности: 2 байта рабочей копии весов, 2 байта градиентов, 4 байта главной копии и по 4 байта на два момента Adam — всего 16 байт на параметр. Это формула, а не измерение, и в неё ещё не входят активации — промежуточные результаты прямого прохода, которые хранятся для обратного. Отличие от запуска модели: для ответа пользователю нужны только веса, то есть 2 байта на параметр в bf16.
Есть и другие варианты. Можно держать моменты Adam в bf16 или даже в 8 битах — так делают 8-битные оптимизаторы (8-bit optimizers), экономя память ценой аккуратной настройки. Можно отказаться от главной копии и использовать стохастическое округление (stochastic rounding): прибавка округляется вверх или вниз случайно, с вероятностью, пропорциональной расстоянию, и в среднем не теряется. Но базовая и самая проверенная схема — главная копия в fp32.
Подробный пример. Возьмём один вес, равный 1, и 1000 раз прибавим к нему 0,0001 — так выглядит медленное, но устойчивое обучение. Сравним вес, который хранится только в bf16, и главную копию в fp32. Потом посчитаем память для модели на 7 миллиардов параметров по формуле 16 байт.
import numpy as np
from lp import bf16
w_bf16 = bf16(1.0); w_fp32 = np.float32(1.0)
upd = 1e-4 # скорость обучения × шаг Adam
for _ in range(1000):
w_bf16 = bf16(w_bf16 + upd) # вес хранится только в bf16
w_fp32 = np.float32(w_fp32 + upd) # главная копия в fp32
print(f"после 1000 шагов по +0.0001: bf16 = {w_bf16[()]:.4f}, fp32 = {w_fp32:.4f}, ожидали 1.1000")
print(f"рабочая копия из fp32-главной: {bf16(w_fp32)[()]:.4f}")
N = 7e9 # модель на 7 млрд параметров
parts = {"веса bf16": 2, "градиенты bf16": 2, "главная копия fp32": 4,
"Adam m fp32": 4, "Adam v fp32": 4}
for k, b in parts.items(): print(f"{k:20} {b} байта/парам -> {N*b/1e9:5.0f} ГБ")
print(f"{'итого':20} {sum(parts.values())} байт/парам -> {N*sum(parts.values())/1e9:5.0f} ГБ (без активаций)")
У нас этот код напечатал:
после 1000 шагов по +0.0001: bf16 = 1.0000, fp32 = 1.1000, ожидали 1.1000
рабочая копия из fp32-главной: 1.1016
веса bf16 2 байта/парам -> 14 ГБ
градиенты bf16 2 байта/парам -> 14 ГБ
главная копия fp32 4 байта/парам -> 28 ГБ
Adam m fp32 4 байта/парам -> 28 ГБ
Adam v fp32 4 байта/парам -> 28 ГБ
итого 16 байт/парам -> 112 ГБ (без активаций)
Вес в чистом bf16 за 1000 шагов не сдвинулся вообще: каждая прибавка 0,0001 была меньше половины шага сетки и округлялась в ноль. Главная копия в fp32 дошла до 1,1 — ровно сколько ожидали, а рабочая копия из неё стала 1,1016, то есть ближайшим числом bf16. Для 7 миллиардов параметров одно только состояние обучения занимает 112 ГБ — больше, чем вмещает один ускоритель на 80 ГБ, хотя веса для запуска занимают 14 ГБ. Повтори: поменяй прибавку на 0,01 и проверь, что застой исчезает — она больше половины шага сетки.
Где обычно ошибаются.
Смешанная точность (mixed precision). Обучение, где тяжёлые вычисления идут в коротком формате, а чувствительные места остаются в fp32.
Главная копия весов (master weights). Веса в fp32, которые обновляет оптимизатор и из которых каждый шаг делается рабочая копия.
Рабочая копия. Веса в bf16 или fp16, на которых считаются прямой и обратный проходы.
Застой (stagnation). Потеря обновления, когда прибавка к весу меньше половины шага сетки и округляется к старому значению.
Активации (activations). Промежуточные результаты прямого прохода, которые хранятся до обратного прохода.
16 байт на параметр. Память под веса, градиенты, главную копию и два момента Adam в схеме смешанной точности, без активаций.
Стохастическое округление (stochastic rounding). Округление вверх или вниз случайно, так что в среднем мелкие прибавки сохраняются.
8-битный оптимизатор (8-bit optimizer). Оптимизатор, хранящий свои моменты в 8 битах ради экономии памяти.
Зачем это в работе. Формат fp16 до сих пор встречается: на видеокартах без быстрого bf16 (например, поколения до NVIDIA Ampere), в чужом коде и в старых рецептах. Его узкий диапазон бьёт именно по градиентам — они часто очень малы. Если в журнале обучения видишь «loss scale», пропущенные шаги или сообщения о бесконечностях в градиентах — это эта ступень.
Как это устроено. Наименьшее обычное число fp16 — около 6·10−5, субнормальные доходят примерно до 6·10−8, а ниже — ноль. Градиенты отдельных весов в больших сетях бывают и меньше; такие значения при переводе в fp16 обнуляются — это называется исчезновением (underflow). Обнулённый градиент — это вес, который на этом шаге не учится, и предупреждения об этом нет.
Решение из той же работы 2017 года — масштабирование потери (loss scaling). Перед обратным проходом потерю умножают на большое число S, например 216. По правилу дифференцирования все градиенты тоже умножаются на S и сдвигаются в удобную для fp16 область. Перед шагом оптимизатора градиенты в fp32 делят обратно на S, так что сам шаг не меняется. Степень двойки берут потому, что умножение на неё меняет только порядок и не вносит ошибки округления.
Ограничение — сверху: если S слишком велико, самые крупные градиенты переполняются в бесконечность. Поэтому применяют динамический множитель (dynamic loss scaling): после каждого шага проверяют градиенты на бесконечность и «не число» (NaN). Если они есть — шаг пропускают и уменьшают S вдвое; если долго, например 2000 шагов, всё чисто — пробуют увеличить вдвое. Так устроен GradScaler в PyTorch. В bf16 такой механизм обычно не нужен: у него диапазон fp32, и мелкие градиенты не исчезают. Не путай масштабирование потери с обрезкой градиента из прошлой дорожки: обрезка меняет сам шаг, а множитель лишь временно сдвигает числа и потом точно снимается.
Подробный пример. Сгенерируем миллион «градиентов» с медианой около 10−6 и большим разбросом, как бывает в глубоких сетях, и посмотрим, какая доля обнулится или переполнится в fp16 при разных множителях. Затем сымитируем динамический множитель на 10 000 шагов, где обычный наибольший градиент 0,01, а на шаге 5000 случается одиночный большой градиент 5.
import warnings; warnings.filterwarnings('ignore')
import numpy as np
rng = np.random.default_rng(0)
g = rng.lognormal(mean=np.log(1e-6), sigma=2.5, size=1_000_000) * rng.choice([-1, 1], 1_000_000)
g = g.astype(np.float32) # «настоящие» градиенты в fp32
print(f"градиенты: медиана |g| = {np.median(np.abs(g)):.1e}, max |g| = {np.abs(g).max():.1e}")
for scale in [1, 2**10, 2**16, 2**24]:
h = (g * scale).astype(np.float16)
zero = np.mean((h == 0) & (g != 0)); inf = np.mean(np.isinf(h))
print(f"множитель 2^{int(np.log2(scale)):<2}: обнулилось {zero:6.2%}, переполнилось {inf:6.2%}")
# динамический множитель: при inf/nan пропускаем шаг и делим на 2, после 2000 чистых шагов умножаем на 2
scale, clean, skipped = 2.0**24, 0, 0
for step in range(10000):
gmax = 1e-2 if step != 5000 else 5.0 # на шаге 5000 — редкий большой градиент
if gmax * scale > 65504:
print(f" шаг {step:>4}: переполнение при 2^{int(np.log2(scale))}, шаг пропущен, множитель / 2")
scale /= 2; clean = 0; skipped += 1; continue
clean += 1
if clean == 2000: scale *= 2; clean = 0
print(f"динамический множитель: пропущено {skipped} шагов из 10000, итоговый множитель 2^{int(np.log2(scale))}")
У нас этот код напечатал:
градиенты: медиана |g| = 1.0e-06, max |g| = 1.4e-01
множитель 2^0 : обнулилось 8.00%, переполнилось 0.00%
множитель 2^10: обнулилось 0.00%, переполнилось 0.00%
множитель 2^16: обнулилось 0.00%, переполнилось 0.00%
множитель 2^24: обнулилось 0.00%, переполнилось 0.05%
шаг 0: переполнение при 2^24, шаг пропущен, множитель / 2
шаг 1: переполнение при 2^23, шаг пропущен, множитель / 2
шаг 2002: переполнение при 2^23, шаг пропущен, множитель / 2
шаг 4003: переполнение при 2^23, шаг пропущен, множитель / 2
шаг 5000: переполнение при 2^22, шаг пропущен, множитель / 2
шаг 9001: переполнение при 2^23, шаг пропущен, множитель / 2
динамический множитель: пропущено 6 шагов из 10000, итоговый множитель 2^22
Без множителя 8% градиентов обнулились — каждый двенадцатый вес на этом шаге не учится. Множители 210 и 216 спасли все, а 224 перегнул: 0,05% градиентов стали бесконечностью, и такой шаг пришлось бы выбросить целиком. Динамический множитель сам нашёл рабочую величину за два первых шага, затем каждые 2000 шагов пробовал подняться и откатывался, а на одиночном большом градиенте пропустил один шаг. Итого 6 пропущенных шагов из 10 000 — это нормальная цена. Повтори: поставь на шаге 5000 градиент 1e6 и посмотри, как множитель уходит вниз на много ступеней.
Где обычно ошибаются.
fp16 (half precision). Двухбайтовый формат с 5 битами порядка и 10 битами мантиссы; точнее bf16, но с наибольшим числом 65 504.
Исчезновение (underflow). Превращение слишком малого числа в ноль при переводе в формат с узким диапазоном.
Масштабирование потери (loss scaling). Умножение потери на большое число, чтобы градиенты попали в диапазон fp16, с делением обратно перед шагом.
Множитель потери (loss scale). Само число S, на которое умножают потерю; обычно степень двойки.
Динамический множитель (dynamic loss scaling). Способ, который сам уменьшает множитель при переполнении и увеличивает после долгой чистой серии шагов.
NaN (not a number). Особое значение «не число», которое получается, например, из бесконечность минус бесконечность и портит все дальнейшие вычисления.
Пропущенный шаг. Шаг обучения, на котором обновление не делается из-за бесконечностей в градиентах.
Зачем это в работе. Короткий формат хорош для хранения чисел и для умножений, но опасен для длинных сумм. А суммы есть в самых важных местах: каждое умножение матриц — это тысячи сложений, softmax во внимании и в потере складывает экспоненты, нормализация считает среднее и разброс. Если накопить сумму в bf16, ошибка не просто растёт, а может остановить рост суммы совсем. Поэтому настоящие системы смешанной точности смешивают её и внутри одной операции.
Как это устроено. При сложении двух чисел результат округляется к сетке формата. Пока сумма маленькая, сетка мелкая и потери малы. Когда сумма растёт, шаг сетки растёт вместе с ней: в bf16 около 4 он уже 0,031. Если очередное слагаемое меньше половины шага, сумма не меняется — тот же застой, что и с весами. Поэтому ускорители умножают входы в bf16 или fp16, а складывают произведения в сумматоре (accumulator) fp32. Тензорные ядра (tensor cores) NVIDIA делают именно так, если код не попросил иного.
Второе правило — какие операции оставить в fp32 целиком. В PyTorch этим занимается автоматическое приведение (autocast): умножения матриц и свёртки оно запускает в коротком формате, а softmax, логарифмы, экспоненты, нормализацию слоёв и функцию потерь — в fp32. Причина у всех одна: там большие суммы или функции, которые резко растут, и ошибка округления превращается в заметную ошибку результата. Экспонента от числа 100 переполнит fp16, а потеря кросс-энтропии складывает логарифмы вероятностей по огромному словарю.
Ограничение: fp32 в этих местах стоит памяти и времени, поэтому выбор — это компромисс, и его делают по операциям, а не по модели целиком. Отличие от главной копии весов: там мы берегли точность хранения между шагами, а здесь — точность одного вычисления внутри шага. Если обучение с bf16 нестабильно, а с fp32 — нет, первым делом проверяют именно эти места.
Подробный пример. Сложим 10 000 раз число 0,01 (точная сумма 100) с сумматором в bf16 и с сумматором в fp32 при входах в bf16. Затем посчитаем скалярное произведение двух векторов длиной 4096 из чисел от 0 до 1 — так выглядит одна клетка результата умножения матриц.
import numpy as np
from lp import bf16
x = np.full(10_000, 0.01, dtype=np.float32)
s_bf = bf16(0.0)
for v in x: s_bf = bf16(s_bf + bf16(v)) # сумматор тоже в bf16
s_32 = np.float32(0)
for v in bf16(x): s_32 = np.float32(s_32 + v) # входы bf16, сумматор fp32
print(f"сумма 10000 × 0.01: сумматор bf16 = {s_bf[()]:.4f}, сумматор fp32 = {s_32:.4f}, точно 100")
rng = np.random.default_rng(1)
a = rng.random(4096).astype(np.float32); b = rng.random(4096).astype(np.float32) # все числа от 0 до 1
exact = np.dot(a.astype(np.float64), b.astype(np.float64))
ab, bb = bf16(a), bf16(b)
acc_bf = bf16(0.0)
for p, q in zip(ab, bb): acc_bf = bf16(acc_bf + bf16(p * q))
acc_32 = np.dot(ab.astype(np.float64), bb.astype(np.float64)).astype(np.float32)
print(f"скалярное произведение длины 4096: точно {exact:.3f}")
print(f" входы bf16, сумматор fp32: {acc_32:.3f} (ошибка {abs(acc_32-exact):.3f})")
print(f" входы bf16, сумматор bf16: {acc_bf[()]:.3f} (ошибка {abs(acc_bf-exact):.3f})")
У нас этот код напечатал:
сумма 10000 × 0.01: сумматор bf16 = 4.0000, сумматор fp32 = 100.0977, точно 100
скалярное произведение длины 4096: точно 1027.632
входы bf16, сумматор fp32: 1027.595 (ошибка 0.037)
входы bf16, сумматор bf16: 256.000 (ошибка 771.632)
Сумматор bf16 застрял на 4: начиная с этого места шаг сетки 0,031, и прибавка 0,01 меньше его половины. Сумматор fp32 дал 100,0977: лишние 0,0977 — это не ошибка сложения, а то, что само 0,01 в bf16 хранится как 0,0100098, и эта погрешность входа честно накопилась 10 000 раз. В скалярном произведении сумматор bf16 застрял на 256 вместо 1027,6, а fp32 ошибся лишь на 0,037. Повтори: уменьши длину до 64 и посмотри, что для коротких сумм разница почти пропадает — беда именно в длине.
Где обычно ошибаются.
Сумматор (accumulator). Переменная, в которой копится сумма произведений; в смешанной точности обычно fp32.
Ошибка округления (rounding error). Разница между точным результатом и ближайшим числом формата.
Тензорные ядра (tensor cores). Блоки ускорителя NVIDIA, которые быстро умножают маленькие матрицы в коротких форматах с суммой в более длинном.
Автоматическое приведение (autocast). Режим PyTorch, который сам выбирает формат для каждой операции: короткий для умножений, fp32 для чувствительных.
Softmax. Превращение набора чисел в вероятности через экспоненты и их сумму; чувствителен к переполнению.
Скалярное произведение (dot product). Сумма попарных произведений двух векторов; одна клетка результата умножения матриц.
Нормализация слоя (layer normalization). Приведение вектора к нулевому среднему и единичному разбросу; считает суммы по всему вектору.
Зачем это в работе. Современные ускорители, начиная с NVIDIA H100 (Hopper), умеют умножать матрицы в fp8, и это ещё раз примерно вдвое быстрее и экономнее bf16 на тех же ядрах. Обучение в fp8 уже применяют для больших моделей: например, DeepSeek в отчёте о DeepSeek-V3 (декабрь 2024) описывает обучение с основными умножениями в fp8. Но у fp8 всего 2–3 бита мантиссы и узкий диапазон, и без отдельных множителей он теряет слишком много.
Как это устроено. Форматы E4M3 и E5M2 описаны в работе NVIDIA, Arm и Intel «FP8 Formats for Deep Learning» (2022). Обычно E4M3 берут для весов и активаций прямого прохода, где важна точность, а E5M2 — для градиентов, где важнее диапазон; некоторые рецепты используют E4M3 везде. Главная копия весов, моменты оптимизатора и сумматоры остаются в более длинных форматах — это та же смешанная точность, только на ступень короче.
Главная техника — множитель масштаба (scaling factor). Перед переводом в fp8 тензор умножают на число s так, чтобы его наибольшее по модулю значение попало к краю диапазона, например к 448 для E4M3; после умножения матриц результат делят обратно. Если множитель один на весь тензор (per-tensor scaling), один выброс (outlier) — значение, во много раз больше остальных, — задаёт масштаб для всех, и мелкие значения проваливаются к нулю. Поэтому переходят на множители для небольших блоков (block scaling): в DeepSeek-V3 описаны полоски 1×128 для активаций и блоки 128×128 для весов, а в открытой спецификации форматов MX (microscaling, консорциум OCP, 2023) у каждого блока из 32 чисел свой общий множитель — степень двойки.
Ограничение — накладные расходы и точность сумм. Множители нужно хранить и учитывать при умножении, а сумматор внутри fp8-умножения в железе может быть короче полного fp32; в отчёте DeepSeek-V3 поэтому частичные суммы периодически переносят в fp32. Отличие от квантования весов из дорожки о сжатии весов: там веса сжимают один раз после обучения ради запуска, а здесь каждое умножение при обучении делается в fp8, а сами веса учатся в длинном формате.
Подробный пример. Возьмём вектор из 4096 активаций порядка 0,01 и добавим один выброс 300. Переведём его в E4M3 тремя способами — без множителя, с одним множителем на тензор и с отдельным множителем на каждый блок из 32 значений — и сравним относительную ошибку обычных значений.
import numpy as np
from lp import e4m3
rng = np.random.default_rng(2)
x = rng.standard_normal(4096) * 0.01 # активации порядка 0.01
x[123] = 300.0 # один выброс
def rel_err(q, x): return np.linalg.norm(q - x) / np.linalg.norm(x)
mask = np.ones_like(x, bool); mask[123] = False
q_raw = e4m3(x)
print(f"без множителя: ошибка обычных значений {rel_err(q_raw[mask], x[mask]):.1%}")
s = 448 / np.abs(x).max() # один множитель на весь тензор
q_t = e4m3(x * s) / s
print(f"множитель на тензор: ошибка обычных значений {rel_err(q_t[mask], x[mask]):.1%}, "
f"обнулилось {np.mean(q_t[mask] == 0):.1%}")
xb = x.reshape(-1, 32) # блоки по 32, у каждого свой множитель
sb = 448 / np.abs(xb).max(axis=1, keepdims=True)
q_b = (e4m3(xb * sb) / sb).ravel()
print(f"множитель на блок из 32: ошибка обычных значений {rel_err(q_b[mask], x[mask]):.1%}, "
f"обнулилось {np.mean(q_b[mask] == 0):.1%}")
print(f"выброс 300 после блочного fp8: {q_b[123]:.1f}")
У нас этот код напечатал:
без множителя: ошибка обычных значений 5.7%
множитель на тензор: ошибка обычных значений 3.9%, обнулилось 5.1%
множитель на блок из 32: ошибка обычных значений 2.3%, обнулилось 0.0%
выброс 300 после блочного fp8: 300.0
Без множителя значения около 0,01 лежат ниже наименьшего обычного числа E4M3 (0,0156) и округляются грубо — ошибка 5,7%. Один множитель на тензор почти не помог: выброс 300 позволил растянуть числа всего в 448/300 ≈ 1,5 раза, и 5,1% обычных значений всё равно стали нулём. Блочные множители дали 2,3% и ни одного нуля, а сам выброс сохранился точно: он испортил масштаб только своему блоку из 32 чисел, а не всем 4096. Оставшиеся 2,3% — это уже предел трёх бит мантиссы, его множителем не обойти. Повтори: поставь размер блока 128 или 1024 и посмотри, как ошибка движется к варианту «на тензор».
Где обычно ошибаются.
fp8 E4M3. Однобайтовый формат с 4 битами порядка и 3 битами мантиссы, наибольшее число 448; точнее, но уже по диапазону.
fp8 E5M2. Однобайтовый формат с 5 битами порядка и 2 битами мантиссы, наибольшее число 57 344; грубее, но шире.
Множитель масштаба (scaling factor). Число, на которое умножают тензор перед переводом в короткий формат и на которое делят результат.
Множитель на тензор (per-tensor scaling). Один множитель на весь тензор; прост, но чувствителен к выбросам.
Блочные множители (block scaling). Свой множитель для каждого небольшого блока значений, например из 32 или 128 чисел.
Выброс (outlier). Значение, во много раз большее остальных в том же тензоре.
MX (microscaling). Открытая спецификация форматов, где каждый блок из 32 чисел хранит общий множитель — степень двойки.
Словарь целиком — /slovar, новости — /novosti. Все дорожки — /put.