当前位置：首页 > news >正文

从 Ring Attention 到 DeepSpeed Ulysses，再到 USP 统一框架

news 2026/5/1 23:41:15

技术日报 2026-04-10

今日主题：序列并行全景深度解析

——从 Ring Attention 到 DeepSpeed Ulysses，再到 USP 统一框架

彻底搞懂超长上下文训练的"第四维并行"

技术背景：为什么需要序列并行？
核心挑战：注意力的平方诅咒
Ring Attention：分块计算 + 环形通信
- 3.1 算法直觉
- 3.2 在线 Softmax：数学基础
- 3.3 计算-通信重叠：流水线实现
- 3.4 因果注意力的负载均衡问题
Striped Attention：修复因果不均衡
DeepSpeed Ulysses：All-to-All 维度转换
- 5.1 算法原理
- 5.2 通信复杂度推导
- 5.3 关键约束：头数整除性
Megatron-LM Context Parallelism：工业级 Ring
USP：统一序列并行框架
- 7.1 二维进程网格
- 7.2 USP-Attn 算法
- 7.3 通信量精确分析
深度对比：Ring vs Ulysses vs USP
与其他并行维度的组合：4D 并行
代码示例：DeepSpeed Ulysses 快速上手
工业实践：主流框架支持情况
选型指南：如何选择序列并行方案
参考资料

一、技术背景：为什么需要序列并行？

大语言模型的上下文窗口在近三年内经历了爆炸式增长：

时间	模型	上下文窗口
2022	GPT-3	4K
2023	Claude 2	100K
2024	Gemini 1.5 Pro	1M
2024	DeepSeek-V3	128K
2025	Kimi 1.5	1M+

更长的上下文意味着更强的 RAG 能力、多轮对话记忆、长文档理解和 Agent 工具调用链。但这也带来了一个不可回避的工程挑战：训练超长上下文的 LLM 需要大量显存。

在三种传统并行方式（数据并行 DP、张量并行 TP、流水线并行 PP，也称"3D 并行"）的基础上，业界引入了第四个维度：序列并行（Sequence Parallelism）/ 上下文并行（Context Parallelism），专门用于在序列（时间步）维度上切分 Attention 计算。

二、核心挑战：注意力的平方诅咒

自注意力计算的显存占用主要来源于注意力矩阵：

$$\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right) \cdot V$$

其中 $QK^T$ 矩阵的大小为 $L \times L$，随序列长度 $L$ 平方增长：

单卡 A100 80G 的近似上限（以 7B 模型为例）：L = 8K  → ~4 GB (注意力矩阵)  ✅ 可行L = 32K → ~64 GB              ✅ 极限L = 128K → ~1 TB              ❌ 单卡不可行L = 1M  → ~60 TB              ❌ 完全不可行

FlashAttention 通过分块计算将 $O(L^2)$ 的显存需求降为 $O(L)$，但计算量（FLOPs）仍然是 $O(L^2)$——单卡的计算时间瓶颈没有解决。这时，序列并行出场：将长序列均分到 $N$ 张 GPU 上，每卡只处理 $L/N$ 的序列，将单卡注意力计算量降到 $O(L^2/N)$。

三、Ring Attention：分块计算 + 环形通信

3.1 算法直觉

论文：Ring Attention with Blockwise Transformers for Near-Infinite Context
作者：Hao Liu, Matei Zaharia, Pieter Abbeel（UC Berkeley）
发表：arXiv:2310.01889，ICLR 2024

Ring Attention 的核心直觉来自一个观察：自注意力的分块计算（Blockwise Attention）可以天然地扩展到多设备环境。

想象 4 张 GPU 排成一个逻辑环（Ring），每张 GPU 持有序列的 $L/4$ 片段：

  ┌──────────────────────────────────────────┐│                                          │GPU 0           GPU 1           GPU 2           GPU 3Q₀,K₀,V₀  →   Q₁,K₁,V₁  →   Q₂,K₂,V₂  →   Q₃,K₃,V₃↑                                                ↓←←←←←←←←←←←← KV 环形传递（P2P）←←←←←←←←←←←←←←

