дорожка · 05.11.2026 · размер пакета

Сколько примеров на один шаг: размер пакета, накопление градиентов и критический пакет

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

Все дорожки — /put. Прошлая — начальные веса.

1 Пакет как выборка: почему градиент по пакету шумит и как шум зависит от размера

Зачем это в работе. Градиент — направление, в котором потеря (мера ошибки модели) растёт быстрее всего; шаг обучения идёт в обратную сторону. Посчитать его честно по всем данным невозможно: у языковой модели это триллионы токенов. Поэтому каждый шаг считают по небольшой случайной порции примеров — пакету (batch). Всё дальнейшее — какую скорость обучения ставить, сколько видеокарт брать, когда увеличивать пакет — опирается на один факт: градиент по пакету — это оценка с шумом, и размер пакета управляет величиной этого шума.

Как это устроено. Полный градиент — среднее градиентов по всем примерам. Градиент по пакету из B примеров — среднее по случайной выборке из них. Это как опрос: среднее по выборке в среднем совпадает с правдой (оценка несмещённая), но каждый конкретный опрос отклоняется. Если градиенты отдельных примеров независимы, то разброс среднего уменьшается как 1/√B: в 4 раза больше пакет — в 2 раза меньше типичное отклонение. Это тот же закон, по которому среднее по 100 броскам кубика ближе к 3.5, чем по 25.

Отсюда главное ограничение: удвоение пакета удваивает вычисления на шаг, а шум уменьшает только в √2 ≈ 1.41 раза. Пока шум велик по сравнению с самим градиентом, больший пакет заметно улучшает направление шага. Когда шум уже мал, дополнительные примеры почти ничего не меняют: направление и так верное, а платим за каждый пример полностью.

Чем это отличается от соседних понятий. Эпоха (epoch) — один полный проход по данным, и при большом пакете в ней просто меньше шагов. Шаг (step, iteration) — одно обновление весов, независимо от того, сколько примеров в него ушло. Обучение «по одному примеру» (B = 1) называют стохастическим градиентным спуском в узком смысле, а с пакетом — мини-пакетным (mini-batch SGD); в обиходе оба называют SGD.

Подробный пример. Возьмём линейную регрессию: 100 000 примеров по 20 признаков, ответ — линейная функция признаков плюс шум. Веса стоят в нуле, как в начале обучения. Считаем полный градиент по всем 100 000 примерам, а потом 300 раз берём случайный пакет размера B и измеряем, насколько его градиент отличается от полного (длина разницы, делённая на длину полного градиента).

import numpy as np
# Линейная регрессия: насколько градиент по пакету из B примеров отличается от градиента по всем данным
rng = np.random.default_rng(0); N, d = 100_000, 20
X = rng.standard_normal((N, d)); w_true = rng.standard_normal(d)
y = X @ w_true + 0.5 * rng.standard_normal(N)            # данные с шумом
w = np.zeros(d)                                          # точка в начале обучения
grad = lambda idx: 2 * X[idx].T @ (X[idx] @ w - y[idx]) / len(idx)
G = grad(np.arange(N))                                   # «истинный» градиент по всем данным
for B in (1, 4, 16, 64, 256, 1024, 4096):
    errs = [np.linalg.norm(grad(rng.integers(0, N, B)) - G) / np.linalg.norm(G) for _ in range(300)]
    print(f"B={B:5d}  отклонение от полного градиента: {np.mean(errs):.3f}   × √B = {np.mean(errs)*np.sqrt(B):.2f}")

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

B=    1  отклонение от полного градиента: 3.670   × √B = 3.67
B=    4  отклонение от полного градиента: 2.152   × √B = 4.30
B=   16  отклонение от полного градиента: 1.138   × √B = 4.55
B=   64  отклонение от полного градиента: 0.570   × √B = 4.56
B=  256  отклонение от полного градиента: 0.282   × √B = 4.52
B= 1024  отклонение от полного градиента: 0.142   × √B = 4.53
B= 4096  отклонение от полного градиента: 0.071   × √B = 4.57

