дорожка · 31.10.2026 · параллелизм

Как обучение делят между многими видеокартами: параллелизм данных, ZeRO, тензорный и конвейерный

В прошлой дорожке мы посчитали, что обучение с Adam в смешанной точности требует около 16 байт на параметр: для модели на 7 миллиардов параметров это 112 ГБ ещё до активаций, а у одной видеокарты H100 80 ГБ памяти. Значит, даже средняя модель на одну видеокарту не помещается, а большая и подавно, и учить её быстро тоже нужно на сотнях и тысячах ускорителей. Сегодня разберём, как работу делят между ними. Способов четыре, и каждый режет своё: батч данных, состояние модели, отдельные матрицы или стопку слоёв. Все примеры — маленькие расчёты на numpy, где несколько видеокарт имитируются массивами; код мы запускали, выводы взяты из этих запусков. Остальные цифры получены по формулам, и это сказано прямо.

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

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

Зачем это в работе. Параллелизм данных (data parallelism) — самый простой и самый распространённый способ ускорить обучение: если модель помещается на одну видеокарту, её копируют на несколько, и каждая обрабатывает свою часть данных. С него начинают почти все реальные установки, а остальные способы добавляют поверх, когда памяти уже не хватает. Чтобы им пользоваться без сюрпризов, нужно понимать, почему результат совпадает с обучением на одной большой видеокарте и в каких местах это совпадение ломается.

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

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

Ограничения. Первое — память: каждая видеокарта держит всё, 16 байт на параметр, поэтому этот способ сам по себе не помогает, если модель не помещается. Второе — связь: после каждого шага нужно переслать столько чисел, сколько параметров в модели, и при большом N или медленной сети видеокарты начинают ждать сеть. Третье — размер батча: добавляя видеокарты, обычно увеличивают глобальный батч, а выше некоторого размера дальнейшее увеличение перестаёт ускорять обучение по числу примеров, и скорость обучения приходится подбирать заново. Соседнее понятие — накопление градиента (gradient accumulation): одна видеокарта прогоняет несколько маленьких кусков подряд и суммирует градиенты перед шагом. Математически это то же самое, только куски обрабатываются по очереди, а не одновременно.

Подробный пример. Возьмём линейную регрессию на 400 примерах и посчитаем градиент средней квадратичной ошибки двумя способами: на всём батче сразу и как среднее градиентов четырёх кусков по 100 примеров, будто их считали четыре видеокарты. Потом сделаем неравные куски — 100, 100, 100 и 40, как бывает на последнем батче эпохи, — и сравним простое среднее со средним, взвешенным по числу примеров.

import numpy as np
rng = np.random.default_rng(0)
X = rng.normal(size=(400, 3)); y = X @ np.array([2.0, -1.0, 0.5]) + rng.normal(0, 0.1, 400)
w = np.zeros(3)
def grad(Xb, yb, w):                       # градиент средней квадратичной ошибки
    return 2 * Xb.T @ (Xb @ w - yb) / len(yb)
full = grad(X, y, w)                       # одна «большая» видеокарта видит весь батч
parts = np.array_split(np.arange(400), 4)  # 4 видеокарты по 100 примеров
avg = np.mean([grad(X[i], y[i], w) for i in parts], axis=0)
print("весь батч:        ", np.round(full, 6))
print("среднее 4 кусков: ", np.round(avg, 6), " разница", f"{np.abs(full-avg).max():.1e}")
# неравные куски: 100, 100, 100, 40 примеров (последний батч эпохи)
idx = np.arange(340); full2 = grad(X[idx], y[idx], w)
parts2 = [idx[:100], idx[100:200], idx[200:300], idx[300:]]
avg2 = np.mean([grad(X[i], y[i], w) for i in parts2], axis=0)
wavg = sum(len(i) * grad(X[i], y[i], w) for i in parts2) / 340
print("неравные куски, простое среднее: разница", f"{np.abs(full2-avg2).max():.1e}")
print("неравные куски, среднее с весами: разница", f"{np.abs(full2-wavg).max():.1e}")

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