算法流程（4 GPU 为例）：

第 0 轮：每个 GPU 用本地 $Q_i$ 计算与本地 $K_i, V_i$ 的注意力，同时向右传 $K_0, V_0$
第 1 轮：GPU $i$ 收到 $K_{i-1}, V_{i-1}$，继续计算交叉注意力，同时传递 KV 到下一个 GPU
...
第 3 轮：每个 GPU 已见过所有 $K, V$，通过在线 Softmax 累积，得到完整输出 $O_i$

关键性质：经过 $N$ 轮后（$N$ = GPU 数），每张 GPU 上的 $Q_i$ 已经完成了与全部 $K, V$ 的注意力计算——结果与单卡完全一致（无近似）。

3.2 在线 Softmax：数学基础

Ring Attention 的正确性依赖于在线 Softmax（Online Softmax）的数值稳定合并公式，这也是 FlashAttention 的核心数学工具。

设当前处理到第 $j$ 个 KV 块，维护以下中间变量：

$m_j$：到目前为止的全局最大值（用于数值稳定）
$l_j$：累积的 softmax 分母
$O_j$：累积的注意力输出

当收到新的第 $j+1$ 个 KV 块时，更新规则为：

$$m_{j+1} = \max\left(m_j,\ \max_k\left(\frac{q_x \cdot k^{(j+1)}}{\sqrt{d}}\right)\right)$$

$$l_{j+1} = l_j \cdot e^{m_j - m_{j+1}} + \sum_k e^{q_x \cdot k^{(j+1)}/\sqrt{d} - m_{j+1}}$$

$$O_{j+1} = \frac{O_j \cdot l_j \cdot e^{m_j - m_{j+1}} + \sum_k e^{q_x \cdot k^{(j+1)}/\sqrt{d} - m_{j+1}} \cdot v_k^{(j+1)}}{l_{j+1}}$$

这个递推公式保证了：无论以什么顺序、分多少次看到 KV 块，最终结果都等价于一次性看全所有 KV 的 softmax。这是 Ring Attention 能够在不传输全部 KV 的情况下正确计算注意力的数学基础。

3.3 计算-通信重叠：流水线实现

Ring Attention 最关键的工程设计是：当 GPU 正在计算当前 KV 块的注意力时，同时用异步通信发送当前 KV、接收下一轮 KV。

# Ring Attention 核心伪代码
for step in range(num_gpus):# 启动异步 P2P 通信（向右发/从左收）send_handle = dist.isend(current_kv, dst=(rank + 1) % world_size)recv_handle = dist.irecv(next_kv,   src=(rank - 1) % world_size)# 在通信的同时，计算当前 KV 块的注意力local_out, local_lse = flash_attn_block(Q_local, current_kv.K, current_kv.V)# 用在线 Softmax 公式合并结果accum_out, accum_lse = online_softmax_merge(accum_out, accum_lse,local_out, local_lse)# 等待通信完成，切换到下一轮 KVsend_handle.wait()recv_handle.wait()current_kv = next_kv

理想情况：当单步计算时间 $≥$ 单步通信时间时，通信被完全隐藏在计算背后，等效通信开销为 0。

通信量分析：

每步传输的数据量 = $2 \times (L/N) \times d \times \text{sizeof(float16)}$（K 和 V 各一份）
共 $N-1$ 步，总传输量 $≈ 2(N-1) \times (L/N) \times d \approx 2Ld$
当 $N$ 和 $L$ 等比例增大时，每卡通信量 $O(L/N \times d)$ 保持不变 → 线性扩展

3.4 因果注意力的负载均衡问题

对于 GPT 类 Causal Transformer，注意力矩阵是下三角形：

因果注意力矩阵（下三角）：token 0  token 1  ... token L-1
token 0  [   ✓        ✗     ...    ✗    ]  ← 计算量最少
token 1  [   ✓        ✓     ...    ✗    ]...   [  ...      ...    ...   ...   ]
token L-1[   ✓        ✓     ...    ✓    ]  ← 计算量最多

原始 Ring Attention 按顺序切分序列：