Начиная с B = 16, отклонение, умноженное на √B, держится около 4.5: это и есть закон 1/√B. При B = 1 и B = 4 произведение меньше, потому что мы усредняем длину отклонения, а не её квадрат, и на очень малых выборках эти величины расходятся. Важная деталь: при B = 16 отклонение больше самого градиента (1.14), то есть отдельный шаг указывает в заметно другую сторону, и обучение движется к цели только в среднем по многим шагам. Повтори: поставь веса ближе к правильным (например, w = w_true * 0.95) — полный градиент станет маленьким, а шум останется, и относительное отклонение при том же B вырастет в разы. К этому вернёмся в ступени 4.

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

  • Считают, что больший пакет «точнее, значит лучше» без оговорок. Точнее — да, но выигрыш падает как 1/√B, а цена растёт линейно.
  • Сравнивают два прогона по числу шагов, хотя у них разный пакет. Честное сравнение — по числу просмотренных примеров или токенов и по потраченному времени.
  • Берут пакеты не случайно, а подряд из отсортированных данных (например, по длине или по источнику). Тогда оценка перестаёт быть несмещённой: каждый шаг тянет модель в сторону одного типа данных.

Пакет (batch). Порция примеров, по которой считается один шаг обучения.

Градиент (gradient). Набор чисел, показывающий, как изменится потеря при малом сдвиге каждого веса.

Несмещённая оценка (unbiased estimate). Оценка, которая в среднем по многим выборкам совпадает с истинным значением.

Шум градиента (gradient noise). Отклонение градиента по пакету от градиента по всем данным.

Шаг (step). Одно обновление весов модели.

Эпоха (epoch). Один полный проход по всему обучающему набору.

Мини-пакетный спуск (mini-batch SGD). Градиентный спуск, где каждый шаг считается по случайному пакету, а не по всем данным.

2 Накопление градиентов: большой пакет, который не влезает в память

Зачем это в работе. Память видеокарты ограничена: на прямом проходе нужно хранить промежуточные результаты каждого слоя (активации), и их объём растёт пропорционально числу примеров в пакете. Часто нужный по рецепту пакет физически не помещается. Тогда его собирают из нескольких маленьких кусков — микропакетов (micro-batches): прогоняют их по очереди, складывают градиенты и делают один шаг. Это называется накоплением градиентов (gradient accumulation). Ошибка в одной строке нормировки здесь не даёт ни падения, ни предупреждения — модель просто учится на перекошенной потере.

Как это устроено. Градиент суммы равен сумме градиентов. Поэтому если потеря пакета — сумма потерь по примерам, то её градиент можно посчитать кусками: прогнали микропакет 1, получили градиент, отложили; прогнали микропакет 2, прибавили; и так k раз. После этого делим на общее число слагаемых и делаем шаг оптимизатора. Математически это тот же шаг, что и с пакетом в k раз больше, только по времени он в k раз дольше, а память нужна как для одного микропакета.

Ограничение — нормировка. Потерю обычно усредняют, а не суммируют. Для языковых моделей среднее берут по токенам (кусочкам текста), а последовательности в пакете бывают разной длины. Если каждый микропакет усредняет потерю по своим токенам, а потом микропакеты усредняются между собой, то каждый токен из короткого микропакета получает больший вес, чем токен из длинного. Правильный способ: копить сумму потерь и общее число токенов, а делить один раз в конце. В октябре 2024 года разработчики библиотеки Unsloth и команда Hugging Face публично описали, что именно такая ошибка нормировки была в распространённом коде обучения и что потеря при накоплении расходилась с потерей полного пакета; это их опубликованное описание, сами мы этот код не проверяли.

Чем это отличается от соседнего понятия. Накопление градиентов меняет только то, как пакет считается, а не его размер с точки зрения оптимизатора. Параллелизм по данным (data parallelism), разобранный в дорожке про параллелизм, делит пакет между несколькими видеокартами одновременно и складывает градиенты по сети. Их часто используют вместе: итоговый пакет = размер микропакета × число шагов накопления × число видеокарт. Ещё одна тонкость: слои, которые смотрят на статистику пакета (пакетная нормализация, ступень 5), при накоплении видят только микропакет, и тут эквивалентность ломается.

Подробный пример. Восемь последовательностей длиной 3, 5, 40, 7, 120, 2, 60 и 9 токенов, простая линейная модель, потеря — средний квадрат ошибки по токенам. Эталон — градиент по всем 8 последовательностям сразу. Потом то же самое четырьмя микропакетами по 2 последовательности: сначала наивно (среднее внутри микропакета, потом среднее микропакетов), потом правильно (копим суммы, делим на 246 токенов).

