Accelerate documentation
🤗 accelerate 中的上下文并行
🤗 accelerate 中的上下文并行
本指南将介绍在 🤗accelerate 中使用上下文并行的基础知识,对于更感兴趣的读者,我们还会在后续章节中介绍一些技术细节。
另请参阅非常相关的序列并行指南。
为什么需要上下文并行?
随着大语言模型以及近期推理模型的兴起,序列长度正在快速增长。加之注意力机制具有二次方级的内存复杂度,这使得我们需要更高效的方式来训练长序列模型。
当序列长度为 128k 时,在采用原生注意力实现的情况下,注意力矩阵的内存需求为 128k * 128k * 2 bytes * num_heads = ~32 GB * num_heads(bf16 精度)。当然,如果使用 flash attention 或 SDPA 这类不会显式生成注意力权重的技术,内存需求会大幅降低,但其增长幅度依然相当可观。
上下文并行允许我们将注意力计算的输入沿序列维度进行分片,并在多个 GPU 上并行计算注意力。借助此技术,我们可以训练具有长序列的模型,序列长度可扩展至 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,则会引发错误。
上下文并行仅在 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 个 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],则应传入buffer_seq_dims=[1, 1],因为序列维度是张量的第二个维度。这对于正确计算模型输出是必需的。no_restore_buffers:上下文并行的实现会就地修改缓冲区,将其转换为torch.distributed.tensor.Dtensor。在上下文管理器退出后,需要启动一个通信内核才能将缓冲区恢复到原始状态(通常是 all-gather)。这需要一定时间,因此建议传入与buffers参数相同的张量,以避免不必要的通信,除非你确定需要在上下文管理器退出后使用这些缓冲区。
上下文并行与
labels不兼容,当labels是input_ids的副本时,🤗 transformers 中的模型可以自行移位以启用因果语言建模。 想象一下这种情况:labels= [l1, l2, l3, l4, … li] 如果我们应用上下文并行,每个 rank 最终会获得一部分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传入模型之前,您需要手动对labels进行移位
可配置选项
Accelerate 仅提供一个配置上下文并行的选项(cp_size 除外)
cp_comm_strategy:用于分片的旋转方法。我们强烈建议将其保持为"allgather",因为在大多数情况下,它很可能比"alltoall"表现更好。
上下文并行大小(Context parallel size)的含义比较直观,即输入数据被分片(sharded)所跨越的 rank 数量。 上下文并行分片轮换(Context parallel shard rotation)定义了输入数据的分片如何在各个 rank 之间进行轮换。我们将在下一节中详细介绍这两种选项。
您可以在 ND 并行示例 文件中查看一个端到端的示例,该示例展示了如何在单个 8xH100 节点上训练一个 8B 模型,上下文长度最高可达 128k。使用多节点训练,您可以将其扩展到多 GPU 上处理 1M+ 的序列长度。您还可以将其与其他并行策略无缝结合,以满足您的需求。
技术细节
本节内容较为技术性,如果您不需要了解上下文并行的内部机制,可以跳过本节,直接开始构建 🚀
在接下来的章节中,我们将大量使用shard一词,因此我们先来定义它。如果我们将张量沿Dth维度在N个 rank 上称为sharded,是指该张量被拆分为N个部分,其中每个部分的形状为[..., D//N, ...]。
那么它是如何工作的呢?
上下文并行通过沿序列维度对Q, K and V矩阵进行分片来实现。每个 rank 拥有其分配的Q分片,我们将其称为Q_i。在整个计算过程中,该矩阵仅驻留在该 rank 上。类似地,每个 rank 拥有自己的K和V分片,我们将其分别称为K_i和V_i。随后,每个 rank 使用其自身的Q_i、K_i和V_i分片来计算注意力,我们将其称为attn_i。在此计算期间,会启动一个通信内核,以从所有其他 rank 收集Ks和Vs。所使用的通信原语取决于context_parallel_shard_rotation选项。
通过这种方式,每个 rank 首先使用Q_i、K_i和V_i计算局部注意力,然后使用来自所有其他 rank 的K_j和V_j进行计算。由于每个 rank 持有的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,以收集来自所有其他 rank 的所有 Ks 和 Vs。当该通信完成后,每个 rank 都拥有了来自所有其他 rank 的 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.
您可以在下图的性能分析器输出中直接看到此问题:
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 的通信与注意力的计算完全重叠。
图 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 子组中的每个 rank 都会收到同一批数据。)同时,我们也会向 dp_shard 组中的每个 rank 分发不同的批次。
可以这样理解:
# 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.