Accelerate documentation

Context Parallel в 🤗 accelerate

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Context Parallel в 🤗 accelerate

В этом руководстве рассматриваются основы использования контекстного параллелизма в 🤗accelerate; для более любопытных читателей в последующих разделах мы также разберем некоторые технические детали.

См. также очень близкий по теме Руководство по параллелизму последовательностей.

Зачем нужна параллельность контекста?

С появлением больших языковых моделей, а в последнее время и моделей рассуждений, длина последовательностей стремительно растёт. В сочетании с квадратичной по памяти сложностью механизма внимания это привело к необходимости более эффективных способов обучения моделей с длинными последовательностями. При длине последовательности 128k требования к памяти для матрицы внимания составляют 128k * 128k * 2 bytes * num_heads = ~32 GB * num_heads для точности bf16 при использовании стандартной реализации внимания. Конечно, при использовании flash attention или SDPA, которые не материализуют эти веса внимания, объём памяти резко снижается, но рост требований к памяти всё ещё остаётся значительным.

Параллелизм контекста позволяет разбивать входные данные для вычисления внимания вдоль измерения последовательности и выполнять вычисления внимания параллельно на нескольких GPU. Благодаря этому можно обучать модели с длинными последовательностями, масштабируя длину последовательности потенциально до 1 млн и более токенов.

Как использовать параллелизм контекста?

from accelerate.utils import ParallelismConfig, TorchContextParallelConfig

+ cp_config = TorchContextParallelConfig(
+       cp_comm_strategy="alltoall", # no need to use cp_config at all, if you want to use the default "allgather"
+ )

+ parallelism_config = ParallelismConfig(
+     cp_size=8,
+     cp_handler=cp_config,  # or just cp_size=8, if you want to use the default "allgather"
+ )

accelerator = Accelerator(
    ...,
    parallelism_config=parallelism_config,
)

Как и в случае с любой другой функцией 🤗accelerate, вы можете включить контекстную параллельность, передав соответствующие флаги в accelerate launch. В этом случае всё происходит так же:

accelerate launch --parallelism-config-cp-size 8 --parallelism-config-cp-comm-strategy [allgather|alltoall] ...

Вы также можете задать параметры cp_size и cp_comm_strategy в команде accelerate config, и они будут сохранены в вашем файле конфигурации accelerate, поэтому вам не нужно будет передавать их каждый запуск скрипта.

Контекстное параллелизование совместимо с другими стратегиями параллелизации, такими как параллелизация данных, тензорное параллелизование и FSDP2. Вы можете просто комбинировать их, задав размеры параллелизации нужными значениями, например --parallelism-config-dp-size 8 --parallelism-config-tp-size 2 --parallelism-config-cp-size 8. Либо вы можете использовать класс ParallelismConfig, чтобы задать их программно.

Контекстный параллелизм тесно связан с FSDP2, о котором вы можете узнать больше в введении в FSDP2. Это означает, что контекстный параллелизм работает только в том случае, если в вашей программе используется FullyShardedDataParallelPlugin или --use-fsdp с версией, установленной в 2. Если FSDP2 не используется, будет выброшена ошибка.

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

После включения контекстного параллелизма с помощью описанных выше методов вы можете применить его к циклу обучения. Мы предоставляем тонкую обёртку вокруг torch.distributed.tensor.experimental.context_parallel, которую можно использовать в цикле обучения; она абстрагирует часть сложности, связанной с её применением (подробнее об этом позже). Чтобы минимизировать изменения, которые необходимо внести в цикл обучения, мы предоставляем контекстный менеджер, который является noop, если контекстный параллелизм не включён, и применяет контекстный параллелизм, если он включён. Таким образом, вы можете использовать его в цикле обучения, не изменяя код в зависимости от конфигурации параллелизма. Вы можете использовать его следующим образом:

for batch in dataloader:
    with accelerator.maybe_context_parallel(
        buffers=[batch["input_ids"], batch["attention_mask"]],
        buffer_seq_dims=[1, 1],
        no_restore_buffers={batch["input_ids"], batch["labels"]},
    ):
        outputs = model(**batch)
        ...

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

Это позволяет масштабировать размер контекста до длины последовательности 1M+. Ниже мы демонстрируем скорость и потребление памяти при использовании контекстного параллелизма для размера контекста до 256k. Мы видим, что при удвоении размера контекста и количества GPU мы можем поддерживать стабильное потребление памяти, что потенциально позволяет бесконечно масштабировать длину контекста.

context parallelism memory usage
Рисунок 1: Использование памяти и скорость контекстного параллелизма для контекста размером до 256k.