import numpy as np
# 8 последовательностей разной длины; потеря — средняя по токенам. Пакет 8 = 4 микропакета по 2.
rng = np.random.default_rng(1); d = 16
lens = [3, 5, 40, 7, 120, 2, 60, 9]                      # длины в токенах
seqs = [(rng.standard_normal((L, d)), rng.standard_normal(L)) for L in lens]
w = rng.standard_normal(d) * 0.1
def loss_sum_and_grad(X, y):                             # сумма квадратов ошибок по токенам и её градиент
    r = X @ w - y; return (r**2).sum(), 2 * X.T @ r
# 1) Эталон: весь пакет сразу, среднее по всем токенам пакета
S = [loss_sum_and_grad(*s) for s in seqs]; T = sum(lens)
g_ref = sum(g for _, g in S) / T
# 2) Наивное накопление: в каждом микропакете своё среднее по токенам, потом среднее микропакетов
g_naive = np.mean([(S[i][1] + S[i+1][1]) / (lens[i] + lens[i+1]) for i in range(0, 8, 2)], axis=0)
# 3) Правильное накопление: копим суммы, делим один раз на общее число токенов
g_fix = sum(S[i][1] + S[i+1][1] for i in range(0, 8, 2)) / T
rel = lambda g: np.linalg.norm(g - g_ref) / np.linalg.norm(g_ref)
print("токенов в микропакетах:", [lens[i] + lens[i+1] for i in range(0, 8, 2)], " всего:", T)
print(f"наивное накопление, отличие от эталона: {rel(g_naive):.3f}")
print(f"накопление сумм,    отличие от эталона: {rel(g_fix):.2e}")
print("вес токена при наивном способе (во сколько раз больше честного):",
      [round(T / (4 * (lens[i] + lens[i+1])), 2) for i in range(0, 8, 2)])

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

токенов в микропакетах: [8, 47, 122, 69]  всего: 246
наивное накопление, отличие от эталона: 0.546
накопление сумм,    отличие от эталона: 9.87e-17
вес токена при наивном способе (во сколько раз больше честного): [7.69, 1.31, 0.5, 0.89]

Наивный способ дал градиент, отличающийся от эталона на 55%: каждый токен первого микропакета (всего 8 токенов) весит в 7.7 раза больше, чем должен, а токены самого длинного — вдвое меньше. Правильное накопление совпало с эталоном до ошибки округления (10−16). Повтори: сделай все длины одинаковыми — наивный способ тоже станет точным. Именно поэтому ошибка долго незаметна на данных, где последовательности дополняют до одной длины.

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

  • Усредняют потерю внутри каждого микропакета и делят ещё раз на число шагов накопления, хотя длины в токенах разные.
  • Забывают обнулить накопленный градиент после шага оптимизатора, и он копится через несколько шагов.
  • Меняют число шагов накопления, чтобы «влезть в память», и не пересчитывают скорость обучения и расписание, хотя для оптимизатора изменился размер пакета.

Накопление градиентов (gradient accumulation). Сложение градиентов нескольких микропакетов перед одним шагом оптимизатора.

Микропакет (micro-batch). Кусок пакета, который помещается в память и прогоняется за один проход.

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

Нормировка потери (loss normalization). Деление суммы потерь на число примеров или токенов, чтобы получить среднее.

Токен (token). Кусочек текста, с которым работает модель: слово, часть слова или знак.

Глобальный пакет (global batch). Итоговый размер пакета для оптимизатора: микропакет × шаги накопления × число видеокарт.

Параллелизм по данным (data parallelism). Деление пакета между видеокартами, у каждой из которых своя копия модели.

3 Пакет и скорость обучения: линейное правило и где оно ломается

Зачем это в работе. Если увеличить пакет и оставить скорость обучения (learning rate, множитель длины шага) прежней, обучение станет дороже на шаг, а шагов почти не сэкономит. Если увеличить и скорость, можно сэкономить шаги — но только до предела, за которым обучение разваливается. Почти любой перенос рецепта на другое число видеокарт упирается в вопрос «какую скорость ставить при новом пакете».

