序列并行：四位书生分读百米长卷

可视化演示

动态演示序列并行Sequence P的核心机制，通过全局/局部/动态/静态四种模式展示关键概念与交互流程。

由来与动机

藏书阁的竹简越编越长，从 1 万字写到 12.8 万字，一个书生的书桌彻底放不下了。于是四人采用“张量并行”：每人负责一种注疏方式——甲注音、乙释义、丙句读、丁点评，相当于把每个字的特征维度（hidden size）切成四份。可问题是，四人仍然要把 100 米长的竹简从头到尾通读一遍，每读一个字都要在自己的本子上写下批注（激活值）。一百米读下来，每个人的桌面都堆满了笔记，显存照样爆掉。

这时有人提出一个关键观察：既然四个人都要逐字读完全文，与其每人读全卷、各注一行，不如按地段分工——甲读 0 到 25 米，乙读 25 到 50 米，丙读 50 到 75 米，丁读 75 到 100 米。这个思路就是序列并行：把序列长度维度 S 切成 N 份，每张卡只需处理属于自己的 S/N 个 token。它与张量并行并不冲突，而是互补——张量并行走“纵向”切 hidden，序列并行走“横向”切序列，两者叠在一起，桌面上的笔记才会真正变少。

Transformer 单层激活的显存占用可以表示为：

$$\displaystyle M_{\text{act}} \propto b \times s \times h$$

1. b（batch size）：一次喂给模型几条样本，相当于同时抄录几卷竹简。

$$b$$

2. s（sequence length）：每条样本的 token 数，也就是长卷的字数，序列并行要切分的正是它。

$$s$$

3. h（hidden size）：每个 token 的隐藏特征数，张量并行沿它切分。

$$h$$

4. 整体含义：三个因子中，只有 s 可以被“按地段分工”直接缩小 N 倍，这正是序列并行省显存的起点。

$$M_{\text{act}} \propto b \times s \times h$$

分地段读长卷让每人的笔记量直接变为原来的四分之一，但这只是故事的开始。真正让序列并行成立的，是长卷中“总批注”与“逐段注疏”的分工，我们接着看。

核心原理

四位书生分好地段后，遇到了新麻烦：竹简上有些地方要求“先通读全卷再写总批”。Transformer 里的 LayerNorm 和 Dropout 就是这样的环节——LayerNorm 需要统计整个 token 的特征分布（均值、方差）才能做归一化，在张量并行下，它必须先把被切碎的 hidden 维拼回完整向量才能计算。而 MLP、Attention 中的矩阵乘法，则是“逐 token 独立”的：每个位置的向量变换只跟它自己那一列有关，完全可以各算各的。

序列并行的核心布局因此诞生：在 LayerNorm 之前，四张卡通过 AllGather 把各自手里的序列段拼成完整长卷，统一做完 LayerNorm/Dropout 之后，再用 ReduceScatter 把序列切回四段，各自继续在本地做 MLP 与 Attention 的矩阵乘法。也就是说，每一层 Transformer 只在这两个“总批”点发生跨卡通信，其余时间大家埋头各读各的段。

这个数据流可以用一个简洁的式子表示，第 i 张卡的输出来自对完整序列做 LayerNorm 后再切回第 i 段：

$$\displaystyle X'_i = \text{LN}\Big(\text{Concat}(X_1, X_2, \dots, X_N)\Big)_i,\qquad i = 1, 2, \dots, N$$

1. Concat(X₁, …, X_N)：AllGather 的数学表达，把 N 张卡各自持有的序列段沿序列维度首尾相接。

$$\text{Concat}(X_1, X_2, \dots, X_N)$$

2. LN(·)：对拼接后的完整序列做 LayerNorm，统计量在隐藏维上计算，需要看到全部序列段。

$$\text{LN}(\cdot)$$

3. 下标 i：归一化完成后，按第 i 卡负责的序列位置切回第 i 段，得到本地结果。

$$(\cdot)_i$$

4. 整体流程：每次 LayerNorm 前后各发生一次全卡通信，之后 MLP 和注意力投影都在本地段上完成，无需跨卡。

$$\text{AllGather} \to \text{LN} \to \text{ReduceScatter} \to \text{本地 MLP/Attention}$$

四书生的抄书流程从“每读一字都要对注释”变成了“只在总批处碰头”，计算效率与显存占用同时得到改善。那么，笔记到底是怎样变少的？下一节细看激活值切分。

激活值切分

在张量并行时代，四人各写各的注疏，可每当遇到总批（LayerNorm），每个人都要把整卷 100 米的内容抄一份到自己的本子上——四张卡各存一份完整序列的激活，冗余极其严重。序列并行改变了笔记的存放方式：总批写完，立刻按地段拆开，甲只保留 0 到 25 米的批注，乙只保留 25 到 50 米，以此类推。四份完整笔记变成四段互补笔记，总量恰好等于一份。

