Skip to content

张量并行、序列并行与上下文并行(TP / SP / CP)

精解 Megatron-LM 列行张量并行、零增量通信序列并行与 Ring/Ulysses 上下文并行。

当前:讲解模式 — 侧重直觉建立、生活类比与分步拆解快捷键 M 切换
概念定义 · 什么是张量并行(TP)、序列并行(SP)与上下文并行(CP)?

当模型单层权重巨大,或者单条训练文本长达几十万 Token 时,光靠数据并行切批次已经装不下了,必须把单个矩阵乘法或单条长文本本身横着、竖着切开塞进多张卡。

张量并行(TP) 把一层里的权重矩阵按行/列切给同机多卡合算;序列并行(SP) 顺手把归一化层和残差激活按序列长度切开省显存;上下文并行(CP,如 Ring Attention / Ulysses) 则专治超长文本,把几十万字切成多段分给不同卡,像接力传球一样轮流交换 KV 块算出完整注意力。

01 问题从何而来:当单层矩阵或一条长文本就把显存撑爆了 ​

前面讲过的 ZeRO / FSDP 虽然能把静态模型参数切分到几十张卡上,但它有一个前提:算到某一层时,单张 GPU 必须能临时装下这一层的完整权重,并独自啃完一整条输入序列的全部激活。

可当模型宽度飙升到 h=8192 甚至 16384,或者你在做 128K 到 1M Token 的 长上下文建模 训练时,这个前提瞬间失效了——光是单条十万字文章在 自注意力机制 和前馈层里产生的中间激活,就能把一张 80GB H100 直接撑爆!这时候,我们必须挥刀剖开单个 Transformer 层内部,沿着“隐藏特征维度”或“文本序列长度”把同一层的计算掰碎了分给多张卡合作完成——这就是 TP(张量并行)、SP(序列并行) 和 CP(上下文并行) 三兄弟的由来。

类比 · 大型翻译车间的三种“内部分工”

把处理一篇十万字超长原著的单个 Transformer 层,想象成一个由 8 位译员(8 张 GPU)组成的翻译车间:

  • 张量并行(TP):把那本巨厚无比的专业词典横向撕成 8 册,每人专攻 1/8 的词汇特征维度,每完成一大段翻译,大家把各自算出的半成品汇总核对一次总账;
  • 序列并行(SP):译员们发现,到了校对标点和排版(LayerNorm、Dropout、残差相加)这种不查大词典的轻量环节,8 个人每人从头到尾重复校对整本十万字原著太浪费桌面了!于是顺手把原著按页拆成 8 份,每人只校对 1/8 页;
  • 上下文并行(CP):原著暴涨到一百万字,连自注意力草稿纸都摊不开了。8 位译员围坐成一张圆桌,每人只拿 1/8 原著,把自己的笔记顺时针传阅一圈就能通读全书(Ring Attention),或者干脆临时按“人物线索/时间线索(注意力头)”互换笔记(Ulysses)!
核心设问

怎么切分两层相连的矩阵乘法,才能避免每算完一层就停下来疯狂同步通信?SP 号称能把非 TP 区的激活显存砍到 1/Nt 却“一字节额外通信都不花”,这怎么可能不违背能量守恒?面对百万 Token 的长序列,Ring Attention 和 Ulysses 又是如何把全长注意力拆开算且精确无损的?

02 核心直觉与生活类比:列行配对、零成本 SP 与圆桌传笔记 ​

这三个层内并行方案之所以成为现代集群的教科书典范,全靠三个极其精妙的数学与通信巧思。

类比 · TP 列并行 + 行并行:为什么两层矩阵必须“一竖切、一横切”?

