Accelerate documentation
Context Parallel в 🤗 accelerate
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 мы можем поддерживать стабильное потребление памяти, что потенциально позволяет бесконечно масштабировать длину контекста.
Рисунок 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.
Вы можете непосредственно увидеть эту проблему в выводе профилировщика на изображении ниже:
Рисунок 1: Красным цветом показано время простоя, пока мы ждем завершения ядра all-to-all. На первом выделенном синим столбце видно, что на завершение уходит ~250 мкс, и это повторяется N-1 раз для каждого вызова внимания, где N — размер контекстного параллелизма.
Почему только FSDP2?
Мы поддерживаем параллелизм контекста только с FSDP2, поскольку создаем объединенную сетку из context_parallel_size и dp_shard_size, чтобы использовать весь его потенциал.
Принцип работы: мы распределяем модель по объединенной сетке размера cp_size*dp_shard_size, что максимизирует экономию памяти.
Это своего рода «бесплатный обед», так как коммуникация FSDP полностью перекрывается с вычислениями внимания, как показано на изображениях ниже.
Рисунок 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.