Accelerate documentation

🤗 accelerate における Context Parallel

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v1.16.0).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

🤗 accelerate における Context Parallel

このガイドでは、🤗accelerateでコンテキスト並列性を使用する基本的な内容について説明します。より詳細を知りたい読者のために、後半のセクションでは技術的な側面にも触れます。

関連性の非常に高いシーケンス並列性ガイドも参照してください。

なぜコンテキスト並列性が必要なのか

大規模言語モデル、そして最近の推論モデルの登場により、シーケンス長は急速に伸びています。これにアテンションの二次的なメモリ複雑度が加わったことで、長いシーケンスを持つモデルを訓練するためのより効率的な手法の必要性が高まっています。 シーケンス長が128kの場合、バニラなアテンション実装を前提とすると、bf16精度におけるアテンション行列のメモリ要件は128k * 128k * 2 bytes * num_heads = ~32 GB * num_headsとなります。確かに、これらのアテンション重みを物化しないflash attentionやSDPAを使用すれば、メモリ使用量は大幅に減少しますが、メモリ要件の増加は依然として無視できない規模です。

Context parallelismは、attention計算の入力をシーケンス次元に沿ってシャードし、複数のGPUでattentionを並列に計算することを可能にします。これにより、長いシーケンスを持つモデルの学習が可能になり、潜在的に100万を超えるシーケンス長までスケーリングできます。

コンテキスト並列性の使用方法

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] ...

accelerate config コマンドで cp_size と cp_comm_strategy を設定することもできます。これらは 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を使用しない場合、エラーが発生します。

Context parallelism は SDPA のみで動作し、マスクなしまたは causal mask のみに対応しています。これを適切に検出することはできないため、SDPA をマスクなしまたは causal mask で使用していることを確認する責任はユーザーにあります。その他の attention 実装を使用すると、エラーが発生します。

上記の方法でコンテキスト並列性を有効にした後、トレーニングループに適用できます。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の数を2倍にすると、メモリ使用量が一定に保たれることがわかります。これにより、コンテキスト長の無制限なスケーリングが実現できる可能性があります。

context parallelism memory usage
図1: 最大256kのコンテキストサイズにおけるコンテキスト並列性のメモリ使用量と速度。

これらの例は、examplesフォルダにあるスクリプトで作成されています。8つのH100 GPU(シーケンス長128k)で例を実行するには、以下のコマンドを使用できます。

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

Accelerateのインターフェース

コンテキストマネージャーは、コンテキスト並列性を設定するために使用されるいくつかの引数を受け取ります。

  • buffers: シーケンス次元にシャードされるテンソルのリストです。これらのテンソルは通常、入力 ID、ラベル、アテンションマスクです。
  • buffer_seq_dims: buffers リストの順序に従って、各バッファのシーケンス次元を指定する整数のリストです。buffers=[input_ids, shift_labels] を渡し、両方の形状が [batch_size, sequence_length] である場合、テンソルのシーケンス次元が2番目の次元であるため、buffer_seq_dims=[1, 1] を渡します。これは、モデルの出力を正しく計算するために必要です。
  • no_restore_buffers: コンテキスト並列性の実装は、バッファをインプレースで変更し、torch.distributed.tensor.Dtensorに変換します。コンテキストマネージャーを抜けた後、バッファを元の状態(通常はオールギャザー)に復元するには、通信カーネルの起動が必要です。これには時間がかかるため、コンテキストマネージャーを抜けた後にバッファを使用する必要があると確信している場合を除き、buffers引数と同じテンソルを渡すことをお勧めします。これにより、不要な通信を回避できます。

コンテキスト並列性は、🤗 transformers のモデルが因果言語モデリングを有効にするためにシフトできる input_ids のコピーである labels とは互換性がありません。 次のケースを想像してください。 labels = [l1, l2, l3, l4, … li] コンテキスト並列性を適用すると、各ランクは labels の一部を保持することになります。例えば、以下のように。 labels_rank_0 = [l1, l2], labels_rank_1 = [l3, l4], … transformers のモデリングコードが labels をシフトすると、以下のような結果になります。 labels_rank_0 = [l2, PAD], labels_rank_1 = [l3, PAD], … ここで PAD はパディングトークンです。これにより、labels がもはや入力とアラインされていないため、誤った損失計算が行われることになります。 このため、モデルに渡す前に labels を手動でシフトする必要があります。

設定可能なオプション

Accelerateは、コンテキスト並列性を設定するためのオプションを1つしか提供していません(cp_sizeを除く)。

  • cp_comm_strategy: シャードに使用する回転メソッドです。ほとんどのケースで"alltoall"よりも高性能が期待できるため、"allgather"のままにすることを強く推奨します。

Context parallel size はその名が示す通り、入力がシャード化されるランクの数を指します。 Context parallel shard rotation は、入力のシャードがランク間でどのようにローテーションされるかを定義します。2つのオプションの詳細については、次のセクションで説明します。

ND parallel exampleファイルにエンドツーエンドの例を確認できます。この例では、単一の8xH100ノード上で、最大128kのコンテキスト長を持つ8Bモデルをトレーニングできます。マルチノードトレーニングを使用することで、この設定を複数のGPU上で1M以上のシーケンス長にスケールアップできます。また、ニーズに合わせて他の並列化戦略とシームレスに組み合わせることも可能です。

技術的な詳細

このセクションは比較的技術的な内容です。コンテキスト並列処理の内部構造を学ぶ必要がない場合は、ここをスキップして構築を開始できます 🚀

次のセクションではshardという用語を頻繁に使用するため、まず定義しておきます。テンソルをDth次元に沿ってN個のランクにわたってshardedと呼ぶ場合、これはそのテンソルがN個の部分に分割されていることを意味し、各部分の形状は[..., D//N, ...]となります。

では、どのように動作するのでしょうか?

Context parallelism は、シーケンス次元に沿って 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を計算した(実際には、通常は計算に時間がかかるため、計算を開始する前に)後、他のすべてのランクから他のKsとVsを集めるためにall-gatherを発行します。この通信が完了すると、各ランクは他のすべてのランクからのKsとVsをすべて保有し、それらを用いてアテンションを逐次的に計算できます。 理想的なシナリオでは、attn_iの計算が完了したまさにその瞬間にall-gatherが完了します。しかし、実際にはそのようなことは起こらず、理想的な実効的なオーバーラップは、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
Figure 1: In red you can see the idle time, while we wait for the all-to-all kernel to finish. Highlighted in the first blue bar, you can see that it takes ~250us to finish, which is repeated N-1 times for each attention call, where N is the context parallel size.

なぜFSDP2のみなのか

コンテキスト並列性はFSDP2でのみサポートしています。これは、context_parallel_sizeとdp_shard_sizeのジョイントメッシュを作成し、その全機能を最大限に活用するためです。 動作原理は以下の通りです。サイズcp_size*dp_shard_sizeのジョイントメッシュ全体にモデルをシャーディングし、メモリ削減を最大化します。 これはある種の「フリーランチ」であり、FSDPの通信はアテンションの計算と完全にオーバーラップするためです。以下の画像に示す通りです。

why FSDP2+CP
図2: 青い長方形(Stream 23)では、`FSDP シャードのプリフェッチがアテンションの計算(Stream 7)と完全にオーバーラップしていることがわかります。一方、赤い長方形(Stream 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