GPU 0（前段 token）：计算量 ≈ $(L/N)^2 / 2$（轻载）
GPU N-1（后段 token）：计算量 ≈ $(L/N)^2 \times N / 2$（重载 N 倍！）

这种严重的负载不均衡会导致木桶效应——整体吞吐由最慢的 GPU 决定，轻载 GPU 大量闲置。

四、Striped Attention：修复因果不均衡

论文：Striped Attention: Faster Ring Attention for Causal Transformers
作者：William Brandon 等（MIT）
发表：arXiv:2311.09431，2023年11月

核心思想：不按连续子序列分配 token，而是交错（Striped）分配：

原始 Ring Attention（连续分配）：GPU 0: [token 0,  1,  2,  3 ]  → 只看三角形左上角（少）GPU 1: [token 4,  5,  6,  7 ]  → 中间偏左（少）GPU 2: [token 8,  9,  10, 11]  → 中间偏右（多）GPU 3: [token 12, 13, 14, 15]  → 三角形右下角（最多）Striped Attention（条纹分配）：GPU 0: [token 0,  4,  8,  12]  → 每 4 个取 1 个（均衡）GPU 1: [token 1,  5,  9,  13]  → 均衡GPU 2: [token 2,  6,  10, 14]  → 均衡GPU 3: [token 3,  7,  11, 15]  → 均衡

条纹分配使得每张 GPU 都处理来自序列各个位置的 token，平均下来每个 GPU 的计算量趋于一致。

性能提升（实验数据）：

序列长度	硬件	Striped vs 原始 Ring Attention
256K	A100 GPU / TPUv4	吞吐提升 1.45×
786K	16× TPUv4	吞吐提升 1.65×

对于极长序列，负载均衡优化带来的提升非常显著。这也是后续 Megatron-LM Context Parallelism 采用 "Zigzag" 分配的原因。

五、DeepSpeed Ulysses：All-to-All 维度转换

5.1 算法原理

论文：DeepSpeed Ulysses: System Optimizations for Enabling Training of Extreme Long Sequence Transformer Models
作者：Sam Ade Jacobs 等（Microsoft）
发表：arXiv:2309.14509，2023年9月

Ulysses 的思路与 Ring Attention 截然不同。它不逐步传递 KV，而是通过 All-to-All 集体通信，一次性转换并行维度：

初始状态（序列并行模式）：每个 GPU 持有完整的注意力头（$H$ 个），但只有 $L/P$ 的序列长度：

GPU 0: Q[seq=0..L/P,  heads=all_H] → shape [bs, L/P, H, d_head]
GPU 1: Q[seq=L/P..2L/P, heads=all_H] → shape [bs, L/P, H, d_head]
...
GPU P-1: Q[seq=(P-1)L/P..L, heads=all_H]

All-to-All 通信（QKV 转换）：每个 GPU 将自己的 QKV 片段重排，使每个 GPU 持有完整序列但只负责 $H/P$ 个头：

通信后（头并行模式）：
GPU 0: Q[seq=0..L, heads=0..H/P] → shape [bs, L, H/P, d_head]
GPU 1: Q[seq=0..L, heads=H/P..2H/P]
...

本地注意力计算：每个 GPU 对完整序列计算部分头的注意力（直接调用 FlashAttention），不需要任何特殊处理：

# GPU i 计算第 H/P × i 到 H/P × (i+1) 个头的完整注意力
output_i = flash_attention(Q_full_seq_partial_heads,K_full_seq_partial_heads,V_full_seq_partial_heads)

第二次 All-to-All（恢复序列维度）：将头并行的输出转换回序列并行，恢复原始分布：

通信后（序列并行模式）：
GPU 0: O[seq=0..L/P, heads=all_H]
GPU 1: O[seq=L/P..2L/P, heads=all_H]
...

整个过程共 2 次 All-to-All + 1 次本地 FlashAttention，代码侵入性极低。

5.2 通信复杂度推导

设模型参数：序列长度 $N$，隐藏维度 $h = H \times d_{head}$，并行度 $P$。

