Accelerate documentation

Последовательная параллельность в 🤗 accelerate

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Последовательная параллельность в 🤗 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 вместо нарезки по измерению головок.

В следующих статьях подробно объясняются различия между двумя технологиями:

Краткое резюме, адаптированное из одной из статей:

  • 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: здесь установите значение deepspeed
  • sp_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_BACKEND
  • PARALLELISM_CONFIG_SP_SEQ_LENGTH
  • PARALLELISM_CONFIG_SP_SEQ_LENGTH_IS_VARIABLE
  • PARALLELISM_CONFIG_SP_ATTN_IMPLEMENTATION
  • PARALLELISM_CONFIG_SP_ALLOW_RECURRENT_LAYERS
  • PARALLELISM_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