如果把 MLP 的两层线性变换 Y=GeLU(XA)B 随便切,算完 XA 要同步一次、算完 B 又要同步一次,通信直接翻倍。Megatron-LM (2019) ↗ 想出绝配切法:

  • 第一层 A 竖着切(Column Parallel):每张卡各算出一小段输出列 XAi。因为后面的激活函数 GeLU 是逐元素独立算的,完全不用通信,每张卡本地直接把 GeLU(XAi) 算完!
  • 第二层 B 横着切(Row Parallel):每张卡手里的局部输出 Zi 刚好和本地横切块 Bi 维度严丝合缝,乘完得到局部结果 Yi=ZiBi,最后全员做仅仅 1 次 All-Reduce 求和,拼出来的 Y=∑iYi 和单卡完整计算数学上分毫不差!

多头自注意力更是天生适配:WQ,WK,WV 按注意力头竖着切,每张卡自己算完分到的那几个头,再把输出投影 WO 横着切,末尾同样只要 1 次 All-Reduce。整个 Transformer 层前向拢共只需要 2 次同步!

类比 · SP 序列并行:拆开 All-Reduce,免费白嫖 8 倍激活省显存

纯 TP 有个隐藏浪费:在 LayerNorm、Dropout 和残差连接处,8 张卡上存着 8 份一模一样的完整序列激活。Megatron-SP (2023) ↗ 盯着 TP 末尾的 All-Reduce 灵机一动——前面学过,一次 All-Reduce 本质上就是一次 Reduce-Scatter 加一次 All-Gather!

那我们直接把这对孪生操作从中间掰开不就行了?

  • 走出横切线性层时,只做 Reduce-Scatter(顺手把结果沿序列长度切成 8 份,每卡只拿 S/8);
  • 接下来的 Dropout、残差加、RMSNorm / LayerNorm 全都是逐词独立操作,每卡在 S/8 的小碎片上各自飞快算完,激活显存直降 8 倍;
  • 等要进下一个竖切线性层前,再补上原本就欠着的那次 All-Gather 拼回全长 S!

合起来还是 Reduce-Scatter + All-Gather,总通信字节数与纯 TP 精确相等(0% 额外通信),却白白抹掉了非 TP 区的全部冗余激活!

类比 · CP 上下文并行:圆桌传纸条(Ring)vs 交换分工表(Ulysses)

如果文章长到 512K,哪怕进了 Attention 也装不下完整序列,就轮到 CP 登场:

  • Ring Attention(arXiv ↗):每张卡死守自己的查询段 Qi,把自己的键值对 (Ki,Vi) 沿着 GPU 圆桌顺时针传给下一张卡。每收到一块新 (Kj,Vj),就用 FlashAttention 的在线 Softmax 公式增量更新一次注意力结果——妙处在于 “左手算当前块注意力,右手同步传下一块 KV”,只要文章够长,通信时间被完全藏进计算时间里!
  • DeepSpeed Ulysses(arXiv ↗):换个维度破局!平时按序列长度切(每卡 S/Nc 长度、全部 H 个头);一到 Attention 门口,全员执行一次 All-to-All 乾坤大挪移,瞬间切换成“每卡拿完整长度 S、但只管 H/Nc 个注意力头”,直接调单卡 FlashAttention 一气呵成,算完再做一次 All-to-All 换回序列切分!

03 把关键公式读成人话 ​

先看 Megatron-LM 列并行 + 行并行零中间通信的矩阵分块恒等式:

Y=GeLU(X[A1⋯ANt])[B1⋮BNt]=∑i=1NtGeLU(XAi)Bi⏟第 i 张卡完全独立计算

**把 TP 矩阵分块读成直觉:**左边的 A 竖切、右边的 B 横切,夹在中间的逐元素激活函数 GeLU 就像透明玻璃一样直接穿透分块边界。每张卡只拿着自己的一片 Ai 和 Bi 闭门造车,算出自己的局部贡献矩阵,最后大家把所有局部结果加起来(All-Reduce),和单卡硬算一模一样。

再看 SP 零额外通信的底层恒等式:

All-Reduce(Y)≡All-Gather入层前(Norm / Dropout在 S/Nt 上独立算(Reduce-Scatter出层后(Y)))