操作	数据规模	每链路通信量
QKV All-to-All（前）	$3 \times N \times h$	$3Nh / P$
Output All-to-All（后）	$1 \times N \times h$	$Nh / P$
合计	$4Nh$	$4Nh/P$

复杂度：$O(N/P)$——当 $N$ 和 $P$ 等比例增大时，每链路通信量保持恒定！

与 Megatron-LM 序列并行（AllGather + ReduceScatter）对比：

$$\frac{\text{Megatron SP 通信量}}{\text{Ulysses 通信量}} = \frac{4Nh}{4Nh/P} = P$$

Ulysses 的通信量仅为 Megatron SP 的 $1/P$。在 $P=8$ 时，通信量减少 8 倍。

5.3 关键约束：头数整除性

Ulysses 要求：并行度 $P$ 必须整除注意力头数 $H$（对 GQA 来说是 KV 头数）。

MHA（多头注意力）：heads=32，则最大并行度 P=32
GQA（分组查询注意力）：kv_heads=8，则最大并行度 P=8实际限制（以 Llama 3 70B 为例）：- KV heads = 8- Ulysses 最大并行度 = 8（仅 1 个节点！）

这是 Ulysses 的主要限制：在 GQA/MQA 流行的今天，可扩展性受到 KV 头数的硬约束。

六、Megatron-LM Context Parallelism：工业级 Ring

Megatron-LM 在 2024 年正式引入 Context Parallelism（CP），本质上是经过工业级打磨的 Ring Attention，专门与 FlashAttention-2 深度集成。

核心实现细节

1. Zigzag（之字形）负载均衡切分

将序列等分为 cp_size × 2 块，按 Zigzag 方式分配：

Rank 0：块 [0, 2×cp-1]（首尾配对）
Rank 1：块 [1, 2×cp-2]
Rank k：块 [k, 2×cp-1-k]

每个 GPU 都处理一个前段轻载块和一个后段重载块，计算量趋于均衡。

cp_size = 4，序列 16 个 token，每 token 一个块：Zigzag 分配：Rank 0: [block 0, block 7]   ← 最轻 + 最重，均衡Rank 1: [block 1, block 6]Rank 2: [block 2, block 5]Rank 3: [block 3, block 4]

2. 双 CUDA Stream 计算-通信重叠

# Megatron CP 伪代码（双流流水线）
for step in range(cp_size):# Stream 1: 启动异步 P2P 通信with torch.cuda.stream(comm_stream):send_kv(current_kv, to_rank=(rank+1) % cp_size)recv_kv(next_kv,   from_rank=(rank-1) % cp_size)# Stream 2: 计算当前 KV 块的 FA2 注意力with torch.cuda.stream(compute_stream):out_step, lse_step = flash_attn_varlen(Q, current_kv.K, current_kv.V,causal=(step==0))# 等待计算完成，合并 LSE 和输出compute_stream.synchronize()out, lse = merge_lse(out, lse, out_step, lse_step)# 等待通信完成comm_stream.synchronize()current_kv = next_kv

3. LSE 合并公式（数值稳定）

FlashAttention-2 输出的 lse（log-sum-exp）用于跨步合并：

$$\text{lse}_{new} = \max(\text{lse}_A, \text{lse}_B) + \log\left(1 + e^{-|\text{lse}_A - \text{lse}_B|}\right)$$

$$O_{new} = \frac{O_A \cdot e^{\text{lse}A - \text{lse}{new}} + O_B \cdot e^{\text{lse}B - \text{lse}{new}}}{1}$$

七、USP：统一序列并行框架

7.1 二维进程网格

论文：USP: A Unified Sequence Parallelism Approach for Long Context Generative AI
作者：Jiarui Fang, Shangchun Zhao（腾讯云 TACO 团队）
发表：arXiv:2405.07719，2024年5月

USP 的核心思想：将序列并行的进程组组织成二维网格，Ulysses 处理列方向（All-to-All），Ring 处理行方向（P2P 环形）。