这意味着每张卡的激活内存从“完整序列”降为“完整序列除以卡数”。对于超长序列训练，这是决定成败的优化。具体到存储量上：

$$\displaystyle M_{\text{TP}} = O(b \times s \times h), \qquad M_{\text{SP}} = O\!\left(\frac{b \times s \times h}{N}\right)$$

1. M_TP：张量并行模式下，LayerNorm/Dropout 的输出每卡都存一份完整拷贝，所以是 b×s×h 量级。

$$M_{\text{TP}} = O(b \times s \times h)$$

2. M_SP：序列并行模式下，每卡只存自己负责的序列段。

$$M_{\text{SP}} = O\left(\frac{b \times s \times h}{N}\right)$$

3. N（卡数）：切分的份数。四卡省四倍，八卡省八倍，卡越多，单卡激活越小。

$$N$$

4. 对比结论：SP 不是把显存“优化”掉，而是把原本重复存储的冗余去掉，让每卡只保留必要的那一份。

$$M_{\text{SP}} = M_{\text{TP}} / N$$

四人的桌面终于清爽了：每人不再摊开 100 米的长卷，而是只摊自己那 25 米。不过，拼卷和拆卷势必产生传纸条的通信开销，这些开销与原来的张量并行相比如何？我们来看通信设计。

通信设计

四位书生传纸条的方式发生了变化。张量并行时，每读完一个字，四个人就要互相核对一次注疏——对应每层 Transformer 的两次 AllReduce，通信频繁且每次都要传整个序列。序列并行把传纸条集中到了两个节点：LayerNorm 前需要 AllGather（每人把自己 25 米的内容报给大家，拼出 100 米全卷），LayerNorm 后需要 ReduceScatter（把总批结果按地段拆回各人）。每层也恰好是两次汇聚加两次拆分。

很多人误以为序列并行是为了“省通信”，其实严谨的说法是：总通信量没有下降，与张量并行同阶。它的真正收益在于消除了重复计算和冗余存储——LayerNorm 和 Dropout 不再由四张卡各自全量算一遍，而是每卡只算自己那四分之一。通信结构则变得与数据并行更相似，方便系统调度和重叠。

通信量对比可以写成：

$$\displaystyle C_{\text{TP}} = 2 \times O(b\,s\,h), \qquad C_{\text{SP}} = 2 \times O(b\,s\,h)$$

1. C_TP：张量并行每层需要 2 次 AllReduce，每次通信量为 b×s×h。

$$C_{\text{TP}} = 2 \times O(b\,s\,h)$$

2. C_SP：序列并行每层需要 2 次 AllGather 与 2 次 ReduceScatter，合并后同样是 b×s×h 量级。

$$C_{\text{SP}} = 2 \times O(b\,s\,h)$$

3. AllGather：把各卡序列段收集拼接，属于“大家把拼图交出来”。

$$\text{AllGather}(X_1, \dots, X_N) = \text{Concat}(X_1, \dots, X_N)$$

4. ReduceScatter：对拼接结果做规约后再按序列段切分回各卡，属于“拼完再拆”。

$$\text{ReduceScatter}(Y) = (Y_1, \dots, Y_N)$$

传纸条的次数和字数没有减少，但四人本子上重复的笔记没了。这是理解序列并行最重要的心态转变：它不省通信，省显存、去冗余。接下来，把显存账本摊开，看看它和 ZeRO 如何各管一摊。

ZeRO配合

抄书除了桌上要摊笔记（激活值），几位书生脑子里还得记住“校勘表”——哪些字是通假字、哪里要加批注、明天修改哪些地方，对应模型训练中的参数、梯度和优化器状态。校勘表非常占地方，于是 ZeRO 出场了：它把这张表切成 N 份，每人只记四分之一，用的时候再互相借阅。序列并行则专管桌上的笔记（激活值），两者各管一摊，互不干扰又完美互补。

实际工程中，显存账本大致由三块构成：模型状态（ZeRO 负责切分）、激活值（序列并行负责切分）、以及少量碎片和通信缓冲。把三项都压到最低，才能装下超大模型和超长序列：

$$\displaystyle \text{总显存} \approx \frac{\Phi_{\text{模型状态}}}{N_{\text{ZeRO}}} + \frac{M_{\text{激活}}}{N_{\text{SP}}} + C$$

1. Φ_model（模型状态）：参数、梯度、优化器状态三者合称，ZeRO 将它们在卡间切分。

$$\Phi_{\text{模型状态}} = \Phi_{\text{参数}} + \Phi_{\text{梯度}} + \Phi_{\text{优化器}}$$

2. N_ZeRO（ZeRO 切分度）：ZeRO-1/2/3 分别切优化器、梯度、参数，切分度越高每卡越省。

$$N_{\text{ZeRO}}$$

3. M_激活 / N_SP：序列并行将激活值按序列段切分到 N 张卡上。

$$\frac{M_{\text{激活}}}{N_{\text{SP}}}$$

4. C（常数项）：激活重计算、通信缓冲、显存碎片等固定开销，不属于任一并行策略直接管辖。