**把 SP 拆解式读成直觉:**原本在出口一口气做完的 Reduce-Scatter + All-Gather,被 SP 巧妙地把后半步 All-Gather 推迟到了下一层的入口。夹在中间的整片非线性区域于是天然运行在 1/Nt 的迷你序列上,省下海量显存,通信账单却一分钱没多收!

04 它在模型里怎么工作 & 与上下游的关系 ​

在多机万卡集群的硬件拓扑里,TP / SP / CP 各守其位,形成清晰的立体分工:

  • 机内高速 NVLink 跑 TP + SP:TP 每层前反向都要同步 4 次,极其吃通信带宽和延迟,因此工业界有一条铁律——严格把 TP 限制在单机 8 卡 NVLink 内部(Nt≤8),并且只要开了 TP 就无条件绑定开启 SP。
  • 跨机长文本交给 CP(或 USP 2D 混合):当训练进入 128K–1M 扩窗阶段,单靠 SP 扛不住 Attention 的长序列显存,就叠加上下文并行 CP。实际部署中常把机内 Ulysses(吃满 NVLink 双向带宽)和机间 Ring Attention 拼成 USP(arXiv ↗),既突破 GQA 注意力头数限制,又能跨多机线性拉长上下文。
  • 与外层并行和显存优化无缝拼装:TP/SP/CP 解决的是层内宽度与长度爆炸;跨层深度交给 流水线与专家并行 (PP/EP),跨样本吞吐交给 数据并行与 ZeRO,剩余的激活峰值再由 训练显存全景优化 中的选择性重计算兜底。

05 演化对比与避坑备忘 ​

并行技术切分维度权重显存激活显存核心通信原语典型瓶颈与上限
TP (Megatron)隐藏维 / 注意力头1/N仅线性层内 1/N每层 2 次 All-Reduce受限 NVLink 与 Hkv,一般 N≤8
TP + SP线性层隐藏维 + 其余序列维1/N全层近似 1/NRS + AG(零额外通信)同 TP,几乎无理由不绑定开启
CP: Ring Attention全层序列维 (S)不切分全层 1/NP2P 异步环形传 KV序列够长才能藏住通信,无头数上限
CP: Ulysses序列维 ↔ 头维转置不切分全层 1/NAttention 前后 All-to-All硬上限 N≤H(GQA 需防 KV 复制)

工程实操中最容易踩的三个隐蔽大坑:

  1. 开启 SP 后忘了同步 LayerNorm / RMSNorm 的梯度:SP 虽然把激活按序列切给了 8 张卡,但 RMSNorm / LayerNorm 的权重本身在 8 张卡上还是完整复制的。每张卡只看了 1/8 句子的激活,算出的 Norm 梯度只是局部和——如果优化器更新前忘了对这些 SP 复制参数额外做一次跨 TP 组的 All-Reduce,8 张卡的 Norm 权重跑几步就会彻底分家!
  2. 在 GQA 模型上盲目拉大 TP 超过 KV 头数:像 LLaMA-3 70B 采用了 GQA 只有 8 个 KV 头。如果硬开 TP=16,只能把每个 KV 头强行复制两份并额外同步梯度,越扩越亏。
  3. 因果 Ring Attention 傻傻按顺序切分,引发严重“木桶效应”:因为因果掩码是个下三角形,如果把文章前 1/8 给 0 号卡、最后 1/8 给 7 号卡,0 号卡只需要算极小一块三角早早收工发呆,7 号卡却要苦哈哈算满整块三角,全集群白白浪费近一半算力!工业界一律采用 Zig-Zag 交错配对切分(把文章切成 2Nc 段,0 号卡拿第 1 段拼最后 1 段,以此类推),让每张卡的三角面积绝对均等。

需要查阅 Megatron-LM 算子共轭推导、TP+SP 单层 Mermaid 数据流图以及可验证精确等价的 verify_megatron_tp_mlp 与 ring_attention_online_softmax_sim 代码?按快捷键 M 或点击顶部 技术 Wiki 随时切换。