Эти примеры были созданы с помощью скрипта, который можно найти в папке examples. Чтобы запустить пример на 8 GPU H100 (длина последовательности 128k), используйте следующую команду:

accelerate launch --use-fsdp --fsdp-activation-checkpointing=TRUE examples/torch_native_parallelism/nd_parallel.py --cp-size=8 --sequence-length=128000

Интерфейс Accelerate

Контекстный менеджер принимает несколько аргументов, которые используются для настройки контекстного параллелизма.

  • buffers: это список тензоров, которые должны быть разбиты по измерению последовательности. Обычно это входные идентификаторы, метки и маска внимания.
  • buffer_seq_dims: это список целых чисел, указывающих размерность последовательности для буферов в том же порядке, что и в списке buffers. Если вы передаёте buffers=[input_ids, shift_labels], и оба имеют форму [batch_size, sequence_length], то нужно передать buffer_seq_dims=[1, 1], так как размерность последовательности является второй размерностью тензоров. Это необходимо для корректного вычисления выходов модели.
  • no_restore_buffers: Реализация контекстного параллелизма изменяет буферы на месте, преобразуя их в torch.distributed.tensor.Dtensor. После выхода из контекстного менеджера для восстановления исходного состояния буферов потребуется запуск ядра коммуникации (обычно all-gather). Это занимает некоторое время, поэтому рекомендуется передавать те же тензоры, что и в аргументе buffers, чтобы избежать ненужной коммуникации, если вы не уверены, что вам нужно использовать буферы после выхода из контекстного менеджера.

Контекстная параллельность несовместима с labels, которые являются копией input_ids, так как модели из 🤗 transformers могут самостоятельно сдвигать их для обеспечения каузального языкового моделирования. Представьте следующий случай: labels = [l1, l2, l3, l4, … li] Если применить контекстную параллельность, каждый ранг получит часть меток, например: labels_rank_0 = [l1, l2], labels_rank_1 = [l3, l4], … После того как код моделирования в transformers сдвинет метки, получится: labels_rank_0 = [l2, PAD], labels_rank_1 = [l3, PAD], … где PAD — это токен отсечки. Это приведет к неверному вычислению функции потерь, так как метки больше не будут соответствовать входным данным. По этой причине вам необходимо вручную сдвинуть метки перед передачей их в модель

Настраиваемые параметры

Accelerate предоставляет только один вариант для настройки контекстного параллелизма (кроме cp_size)

  • cp_comm_strategy: метод ротации, используемый для шардов. Мы настоятельно рекомендуем оставить значение "allgather", так как в большинстве случаев он, скорее всего, будет работать быстрее, чем "alltoall".

Размер контекстного параллелизма (context parallel size) говорит сам за себя: это количество рангов, на которые разбиваются входные данные. Поворот фрагментов контекстного параллелизма (context parallel shard rotation) определяет, как фрагменты входных данных перемещаются между рангами. Мы подробнее рассмотрим два варианта в следующем разделе.

Вы можете найти пример полного цикла в файле ND parallel example, где показано, как обучить модель 8B с длиной контекста до 128k на одном узле 8xH100. С помощью обучения на нескольких узлах можно масштабировать это до длины последовательности 1M+ на нескольких GPU. Также его можно бесшовно сочетать с другими стратегиями параллелизма в соответствии с вашими потребностями.

Технические детали

Этот раздел достаточно технический, поэтому, если вам не нужно изучать внутреннее устройство контекстного параллелизма, вы можете пропустить его и приступить к разработке 🚀