$$C$$

四位书生的“脑内校勘表”和“桌上笔记”都瘦了身，长卷终于可以继续加长。那么，把 100 米竹简换成 500 米，序列并行还能撑住吗？下面看长上下文优势。

长上下文优势

当竹简从 100 米加长到 500 米，四位书生又不够用了——但这次解法很直接：从四人扩到十六人，每人仍然只读 25 米。序列并行让激活显存随卡数线性摊分，因此显存允许的序列长度上限，可以随 GPU 数量的增加近乎线性地扩展。这正是 128K、1M 上下文模型能够训练出来的底层原因之一。

当然，序列并行的优势不是孤立的：它需要 FlashAttention 这类技术把注意力的 O(S²) 计算量和 KVCache 降下来，需要 ZeRO 把模型状态摊分掉，甚至需要流水并行把层数切分到不同设备上。业界实践中，Megatron-LM 的 Sequence Parallelism 与张量并行深度融合，DeepSpeed 的 Ulysses 也采用类似的序列切分思路——它们共同支撑起长上下文大模型的训练与推理。

在“激活显存受限且序列并行开启”的理想条件下，可训练的最大序列长度与卡数成正比：

$$\displaystyle s_{\max}^{(SP)} \propto N_{\text{GPU}} \times s_{\max}^{(\text{单卡})}$$

1. s_max（单卡）：单张卡在有限显存内能处理的最大序列长度，受激活大小限制。

$$s_{\max}^{(\text{单卡})}$$

2. N_GPU（卡数）：序列并行划分的份数，卡数翻倍，每卡负担的序列段减半。

$$N_{\text{GPU}}$$

3. 线性关系：卡数越多，能拼出的完整序列越长，这就是长上下文训练的可扩展性。

$$s_{\max}^{(SP)} \propto N_{\text{GPU}}$$

4. 前提条件：该式成立需要激活重计算、注意力优化等措施保证激活不成为新的瓶颈。

$$\text{FlashAttention} + \text{ZeRO} + \text{SP}$$

从 100 米到 500 米，十六位书生接力诵读，每个人桌上的笔记依然只有 25 米。序列并行让“长”不再是显存的天花板，而是通过堆卡就能换来的线性扩展能力。

AI 应用场景

Python 演示

import numpy as np def layer_norm(x, eps=1e-5):    """Standard LayerNorm over the last dimension."""    mean = x.mean(axis=-1, keepdims=True)    var = x.var(axis=-1, keepdims=True)    return (x - mean) / np.sqrt(var + eps)  def simulate_sequence_parallel():    B, S, H = 2, 128, 64   # batch, sequence length, hidden size    N = 4                  # number of GPUs    chunk = S // N         # local sequence length per GPU     rng = np.random.default_rng(42)    X = rng.standard_normal((B, S, H)).astype(np.float32)    W = rng.standard_normal((H, H)).astype(np.float32)     # Baseline: tensor parallelism stores full sequence activation per GPU    act_tp = X.nbytes     # Sequence parallelism: activation split along sequence dim    act_sp = X[:, :chunk, :].nbytes     # Forward with SP: each GPU computes MLP on its own segment    local_outs = []    for i in range(N):        x_local = X[:, i * chunk:(i + 1) * chunk, :]        local_outs.append(x_local @ W)    # AllGather: concatenate segments to recover full sequence    gathered = np.concatenate(local_outs, axis=1)    # LayerNorm needs the full sequence (global statistics on hidden dim)    normed = layer_norm(gathered)    # ReduceScatter: split back to segments for the next stage    after_sp = [normed[:, i * chunk:(i + 1) * chunk, :] for i in range(N)]     print("每卡激活字节数(TP):", act_tp)    print("每卡激活字节数(SP):", act_sp)    print("SP 节省比例: {:.1%}".format(1 - act_sp / act_tp))    print("SP 前向结果形状:", normed.shape, "分段数量:", len(after_sp))    print("结果数值有效:", bool(np.isfinite(normed).all()))  if __name__ == "__main__":    simulate_sequence_parallel()

1. chunk = S // N计算每张卡分到的序列段长度，这是序列切分的起点。
2. act_tp = X.nbytes张量并行基线：每卡都持有完整序列的激活，显存占用全额计算。
3. act_sp = X[:, :chunk, :].nbytes序列并行下每卡只持有自己那一段激活，字节数直接除以卡数。
4. x_local @ W每张卡在本地序列段上独立完成矩阵乘法，全程无需跨卡通信。
5. np.concatenate(local_outs, axis=1)模拟 AllGather：沿序列维把四个分段拼回完整序列。
6. layer_norm(gathered)LayerNorm 必须拿到完整序列才能计算隐藏维上的均值与方差。
7. normed[:, i * chunk:(i + 1) * chunk, :]模拟 ReduceScatter：归一化结果按段切回各卡，供下一阶段继续本地计算。

常见误区

面试题