Как это устроено. Пока шум велик, k шагов с пакетом B и скоростью η делают примерно то же, что один шаг с пакетом kB и скоростью kη: и там и там веса сдвигаются на сумму k градиентов, просто во втором случае они посчитаны все в одной точке. Отсюда линейное правило масштабирования (linear scaling rule): увеличил пакет в k раз — увеличь скорость в k раз. Его опубликовали Гоял и соавторы в работе «Accurate, Large Minibatch SGD» (2017), где ResNet-50 обучали с пакетом 8192 изображения; для первых шагов они добавляли плавный разогрев скорости (warmup), потому что в начале градиент меняется быстро и приближение «все градиенты в одной точке» неверно.

Где правило ломается. Оно перестаёт работать, когда шаг становится слишком длинным для кривизны потери. Для простой квадратичной потери это можно посчитать точно: градиентный спуск устойчив, только пока скорость меньше 2/λmax, где λmax — самая большая кривизна (наибольшее собственное число матрицы вторых производных, гессиана). Выше этого порога веса раскачиваются и улетают, сколько бы примеров ни было в пакете. У больших нейросетей порог не считается так просто, но смысл тот же: есть скорость, выше которой обучение нестабильно, и линейное правило доводит до неё довольно быстро.

Чем это отличается для Adam. Adam (оптимизатор, делящий шаг на скользящую оценку размаха градиента, см. дорожку про оптимизатор) сам частично нормирует шум, поэтому для него опубликовано другое правило: скорость растёт как квадратный корень из множителя пакета. Его вывели Малади и соавторы в работе о стохастических дифференциальных уравнениях для адаптивных оптимизаторов (2022). На практике лаборатории всё равно подбирают скорость перебором на малых моделях; оба правила — отправная точка, а не закон.

Подробный пример. Линейная регрессия на 100 000 примерах, признаки разного масштаба, неустранимый шум даёт минимум потери 0.25. Считаем, за сколько шагов потеря опустится на 5% выше этого минимума (проверка раз в 10 шагов, медиана трёх запусков). Сравниваем пакеты от 8 до 2048 с постоянной скоростью 0.004 и со скоростью, выросшей пропорционально пакету.

import numpy as np
# Тот же разброс B, разные скорости обучения: сколько шагов нужно, чтобы потеря упала ниже порога
rng = np.random.default_rng(2); N, d = 100_000, 20
X = rng.standard_normal((N, d)) * np.linspace(0.3, 1.5, d)   # признаки разного масштаба
w_true = rng.standard_normal(d); y = X @ w_true + 0.5 * rng.standard_normal(N)
H = 2 * X.T @ X / N; lam_max = np.linalg.eigvalsh(H).max()
loss = lambda w: ((X @ w - y)**2).mean()
target = 0.25 * 1.05                                     # 5% выше неустранимого шума 0.25
def steps_to_target(B, lr, seed, max_steps=20000):
    r = np.random.default_rng(seed); w = np.zeros(d)
    for t in range(1, max_steps + 1):
        idx = r.integers(0, N, B); w -= lr * 2 * X[idx].T @ (X[idx] @ w - y[idx]) / B
        if not np.isfinite(w).all() or np.abs(w).max() > 1e6: return None
        if t % 10 == 0 and loss(w) < target: return t
    return None
print(f"предел устойчивости 2/λ_max = {2/lam_max:.3f}")
base_B, base_lr = 8, 0.004
for B in (8, 32, 128, 512, 2048):
    lr_lin = base_lr * B / base_B
    res = []
    for lr in (base_lr, lr_lin):
        s = [steps_to_target(B, lr, k) for k in range(3)]
        res.append("расходится" if None in s else f"{int(np.median(s)):5d} шагов")
    print(f"B={B:5d}  lr={base_lr} : {res[0]:>11s}   lr×B/8={lr_lin:.3f} : {res[1]:>11s}")

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

предел устойчивости 2/λ_max = 0.445
B=    8  lr=0.004 :   900 шагов   lr×B/8=0.004 :   900 шагов
B=   32  lr=0.004 :   860 шагов   lr×B/8=0.016 :   230 шагов
B=  128  lr=0.004 :   860 шагов   lr×B/8=0.064 :    60 шагов
B=  512  lr=0.004 :   860 шагов   lr×B/8=0.256 :    20 шагов
B= 2048  lr=0.004 :   860 шагов   lr×B/8=1.024 :  расходится