16 个 GPU 的 USP 网格（Ulysses=4, Ring=4）：Ring 方向 →Ring 0  Ring 1  Ring 2  Ring 3
Ulysses  GPU 0   GPU 1   GPU 2   GPU 3↓      GPU 4   GPU 5   GPU 6   GPU 7GPU 8   GPU 9   GPU 10  GPU 11GPU 12  GPU 13  GPU 14  GPU 15All-to-All 在每列（Ulysses 方向）内执行
P2P 通信在每行（Ring 方向）内执行

总并行度 $N = N_{Ulysses} \times N_{Ring}$，可以灵活分配两个方向的大小。

7.2 USP-Attn 算法

# USP-Attention 算法（来自 arXiv:2405.07719 Algorithm 1）
def usp_attention(Q, K, V, ulysses_group, ring_group):# 输入形状：[bs, L/N, H, d_head]  (每 GPU 持有 L/N 的序列，全部 H 个头)# Step 1: Ulysses All-to-All（在 ulysses_group 内）# [bs, L/N, H, d_head] → [bs, L/N_ring, H/N_ulysses, d_head]Q, K, V = all_to_all_4d(Q, K, V, ulysses_group, scatter_dim=2, gather_dim=1)# Step 2: 负载均衡 Ring Attention（在 ring_group 内，使用 Zigzag 分配）# 在 ring_group 内完成超长序列的分块注意力计算O = load_balanced_ring_attn(Q, K, V, ring_group, causal=True)# Step 3: 反向 All-to-All（恢复序列维度）# [bs, L/N_ring, H/N_ulysses, d_head] → [bs, L/N, H, d_head]O = all_to_all_4d_reverse(O, ulysses_group, scatter_dim=1, gather_dim=2)return O

7.3 通信量精确分析

方案	每 Transformer 块的激活通信量
TP-SP（Megatron）	$10 \times O(bs \cdot L \cdot d)$（AllGather + ReduceScatter）
SP-Ring	$4 \times O(bs \cdot L \cdot d)$（P2P，可重叠）
SP-Ulysses	$\frac{8}{N_{ulysses}} \times O(bs \cdot L \cdot d)$（All-to-All）
USP	$\leq 4 \times O(bs \cdot L \cdot d)$（两者混合，取更低值）

性能实测数据（来自 USP 论文）：

硬件	序列长度	USP 配置	TFLOPS/GPU	对比
8× A100（NVLink）	32K	u=8, r=1	136.4	Ring 仅 113.8
8× L20（PCIe）	128K	u=4, r=2	5.48	Ring 仅 5.19
16× A800（RDMA）	208K	TP8 + r=2	147.3（MFU=0.47）	最优配置

八、深度对比：Ring vs Ulysses vs USP

对比维度	Ring Attention	DeepSpeed Ulysses	USP（混合）
通信模式	P2P 点对点（环形）	All-to-All 集体通信	All-to-All + P2P
通信量复杂度	$O(L \cdot d)$，可重叠	$O(L \cdot d / P)$	$\leq O(L \cdot d / P_{ulysses})$
计算-通信重叠	✅ 天然流水线	❌ 需等待 All-to-All	✅ Ring 部分可重叠
头数约束	❌ 无约束（GQA 友好）	✅ $P$ 整除 KV 头数	❌ 无约束（Ring 负责扩展）
对网络要求	低（P2P 对普通网络友好）	高（NVLink/IB 效果最佳）	可配置
负载均衡（因果）	⚠️ 需 Striped/Zigzag	✅ 自然均衡	✅ 通过 Zigzag Ring
实现复杂度	高（需定制 Attention kernel）	低（包裹 CoreAttn，2行代码）	中
变长序列支持	⚠️ 较困难	✅ 较好	✅ 支持
与 FlashAttention	✅ 天然兼容（分块 softmax 一致）	✅ 支持（FA 计算局部注意力）	✅ 完全支持
与 TP 兼容	✅ 友好	⚠️ 有冲突（DeepSpeed）	✅ 可与 TP 结合
GQA/MQA 场景	✅ 无限制	❌ 最多 8 路并行	✅ Ring 部分不受头数限制

核心结论：

节点内 NVLink + MHA（头数多）：Ulysses 或 USP（高 Ulysses 比例）效率最高
跨节点或 GQA/MQA：Ring Attention 或 USP（高 Ring 比例）
生产大规模训练：USP 混合方案灵活性最强，配合 4D 并行使用