В следующих разделах мы будем активно использовать термин shard, поэтому сначала определим его. Если мы говорим, что тензор sharded по Dth измерению на N рангах, мы имеем в виду, что этот тензор разделен на N частей, где каждая часть тензора имеет форму [..., D//N, ...].

Так как же это работает?

Контекстный параллелизм работает за счёт шардирования матриц Q, K and V по измерению последовательности. У каждого ранга есть его назначенный шард Q, назовём его Q_i. Эта матрица остаётся только на этом ранге на протяжении всего вычисления. Аналогично, у каждого ранга есть собственный шард K и V, назовём их K_i и V_i. Затем каждый ранг вычисляет внимание со своим шардом Q_i, K_i и V_i, назовём его attn_i. Во время этого вычисления запускается ядро коммуникации для сбора Ks и Vs со всех остальных рангов. Какой примитив коммуникации используется, зависит от опции context_parallel_shard_rotation. Таким образом, каждый ранг вычисляет локальное внимание, сначала с Q_i, K_i и V_i, а затем с K_j и V_j со всех остальных рангов. Поскольку каждый ранг хранит матрицы Q, K and V, шардированные по измерению последовательности, результирующие матрицы становятся меньше и могут поместиться на одном GPU.

Мы можем формализовать это в виде следующего псевдокода:

comm_kernel = {"allgather": allgather, "alltoall": alltoall}[context_parallel_shard_rotation]
Qi, Ki, Vi = shard(Q, K, V, seq_dim)
attn[i] = attn(Qi, Ki, Vi)
for j in range(context_parallel_size):
    Kj, Vj = comm_kernel()
    attn[j] = attn(Qi, Kj, Vj) # [batch, num_heads, seq_len // context_parallel_size, head_dim]

final_attn = combine(attn)

all-to-all и all-gather

all-gather

В чём же разница между all-to-all и all-gather? При all-gather коммуникация очень проста. После (хотя, как правило, до, поскольку это занимает больше времени) вычисления локального внимания attn_i мы запускаем all-gather, чтобы собрать все остальные Ks и Vs со всех других рангов. Когда эта коммуникация завершена, каждый ранг имеет все Ks и Vs со всех других рангов и может последовательно вычислять внимание с ними. В идеальном сценарии all-gather завершается ровно в тот момент, когда закончено вычисление attn_i. Однако на практике это никогда не происходит, поэтому идеальное реальное перекрытие достигается, когда полное attn_i перекрывается с частью коммуникации, а затем, чтобы начать вычисление с K_j и V_j, мы ждём завершения all-gather.

all-to-all

All-to-all, or sometimes called ring-rotation utilizes a ring-like communication pattern. After concluding attn_i computation, an all-to-all is launched to send K_i and V_i to the neighbouring ranks. We then repeat this context_parallel_size-1 times, so that each rank sees all the shards of K and V from all other ranks once. In ideal scenario, we prefetch shards K_i+1 and V_i+1 from the neighbouring rank and this communication is exactly overlapped with computation of our current attn_i. Again, realistically, this perfect overlap doesn’t ever happen. Given the nature of this approach, if we don’t achieve perfect overlap, the penalty is way larger than with all-gather.

Как выбрать правильный метод вращения?

In theory, all-to-all should be the better choice. Though in practice, it rarely is. Therefore, we default to all-gather, as it’s more likely to achieve better performance. Extensive benchmarks from the torchtitan team also show that all-to-all rarely outperforms all-gather. Though, we still provide both options, as you might find one to be better for your use case.

Вы можете непосредственно увидеть эту проблему в выводе профилировщика на изображении ниже:

all-to-all profiler output
Рисунок 1: Красным цветом показано время простоя, пока мы ждем завершения ядра all-to-all. На первом выделенном синим столбце видно, что на завершение уходит ~250 мкс, и это повторяется N-1 раз для каждого вызова внимания, где N — размер контекстного параллелизма.

Почему только FSDP2?

Мы поддерживаем параллелизм контекста только с FSDP2, поскольку создаем объединенную сетку из context_parallel_size и dp_shard_size, чтобы использовать весь его потенциал. Принцип работы: мы распределяем модель по объединенной сетке размера cp_size*dp_shard_size, что максимизирует экономию памяти. Это своего рода «бесплатный обед», так как коммуникация FSDP полностью перекрывается с вычислениями внимания, как показано на изображениях ниже.

why FSDP2+CP
Рисунок 2: В синих прямоугольниках (поток 23) видно, что предварительная загрузка шарда `FSDP` полностью перекрывается с вычислениями внимания (поток 7), тогда как в красных прямоугольниках (поток 24) видно, что ядро all-gather приводит к появлению «пузыря» простоя, в течение которого наш вычислительный поток (7) простаивает.

In the figure above, you can also note the difference between all-to-all and all-gather. While in all-to-all (Figure 1), we launch a communication kernel N-1 times for each attention call, in all-gather (Figure 2), we launch a communication kernel only once. This results in a bigger bubble, but it only happens once per attention call, while in all-to-all, it happens N-1 times.

Диспетчеризация данных в объединённой сетке

Мы гарантируем, что один и тот же пакет данных отправляется на всю подгруппу cp, чтобы результаты были корректными (то есть каждый ранг в подгруппе cp получает один и тот же пакет данных). При этом на каждый ранг группы dp_shard отправляются разные пакеты данных. Представьте это так:

# 8 GPUS, --dp_shard_size 4, --cp_size 2
# mesh = [[0, 1], [2, 3], [4, 5], [6, 7]]
# model is sharded across the whole mesh (each GPU holds 1/8 of the model)
# GPUs 0,1 = batch 0
# GPUs 2,3 = batch 1
... and so on.
Update on GitHub