С постоянной скоростью больший пакет ничего не дал: около 860–900 шагов при любом B, то есть пакет 2048 потратил в 256 раз больше вычислений впустую. Линейное правило сократило шаги почти точно пропорционально: 900, 230, 60, 20 — до B = 512. При B = 2048 скорость 1.024 перешла посчитанный предел устойчивости 0.445, и обучение разошлось. Повтори: поставь для B = 2048 скорость 0.4 — она чуть ниже предела, и посмотри, сколько шагов получится по сравнению с B = 512.

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

  • Увеличивают число видеокарт и, значит, глобальный пакет, но оставляют скорость обучения из старого рецепта.
  • Применяют линейное правило к Adam без проверки и получают нестабильность на больших пакетах.
  • Масштабируют скорость, но не разогрев: при большом пакете и большой скорости первые шаги без разогрева раскачивают модель.

Скорость обучения (learning rate). Множитель, задающий, насколько далеко сдвигаются веса за шаг.

Линейное правило масштабирования (linear scaling rule). Совет увеличивать скорость обучения во столько же раз, во сколько вырос пакет.

Правило квадратного корня (square-root scaling). Вариант для Adam: скорость растёт как √ множителя пакета.

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

Кривизна (curvature). Насколько быстро меняется наклон потери; большая кривизна требует коротких шагов.

Гессиан (Hessian). Таблица вторых производных потери по весам, описывающая кривизну во всех направлениях.

Предел устойчивости. Наибольшая скорость, при которой спуск ещё не раскачивается; для квадратичной потери это 2/λmax.

4 Шумовой масштаб и критический размер пакета: где больше не значит быстрее

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

Как это устроено. Маккэндлиш и соавторы в работе «An Empirical Model of Large-Batch Training» (2018) ввели шумовой масштаб (gradient noise scale): Bnoise = tr(Σ) / |G|². Здесь G — полный градиент, а tr(Σ) — суммарный разброс градиентов отдельных примеров вокруг него. Смысл простой: это размер пакета, при котором шум градиента по пакету сравнивается с самим градиентом. Пакеты сильно меньше Bnoise — шумные, и увеличение пакета почти линейно сокращает шаги. Пакеты сильно больше — шум уже мал, и дальше число шагов почти не падает.

Авторы опубликовали и простую модель компромисса: число шагов S и число примеров E связаны так, что S/Smin − 1 = 1 / (E/Emin − 1). Пакет около Bnoise называют критическим: на нём обучение тратит примерно вдвое больше минимальных шагов и вдвое больше минимальных примеров. Меньше — экономнее по вычислениям, но дольше по времени; больше — быстрее по времени, но всё дороже.

Важное ограничение: шумовой масштаб не постоянен. По мере обучения потеря падает, полный градиент G становится меньше, а разброс отдельных примеров уменьшается медленнее, поэтому Bnoise растёт. Маккэндлиш и соавторы сообщали, что в их опытах он рос по ходу обучения и был больше у более трудных задач. Отсюда практика увеличивать пакет по ходу обучения (ступень 5). Чем это отличается от предела устойчивости из ступени 3: тот ограничивает скорость, а этот — пользу от размера пакета; упереться можно в любой из них.

Подробный пример. Та же регрессия. Сначала меряем шумовой масштаб в трёх точках: в нуле, на 90% и на 97% пути к минимуму. Потом для каждого пакета подбираем лучшую скорость из 12 значений от 0.002 до 0.4 и считаем, сколько шагов и примеров нужно, чтобы потеря стала на 2% выше минимума (проверка раз в 5 шагов, медиана трёх запусков).

import numpy as np
# Для каждого размера пакета подбираем лучшую скорость обучения и считаем шаги и примеры до порога
rng = np.random.default_rng(2); N, d = 100_000, 20
X = rng.standard_normal((N, d)) * np.linspace(0.3, 1.5, d)
w_true = rng.standard_normal(d); y = X @ w_true + 0.5 * rng.standard_normal(N)
w_opt = np.linalg.lstsq(X, y, rcond=None)[0]
loss = lambda w: ((X @ w - y)**2).mean(); target = 0.25 * 1.02
def noise_scale(w):                                      # B_simple = tr(Σ) / |G|²
    per = 2 * X * (X @ w - y)[:, None]                   # градиент каждого примера отдельно
    G = per.mean(0); return ((per - G)**2).sum(1).mean() / (G @ G)