当模型单层隐藏维度高达 h=8192–16384,或者 长上下文建模 训练序列长度飙升至 128K–1M Tokens 时,哪怕仅切分 数据并行 或按层 流水线并行 切分,单个 Transformer 层的矩阵权重或激活张量本身都可能击穿单卡 HBM 容量与计算延迟上限。张量并行(Tensor Parallelism, TP)、序列并行(Sequence Parallelism, SP) 与上下文并行(Context Parallelism, CP) 代表了三种层内(Intra-layer)细粒度切分范式:分别沿隐藏/头维度与序列长度维度解剖单个 Transformer Block,在高速互联拓扑上实现近乎无损的并行扩展。

直观理解

可以把处理一篇十万字超长文章的单个 Transformer 层想象成一个大型翻译车间:张量并行(TP) 是把庞大的词典和专家团队横向拆给 8 位工匠,每人只负责查自己那 1/8 的特征维度,每完成一大步大家核对一次总账;序列并行(SP) 发现在不用查大词典的轻量环节(如 LayerNorm 校对),让 8 个人每人重复校对整篇文章太浪费桌面,于是把文章按页均分给 8 人各自校对;而当文章长到百万字连注意力草稿纸都摊不开时,上下文并行(CP) 让 8 位工匠围成圆桌,每人手握 1/8 篇文章并把自己的笔记顺时针传阅一圈(Ring Attention),或临时按注意力头分工互换笔记(Ulysses),从而合力读懂整篇巨著。

问题动机与演进背景 ​

  1. 为什么 Megatron-LM TP 不能随意逐层独立切分? 如果对每一个线性层都单独切分并立即同步,MLP 两层与 Attention 四层线性投影将触发海量阻塞式 All-Reduce 通信。Megatron-LM 的精妙之处在于将两层矩阵配对为 “先列切分(ColumnParallel)+ 后行切分(RowParallel)”,使中间激活天然保持切分形态直接穿过逐元素激活函数(GeLU/SwiGLU)与多头注意力计算,将整个 Transformer 层的同步压缩至仅 2 次前向 All-Reduce 与 2 次反向 All-Reduce。
  2. TP 的残余激活冗余与 SP 的诞生 在纯 TP 中,LayerNorm、Dropout、残差连接(Residual Add)以及进入并行线性层前的输入激活在所有 Nt 张 TP 卡上是完全冗余复制的。当序列长度 S 增大时,这部分未经切分的激活反而成为显存主导项。Megatron-SP(Sequence Parallelism) 发现,只需将 TP 边界的 All-Reduce 拆解为等价的 Reduce-Scatter + All-Gather,即可在总通信量绝对不变(零额外通信字节) 的前提下,顺手把所有非 TP 区域的激活沿序列维 S 切分为 1/Nt!
  3. 迈向 128K–1M 长文本的上下文并行(CP) Megatron-SP 仅在 LayerNorm/Dropout 处切分序列,进入 Attention 计算前仍需 All-Gather 恢复完整序列 S,且受限于注意力头数(特别是 GQA 中 KV 头数常仅为 8,导致 TP 度上限被锁死在 8)。面向超长序列,上下文并行(CP) 将完整序列在包括 Attention 在内的全部算子上全程切分给 Nc 张卡,演化出 Ring Attention(基于 Q/KV 环形接力) 与 DeepSpeed Ulysses(基于序列维与头维 All-to-All 转置) 两大主流流派。

核心原理与数学推导 ​

1. Megatron-LM 张量并行(TP):列并行 + 行并行 ​

考虑一个两层 MLP(以 Y=GeLU(XA)B 为例,其中 X∈Rb×s×h,A∈Rh×4h,B∈R4h×h)。将权重 A 按列切分(Column Parallel)、权重 B 按行切分(Row Parallel) 到 Nt 张 GPU:

A=[A1A2⋯ANt],B=[B1B2⋮BNt]

由于 GeLU 是逐元素算子,满足分块独立性:

GeLU(XA)=[GeLU(XA1)⋯GeLU(XANt)]=[Z1⋯ZNt]

第 i 张卡本地计算局部输出 Yi=ZiBi∈Rb×s×h,最后经一次 All-Reduce(Sum) 合并得到数学上严格等价的完整输出:

Y=∑i=1NtZiBi=∑i=1NtGeLU(XAi)Bi

Multi-Head Attention 的对称切分:由于各个注意力头天然相互独立,将 WQ,WK,WV 按头维度(列并行)切分,每张卡独立完成本地 H/Nt 个头的完整 Self-Attention 计算,再将输出投影矩阵 WO 按行切分,最后执行一次 All-Reduce 汇总。

定义两个共轭分布式算子 f 与 g:

  • f:前向为恒等映射(Identity),反向为 All-Reduce;
  • g:前向为 All-Reduce,反向为恒等映射(Identity)。

于是每个 Transformer Block(Attention + MLP)前向仅需 2 次 All-Reduce,反向仅需 2 次 All-Reduce。每次 All-Reduce 通信激活张量大小为 bsh(BF16 占 2bsh 字节),每层单卡单步总通信量约为 8⋅Nt−1Nt⋅2bsh≈16bsh 字节。

2. 序列并行(SP):零通信增量消除残余激活 ​

回顾 Ring All-Reduce 的恒等分解:

All-Reduce(Y)≡All-Gather(Reduce-Scatter(Y))

Megatron-SP 正是利用这一分解重构了 TP 与非 TP 区域的接口:

  • 在 Attention / MLP 内部仍保持 TP 切分,但退出 RowParallelLinear 时不再执行完整的 All-Reduce,而是仅执行沿序列维 S 切分的 Reduce-Scatter;
  • 此后紧接的 Dropout、Residual Add、LayerNorm / RMSNorm 全部在长度为 s/Nt 的本地序列分片上独立并行执行(完全不跨 Token,数学严格等价);
  • 在进入下一个 Attention / MLP 的 ColumnParallelLinear 之前,再执行一次沿序列维的 All-Gather 拼回完整长度 s。

记算子 f¯ 为“前向 All-Gather、反向 Reduce-Scatter”,g¯ 为“前向 Reduce-Scatter、反向 All-Gather”。每层前向变为 2 次 All-Gather + 2 次 Reduce-Scatter,总通信字节数与纯 TP 的 2 次 All-Reduce 严格相等(0% 额外通信),却将非 TP 区的激活显存精确缩减为原来的 1/Nt!

3. 上下文并行(CP):Ring Attention 与 DeepSpeed Ulysses ​

当序列长度 S 达到 128K–1M 时,必须将输入序列沿长度维切分为 Nc 块 X=[X1,…,XNc](每卡仅存 S/Nc 个 Token 的完整激活)。其中 Linear、Norm、MLP 均为 Token 独立算子,零通信即可直接运行;唯一跨 Token 耦合的瓶颈在于 Self-Attention。业界存在两种核心解法:

方案 A:Ring Attention(环形通信 + 在线 Softmax 归约) ​

每张 GPU i 固定持有自己的查询块 Qi∈R(S/Nc)×d,并初始持有本地的 (Ki,Vi)。算法执行 Nc 轮环形流水线:

  • 在第 r 轮中,GPU i 用本地 Qi 与当前手头收到的 (Kj,Vj) 执行 FlashAttention 局部块计算,并利用在线 Softmax 统计量(局部最大值 m 与归一化分母 l)实时合并输出:mnew=max(mold,mblk),lnew=emold−mnewlold+emblk−mnewlblkOnew=loldemold−mnewOold+lblkemblk−mnewOblklnew
  • 计算与通信完美重叠:就在 GPU i 计算当前块注意力的同时,通过异步 P2P 通信将当前 (Kj,Vj) 发送给环上下游 GPU (i+1)modNc,并从上游接收下一块。只要局部块计算耗时 Tcomp∝(S/Nc)2d 大于通信耗时 Tcomm∝(S/Nc)dkv,通信延迟即可被完全隐藏!
  • 因果掩码负载均衡(Zig-Zag / Striped Ring Attention):若按连续顺序切分序列,由于下三角因果掩码存在,GPU 0 只需算 1/Nc 面积而最后一张卡要算满三角,负载极度不均。工程标准采用 Zig-Zag 交错切分(把序列切成 2Nc 段,第 i 张卡拿第 i 段与倒数第 i 段配对),使每张卡的因果有效计算量严格均等。