весь батч:         [-3.834769  1.680046 -0.957963]
среднее 4 кусков:  [-3.834769  1.680046 -0.957963]  разница 4.4e-16
неравные куски, простое среднее: разница 9.6e-02
неравные куски, среднее с весами: разница 8.9e-16

При равных кусках разница 4·10−16 — это просто ошибка округления в другом порядке сложения. При неравных кусках простое среднее ошиблось на 0,096 при компонентах градиента порядка единицы: 40 примеров последнего куска получили такой же вес, как 100 примеров остальных. Среднее с весами снова совпадает. Повтори: поменяй размеры кусков на 200, 100, 50, 50 и посмотри, как растёт ошибка простого среднего.

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

  • Усредняют градиенты кусков разного размера без весов. Обычно это случается на хвосте эпохи или при упаковке последовательностей разной длины, когда потерю усредняют по токенам внутри каждой видеокарты, а число токенов у всех разное.
  • Добавляют видеокарты, увеличивают глобальный батч и оставляют прежнюю скорость обучения и прогрев. Шаг с большим батчем — это другой шаг, расписание приходится проверять заново.
  • Забывают, что случайность у копий должна быть согласована: начальные веса одинаковые, а перемешивание данных и dropout — разные на разных видеокартах. Если у всех одинаковый генератор данных, четыре копии учатся на одних и тех же примерах.

Параллелизм данных (data parallelism). Способ, при котором каждая видеокарта держит полную модель и обрабатывает свою часть батча.

Глобальный батч (global batch). Все примеры, по которым считается один шаг обучения, суммарно на всех видеокартах.

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

All-reduce. Коллективная операция, после которой у каждого участника оказывается сумма или среднее массивов всех участников.

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

Ранг (rank). Номер процесса, обычно одной видеокарты, в группе распределённого обучения.

Взвешенное среднее. Среднее, в котором каждый кусок учитывается пропорционально числу своих примеров или токенов.

2 Как видеокарты складывают градиенты: кольцевой all-reduce и цена связи

Зачем это в работе. При параллелизме данных каждый шаг обучения заканчивается all-reduce по всем градиентам, и если сеть не успевает, дорогие ускорители простаивают. Понимание того, сколько данных реально гоняется по сети, позволяет заранее прикинуть, упрётся ли обучение в связь, и объясняет, почему видеокарты внутри одного сервера соединяют быстрыми линиями, а между серверами ставят отдельную сеть.

Как это устроено. Наивный способ — собрать все градиенты на одной видеокарте, сложить и разослать обратно — упирается в эту одну видеокарту: через неё проходит в N раз больше данных, чем через остальные. Кольцевой all-reduce (ring all-reduce) выстраивает видеокарты в кольцо, где каждая шлёт данные только соседу справа, и делит градиент на N равных частей. Первая фаза называется reduce-scatter: за N − 1 тактов каждая видеокарта передаёт соседу одну часть, сосед прибавляет к ней свою; в конце у каждой видеокарты лежит полная сумма ровно одной части. Вторая фаза — all-gather: ещё за N − 1 тактов готовые части раздаются по кругу, и у всех оказывается вся сумма.

Сколько это стоит. В каждом такте видеокарта отправляет 1/N градиента, тактов 2(N − 1), значит, всего она отправляет 2(N − 1)/N от размера градиента. Это формула, и важна она тем, что почти не зависит от N: при 8 видеокартах множитель 1,75, при 64 — 1,97, но никогда больше 2. Нагрузка распределена поровну, и пропускная способность сети используется полностью. Зато число тактов растёт с N, а у каждого такта есть фиксированная задержка (latency), поэтому для очень больших групп и маленьких сообщений используют другие схемы, например деревья. На практике это делает библиотека связи, у NVIDIA — NCCL (NVIDIA Collective Communications Library), и сама выбирает алгоритм.