for frac in (0.0, 0.9, 0.97):
    w = w_opt * frac
    print(f"точка: {frac:.0%} пути к минимуму, потеря {loss(w):.3f}, шумовой масштаб B_noise ≈ {noise_scale(w):.0f}")
def steps(B, lr, seed, max_steps=6000):
    r = np.random.default_rng(seed); w = np.zeros(d)
    for t in range(1, max_steps + 1):
        idx = r.integers(0, N, B); w -= lr * 2 * X[idx].T @ (X[idx] @ w - y[idx]) / B
        if np.abs(w).max() > 1e6: return None
        if t % 5 == 0 and loss(w) < target: return t
    return None
for B in (4, 16, 64, 256, 1024, 4096):
    best = None
    for lr in np.geomspace(0.002, 0.4, 12):
        s = [steps(B, lr, k) for k in range(3)]
        if None not in s and (best is None or np.median(s) < best[0]): best = (np.median(s), lr)
    print(f"B={B:5d}  лучшая lr={best[1]:.3f}  шагов {int(best[0]):5d}  примеров {int(best[0]*B):8d}")

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

точка: 0% пути к минимуму, потеря 13.408, шумовой масштаб B_noise ≈ 15
точка: 90% пути к минимуму, потеря 0.383, шумовой масштаб B_noise ≈ 42
точка: 97% пути к минимуму, потеря 0.263, шумовой масштаб B_noise ≈ 317
B=    4  лучшая lr=0.005  шагов  1510  примеров     6040
B=   16  лучшая lr=0.022  шагов   380  примеров     6080
B=   64  лучшая lr=0.058  шагов   125  примеров     8000
B=  256  лучшая lr=0.153  шагов    50  примеров    12800
B= 1024  лучшая lr=0.400  шагов    20  примеров    20480
B= 4096  лучшая lr=0.400  шагов    15  примеров    61440

Шумовой масштаб вырос с 15 в начале до 317 у самого минимума — тот же эффект, о котором писали авторы. Шаги падают почти пропорционально пакету от 4 до 64 (1510 → 380 → 125), а примеров при этом нужно почти столько же (6040, 6080, 8000). Дальше выигрыш тает: от 1024 к 4096 шагов стало 20 → 15, а примеров втрое больше. На больших пакетах лучшая скорость упёрлась в верх перебора 0.4, близкий к пределу устойчивости, — здесь сработали оба ограничения сразу. Повтори: сузь цель до 1% над минимумом — шумовой масштаб у финиша выше, и выгодный пакет сдвинется вправо.

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

  • Меряют шумовой масштаб один раз в начале обучения и выбирают пакет по нему, хотя к концу он в разы больше.
  • Читают «критический пакет» как оптимальный. Он лишь граница между экономией вычислений и экономией времени; выбор зависит от того, что дороже.
  • Сравнивают пакеты, не подобрав скорость для каждого: тогда разница в пакете смешивается с плохой скоростью.

Шумовой масштаб (gradient noise scale). Размер пакета, при котором шум градиента сравнивается с самим градиентом.

Критический размер пакета (critical batch size). Пакет, начиная с которого увеличение почти не сокращает число шагов.

Разброс градиентов (gradient variance). Насколько градиенты отдельных примеров отличаются от их среднего.

След матрицы (trace). Сумма диагональных чисел матрицы; здесь — суммарный разброс по всем весам.

Время по часам (wall-clock time). Реальная длительность обучения, в отличие от числа операций.

Вычислительный бюджет (compute budget). Сколько всего операций можно потратить на обучение.

Компромисс шаги — примеры. Чем меньше шагов, тем больше примеров требуется, и наоборот.

5 Пакет у языковых моделей: токены, рост пакета по ходу обучения и зависимость от соседей

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

Как это устроено. Пакет в токенах = число последовательностей × длина последовательности. Пакет 4 млн токенов при контексте 4096 — это примерно 1000 последовательностей, при контексте 8192 — примерно 500. Для оптимизатора важна именно эта величина: шум градиента определяется числом токенов, по которым он усреднён, хотя токены внутри одного текста не независимы, поэтому выгода от длинного контекста меньше, чем от того же числа токенов в разных текстах.