方案 B:DeepSpeed Ulysses(序列维 ↔ 头维 All-to-All 转置) ​

Ulysses 换了一个巧妙视角:Attention 跨序列耦合,但跨注意力头完全独立!

  1. 进入 Attention 前,每卡持有形状为 [B, S/N_c, H, d_h] 的 Q,K,V;
  2. 执行一次 All-to-All 集体通信,将“序列维切分”转置为“注意力头维切分”,张量形状变为 [B, S, H/N_c, d_h];
  3. 每卡直接调用原生单卡 FlashAttention,一次性算完本地 H/Nc 个头的全长 S 注意力;
  4. Attention 结束后再执行一次反向 All-to-All,将结果 [B, S, H/N_c, d_h] 转置回 [B, S/N_c, H, d_h] 继续后续 MLP。

Ulysses 通信总量为固定 O(Sd/Nc)(随 Nc 增大反而减小),极适配高带宽 NVLink 域;其唯一硬约束是并行度受限于注意力头数 Nc≤Hkv(在 GQA 中可对 KV 头复制或与 Ring Attention 组合成 USP 混合 2D 上下文并行)。

算法架构与数据流图 ​

下图展示了结合 TP + SP 的标准 Megatron-LM Transformer 层数据流,以及 Ulysses 与 Ring Attention 两种上下文并行的对比:

图表加载中...

复杂度与横向对比 ​

设单层隐藏维度 h、序列长度 S、微批次 b、注意力头数 H(KV 头数 Hkv),并行度为 N:

并行技术切分维度权重显存缩放激活显存缩放核心通信原语扩展度上限与瓶颈典型网络层级
TP (Megatron)隐藏维 / 注意力头维1/N仅线性层内 1/N(Norm/残差冗余)每层 2 次 All-Reduce (FWD)受限于 Hkv 与高通信频次,通常 N≤8机内高速 NVLink
TP + SP线性层隐藏维 + 非线性层序列维1/N全层近似 1/NReduce-Scatter + All-Gather(与 TP 通信量相等)同 TP,几乎无理由不与 TP 绑定开启机内高速 NVLink
CP: Ring Attention全层序列维 (S)不切分(依赖 FSDP/TP)全层 1/N(含长序列 KV)P2P 异步环形传输 KV几乎无上限;需长序列 (S/N 足够大) 隐藏通信机内或跨机 InfiniBand
CP: Ulysses非 Attention 切序列 + Attention 切头不切分(依赖 FSDP/TP)全层 1/NAttention 前后各一次 All-to-All硬上限 N≤H(GQA 时注意 KV 复制开销)高双向带宽 NVLink / RoCE
USP (Ring + Ulysses)2D 混合(机内 Ulysses + 机间 Ring)不切分全层 1/N机内 All-to-All + 机间 P2P Ring突破头数限制并最大化长序列吞吐多机百万级长上下文集群

核心 PyTorch 参考实现 ​

下面代码单机完整演示 Megatron ColumnParallel + RowParallel MLP 的等价性验证,以及 Ring Attention 在线 Softmax 跨块归约 的核心算法逻辑:

python
import math
import torch
import torch.nn.functional as F