九、与其他并行维度的组合：4D 并行

现代大模型训练通常需要 TP + SP + DP/ZeRO + PP 的四维并行组合：

┌─────────────────────────────────────────────────────┐
│                    4D 并行全景                        │
│                                                       │
│  DP（数据并行）：多个相同模型副本，处理不同 mini-batch  │
│     ↓                                                 │
│  PP（流水线并行）：模型层间切分，不同 GPU 处理不同层    │
│     ↓                                                 │
│  TP（张量并行）：层内切分，每层的权重矩阵分到多个 GPU   │
│     ↓                                                 │
│  SP（序列并行）：在序列维度切分，突破长上下文瓶颈       │
└─────────────────────────────────────────────────────┘

典型推荐配置（以 128 GPU 集群为例，训练 70B 模型，128K 上下文）：

节点内（8× A100 NVLink）：TP = 4                    ← 节点内张量并行SP-Ulysses = 2            ← 节点内 Ulysses（头数充足时）跨节点（16 节点）：SP-Ring = 4               ← 跨节点 Ring 环形ZeRO-DP = 4               ← 跨节点数据并行（ZeRO-1/2）PP = 2（可选）            ← 跨节点流水线并行总并行度：4(TP) × 2(Ulysses) × 4(Ring) × 4(DP) = 128 GPU ✅

4D 并行配置的黄金法则：

1. TP 最优先使用 NVLink（节点内）
2. Ulysses 在 TP 组内共享高速互联（减少 All-to-All 开销）
3. Ring 跨节点使用，利用计算-通信重叠隐藏 IB 延迟
4. ZeRO 与 SP 独立，可随意叠加
5. PP 引入流水线气泡，通常是最后考虑的选项

通信量对比（Megatron-LM 技术报告数据）：

选择 USP（Ulysses + Ring）替代纯 TP-SP，在 16× A800 上：

序列长度 64K → MFU 从 0.38 提升到 0.44
序列长度 208K → MFU 0.47（USP 使能了 208K 训练，TP 单独无法做到）

十、代码示例：DeepSpeed Ulysses 快速上手

安装与环境

# 安装 DeepSpeed（v0.10.2+）
pip install deepspeed>=0.10.2# 或安装最新版
pip install git+https://github.com/deepspeedai/DeepSpeed.git

第一步：封装你的注意力模块

import torch
import torch.nn as nn
from deepspeed.sequence.layer import DistributedAttentionclass LlamaAttentionWithUlysses(nn.Module):def __init__(self, config, seq_parallel_group):super().__init__()self.hidden_size = config.hidden_sizeself.num_heads = config.num_attention_headsself.head_dim = self.hidden_size // self.num_headsself.q_proj = nn.Linear(self.hidden_size, self.hidden_size, bias=False)self.k_proj = nn.Linear(self.hidden_size, self.hidden_size, bias=False)self.v_proj = nn.Linear(self.hidden_size, self.hidden_size, bias=False)self.o_proj = nn.Linear(self.hidden_size, self.hidden_size, bias=False)# 用 DistributedAttention 包裹本地 CoreAttentionfrom flash_attn import flash_attn_funcself.core_attn = flash_attn_func  # FlashAttention# 关键：传入序列并行通信组self.dist_attn = DistributedAttention(self.core_attn,seq_parallel_group  # torch.distributed.ProcessGroup)def forward(self, hidden_states, attention_mask=None):bsz, seq_len, _ = hidden_states.shape# 线性投影（此时每卡持有 seq_len/P 的序列）Q = self.q_proj(hidden_states)K = self.k_proj(hidden_states)V = self.v_proj(hidden_states)# reshape 为多头格式Q = Q.view(bsz, seq_len, self.num_heads, self.head_dim)K = K.view(bsz, seq_len, self.num_heads, self.head_dim)V = V.view(bsz, seq_len, self.num_heads, self.head_dim)# DistributedAttention 自动处理 All-to-All + CoreAttn + All-to-Allcontext = self.dist_attn(Q, K, V, attention_mask)# reshape 回来context = context.view(bsz, seq_len, self.hidden_size)output = self.o_proj(context)return output

