Вчерашняя дорожка про низкоранговую адаптацию сократила память оптимизатора, но оставила одну строчку без ответа: промежуточные результаты прямого прохода — активации — всё равно лежат в памяти до обратного прохода. Сегодня узкий вопрос: что делать, когда именно они не влезают. Самый распространённый приём — пересчёт активаций (gradient checkpointing, activation recomputation): часть промежуточных результатов не хранят, а вычисляют заново, когда они понадобятся. Разберём, откуда берётся эта память, как устроен пересчёт, где ставить контрольные точки, какие у приёма соседи и где он тихо ломается. Все примеры ниже запускались в numpy на коробке, цифры — из этих запусков. Утверждения статей помечены как опубликованные, а не измеренные нами.
Все дорожки — /put. Прошлая — низкоранговая адаптация.
Зачем это в работе. Сообщение «не хватает памяти видеокарты» (out of memory, OOM) при обучении почти никогда не означает, что не влезают сами веса. Обычно модель спокойно помещается для генерации текста, а обучение падает на первом же шаге с длинными примерами. Чтобы понять, какой рычаг тянуть — уменьшать пакет, резать длину, включать пересчёт активаций или менять точность чисел, — нужно знать, из каких частей складывается память шага обучения и какая из них зависит от данных.
Как это устроено. Память шага обучения состоит из четырёх частей. Первая — сами веса. Вторая — градиенты: по одному числу на каждый вес. Третья — состояние оптимизатора: у Adam это два «момента» на каждый вес, то есть ещё два числа (подробно — в дорожке про оптимизатор). Эти три части зависят только от числа параметров и не меняются от того, сколько текста вы подаёте. Четвёртая часть — активации, то есть промежуточные результаты прямого прохода, которые нужно дождаться до обратного.
Зачем их хранить. Обратный проход (backpropagation) считает градиенты по цепному правилу: чтобы получить градиент по весам слоя y = xW, нужен вход x этого слоя, а чтобы пройти через нелинейность вроде tanh, нужно её значение в той же точке. Прямой проход идёт снизу вверх, обратный — сверху вниз, поэтому вход первого слоя понадобится последним. Всё, что прямой проход посчитал, приходится держать, пока обратный проход до этого места не дойдёт.
Отсюда главное свойство: память активаций пропорциональна размеру пакета (сколько примеров за шаг), длине последовательности (сколько токенов в каждом примере), ширине модели и числу слоёв. Удвоили длину контекста — удвоили эту часть, а в обычном внимании ещё и матрица «каждый токен с каждым» растёт как квадрат длины (ступень 4). Веса от этого не растут вовсе.
Чем это отличается от памяти при генерации. При генерации (inference) обратного прохода нет, поэтому промежуточные результаты слоя выбрасываются сразу после того, как следующий слой их прочитал; отдельно хранится только кэш ключей и значений (дорожка про KV-кэш). Поэтому «модель запускается, а обучать не получается» — нормальная ситуация, а не ошибка установки.
Подробный пример. Сеть из 24 полносвязных слоёв шириной 1024 с tanh, все числа float32 (4 байта). Для обратного прохода сохраняем вход сети и выход каждого слоя — 25 массивов размером «пакет × 1024». Меняем размер пакета и сравниваем память активаций с памятью весов.
import numpy as np
# MLP: L слоёв ширины d, tanh. Для обратного прохода храним вход сети и выход каждого слоя (L+1 массивов B x d).
L, d = 24, 1024
W = [np.zeros((d, d), dtype=np.float32) for _ in range(L)]
wbytes = sum(w.nbytes for w in W)
print(f"веса: {L} слоёв по {d}x{d} float32 = {wbytes/2**20:.0f} МиБ")
print(f"градиенты + 2 момента Adam (float32): ещё {3*wbytes/2**20:.0f} МиБ, от пакета не зависят")
for B in (8, 64, 512, 4096):
x = np.zeros((B, d), dtype=np.float32)
saved = [x] # вход сети
for w in W:
x = np.tanh(x @ w)
saved.append(x) # выход слоя: он же вход следующего (для dL/dW) и нужен для производной tanh 1 - h^2
ab = sum(a.nbytes for a in saved)
print(f"пакет B={B:5d}: сохранённые активации {ab/2**20:8.1f} МиБ = {ab/wbytes:5.2f} x размер весов")
У нас этот код напечатал:
веса: 24 слоёв по 1024x1024 float32 = 96 МиБ
градиенты + 2 момента Adam (float32): ещё 288 МиБ, от пакета не зависят
пакет B= 8: сохранённые активации 0.8 МиБ = 0.01 x размер весов
пакет B= 64: сохранённые активации 6.2 МиБ = 0.07 x размер весов
пакет B= 512: сохранённые активации 50.0 МиБ = 0.52 x размер весов
пакет B= 4096: сохранённые активации 400.0 МиБ = 4.17 x размер весов
Веса, градиенты и состояние Adam вместе — 384 МиБ при любом пакете. Активации при пакете 8 — меньше мегабайта, при 512 — половина размера весов, при 4096 — 400 МиБ, больше всего остального. В языковой модели роль «пакета» играет произведение числа примеров на длину в токенах: 8 примеров по 512 токенов — это те же 4096 строк. Это и есть типичная картина длинного контекста: пол-сети памяти уходит на то, что прямой проход оставил обратному.
Где обычно ошибаются.
Словарь ступени.
Активации (activations). Промежуточные результаты прямого прохода, которые нужны обратному проходу для подсчёта градиентов.
Прямой проход (forward pass). Вычисление выхода сети по входу, слой за слоем снизу вверх.
Обратный проход (backward pass, backpropagation). Вычисление градиентов от потери к нижним слоям по цепному правилу.
Цепное правило (chain rule). Правило, по которому производная сложной функции равна произведению производных её частей в точке, посчитанной на прямом проходе.
Состояние оптимизатора (optimizer state). Дополнительные числа на каждый вес, которые оптимизатор хранит между шагами; у Adam их два.
Нехватка памяти (out of memory, OOM). Ошибка, когда для очередного массива на видеокарте не нашлось места.
МиБ (MiB). Мебибайт, 220 байт; так считают память numpy и большинство инструментов видеокарт.
Зачем это в работе. Пересчёт активаций — включаемая одной строкой опция почти в любом фреймворке обучения, и её включают первой, когда длинные примеры не влезают. Чтобы доверять ей, надо понимать, почему она не меняет результат обучения ни на бит в обычном случае, сколько стоит по времени и в каких местах результат всё-таки может измениться.
Как это устроено. Сеть делят на сегменты — подряд идущие группы слоёв. На прямом проходе сохраняют только вход каждого сегмента; это и есть контрольные точки (checkpoints). Всё, что сегмент посчитал внутри себя, сразу выбрасывают. Потеря считается как обычно.
На обратном проходе сегменты обрабатывают с конца. Для очередного сегмента берут его сохранённый вход, ещё раз прогоняют сегмент вперёд, получая все внутренние активации заново, и тут же делают по ним обычный обратный проход через этот сегмент. Внутренние активации сегмента после этого снова выбрасывают и переходят к предыдущему сегменту. В памяти одновременно лежат все контрольные точки плюс внутренности одного сегмента.
Почему градиенты те же самые. Пересчёт — это те же операции над теми же входами с теми же весами. Если вычисление детерминировано, то есть одинаковые входы дают одинаковые выходы до последнего бита, то и восстановленные активации совпадают с выброшенными, а значит, и градиенты совпадают. Это не приближение, в отличие от, скажем, квантования активаций. Исключения — случайность внутри сегмента и недетерминированные ядра видеокарты; о них ступень 5.
Ограничение — время. Каждый слой внутри сегментов проходится вперёд дважды. Обратный проход обычно оценивают примерно как два прямых (градиент по входу и градиент по весам), поэтому добавка одного лишнего прямого прохода — порядка трети к шагу. Это прикидка, а не закон: реальная цена зависит от того, какие операции дорогие, и её надо мерить. Чем пересчёт отличается от накопления градиента (gradient accumulation): накопление режет пакет на куски и складывает градиенты нескольких маленьких проходов, то есть уменьшает пакет на один проход; пересчёт оставляет пакет прежним и уменьшает число сохранённых массивов на слой. Их часто включают вместе.
Подробный пример. Сеть из 16 слоёв tanh шириной 64, пакет 32, квадратичная потеря. Пишем руками обратный проход с полным хранением и вариант с контрольными точками каждые k слоёв, считаем, сколько массивов активаций лежит в памяти в худший момент (пик) и сколько раз вызывается слой. Градиенты по всем 16 матрицам сравниваем поэлементно.
import numpy as np
rng = np.random.default_rng(0)
L, d, B = 16, 64, 32
W = [rng.normal(0, 1/np.sqrt(d), (d, d)) for _ in range(L)]
x0 = rng.normal(size=(B, d)); target = rng.normal(size=(B, d))
calls = 0
def layer(x, w):
global calls; calls += 1
return np.tanh(x @ w)
def backward_segment(xs, g, ws, grads, idx0):
# xs: входы и выходы слоёв сегмента, g: градиент по выходу сегмента
for j in range(len(ws) - 1, -1, -1):
h = xs[j + 1]; gz = g * (1 - h**2)
grads[idx0 + j] = xs[j].T @ gz
g = gz @ ws[j].T
return g
def full():
global calls; calls = 0
xs = [x0]
for w in W: xs.append(layer(xs[-1], w))
g = 2 * (xs[-1] - target) / B
grads = [None] * L
backward_segment(xs, g, W, grads, 0)
return grads, len(xs), calls
def checkpointed(k):
global calls; calls = 0
ck = {0: x0}; x = x0 # храним только входы сегментов
for i, w in enumerate(W):
x = layer(x, w)
if (i + 1) % k == 0 and i + 1 < L: ck[i + 1] = x
g = 2 * (x - target) / B
grads = [None] * L; peak = len(ck) + 1
for s in sorted(ck, reverse=True): # сегменты с конца
e = min(s + k, L)
xs = [ck[s]]
for w in W[s:e]: xs.append(layer(xs[-1], w)) # пересчёт сегмента
peak = max(peak, len(ck) + len(xs) - 1)
g = backward_segment(xs, g, W[s:e], grads, s)
return grads, peak, calls
gf, mf, cf = full()
print(f"полное хранение: массивов активаций {mf}, вызовов слоя {cf}")
for k in (2, 4, 8):
gc, mc, cc = checkpointed(k)
diff = max(np.abs(a - b).max() for a, b in zip(gf, gc))
print(f"контрольная точка каждые {k} слоя: пик массивов {mc:2d}, вызовов слоя {cc}, макс. расхождение градиентов {diff:.1e}")
У нас этот код напечатал:
полное хранение: массивов активаций 17, вызовов слоя 16
контрольная точка каждые 2 слоя: пик массивов 10, вызовов слоя 32, макс. расхождение градиентов 0.0e+00
контрольная точка каждые 4 слоя: пик массивов 8, вызовов слоя 32, макс. расхождение градиентов 0.0e+00
контрольная точка каждые 8 слоя: пик массивов 10, вызовов слоя 32, макс. расхождение градиентов 0.0e+00
Расхождение градиентов — ровно ноль при любом k: пересчёт восстанавливает те же самые числа. Пик хранения упал с 17 массивов до 8 при k = 4, а вызовов слоя стало 32 вместо 16 — каждый слой посчитан дважды. Обратите внимание, что k = 2 и k = 8 дают одинаковый пик 10: при мелких сегментах много контрольных точек, при крупных — длинный пересчитываемый кусок. Как найти середину, разбирает следующая ступень.
Ту же сеть мы запустили в размере, где время уже измеримо: ширина 1024, пакет 512, контрольные точки каждые 4 слоя, лучшее из пяти прогонов.
import numpy as np, time
exec(open('ckpt.py').read().split("gf, mf, cf = full()")[0].replace("L, d, B = 16, 64, 32", "L, d, B = 16, 1024, 512"))
def best(f, *a):
ts = []
for _ in range(5):
t0 = time.perf_counter(); f(*a); ts.append(time.perf_counter() - t0)
return min(ts)
tf = best(full); tc = best(checkpointed, 4)
print(f"d=1024, B=512, 16 слоёв: полное хранение {tf*1000:.0f} мс, контрольные точки каждые 4 слоя {tc*1000:.0f} мс, замедление {tc/tf:.2f}x")
d=1024, B=512, 16 слоёв: полное хранение 142 мс, контрольные точки каждые 4 слоя 160 мс, замедление 1.13x
На этой машине замедление 13%, меньше «трети»: в нашем обратном проходе две матрицы на слой против одной в прямом плюс накладные расходы numpy. Это одно измерение на процессоре, а не правило для видеокарты; на своей системе замедление надо мерить.
Где обычно ошибаются.
Словарь ступени.
Пересчёт активаций (gradient checkpointing, activation recomputation). Приём, при котором часть активаций не хранят, а вычисляют заново на обратном проходе.
Контрольная точка (checkpoint). Сохранённый вход сегмента, от которого сегмент можно пересчитать.
Сегмент. Группа подряд идущих слоёв, которую пересчитывают целиком.
Пик памяти (peak memory). Наибольший объём, занятый одновременно за шаг; именно он упирается в предел карты.
Детерминированное вычисление. Вычисление, которое на одинаковых входах даёт побитово одинаковый результат.
Накопление градиента (gradient accumulation). Сложение градиентов нескольких маленьких проходов перед одним шагом оптимизатора.
Не путать с контрольной точкой обучения. Файл с весами на диске (training checkpoint) — совсем другое: он нужен, чтобы продолжить обучение после остановки.
Зачем это в работе. Во фреймворках пересчёт обычно включается «на каждый блок трансформера», но в самописном коде, в нестандартных архитектурах и при ручной настройке (например, пересчитывать только каждый второй блок) решение о расстановке точек принимаете вы. От него зависит, сколько памяти вы реально выиграете и сколько времени заплатите.
Как это устроено. Пусть в сети n одинаковых слоёв и активация одного слоя занимает единицу памяти. Делим сеть на сегменты по k слоёв. В памяти одновременно лежат n/k контрольных точек и до k активаций пересчитываемого сегмента. Пик ≈ n/k + k. Первое слагаемое падает с ростом k, второе растёт; их сумма минимальна, когда они равны, то есть при k ≈ √n, и тогда пик ≈ 2√n вместо n.
Эта оценка опубликована у Chen, Xu, Zhang и Guestrin в статье «Training Deep Nets with Sublinear Memory Cost» (2016): память растёт как корень из глубины ценой примерно одного дополнительного прямого прохода. Там же описан рекурсивный вариант — пересчитывать сегменты тоже по частям, — который сжимает память ещё сильнее (до логарифма от n) ценой нескольких прямых проходов. На практике почти всегда используют одноуровневую схему.
Важно, что лишнее время почти не зависит от k: при любой расстановке каждый слой внутри сегментов считается ещё раз, то есть добавка — около одного прямого прохода. Поэтому выбор k — это выбор памяти, а не времени, пока сегменты вообще есть. Исключение — когда последний сегмент не пересчитывают (его активации ещё лежат в памяти к началу обратного прохода): тогда экономится одна k-я часть пересчёта.
Реальные сети неоднородны. Слои разной «толщины» хранят разный объём, поэтому точки выгодно ставить на узких местах — там, где вход сегмента маленький, а внутри много больших массивов. В трансформере таким естественным местом оказывается граница блока: на входе один тензор «токены × ширина», а внутри — проекции внимания, матрица вероятностей и расширенный в несколько раз промежуточный слой. Поэтому типичная настройка «точка на вход каждого блока» хорошо работает, хотя формально это k = 1 по блокам.
Подробный пример. Сеть из 64 одинаковых слоёв. Считаем пик памяти по формуле n/k + k при разных размерах сегмента и сравниваем с полным хранением (65 активаций, включая вход). Пример из ступени 2 — проверка, что формула совпадает с реальным счётом: при n = 16, k = 4 мы получили 8 = 4 + 4.
import math
# n слоёв, контрольная точка в начале каждого сегмента из k слоёв.
# Пик памяти (в единицах «одна активация B x d»): n/k сохранённых входов + k активаций пересчитываемого сегмента.
# Лишняя работа при любом k: примерно один дополнительный прямой проход (каждый слой считается дважды).
n = 64
print(f"n = {n} слоёв, sqrt(n) = {math.isqrt(n)}")
print(" k | точек | пик памяти | против хранения всего")
for k in (1, 2, 4, 8, 16, 32, 64):
pts = math.ceil(n / k); peak = pts + k
print(f"{k:2d} | {pts:5d} | {peak:10d} | {peak/(n+1):.2f}")
У нас этот код напечатал:
n = 64 слоёв, sqrt(n) = 8
k | точек | пик памяти | против хранения всего
1 | 64 | 65 | 1.00
2 | 32 | 34 | 0.52
4 | 16 | 20 | 0.31
8 | 8 | 16 | 0.25
16 | 4 | 20 | 0.31
32 | 2 | 34 | 0.52
64 | 1 | 65 | 1.00
Минимум — ровно при k = 8 = √64: 16 единиц вместо 65, четверть исходной памяти. Кривая симметрична: k = 4 и k = 16 дают одинаковые 20 единиц, k = 2 и k = 32 — одинаковые 34. Крайние случаи бесполезны: k = 1 хранит всё, k = 64 хранит только вход, но пересчитывает всю сеть разом и держит её активации одновременно. Если 16 единиц всё ещё не влезают, следующий шаг — не другая расстановка, а рекурсивный пересчёт, выгрузка или меньший пакет.
Где обычно ошибаются.
Словарь ступени.
Правило корня из n. Сегменты длиной около √n слоёв дают пик памяти около 2√n вместо n.
Сублинейная память (sublinear memory). Память, растущая медленнее, чем число слоёв, — например, как корень из него.
Рекурсивный пересчёт. Пересчёт сегментов, которые сами разбиты на подсегменты с точками; меньше памяти, больше лишних проходов.
Узкое место сети. Граница, через которую проходит маленький тензор; выгодное место для контрольной точки.
Слой расширения. Промежуточный слой полносвязного блока трансформера, в несколько раз шире основной ширины модели.
Блок трансформера. Повторяющийся узел модели из внимания, полносвязного блока, нормализаций и остаточных связей.
Зачем это в работе. Полный пересчёт каждого блока — грубый инструмент: он платит одинаково за дешёвые и дорогие для пересчёта активации. В современных системах обучения его комбинируют с более точными приёмами, и в настройках вы увидите их отдельными флагами. Нужно понимать, что каждый из них делает, чтобы не включать два способа экономить одно и то же.
Как это устроено: избирательный пересчёт. Активации различаются по соотношению «сколько места занимают / сколько стоит их посчитать». Матрица вероятностей внимания занимает место, растущее как квадрат длины, а вычисляется сравнительно дёшево — из запросов и ключей, которые и так хранятся. Выходы больших матричных умножений, наоборот, дорогие. Избирательный пересчёт (selective activation recomputation) хранит дорогие активации и пересчитывает только дешёвые и объёмные. Korthikanti и соавторы (NVIDIA, «Reducing Activation Recomputation in Large Transformer Models», 2022) опубликовали, что такой выбор вместе с параллелизмом по последовательности сохраняет большую часть экономии памяти полного пересчёта при малой доле его лишних вычислений. Это их измерения на их системе, не наши.
Пересчёт внутри внимания. FlashAttention (Dao и соавторы, 2022) вообще не записывает матрицу вероятностей внимания в память видеокарты: на прямом проходе она считается кусками в быстрой памяти внутри чипа, а на обратном пересчитывается из запросов, ключей и сохранённых нормирующих сумм. Это тот же принцип «посчитай заново вместо хранения», только встроенный в одно ядро. Отсюда практический вывод: если внимание уже работает через такое ядро, квадратичной матрицы в памяти нет, и главный объём составляют остальные активации блока.
Выгрузка (offloading). Другой путь — не пересчитывать, а перенести активации или состояние оптимизатора в оперативную память процессора и вернуть к обратному проходу. Это не тратит вычисления видеокарты, но тратит пропускную способность шины между процессором и видеокартой; если копирование не успевает спрятаться за вычислениями, шаг ждёт. Пересчёт платит вычислениями, выгрузка — передачей данных.
Наконец, разбиение по устройствам: параллелизм по тензорам и по последовательности (дорожка про параллелизм) делит сами активации между картами. Это уменьшает активации на каждой карте без лишних вычислений, но требует нескольких устройств и связи между ними.
Подробный пример. Две проверки на одной голове внимания с размером 64. Первая — сколько памяти занимает матрица вероятностей P размером «длина × длина» против запросов, ключей и значений, из которых она получается. Вторая — что градиенты по Q, K, V одинаковы, сохранили мы P на прямом проходе или пересчитали её в обратном.
import numpy as np
# Память матрицы вероятностей внимания T x T против Q, K, V (T x 64) на одну голову, float32
for T in (512, 2048, 8192, 32768):
qkv = 3 * T * 64 * 4; p = T * T * 4
print(f"T={T:6d}: Q,K,V {qkv/2**20:7.2f} МиБ, матрица P {p/2**20:8.1f} МиБ, P/QKV = {p/qkv:6.1f}")
# Обратный проход внимания: P храним или пересчитываем из Q, K — градиенты совпадают
rng = np.random.default_rng(1); T, dh = 128, 64
Q, K, V = (rng.normal(size=(T, dh)) for _ in range(3)); dO = rng.normal(size=(T, dh))
def probs(Q, K):
S = Q @ K.T / np.sqrt(dh); S -= S.max(1, keepdims=True); E = np.exp(S); return E / E.sum(1, keepdims=True)
def grads(P):
dV = P.T @ dO; dP = dO @ V.T
dS = P * (dP - (dP * P).sum(1, keepdims=True)) / np.sqrt(dh)
return dS @ K, dS.T @ Q, dV
P_saved = probs(Q, K)
g1 = grads(P_saved) # P сохранили на прямом проходе
g2 = grads(probs(Q, K)) # P пересчитали в обратном проходе
print("расхождение dQ, dK, dV:", [f"{np.abs(a-b).max():.1e}" for a, b in zip(g1, g2)])
У нас этот код напечатал:
T= 512: Q,K,V 0.38 МиБ, матрица P 1.0 МиБ, P/QKV = 2.7
T= 2048: Q,K,V 1.50 МиБ, матрица P 16.0 МиБ, P/QKV = 10.7
T= 8192: Q,K,V 6.00 МиБ, матрица P 256.0 МиБ, P/QKV = 42.7
T= 32768: Q,K,V 24.00 МиБ, матрица P 4096.0 МиБ, P/QKV = 170.7
расхождение dQ, dK, dV: ['0.0e+00', '0.0e+00', '0.0e+00']
При 512 токенах матрица P всего в 2,7 раза больше Q, K, V вместе, при 8192 — в 43 раза, при 32 768 — в 171 раз: 4 ГиБ на одну голову одного слоя против 24 МиБ. Пересчёт P из Q и K даёт градиенты, совпадающие до бита. Именно поэтому P — первый кандидат на пересчёт: хранить её дорого, восстановить — одно умножение и софтмакс. Заметьте, что сама FlashAttention считает не так, как наш код (кусками и с сохранёнными нормирующими суммами), — пример показывает только принцип.
Где обычно ошибаются.
Словарь ступени.
Избирательный пересчёт (selective activation recomputation). Пересчёт только тех активаций, которые занимают много места, но дёшевы в вычислении.
Матрица вероятностей внимания. Таблица «каждый токен с каждым» после софтмакса; растёт как квадрат длины последовательности.
FlashAttention. Ядро внимания, которое не записывает матрицу вероятностей в память видеокарты и пересчитывает её на обратном проходе.
Ядро (kernel). Одна программа, которую видеокарта выполняет целиком, например «посчитать внимание».
Выгрузка (offloading). Перенос данных из памяти видеокарты в оперативную память процессора и обратно.
Пропускная способность шины. Сколько байт в секунду можно передать между процессором и видеокартой.
ГиБ (GiB). Гибибайт, 230 байт, 1024 МиБ.
Зачем это в работе. Пересчёт активаций обещает те же градиенты, и чаще всего так и есть. Но он полагается на одно скрытое условие: второй прогон сегмента должен вести себя ровно как первый. Если внутри сегмента есть случайность, состояние, которое меняется при каждом прямом проходе, или ветвление, зависящее от чего-то внешнего, условие нарушается — и модель обучается на неверных градиентах без единой ошибки в логе.
Как это устроено: случайность. Отключение нейронов (dropout) на каждом прямом проходе выбирает случайную маску — какие числа обнулить. Если при пересчёте генератор случайных чисел выдаст другую маску, обратный проход пойдёт через другую сеть, чем та, по которой посчитана потеря. Поэтому библиотечные реализации сохраняют состояние генератора у контрольной точки и восстанавливают его перед пересчётом; в PyTorch за это отвечает параметр preserve_rng_state у torch.utils.checkpoint, по умолчанию включённый. Самописный пересчёт этого не делает, если вы не позаботились.
Состояние слоя. Нормализация по пакету (batch normalization) на каждом прямом проходе в режиме обучения обновляет бегущее среднее и дисперсию. Если такой слой попал внутрь пересчитываемого сегмента и реализация этого не учитывает, статистики обновятся дважды за шаг. В трансформерах обычно стоит нормализация по слою, у которой нет бегущих статистик, но в свёрточных и смешанных моделях проблема реальна.
Кэш и флаги. В библиотеке Hugging Face transformers пересчёт включается вызовом gradient_checkpointing_enable(), и при обучении он несовместим с кэшем ключей и значений: библиотека предупреждает и отключает use_cache. А у старого варианта PyTorch-пересчёта (use_reentrant=True) есть известная ловушка: если ни один вход сегмента не требует градиента — например, вход идёт из замороженного слоя эмбеддингов при обучении адаптера из вчерашней дорожки, — градиенты параметров внутри сегмента не посчитаются. Документация PyTorch рекомендует явно указывать use_reentrant=False; для варианта с reentrant распространённое обходное решение — включить требование градиента у входа (в transformers для этого есть enable_input_require_grads()).
Подробный пример. Два слоя с отключением нейронов с вероятностью 0,5 между ними. Потеря посчитана с одной маской, а обратный проход после «пересчёта» идёт либо с той же маской (генератор восстановлен), либо с новой. Отдельно — бегущее среднее нормализации по пакету с моментом 0,1 после одного шага с пересчётом и без.
import numpy as np
rng0 = np.random.default_rng(0); B, d = 32, 64
x = rng0.normal(size=(B, d)); W1 = rng0.normal(0, .1, (d, d)); W2 = rng0.normal(0, .1, (d, d)); t = rng0.normal(size=(B, d))
def grad_W1(mask_fwd, mask_bwd):
# прямой проход с маской отключения (dropout p=0.5), потеря считается по нему
h = np.tanh(x @ W1); y = (h * mask_fwd / 0.5) @ W2; g = 2 * (y - t) / B
# обратный проход после пересчёта сегмента: h и маска получены заново
gh = (g @ W2.T) * mask_bwd / 0.5; gz = gh * (1 - h**2)
return x.T @ gz
gen = np.random.default_rng(42); m1 = gen.random((B, d)) > 0.5
ref = grad_W1(m1, m1)
gen = np.random.default_rng(42); same = gen.random((B, d)) > 0.5
print("пересчёт с тем же состоянием генератора: расхождение", f"{np.abs(grad_W1(m1, same) - ref).max():.1e}")
fresh = np.random.default_rng(7).random((B, d)) > 0.5
err = np.abs(grad_W1(m1, fresh) - ref).max(); rel = np.linalg.norm(grad_W1(m1, fresh) - ref) / np.linalg.norm(ref)
print(f"пересчёт с новой случайной маской: макс. расхождение {err:.2e}, относительная ошибка {rel:.2f}")
print("совпадение масок:", f"{(m1 == fresh).mean():.2f}")
# Нормализация по пакету: бегущее среднее обновляется на каждом прямом проходе
mom = 0.1; batch_mean = 1.0
rm = 0.0; rm = (1 - mom) * rm + mom * batch_mean
print(f"бегущее среднее после 1 шага без пересчёта: {rm:.3f}")
rm = 0.0
for _ in range(2): rm = (1 - mom) * rm + mom * batch_mean
print(f"после 1 шага с пересчётом (слой прошёл вперёд дважды): {rm:.3f}")
У нас этот код напечатал:
пересчёт с тем же состоянием генератора: расхождение 0.0e+00
пересчёт с новой случайной маской: макс. расхождение 1.98e+00, относительная ошибка 0.91
совпадение масок: 0.52
бегущее среднее после 1 шага без пересчёта: 0.100
после 1 шага с пересчётом (слой прошёл вперёд дважды): 0.190
С восстановленным генератором расхождение ноль. С новой маской относительная ошибка градиента 0,91 — градиент почти весь неверный, хотя маски совпадают на 52% позиций, как и положено двум случайным маскам с p = 0,5. Обучение при этом не падает: потеря будет снижаться хуже и шумнее, и без такой проверки причину не найти. Бегущее среднее после одного шага с пересчётом — 0,190 вместо 0,100: слой «увидел» пакет дважды.
Практическая проверка, которую стоит сделать при первом включении пересчёта: на одном пакете с фиксированным зерном генератора посчитать градиенты с пересчётом и без и сравнить их. Для детерминированных слоёв они должны совпасть до бита или до ошибки округления недетерминированных ядер; заметное расхождение — повод искать, что именно не повторилось.
Где обычно ошибаются.
Словарь ступени.
Отключение нейронов (dropout). Случайное обнуление части чисел на каждом прямом проходе при обучении, чтобы сеть не полагалась на отдельные нейроны.
Состояние генератора (RNG state). Внутреннее число генератора случайных чисел; восстановив его, получают ту же последовательность «случайных» значений.
preserve_rng_state. Параметр torch.utils.checkpoint, который сохраняет и восстанавливает состояние генератора вокруг пересчёта.
Нормализация по пакету (batch normalization). Нормализация по статистикам текущего пакета с бегущим средним для режима генерации.
Бегущее среднее (running mean). Сглаженная оценка среднего, которая обновляется на каждом прямом проходе при обучении.
use_reentrant. Параметр PyTorch, выбирающий старую или новую реализацию пересчёта; у старой есть ловушка с входами без градиента.
Зерно генератора (seed). Начальное значение генератора; фиксируют, чтобы прогоны можно было сравнить.
Словарь целиком — /slovar, новости — /novosti. Все дорожки — /put.