def verify_megatron_tp_mlp(tp_size: int = 4, B: int = 2, S: int = 16, H: int = 64):
    """验证 Megatron-LM 列并行 + 行并行 MLP 与单卡完整 MLP 的数学严格等价性。"""
    torch.manual_seed(42)
    X = torch.randn(B, S, H)          # [B, S, H]
    W1 = torch.randn(H, 4 * H) * 0.02 # [H, 4H]
    W2 = torch.randn(4 * H, H) * 0.02 # [4H, H]

    # 1. 单卡参考结果
    ref_out = F.gelu(X @ W1) @ W2     # [B, S, H]

    # 2. 模拟 tp_size 张卡:W1 按列切分,W2 按行切分
    W1_shards = W1.chunk(tp_size, dim=1)  # 每片 [H, 4H/tp]
    W2_shards = W2.chunk(tp_size, dim=0)  # 每片 [4H/tp, H]

    partial_outs = []
    for r in range(tp_size):
        Z_r = F.gelu(X @ W1_shards[r])    # 本地激活无需通信: [B, S, 4H/tp]
        Y_r = Z_r @ W2_shards[r]          # 本地部分和: [B, S, H]
        partial_outs.append(Y_r)

    # 仅需一次 All-Reduce (Sum) 汇总最终输出
    tp_out = torch.stack(partial_outs, dim=0).sum(dim=0)
    max_diff = (ref_out - tp_out).abs().max().item()
    print(f"[TP MLP] 最大数值误差: {max_diff:.2e} (数学严格等价)")


def ring_attention_online_softmax_sim(cp_size: int = 4, B: int = 2, S: int = 64, D: int = 32):
    """模拟 Ring Attention:将 Q/K/V 沿序列切分到 cp_size 张卡,通过环形传递 KV 与在线 Softmax 归约。"""
    torch.manual_seed(7)
    Q = torch.randn(B, S, D)
    K = torch.randn(B, S, D)
    V = torch.randn(B, S, D)
    scale = 1.0 / math.sqrt(D)

    # 1. 标准单卡全序列非因果注意力参考解
    ref_attn = F.softmax((Q @ K.transpose(-2, -1)) * scale, dim=-1) @ V  # [B, S, D]

    # 2. 按序列维均分到 cp_size 张卡
    Q_chunks = list(Q.chunk(cp_size, dim=1))  # 每卡 [B, S/cp, D]
    K_chunks = list(K.chunk(cp_size, dim=1))
    V_chunks = list(V.chunk(cp_size, dim=1))
    S_local = S // cp_size

    # 初始化各卡的在线 Softmax 归约状态: 输出 O、最大值 m、归一化分母 l
    O_acc = [torch.zeros(B, S_local, D) for _ in range(cp_size)]
    m_acc = [torch.full((B, S_local, 1), float("-inf")) for _ in range(cp_size)]
    l_acc = [torch.zeros(B, S_local, 1) for _ in range(cp_size)]

    # 环形传递 cp_size 步:第 step 轮 GPU r 持有来自源 (r - step) % cp_size 的 KV 块
    for step in range(cp_size):
        for r in range(cp_size):
            kv_src = (r - step) % cp_size
            q_r = Q_chunks[r]                     # [B, S_local, D]
            k_j, v_j = K_chunks[kv_src], V_chunks[kv_src]

            # 局部块 FlashAttention 统计量计算
            scores = (q_r @ k_j.transpose(-2, -1)) * scale          # [B, S_local, S_local]
            m_blk = scores.max(dim=-1, keepdim=True).values         # [B, S_local, 1]
            p_blk = torch.exp(scores - m_blk)                       # [B, S_local, S_local]
            l_blk = p_blk.sum(dim=-1, keepdim=True)                 # [B, S_local, 1]
            o_blk = p_blk @ v_j                                     # [B, S_local, D] (未除以 l_blk)

            # 在线 Softmax 增量归约
            m_new = torch.maximum(m_acc[r], m_blk)
            alpha = torch.exp(m_acc[r] - m_new)
            beta = torch.exp(m_blk - m_new)
            l_new = alpha * l_acc[r] + beta * l_blk
            O_acc[r] = (alpha * l_acc[r] * O_acc[r] + beta * o_blk) / l_new
            m_acc[r], l_acc[r] = m_new, l_new

    ring_out = torch.cat(O_acc, dim=1)  # 拼回完整序列验证精度
    max_diff = (ref_attn - ring_out).abs().max().item()
    print(f"[Ring Attention] 最大数值误差: {max_diff:.2e} (在线归约精确等价)")


