Accelerate documentation
Последовательная параллельность в 🤗 accelerate
Последовательная параллельность в 🤗 accelerate
В этом руководстве рассматриваются основы использования последовательной параллельности в 🤗accelerate.
См. также очень близкое по смыслу Context Parallelism.
Зачем нужна последовательная параллельность?
С появлением больших языковых моделей, а в последнее время и моделей рассуждений, длина последовательностей стремительно растёт. В сочетании с квадратичной по памяти сложностью механизма внимания это привело к необходимости более эффективных способов обучения моделей с длинными последовательностями.
При длине последовательности 128k требования к памяти для матрицы внимания составляют 128k * 128k * 2 bytes * num_heads = ~32 GB * num_heads для точности bf16 при использовании стандартной реализации внимания. Конечно, при использовании flash attention или SDPA, которые не материализуют эти веса внимания, объём памяти резко снижается, но рост требований к памяти всё ещё остаётся значительным.
Параллелизм последовательности Ulysses позволяет разбивать входные данные для вычисления внимания вдоль измерения последовательности и вычислять внимание в обычном режиме, но используя на каждом GPU только часть головок внимания. Благодаря этому мы можем обучать модели с длинными последовательностями, а с помощью нескольких дополнительных инструментов масштабироваться до длины последовательности более 15 млн токенов. Чтобы узнать, как дополнить Ulysses SP с помощью TiledMLP, Liger-Kernel, выгрузки контрольных точек активаций в CPU и нескольких других приёмов, обратитесь к статье: Arctic Long Sequence Training: Scalable And Efficient Training For Multi-Million Token Sequences.
Чем Ulysses SP отличается от FSDP CP
В документе Context Parallelism вы можете узнать о развёртывании другой технологии — Context Parallelism, которая также выполняет нарезку по измерению последовательности, но использует Ring Attention вместо нарезки по измерению головок.
В следующих статьях подробно объясняются различия между двумя технологиями:
- https://insujang.github.io/2024-01-11/tensor-parallelism-and-sequence-parallelism-detailed-analysis/
- https://huggingface.co/blog/exploding-gradients/ulysses-ring-attention
Краткое резюме, адаптированное из одной из статей:
- Ulysses SP имеет относительно низкие накладные расходы на коммуникацию, но ограничен количеством Attention Heads, поэтому предъявляет определенные требования к топологии сети (количество attention heads должно делиться на количество участвующих GPU для одной реплики). Все-со-всеми (all-to-all) коммуникация чувствительна к задержкам и требует Deepspeed.
- P2P-кольцевая коммуникация в FSDP CP Ring-Attention не имеет вышеуказанных требований к делимости, но характеризуется более высоким объёмом коммуникации.
В конечном итоге должно стать возможным объединение SP + CP, как описано в статье USP: A Unified Sequence Parallelism Approach for Long Context Generative AI, для поддержки ещё большей длины последовательности, хотя эта функция пока не интегрирована в 🤗accelerate.
Поддерживаемые бэкенды параллелизма последовательностей
В настоящее время единственным бэкендом последовательного параллелизма является deepspeed, основанный на модернизированном Ulysses SP, который входит в состав технологии Arctic Long Sequence Training. Также доступен туториал, если вы хотите интегрировать его непосредственно в собственный код.
Как использовать параллелизм последовательностей?
from accelerate.utils import ParallelismConfig, DeepSpeedSequenceParallelConfig
+# Example: 4 GPUs with sp_size=4, dp_shard_size=1
+# Ensure: dp_replicate_size × dp_shard_size × sp_size = 1 × 1 × 4 = 4 GPUs
parallelism_config = ParallelismConfig(
+ sp_backend="deepspeed",
+ sp_size=4,
+ dp_shard_size=1, # Explicit: no data parallelism
+ sp_handler=DeepSpeedSequenceParallelConfig(
+ sp_seq_length_is_variable: true,
+ sp_attn_implementation="sdpa",
+ ),
+ )
accelerator = Accelerator(
...,
parallelism_config=parallelism_config,
)Как и в случае с любой другой функцией 🤗accelerate, вы можете включить параллелизм последовательности, передав соответствующие флаги в accelerate launch. В этом случае всё происходит так же:
accelerate launch --parallelism-config-sp-size 8 ...
Вы также можете задать
sp_sizeи другие параметры в командеaccelerate config, которая сохранит их в вашем файле конфигурацииaccelerate, чтобы вам не приходилось передавать их каждый запуск скрипта.
sequence parallelism комбинируется с data parallelism. Для этого не требуются дополнительные GPU. Таким образом, если у вас 8 GPU, вы можете выполнить:
--parallelism-config-dp-shard-size 8 --parallelism-config-sp-size 8. Либо вы можете использовать классParallelismConfig, чтобы задать их программно.Важно: необходимо убедиться, что
dp_replicate_size × dp_shard_size × sp_size = num_processes. Например, при 8 GPU иsp_size=8требуетсяdp_shard_size=1(поскольку 1 × 1 × 8 = 8). При 4 GPU иsp_size=2можно использоватьdp_shard_size=2(поскольку 1 × 2 × 2 = 4) для 2D-параллелизма.
Конфигурация бэкенда ALST/Ulysses SP
ALST/UlyssesSP реализует параллелизм последовательности с использованием параллелизма по головам внимания, как описано в этой статье. Для простоты мы переиспользуем концепцию и настройку параллелизма последовательности, которая с точки зрения пользователя остаётся прежней: несколько GPU используются для обработки одной партии.
Чтобы дать представление о возможностях ALST: он позволил обучать в bf16 с последовательностью из 500K токенов на одном GPU H100, 3.7M на одном узле и 15M на Llama-8B, используя всего четыре узла. Эта функция HF Accelerate включает только 1 из 3 компонентов ALST, поэтому достижимая длина последовательности будет меньше. Чтобы получить всю мощь ALST, необходимо включить TiledMLP, Activation checkpoint offload to CPU и несколько других опций. Подробности см. в этом руководстве.
Чтобы настроить бэкенд deepspeed:
# Example: 4 GPUs with sp_size=4, dp_shard_size=1
# Ensure: dp_replicate_size × dp_shard_size × sp_size = 1 × 1 × 4 = 4 GPUs
parallelism_config = ParallelismConfig(
sp_backend="deepspeed",
sp_size=4,
dp_shard_size=1, # Explicit: no data parallelism
sp_handler=DeepSpeedSequenceParallelConfig(
sp_seq_length=256,
sp_seq_length_is_variable=True,
sp_attn_implementation="sdpa",
),
)
accelerator = Accelerator(
...,
parallelism_config=parallelism_config,
)sp_backend: здесь установите значениеdeepspeedsp_size— это степень параллелизма последовательности. В приведённом выше примере она равна 4, поэтому для обработки одной партии (batch) будут задействованы 4 GPU (при этом на тех же GPU выполняется DP=4).sp_seq_lengthиsp_seq_length_is_variableиспользуются для работы с длиной последовательности. Еслиsp_seq_length_is_variable=True, бэкенд будет работать с длиной последовательности, которая может меняться между батчами; в этом случае значениеsp_seq_lengthможно установить на любое число, кратное степени параллелизма последовательности, или вообще не задавать. В таком случае при каждом вызовеforwardпеременные последовательности будут вычисляться на основе входных данных. ЕслиFalse, тоseq_lengthдолжно совпадать с размером измерения длины последовательности в батче, который затем необходимо дополнить (padding), чтобы он всегда оставался одинаковым. По умолчанию установлено значениеTrue.sp_attn_implementation— это одно из значений:sdpa,flash_attention_2илиflash_attention_3. Эта реализация последовательного параллелизма используетposition_idsвместоattention_mask, поэтомуeagerздесь не работает, пока не будет поддержана работа сposition_ids. Также обратите внимание, чтоsdpaнекорректно обрабатывает несколько объединённых в один образец; он обращается ко всему объединённому образцу как к одному. Если образцы не объединены,sdpaбудет работать корректно. Таким образом, Flash Attention является идеальным выбором, так как он всегда работает.sp_allow_recurrent_layers: модели с слоями линейного внимания (например, Gated DeltaNet) по умолчанию отклоняются, поскольку такие слои переносят рекуррентное состояние вдоль последовательности, и каждый ранг начинает его с нуля. Установите значениеTrueтолько в том случае, если модель сама обменивается этим состоянием между рангами последовательного параллелизма. Значение по умолчанию —False.sp_disable_in_eval: еслиTrue, параллелизм последовательности отключается в режиме eval, и каждый ранг обрабатывает всю последовательность. УстановитеFalse, чтобы оставить его включённым для длинных последовательностей оценки; в этом случае загрузчик данных для оценки должен быть разбит на части так же, как и для обучения. По умолчанию —True.
Вместо того чтобы задавать эти значения в объекте DeepSpeedSequenceParallelConfig, вы можете использовать переменные окружения для достижения того же результата — ниже они приведены в том же порядке, что и элементы списка выше.
PARALLELISM_CONFIG_SP_BACKENDPARALLELISM_CONFIG_SP_SEQ_LENGTHPARALLELISM_CONFIG_SP_SEQ_LENGTH_IS_VARIABLEPARALLELISM_CONFIG_SP_ATTN_IMPLEMENTATIONPARALLELISM_CONFIG_SP_ALLOW_RECURRENT_LAYERSPARALLELISM_CONFIG_SP_DISABLE_IN_EVAL
Если sp_size не передан в коде, его можно задать через аргумент командной строки --parallelism_config_sp_size. То же самое касается и других аргументов. Также можно использовать конфигурацию в стиле файла accelerate config, например, для 2 GPU:
distributed_type: DEEPSPEED
deepspeed_config:
deepspeed_config_file: path/to/ds_config.json
machine_rank: 0
num_machines: 1
num_processes: 2
parallelism_config:
parallelism_config_dp_replicate_size: 1
parallelism_config_dp_shard_size: 1 # Must satisfy: 1 × 1 × 2 = 2 num_processes
parallelism_config_sp_size: 2
parallelism_config_sp_backend: deepspeed
parallelism_config_sp_seq_length_is_variable: true
parallelism_config_sp_attn_implementation: sdpa
Как упоминалось ранее, параллелизм последовательности Ulysses обычно накладывается на параллелизм данных — одни и те же ранги используются для подачи уникальных потоков данных и одновременно выполняют параллелизм последовательности Ulysses. Однако вы также можете создать реплики следующим образом:
# Example: 4 GPUs with 2D parallelism (SP=2, DP=2)
# Ensure: dp_replicate_size × dp_shard_size × sp_size = 2 × 1 × 2 = 4 GPUs
parallelism_config = ParallelismConfig(
dp_replicate_size=2,
dp_shard_size=1, # Explicit: no sharding within replicas
sp_size=2,
sp_backend="deepspeed",
sp_handler=DeepSpeedSequenceParallelConfig(...),
)Здесь мы используем 4 gpus с 2 репликами sequence parallelism. Deepspeed-ZeRO обеспечивает data parallelism в данном случае.
Обратите внимание, что внутри UlyssesSPDataLoaderAdapter скрыто много «магии». Он используется за кулисами, оборачивая ваш исходный объект DataLoader, но о его наличии стоит знать, если вы столкнётесь с какими-либо проблемами. Кроме того, он автоматически вставляет корректное значение shift_labels в словарь батча до того, как батч будет разбит по участвующим рангам.
Теперь для начала использования ALST/UlyssesSP остаётся только агрегировать потерю по рангам с помощью дифференцируемого all_gather, чтобы корректно вычислить градиенты. Приведённый ниже код выполняет это, одновременно исключая токены, замаскированные значением -100, чтобы получить правильное среднее:
sp_size = parallelism_config.sp_size if parallelism_config is not None else 1
if sp_size > 1:
sp_group = accelerator.torch_device_mesh["sp"].get_group()
sp_world_size = parallelism_config.sp_size
# Normal training loop
for iter, batch in enumerate(dl):
optimizer.zero_grad()
batch = move_to_device(batch, model.device)
# The model automatically receives shift_labels via **kwargs and uses it for loss computation.
# Both standard transformers models and Liger-patched models handle this correctly.
outputs = model(**batch)
loss = outputs.loss
shift_labels = batch["shift_labels"]
if sp_size > 1:
# differentiable weighted per-shard-loss aggregation across ranks
losses_per_rank = torch.distributed.nn.functional.all_gather(loss, group=sp_group)
# special dealing with SFT that has prompt tokens that aren't used in loss computation
good_tokens = (shift_labels != -100).view(-1).sum()
good_tokens_per_rank = torch.distributed.nn.functional.all_gather(
good_tokens, group=sp_group
)
# Skip ranks with zero valid tokens to avoid NaN contamination (NaN * 0 = NaN)
total_loss = sum(
losses_per_rank[rank] * good_tokens_per_rank[rank]
for rank in range(sp_world_size)
if good_tokens_per_rank[rank] > 0
)
total_good_tokens = sum(good_tokens_per_rank)
loss = total_loss / max(total_good_tokens, 1)
if rank == 0: accelerator.print(f"{iter}: {loss=}")
accelerator.log(dict(train_loss=loss, step=iter))
accelerator.backward(loss)
optimizer.step()Обратите внимание, что модели автоматически обрабатывают shift_labels, если он присутствует в батче. Forward-проход модели получает shift_labels через **kwargs и передает его в функцию потерь, которая корректно вычисляет потерю для sequence parallelism. Если вы используете Liger Kernel, он также бесшовно обрабатывает shift_labels и вычисляет потерю очень экономично по памяти. Liger настоятельно рекомендуется для длинных последовательностей, так как он освобождает память GPU за счет использования слиянных операций (например, слиянного вычисления logit-loss, которое никогда не материализует полный тензор logits в памяти).
Если вы хотите узнать, что HF Accelerate делал «под капотом», прочитайте это полное руководство по интеграции.
Пример цикла обучения Accelerate с включёнными ALST/UlyssesSP см. в examples/alst_ulysses_sequence_parallelism.
[!Предупреждение]
Этот API довольно новый и всё ещё находится на экспериментальной стадии. Мы стремимся обеспечить стабильность API, однако некоторые небольшие части публичного API могут измениться в будущем.
Поскольку в качестве бэкенда используется DeepSpeed, применяются стандартные настройки DeepSpeed, поэтому вы также можете комбинировать параллелизм последовательностей с выгрузкой состояний оптимизатора и/или весов, чтобы освободить больше памяти GPU и обеспечить ещё более длинную длину последовательности. Эта технология протестирована и работает с DeepSpeed ZeRO этапами 2 и 3.
Update on GitHub