第二步：初始化序列并行通信组

import torch.distributed as distdef init_sequence_parallel(sequence_parallel_size: int):"""初始化序列并行通信组Args:sequence_parallel_size: 序列并行度，必须整除注意力头数Returns:seq_parallel_group: 当前 rank 所在的序列并行组"""world_size = dist.get_world_size()rank = dist.get_rank()assert world_size % sequence_parallel_size == 0, \f"world_size={world_size} must be divisible by sp_size={sequence_parallel_size}"num_sp_groups = world_size // sequence_parallel_sizeseq_parallel_group = Nonefor i in range(num_sp_groups):ranks = list(range(i * sequence_parallel_size, (i + 1) * sequence_parallel_size))group = dist.new_group(ranks)if rank in ranks:seq_parallel_group = groupreturn seq_parallel_group# 使用示例（在 torchrun 启动后）
if __name__ == "__main__":dist.init_process_group(backend="nccl")SP_SIZE = 4  # 4 路序列并行（必须整除 num_kv_heads）sp_group = init_sequence_parallel(SP_SIZE)# 构建模型model = YourModel(seq_parallel_group=sp_group)# 数据加载：每个 SP 组内所有 rank 必须接收相同的数据# 用 DistributedSampler 时，相同 SP 组内 rank 共享同一个 batch

第三步：启动脚本（Megatron-DeepSpeed 示例）

# 8 GPU 节点，SP=4，序列长度 128K
torchrun --nproc_per_node=8 \pretrain_gpt.py \--num-layers 32 \--hidden-size 4096 \--num-attention-heads 32 \--seq-length 131072 \--max-position-embeddings 131072 \--ds-sequence-parallel-size 4 \--use-flash-attn \--micro-batch-size 1 \--global-batch-size 8

Ring Attention 快速上手（ring-flash-attention）

# pip install ring-flash-attn
from ring_flash_attn import ring_flash_attn_func
import torch.distributed as dist# 获取序列并行组（Ring 模式）
ring_pg = dist.new_group(ranks=[0, 1, 2, 3])  # 4 个 GPU 组成环# 直接替换 flash_attn_func
output = ring_flash_attn_func(q,                      # [bs, local_seq_len, n_heads, head_dim]k,                      # [bs, local_seq_len, n_heads, head_dim]  v,                      # [bs, local_seq_len, n_heads, head_dim]dropout_p=0.0,softmax_scale=None,causal=True,            # 因果注意力ring_pg=ring_pg         # 传入 Ring 进程组
)

USP 统一序列并行（long-context-attention 库）

# pip install yunchang
from yunchang import UlyssesAttnWithFlashAttn, LongContextAttention
from yunchang.globals import set_seq_parallel_pg# 设置序列并行进程组
set_seq_parallel_pg(sp_ulysses_degree=2,      # Ulysses 并行度sp_ring_degree=4,          # Ring 并行度pg=dist.new_group(ranks=[...]),use_zigzag_ring_attn=True  # 使用 Zigzag 负载均衡
)# 使用 USP 注意力层替换原始注意力
attn_layer = LongContextAttention(local_attn=YourFlashAttn(),  # 你的本地注意力实现
)# 直接 forward
output = attn_layer(q, k, v, causal=True)

十一、工业实践：主流框架支持情况

框架	支持方案	最大序列长度	备注
Megatron-LM	Context Parallelism（Zigzag Ring）	数百 K	NVIDIA 官方，与 FA2 深度集成
DeepSpeed	Ulysses	1M+	简单集成，头数受限
LLaMA-Factory	Ulysses + Ring（混合）	200K+	通过 ms-swift 集成
ms-swift（ModelScope）	Ulysses + Ring	200K+	中文社区最佳实践
Axolotl	Ring Attention（ring-flash-attention）	128K+	简单配置
verl（RL 训练）	DeepSpeed Ulysses	32K+	强化学习训练适配
NeMo	Context Parallelism（Megatron 同款）	256K+	NVIDIA NeMo 框架
long-context-attention（yunchang）	USP（Ulysses + Ring + Zigzag）	任意	最灵活，生产推荐