Рост пакета по ходу обучения. Раз шумовой масштаб растёт (ступень 4), в начале выгодны маленькие пакеты, а потом большие. Так и делают: в статье о GPT-3 (2020) авторы сообщили, что линейно увеличивали пакет от 32 тысяч токенов до полного размера за первые 4–12 миллиардов токенов обучения, а у самой большой модели полный пакет был 3.2 млн токенов. Это опубликованный рецепт, не наше измерение. Увеличение пакета похоже по действию на снижение скорости обучения: и то и другое уменьшает шум в шаге.

Зависимость от соседей. Пакетная нормализация (batch normalization, Иоффе и Сегеди, 2015) приводит каждый признак к нулевому среднему и единичному разбросу, считая их по примерам пакета. Значит, выход одного примера зависит от того, кто ещё в пакете. Нормализация слоя (layer normalization, Ба и соавторы, 2016) считает те же величины по признакам одного примера — от соседей она не зависит. В трансформерах используют нормализацию слоя или её упрощение RMSNorm (см. дорожку про нормализацию): при обучении на текстах разной длины, при накоплении градиентов и при ответе на один запрос это убирает целый класс ошибок.

Подробный пример. Возьмём один пример из 8 признаков и положим его в два пакета по 4: в первом соседи обычные, во втором сдвинуты на +3, как если бы пришли из другого источника данных. Пропустим оба пакета через пакетную нормализацию и нормализацию слоя и сравним выход нашего примера. Последней строкой — пакетная нормализация на пакете из одного примера.

import numpy as np
# Один и тот же пример в двух разных пакетах: зависит ли его выход от соседей?
rng = np.random.default_rng(3); d = 8
x = rng.standard_normal(d)                                # наш пример
batch_a = np.vstack([x, rng.standard_normal((3, d))])     # соседи — обычные примеры
batch_b = np.vstack([x, rng.standard_normal((3, d)) + 3]) # соседи сдвинуты, например другой источник данных
bn = lambda B: (B - B.mean(0)) / np.sqrt(B.var(0) + 1e-5)                         # по пакету, на каждый признак
ln = lambda B: (B - B.mean(1, keepdims=True)) / np.sqrt(B.var(1, keepdims=True) + 1e-5)  # по признакам примера
print("пакетная нормализация, разница выхода нашего примера:", f"{np.abs(bn(batch_a)[0] - bn(batch_b)[0]).max():.3f}")
print("нормализация слоя,     разница выхода нашего примера:", f"{np.abs(ln(batch_a)[0] - ln(batch_b)[0]).max():.1e}")
print("пакетная нормализация, пакет из 1 примера:", np.round(bn(x[None])[0][:4], 3), "...")

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

пакетная нормализация, разница выхода нашего примера: 3.141
нормализация слоя,     разница выхода нашего примера: 0.0e+00
пакетная нормализация, пакет из 1 примера: [0. 0. 0. 0.] ...

При пакетной нормализации выход того же примера изменился до 3.1 по одному признаку только из-за соседей; при нормализации слоя — ровно ноль. На пакете из одного примера пакетная нормализация вообще стирает вход в нули: среднее пакета равно самому примеру. Поэтому в режиме проверки она использует накопленную за обучение статистику, а не статистику пакета, и забытое переключение режима — частая ошибка. Повтори: сделай соседей во втором пакете копиями нашего примера и посмотри, что станет с его выходом.

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

  • Переносят «пакет 1024» из статьи, не уточнив, последовательности это или тысячи токенов, и при другой длине контекста получают другой пакет для оптимизатора.
  • Используют пакетную нормализацию в модели, которую потом учат с накоплением градиентов или запускают по одному запросу, и забывают про режим проверки.
  • Растят пакет по ходу обучения, но не меняют скорость обучения и расписание согласованно, и эффекты двух настроек накладываются.

Пакет в токенах (tokens per batch). Число последовательностей в пакете, умноженное на их длину.

Длина контекста (context length). Сколько токенов модель видит в одной последовательности.

Рост пакета (batch size warmup). Постепенное увеличение пакета в начале обучения.

Пакетная нормализация (batch normalization). Выравнивание признаков по статистике примеров пакета.

Нормализация слоя (layer normalization). Выравнивание признаков по статистике одного примера, без зависимости от соседей.

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

Режим проверки (eval mode). Режим модели, в котором слои вроде пакетной нормализации используют накопленную статистику.

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