if __name__ == "__main__":
    verify_megatron_tp_mlp()
    ring_attention_online_softmax_sim()

工程实践与常见陷阱 ​

工程实践

  1. 严格将 TP 限制在单节点高速互联内:由于 TP 在每一层前后都要执行延迟敏感的同步集合通信,跨节点(InfiniBand/RoCE)拉大 TP(如 TP=16)会导致通信耗时激增、MFU 暴跌。工业铁律是:机内 8 卡 NVLink 跑 TP+SP,跨机靠 DP/FSDP、PP 或 CP 扩展。
  2. 异步 TP 通信与 GEMM 细粒度重叠(Async TP / Micro-pipelining):在 ColumnParallel 前的 All-Gather 与 RowParallel 后的 Reduce-Scatter 中,可将张量切分为若干子块,借助 NVSHMEM 或 CUDA Stream 实现“刚收到第一块数据立刻送入矩阵乘”,在 H100 上可再隐藏 30%–50% 的 TP 通信延迟。
  3. SP 下的词表并行交叉熵(VocabParallelCrossEntropy):词嵌入层与输出头 LM Head(形状 [H, V])同样可按词表维 V 切分到 Nt 张 TP 卡,避免把巨大的 [B, S, 128K] Logits 聚合到单卡,仅需跨 TP 卡同步标量级的局部 max 与 sum(exp) 即可完成精确交叉熵计算。

常见陷阱

  1. TP + SP 下的梯度同步遗漏:开启 SP 后,LayerNorm / RMSNorm 的权重在各 TP 卡上仍是完整复制的,但由于每张卡只处理了 1/Nt 的序列分片,它们算出的 Norm 参数梯度只是局部和!因此在优化器更新前,必须对所有 SP 复制参数的梯度额外执行一次跨 TP 组的 All-Reduce(否则各卡 Norm 权重会迅速分叉)。
  2. GQA 架构下 TP 大于 KV 头数的隐性浪费:例如在采用 GQA 的 LLaMA-3 70B 中仅有 Hkv=8 个 KV 头。若强行开启 TP=16,则必须把每个 KV 头复制到两张卡上并额外同步梯度,既增加显存又损失效率。
  3. Ring Attention 未启用 Zig-Zag 导致严重木桶效应:在因果语言建模中结合 FlashAttention 使用朴素连续切分时,最慢的 GPU 算力负载是平均值的近 2 倍,其余 GPU 一半时间都在空等,直接造成近 50% 的算力浪费。务必采用 Zig-Zag 对称配对切分或动态负载均衡策略。

延伸阅读与参考论文 ​

  • Shoeybi, M., et al. (2019). Megatron-LM: Training Multi-Billion Parameter Language Models Using Model Parallelism. NVIDIA. (arXiv:1909.08053 ↗)
  • Korthikanti, V. A., et al. (2023). Reducing Activation Recomputation in Large Transformer Models (Megatron-SP). MLSys 2023. (arXiv:2205.05198 ↗)
  • Liu, H., Zaharia, M., & Abbeel, P. (2023). Ring Attention with Blockwise Transformers for Near-Infinite Context. ICLR 2024. (arXiv:2310.01889 ↗)
  • Jacobs, S. A., et al. (2023). DeepSpeed Ulysses: System Optimizations for Enabling Training of Extreme Long Sequence Transformer Models. (arXiv:2309.14509 ↗)
  • Brandon, W., et al. (2023). Striped Attention: Faster Ring Attention for Causal Transformers. (arXiv:2311.09431 ↗)
  • Fang, J., & Zhao, S. (2024). USP: A Unified Sequence Parallelism Approach for Long Context Generative AI. (arXiv:2405.07719 ↗)