近期重要进展（2025-2026）：

2026-03：Hugging Face 发布 Ulysses SP 博客，详细介绍 Transformers 库集成方案
2026-04：Axolotl 发布序列并行配置向导，一行配置启用 SP
vLLM 长序列推理 CP：arXiv:2411.01783 提出推理侧的 Context Parallelism，在 128× H100 上实现百万 token prefill 的近线性扩展

十二、选型指南：如何选择序列并行方案

快速决策树

你需要训练多长的序列？
│
├─ ≤ 32K → 通常单卡 FlashAttention 够用，无需 SP
│
├─ 32K ~ 128K：
│   ├─ 节点内 NVLink + MHA（头数≥P）→ Ulysses（最快最简单）
│   └─ PCIe 或 GQA/MQA（kv_heads 少）→ Ring 或 USP（u=1, r=8）
│
└─ > 128K：├─ 资源充足（大型集群）→ USP 混合（u=2~4, r=4~8）+ 4D 并行├─ 跨节点（InfiniBand）→ Ring 部分提高比例（隐藏跨节点延迟）└─ 节点内（NVLink）→ Ulysses 部分提高比例（All-to-All 带宽高）

具体建议

场景 A：科研快速迭代（小集群，8-16 GPU）

推荐：DeepSpeed Ulysses（代码最简单，2 行代码集成）
注意：确保 SP_SIZE 整除 KV 头数

场景 B：GQA 模型大规模训练（如 Llama 3，kv_heads=8）

推荐：Ring Attention + Zigzag（ring-flash-attention 库）
或：USP（设 ulysses=1, ring=N），绕开头数限制

场景 C：生产环境超长上下文（>256K，百 GPU 以上）

推荐：USP（long-context-attention 库），配合以下组合：
- TP=4~8（节点内 NVLink）
- Ulysses=2（节点内额外增益）
- Ring=4~8（跨节点）
- ZeRO-1/2（显存优化）

场景 D：推理侧长上下文（Prefill 加速）

推荐：Context Parallelism（Ring 方式），参考 arXiv:2411.01783
vLLM 正在集成 CP 特性（RFC #30055）

十三、参考资料

Ring Attention 原论文
Ring Attention with Blockwise Transformers for Near-Infinite Context (arXiv:2310.01889) — Hao Liu, Matei Zaharia, Pieter Abbeel (UC Berkeley), ICLR 2024
DeepSpeed Ulysses 原论文
DeepSpeed Ulysses: System Optimizations for Enabling Training of Extreme Long Sequence Transformer Models (arXiv:2309.14509) — Sam Ade Jacobs et al. (Microsoft), 2023
Striped Attention
Striped Attention: Faster Ring Attention for Causal Transformers (arXiv:2311.09431) — William Brandon et al. (MIT), 2023
USP 统一序列并行
USP: A Unified Sequence Parallelism Approach for Long Context Generative AI (arXiv:2405.07719) — Jiarui Fang, Shangchun Zhao (腾讯云), 2024
Context Parallelism for Inference
Context Parallelism for Scalable Million-Token Inference (arXiv:2411.01783) — 2024
DeepSpeed Ulysses 官方教程
Getting Started with DeepSpeed-Ulysses — DeepSpeed 官方文档
Ring Flash Attention 开源实现
zhuzilin/ring-flash-attention — GitHub
USP 开源实现（long-context-attention）
feifeibear/long-context-attention — GitHub
Megatron-LM Context Parallelism 原理与代码解析
[并行训练]Context Parallelism的原理与代码浅析 — 腾讯云开发者社区，2024
DeepSeek-V3 技术报告
DeepSeek-V3 Technical Report (arXiv:2412.19437) — DeepSeek AI, 2024
Ulysses vs Ring vs USP 对比
Ulysses vs Ring vs USP — DeepWiki — 2025
超长序列并行技术原理与实现
超长序列并行之 Ulysses + Ring-Attention 技术原理与实现 — 阿里云开发者社区，2025