Связь можно частично спрятать за вычислениями. Обратный проход идёт от последнего слоя к первому, и градиенты последних слоёв готовы раньше. Фреймворки собирают их в пакеты (buckets) и запускают all-reduce для готового пакета, пока видеокарта ещё считает градиенты ранних слоёв; так делает, например, DistributedDataParallel в PyTorch. Отличие от следующей ступени: здесь сумма нужна целиком на каждой видеокарте, а при ZeRO достаточно, чтобы каждая получила только свою часть суммы — то есть только первую фазу.

Подробный пример. Сымитируем кольцо из четырёх видеокарт, у каждой градиент из восьми чисел. Проведём обе фазы честно, по тактам, проверим, что у всех получилась одна и та же сумма, и посчитаем, сколько чисел отправила каждая. Потом по формуле прикинем трафик для модели на 7 миллиардов параметров с градиентами в bf16.

import numpy as np
rng = np.random.default_rng(2)
N, L = 4, 8                                   # 4 видеокарты, у каждой градиент из 8 чисел
g = [rng.integers(0, 10, L).astype(float) for _ in range(N)]
buf = [x.copy() for x in g]; chunk = lambda c: slice(c * L // N, (c + 1) * L // N)
sent = [0] * N
for step in range(N - 1):                     # 1) reduce-scatter: передаём и складываем
    msgs = [(i, (i - step) % N, buf[i][chunk((i - step) % N)].copy()) for i in range(N)]
    for i, c, data in msgs:
        buf[(i + 1) % N][chunk(c)] += data; sent[i] += len(data)
for step in range(N - 1):                     # 2) all-gather: раздаём готовые суммы
    msgs = [(i, (i + 1 - step) % N, buf[i][chunk((i + 1 - step) % N)].copy()) for i in range(N)]
    for i, c, data in msgs:
        buf[(i + 1) % N][chunk(c)] = data; sent[i] += len(data)
total = sum(g)
print("сумма по кольцу совпала у всех:", all(np.array_equal(b, total) for b in buf))
print("отправила каждая видеокарта:", sent, "чисел; формула 2(N-1)/N*L =", 2 * (N - 1) / N * L)
P = 7e9; size = 2 * P                         # градиенты bf16 модели 7 млрд параметров
for N in [8, 64]:
    print(f"N = {N}: каждая видеокарта за шаг отправляет {2*(N-1)/N*size/1e9:.1f} ГБ")

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

сумма по кольцу совпала у всех: True
отправила каждая видеокарта: [12, 12, 12, 12] чисел; формула 2(N-1)/N*L = 12.0
N = 8: каждая видеокарта за шаг отправляет 24.5 ГБ
N = 64: каждая видеокарта за шаг отправляет 27.6 ГБ

Каждая видеокарта отправила 12 чисел из 8 — ровно 2·3/4·8, как в формуле, и нагрузка одинаковая у всех. Для модели на 7 миллиардов параметров это 24,5 ГБ на видеокарту за шаг при 8 участниках и 27,6 ГБ при 64. Отсюда понятно, почему скорость линий между видеокартами так важна: при скорости 100 ГБ/с в одну сторону только пересылка займёт около четверти секунды на каждый шаг; это прикидка по формуле, а не замер. Повтори: поставь N = 5 и L = 10 и проверь, что формула по-прежнему совпадает с подсчётом.

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

  • Думают, что трафик all-reduce растёт пропорционально числу видеокарт. На каждую видеокарту он почти постоянен, растёт только число тактов и, значит, вклад задержек.
  • Измеряют скорость сети по одной паре видеокарт и переносят на всю установку. Внутри сервера и между серверами скорости различаются в разы, и самое медленное звено задаёт темп всего кольца.
  • Делают пакеты слишком мелкими или слишком крупными. Мелкие пакеты дают много задержек, крупные — поздно запускаются и плохо прячутся за вычислениями.

Кольцевой all-reduce (ring all-reduce). Алгоритм, в котором видеокарты по кругу передают части массива соседу, складывают и раздают их.

Reduce-scatter. Операция, после которой каждый участник держит сумму только своей части массива.

All-gather. Операция, после которой каждый участник получает части всех остальных и собирает массив целиком.

Пропускная способность (bandwidth). Сколько байт в секунду проходит по линии связи.

Задержка (latency). Фиксированное время на одно сообщение, не зависящее от его размера.

NCCL. Библиотека NVIDIA, которая выполняет коллективные операции между видеокартами.

Пакет градиентов (bucket). Группа градиентов соседних слоёв, которую отправляют одним all-reduce, как только она готова.

3 ZeRO и FSDP: не держать всё на каждой видеокарте

Зачем это в работе. Обычный параллелизм данных хранит на каждой видеокарте одни и те же 16 байт на параметр — N одинаковых копий. ZeRO (Zero Redundancy Optimizer, работа Раджбхандари и соавторов из Microsoft, 2019) убирает это дублирование: каждая видеокарта хранит только свою долю. Это главный способ уместить модель в память, не меняя код самой модели. В PyTorch ту же идею реализует FSDP (Fully Sharded Data Parallel), в библиотеке DeepSpeed — ZeRO, и в настройках обучения ты почти наверняка встретишь их стадии.

Как это устроено. В работе ZeRO три стадии. Стадия 1 делит между видеокартами состояние оптимизатора — главную копию весов fp32 и два момента Adam, 12 из 16 байт. Каждая видеокарта обновляет только свою 1/N часть параметров. Для этого ей нужна сумма градиентов только по своей части, то есть вместо полного all-reduce достаточно reduce-scatter из прошлой ступени; затем обновлённые веса раздаются всем через all-gather. Стадия 2 вдобавок не хранит чужие градиенты: после reduce-scatter каждая видеокарта держит только свою часть суммы.

Стадия 3 делит и сами веса bf16. Тогда перед вычислением каждого слоя видеокарты собирают его веса через all-gather, считают и сразу выбрасывают чужие части; при обратном проходе собирают ещё раз. Такое деление называют шардированием (sharding), а долю на одной видеокарте — шардом (shard). По оценке авторов ZeRO, стадии 1 и 2 гоняют по сети столько же данных, сколько обычный параллелизм данных, а стадия 3 — примерно в 1,5 раза больше. Это цена: памяти освобождается много, но связь нагружается сильнее, и её нужно прятать за вычислениями, заранее подгружая веса следующего слоя (prefetch).

Ограничение: ZeRO делит только состояние модели, но не активации. Каждая видеокарта по-прежнему считает слой целиком на своём микро-батче, и активации длинной последовательности могут не поместиться даже при идеальном шардировании. Для них есть другой приём — пересчёт активаций (activation checkpointing): хранить только входы некоторых слоёв и при обратном проходе пересчитывать остальное, платя примерно ещё одним прямым проходом. Отличие от тензорного параллелизма на следующей ступени: при ZeRO-3 слой собирается целиком и считается одной видеокартой, а при тензорном параллелизме сама матрица навсегда разрезана и каждая видеокарта считает только свою часть произведения.

Подробный пример. Посчитаем по формулам из работы ZeRO, сколько памяти на видеокарту нужно для модели на 7 миллиардов параметров на 8 и на 64 видеокартах. В формулах 2 байта весов bf16, 2 байта градиентов и K = 12 байт состояния оптимизатора; активации не учитываем.

P = 7e9; K = 12            # параметры; 12 байт: главная копия fp32 + два момента Adam
GB = 1e9
for N in [8, 64]:
    rows = {
        "обычный параллелизм данных": 2*P + 2*P + K*P,
        "ZeRO-1 (делим состояние оптимизатора)": 2*P + 2*P + K*P/N,
        "ZeRO-2 (+ делим градиенты)": 2*P + (2+K)*P/N,
        "ZeRO-3 / FSDP (+ делим веса)": (2+2+K)*P/N,
    }
    print(f"N = {N} видеокарт, модель 7 млрд параметров, без активаций:")
    for k, v in rows.items():
        print(f"  {k:<40} {v/GB:7.1f} ГБ на видеокарту")

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

N = 8 видеокарт, модель 7 млрд параметров, без активаций:
  обычный параллелизм данных                 112.0 ГБ на видеокарту
  ZeRO-1 (делим состояние оптимизатора)       38.5 ГБ на видеокарту
  ZeRO-2 (+ делим градиенты)                  26.2 ГБ на видеокарту
  ZeRO-3 / FSDP (+ делим веса)                14.0 ГБ на видеокарту
N = 64 видеокарт, модель 7 млрд параметров, без активаций:
  обычный параллелизм данных                 112.0 ГБ на видеокарту
  ZeRO-1 (делим состояние оптимизатора)       29.3 ГБ на видеокарту
  ZeRO-2 (+ делим градиенты)                  15.5 ГБ на видеокарту
  ZeRO-3 / FSDP (+ делим веса)                 1.8 ГБ на видеокарту

Без ZeRO 112 ГБ не помещаются в одну видеокарту на 80 ГБ ни при каком числе копий. Уже стадия 1 на 8 видеокартах даёт 38,5 ГБ, и место остаётся под активации. Стадия 3 на 64 видеокартах опускает долю до 1,8 ГБ: модель «размазана» тонким слоем. Заметь, что стадии 1 и 2 упираются в нижнюю границу — полные веса и градиенты bf16, 4 байта на параметр, то есть 28 ГБ, — и только стадия 3 масштабируется дальше. Повтори: подставь 70 миллиардов параметров и найди, при каком N стадия 3 укладывается в 40 ГБ на видеокарту.

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

  • Включают ZeRO-3 на медленной сети между серверами и удивляются падению скорости. Стадия 3 гоняет больше данных, и если связь не прячется за вычислениями, лучше остаться на стадии 2.
  • Считают, что шардирование решает проблему памяти полностью, и забывают про активации. Для длинного контекста основной расход часто именно в них.
  • Сохраняют контрольную точку (checkpoint) как набор шардов и потом не могут загрузить её на другом числе видеокарт. Нужно заранее знать, умеет ли фреймворк пересобирать шарды под новую конфигурацию.

ZeRO (Zero Redundancy Optimizer). Метод Microsoft, убирающий дублирование состояния модели при параллелизме данных; имеет стадии 1, 2 и 3.

FSDP (Fully Sharded Data Parallel). Реализация полного шардирования весов, градиентов и оптимизатора в PyTorch, по смыслу близкая к ZeRO-3.

Шардирование (sharding). Разделение массива на части, каждая из которых хранится на своей видеокарте.

Шард (shard). Часть массива, хранящаяся на одной видеокарте.

Состояние оптимизатора (optimizer state). Всё, что оптимизатор хранит между шагами; у Adam в смешанной точности это главная копия весов и два момента.

Предзагрузка (prefetch). Сбор весов следующего слоя заранее, пока считается текущий.

Пересчёт активаций (activation checkpointing). Приём, при котором часть активаций не хранят, а пересчитывают при обратном проходе, обменивая время на память.

Контрольная точка (checkpoint). Сохранённое на диск состояние обучения, с которого его можно продолжить.

4 Тензорный параллелизм: одна матрица на нескольких видеокартах

Зачем это в работе. Бывает, что отдельный слой слишком велик или слишком медленный для одной видеокарты, либо нужно, чтобы каждая видеокарта держала и считала меньше активаций. Тогда режут сами матрицы: каждая видеокарта хранит и считает только часть каждого слоя. Это тензорный параллелизм (tensor parallelism), и он же используется при запуске больших моделей, когда один ответ должен считаться сразу на нескольких видеокартах, чтобы быстрее выдавать токены.

Как это устроено. Умножение матриц можно разрезать двумя способами. Если разрезать матрицу весов по столбцам (column parallel), каждая видеокарта получает полный вход и выдаёт свою часть выходных признаков — ничего складывать не нужно, выходы просто лежат рядом. Если разрезать по строкам (row parallel), каждой видеокарте нужна своя часть входа, а её результат — частичная сумма; чтобы получить настоящий выход, частичные суммы надо сложить через all-reduce.

Схема из работы Megatron-LM (Шоеби и соавторы, NVIDIA, 2019) сочетает оба разреза в блоке MLP трансформера: Y = GeLU(X·A)·B. Первую матрицу A режут по столбцам: каждая видеокарта получает свою часть промежуточных признаков и применяет к ней нелинейную функцию GeLU у себя, без общения, — это возможно, потому что GeLU действует на каждый признак отдельно. Вторую матрицу B режут по строкам, ровно по тем же признакам: каждая видеокарта умножает свою часть и получает частичную сумму. Одно all-reduce в конце даёт полный выход. С блоком внимания так же: головы внимания делят между видеокартами, и снова одно all-reduce на выходе. Итого при прямом проходе два all-reduce на слой трансформера и ещё два при обратном.

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

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

import numpy as np
rng = np.random.default_rng(1)
gelu = lambda z: 0.5 * z * (1 + np.tanh(0.79788456 * (z + 0.044715 * z**3)))
X = rng.normal(size=(4, 8))           # 4 токена, ширина 8
A = rng.normal(size=(8, 32))          # первая матрица блока MLP: 8 -> 32
B = rng.normal(size=(32, 8))          # вторая: 32 -> 8
Y = gelu(X @ A) @ B                   # как считает одна видеокарта
# Две видеокарты: A режем по столбцам, B — по строкам
A1, A2 = A[:, :16], A[:, 16:]
B1, B2 = B[:16], B[16:]
Y1 = gelu(X @ A1) @ B1                # считает видеокарта 1 без общения
Y2 = gelu(X @ A2) @ B2                # видеокарта 2
print("столбцы/строки, одно сложение в конце: ошибка", f"{np.abs(Y - (Y1 + Y2)).max():.1e}")
# Неправильный разрез: A по строкам (по входу), gelu до сложения
Ar1, Ar2 = A[:4], A[4:]
Z_bad = gelu(X[:, :4] @ Ar1) + gelu(X[:, 4:] @ Ar2)
print("A по строкам, gelu до сложения:     ошибка", f"{np.abs(gelu(X @ A) - Z_bad).max():.1e}")

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

столбцы/строки, одно сложение в конце: ошибка 2.8e-15
A по строкам, gelu до сложения:     ошибка 3.1e+00

Правильный разрез совпал с полным расчётом до 3·10−15, то есть до округления. Неправильный ошибся на 3,1: GeLU от суммы не равна сумме GeLU, поэтому при разрезе по строкам частичные суммы нужно сложить до нелинейности, а это лишнее all-reduce на каждом блоке. Порядок «сначала столбцы, потом строки» выбран ровно для того, чтобы общения было меньше. Повтори: замени GeLU на тождественную функцию lambda z: z и убедись, что тогда оба разреза дают верный ответ.

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

  • Растягивают тензорную группу за пределы одного сервера. Всё обучение начинает ждать медленную сеть на каждом слое.
  • Выбирают число видеокарт, на которое не делится число голов внимания или ширина слоя. Головы и признаки должны делиться поровну.
  • Забывают, что всё, что стоит вне разрезанных матриц — нормализация, dropout, — повторяется на всех видеокартах группы. Если у них разные случайные маски dropout в этих местах, копии расходятся.

Тензорный параллелизм (tensor parallelism). Разрезание матриц каждого слоя между видеокартами, которые считают части одного произведения.

Разрез по столбцам (column parallel). Каждая видеокарта держит часть столбцов матрицы и выдаёт часть выходных признаков без сложения.

Разрез по строкам (row parallel). Каждая видеокарта держит часть строк матрицы, выдаёт частичную сумму, и суммы складываются через all-reduce.

GeLU. Гладкая нелинейная функция, которую применяют к каждому признаку внутри блока MLP трансформера.

Блок MLP. Часть слоя трансформера из двух матриц и нелинейности между ними, обрабатывающая каждый токен отдельно.

Megatron-LM. Работа и библиотека NVIDIA, где описан тензорный параллелизм трансформера с двумя all-reduce на слой в прямом проходе.

NVLink. Быстрое соединение NVIDIA между видеокартами внутри одного сервера.

5 Конвейерный параллелизм и как всё сочетают: пузырь, микро-батчи и 3D

Зачем это в работе. Модель из сотни слоёв можно разложить по видеокартам стопками: первые слои на одной, следующие на другой. Это конвейерный параллелизм (pipeline parallelism). Связь здесь самая скромная — между соседними ступенями передаются только активации на границе, — поэтому его используют между серверами, где сеть медленнее. Но у конвейера есть простой, и от того, как ты нарежешь батч, зависит, будут ли видеокарты работать или ждать.

Как это устроено. Слои делят на p ступеней (stages), по одной на видеокарту или группу видеокарт. Если подать весь батч разом, вторая ступень ждёт, пока закончит первая, третья — вторую, и в каждый момент работает только одна из p видеокарт. Поэтому батч режут на m микро-батчей и пускают их друг за другом: пока вторая ступень считает первый микро-батч, первая уже взялась за второй. Остаётся простой в начале, пока конвейер заполняется, и в конце, пока он пустеет; его называют пузырём (pipeline bubble). В схеме GPipe (Хуан и соавторы, Google, 2018) доля простоя равна (p − 1)/(m + p − 1): чем больше микро-батчей на ступень, тем меньше пузырь.

Ограничение — память на активации. В GPipe сначала проходят все m прямых проходов, потом все обратные, и первая ступень держит активации всех m микро-батчей сразу. Расписание 1F1B («один вперёд, один назад», one forward one backward), описанное в работе PipeDream (Нараянан и соавторы, 2019), начинает обратный проход каждого микро-батча, как только это возможно, и чередует прямые и обратные; тогда первая ступень держит активации не больше чем p микро-батчей, а не m. Пузырь у простого 1F1B тот же, а уменьшают его чередующимися расписаниями (interleaved), где каждая видеокарта держит несколько несмежных кусков модели. Ещё одно ограничение: ступени должны быть сбалансированы, иначе самая медленная задаёт темп, а первая и последняя ступени часто тяжелее из-за слоя эмбеддингов и выходного слоя.

Как всё сочетают. В реальной установке используют все способы сразу, и это называют 3D-параллелизмом: тензорный — внутри сервера, где быстрые линии; конвейерный — между несколькими серверами; параллелизм данных, часто с ZeRO, — поверх, чтобы размножить всю эту конструкцию. Такую раскладку обосновывает работа Megatron-LM 2021 года (Нараянан и соавторы, NVIDIA): чем чаще способ общается, тем ближе друг к другу должны стоять его видеокарты. Число видеокарт равно произведению трёх размеров групп, например 8 × 4 × 32 = 1024. Для смеси экспертов из дорожки о MoE добавляют четвёртое измерение — параллелизм экспертов, а для очень длинного контекста — пятое, деление последовательности.

Подробный пример. Посчитаем по формуле GPipe долю простоя для конвейера из 4 и 8 ступеней при разном числе микро-батчей и сколько активаций держит первая ступень в GPipe и 1F1B. Потом нарисуем расписание прямого прохода для 4 ступеней и 4 микро-батчей.

for p in [4, 8]:
    print(f"ступеней конвейера p = {p}:")
    for m in [1, 4, 8, 32]:
        bubble = (p - 1) / (m + p - 1)
        print(f"  микро-батчей m = {m:>2}: простой {bubble:6.1%};"
              f" активаций держит 1-я ступень: GPipe {m:>2}, 1F1B {min(m, p)}")
# Расписание прямого прохода GPipe, p = 4, m = 4: цифра — номер микро-батча, точка — простой
p, m = 4, 4
print("такт:     " + " ".join(str(t) for t in range(m + p - 1)))
for s in range(p):
    row = [str(t - s + 1) if 0 <= t - s < m else "." for t in range(m + p - 1)]
    print(f"ступень {s+1}: " + " ".join(row))

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

ступеней конвейера p = 4:
  микро-батчей m =  1: простой  75.0%; активаций держит 1-я ступень: GPipe  1, 1F1B 1
  микро-батчей m =  4: простой  42.9%; активаций держит 1-я ступень: GPipe  4, 1F1B 4
  микро-батчей m =  8: простой  27.3%; активаций держит 1-я ступень: GPipe  8, 1F1B 4
  микро-батчей m = 32: простой   8.6%; активаций держит 1-я ступень: GPipe 32, 1F1B 4
ступеней конвейера p = 8:
  микро-батчей m =  1: простой  87.5%; активаций держит 1-я ступень: GPipe  1, 1F1B 1
  микро-батчей m =  4: простой  63.6%; активаций держит 1-я ступень: GPipe  4, 1F1B 4
  микро-батчей m =  8: простой  46.7%; активаций держит 1-я ступень: GPipe  8, 1F1B 8
  микро-батчей m = 32: простой  17.9%; активаций держит 1-я ступень: GPipe 32, 1F1B 8
такт:     0 1 2 3 4 5 6
ступень 1: 1 2 3 4 . . .
ступень 2: . 1 2 3 4 . .
ступень 3: . . 1 2 3 4 .
ступень 4: . . . 1 2 3 4

При одном микро-батче конвейер из 4 ступеней простаивает 75% времени — по сути это последовательный расчёт на одной видеокарте за раз. При 32 микро-батчах простой 8,6%, но GPipe держит на первой ступени 32 набора активаций, а 1F1B — только 4. На рисунке точки — это пузырь: три такта в начале у последней ступени и три в конце у первой. Для 8 ступеней тот же простой требует примерно вдвое больше микро-батчей, а значит, большего глобального батча — это и есть скрытая цена глубокого конвейера. Повтори: найди, при каком m простой конвейера из 8 ступеней опускается ниже 10%.

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

  • Делят слои поровну по количеству, а не по времени расчёта. Ступень со слоем эмбеддингов или выходным слоем на большой словарь оказывается самой медленной, и остальные её ждут.
  • Берут мало микро-батчей, чтобы не увеличивать глобальный батч, и теряют половину времени в пузыре. Число микро-батчей нужно выбирать вместе с глубиной конвейера.
  • Расставляют группы наоборот: тензорную — между серверами, конвейерную — внутри. Частое общение должно идти по быстрым линиям, редкое — по медленной сети.

Конвейерный параллелизм (pipeline parallelism). Разбиение стопки слоёв модели на ступени, которые стоят на разных видеокартах и передают друг другу активации.

Ступень конвейера (stage). Группа подряд идущих слоёв, которую считает одна видеокарта или одна группа видеокарт.

Пузырь (pipeline bubble). Время, когда ступени конвейера простаивают при его заполнении и опустошении.

GPipe. Схема Google, где все микро-батчи сначала проходят вперёд, потом назад; доля простоя (p − 1)/(m + p − 1).

1F1B (one forward one backward). Расписание, чередующее прямой и обратный проходы, чтобы держать меньше активаций.

Чередующееся расписание (interleaved schedule). Вариант конвейера, где каждая видеокарта держит несколько несмежных кусков модели, чтобы уменьшить пузырь.

3D-параллелизм. Одновременное использование параллелизма данных, тензорного и конвейерного с раскладкой по скорости связи.

Параллелизм экспертов (expert parallelism). Размещение разных экспертов смеси экспертов на разных видеокартах.

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