假设你经营一家回转寿司店，招牌菜多到需要摆满一百万个盘位。按老规矩，所有菜品必须一次性全部摆上台面，客人才能自由挑选。可台面（显存）只有那么几平方米，别说一百万盘，一万盘就已经叠到天花板。环形注意力（Ring Attention）的解法是：请来多位“客人”围着环形传送带坐好，把菜单切成小盘（KV 分块），菜盘沿传送带单向流转，每位客人逐一品尝，最终尝遍全部菜品。更精妙的是，传送带一直在转，客人边吃边看——计算与通信重叠，谁也不等谁。整个餐厅虽然分工协作，但每位客人最后感受到的“美味总和”（注意力输出）与一次性摆满所有菜完全一致。这就是 Ring Attention：把长序列分散到多张卡上，用环形传递配合在线 Softmax，把显存需求从平方级压到线性级，让百万 token 级上下文成为可能。

岗位关联

对 AI 从业者而言，掌握 Ring Attention 意味着理解大模型如何突破单卡上下文极限，这直接决定你在超长序列训练时的集群规划、显存预算与分布式策略设计能力。

目录
  1. 可视化演示
  2. 背景与瓶颈
  3. 分块注意力
  4. 环状拓扑
  5. 隐藏通信
  6. 显存与扩展
  7. 工程实现
  8. 应用与展望
  9. AI 应用场景
  10. Python 演示
  11. 常见误区
  12. 面试题

可视化演示

本节配有交互动效（进入视口后自动加载，约 3KB）。

背景与瓶颈

想象你经营一家回转寿司店，招牌菜多到需要摆满一百万个盘位。按老规矩，所有菜品必须一次性全部摆上台面，客人才能自由挑选。可台面（显存）只有那么几平方米，别说一百万盘，一万盘就已经叠到天花板。客人越多、菜单越长，问题越严重——这正是大模型处理超长序列时遇到的窘境。

大模型里，序列中的每个 token 都要“看”一遍所有其他 token，才能决定自己应该携带什么信息。这个“互相看”的过程，需要一张巨大的注意力得分表：长度为 n 的序列，得分表有 n 行 n 列。一本书 10 万 token，得分表就有 100 亿个格子，单张 GPU 的显存根本装不下。于是“把菜全摆上台面”的老规矩，在超长序列面前首先崩塌。

标准注意力中，$QK^T$ 得分矩阵的空间复杂度为 O(n²)：序列翻倍，显存需求翻四倍；序列涨到 100 万 token，得分矩阵达到 TB 量级，远超单卡 80GB 的物理上限。这就是长序列必须“分块”的根本动机——既不能全摆上台面，就只能分批上菜。

所以老板决定改革：不让所有菜同时上台，而是把菜单切成几百个小盘，让它们在环形传送带上依次转起来，每位客人坐等品尝即可。Ring Attention 的“分块”思路，就从这里开始，也把显存这座大山凿出了第一道口子。

Mattn=O(n2)M_{\text{attn}} = \mathcal{O}(n^2)
含义：序列长度 n 每增加一倍，注意力得分矩阵的显存占用变为原来的四倍，这是长序列扩展的第一道墙。
  1. 序列长度 n输入 token 的数量。一段 10 万字的书、一小时视频抽帧后的 token，都能让 n 变得很大。
    nn
  2. 得分矩阵形状$QK^{\top}$ 的结果是 n 行 n 列的方阵，行是查询、列是键，每个格子代表一对 token 的相似度。
    QK⊤∈Rn×nQK^{\top} \in \mathbb{R}^{n \times n}
  3. 平方级复杂度显存随 n 平方爆炸，序列翻倍显存翻四倍，单卡物理上限很快被击穿。
    Mattn=O(n2)M_{\text{attn}} = \mathcal{O}(n^2)

分块注意力

新的经营方案确定后，客人坐定，厨房把菜单切成小盘，传送带一盘接一盘送到面前。客人每接到一盘菜，不是简单吞下，而是掏出记账本——记录“目前吃到的最美味值”和“累计美味和”，边吃边更新账本，确保最后算出的综合体验与一次性吃完全部菜品完全一致。

分块注意力做的正是这件事。Q、K、V 按序列维度切成大小相同的块。比如设备 i 持有自己的 Query 分块 Q_i，当第 j 个 KV 分块（K_j、V_j）从环上到来时，它计算局部得分 S_{i,j} = Q_i K_j^T / \sqrt{d_k}，再通过“在线 Softmax”把这一块的统计量并入全局统计量。整个过程中，那张巨大的 n×n 得分矩阵从未被完整存储过。

在线 Softmax 的核心是维护两个量：行最大值 m 与指数和 ℓ（softmax 的分母）。每来一个新分块，先比较出新最大值，再按比例缩放旧统计量，最后并入新分块的指数和与输出。这就像客人记账：新菜打破纪录就更新“最高纪录”，旧账按新基准缩放，再添上新菜的贡献。

客人账本记得清清楚楚，最后加权平均出“综合美味”。分块注意力算出的结果与一次性算完整注意力在数学上完全相等——只是台面（显存）不再需要同时摆下所有菜了。

m←max⁡(m,rowmax(Sb)),ℓ←ℓ⋅emold−m+rowsum(eSb−m)m \leftarrow \max\left(m, \mathrm{rowmax}(S_b)\right), \quad\ell \leftarrow \ell \cdot e^{m_{\text{old}} - m} + \mathrm{rowsum}\left(e^{S_b - m}\right)
通俗讲：来了新菜先看有没有打破最高纪录，有就更新纪录；然后把旧账本按新纪录缩放，再把新菜的贡献加进去。这样算出的结果与一次性吃完所有菜完全一致。
  1. 计算分块得分查询块与当前键块的相似度矩阵，d_k 是键向量的维度，用于缩放防止数值过大。
    Sb=QiKb⊤/dkS_b = Q_i K_b^{\top} / \sqrt{d_k}
  2. 更新行最大值新块得分更高时整体最大值上调，保证后续指数运算不溢出。
    m←max⁡(m,rowmax(Sb))m \leftarrow \max\left(m, \mathrm{rowmax}(S_b)\right)
  3. 旧账缩放最大值变化后，旧的指数和要乘以缩放因子，才能与新的基准对齐。
    ℓ⋅emold−m\ell \cdot e^{m_{\text{old}} - m}
  4. 并入新块当前块的指数和成为 softmax 分母的一部分，记账本越记越全。
    rowsum(eSb−m)\mathrm{rowsum}\left(e^{S_b - m}\right)
  5. 更新输出旧输出按新分母重新加权，新块的值按权重加入，两部分的贡献精确合并。
    O←ℓold⋅emold−mℓ⋅O+eSb−mℓ⋅VbO \leftarrow \frac{\ell_{\text{old}} \cdot e^{m_{\text{old}} - m}}{\ell} \cdot O + \frac{e^{S_b - m}}{\ell} \cdot V_b

环状拓扑

传菜方式也要改革。餐厅把客人安排在环形传送带周围，每人面前是一段固定的座位区。刚才提到“把每道菜端给每个客人”的难题，在这里变成“菜盘沿环单向转一圈”——传送带永远不会逆行，也不会有人满餐厅跑。

在 Ring Attention 中，“客人座位”就是 GPU 设备。设备被组织成逻辑上的环：0 → 1 → 2 → … → m-1 → 0。每台设备初始持有自己的 K/V 分块。每一轮，设备把自己手里的 KV 块传给下一个设备，同时从上一个设备收到新的 KV 块。发送与接收天然配对，不需要额外的路由表。

这样的单向传递有两大好处：一是每台设备只与邻居通信，通信量均衡，不会出现某个节点要同时给所有人发数据的“广播瓶颈”；二是传递与计算天然可流水线化。经过 m-1 次传递，每个 Query 分块都见过环上所有 KV 分块，注意力就算完了。

“转一圈”让每位客人都尝遍所有菜。环状拓扑的本质，是把“全网互联”降级为“邻居互传”：不需要昂贵的高速全互联网络，一条逻辑上的环形传送带就够了。

Nsteps=m−1N_{\text{steps}} = m - 1
含义：环上有 m 台设备，自己的 KV 块已在手边，只需再接收 m-1 个其他设备的 KV 块，就完成了全量注意力。
  1. 设备数 m环上参与计算的 GPU 数量，m 越大可切分的序列块越多。
    mm
  2. 单步传递每步每台设备发出一个 KV 块、接收一个 KV 块，通信量只与块大小 b 和向量维度 d 有关。
    comm per step=O(b⋅d)\text{comm per step} = \mathcal{O}(b \cdot d)
  3. 总步数m-1 步后，每个 KV 块恰好绕环一周，所有查询块完成对所有键值块的注意力。
    Nsteps=m−1N_{\text{steps}} = m - 1

隐藏通信

最妙的一招在这里：客人不需要等传送带停下再吃。菜盘还在传送带上移动时，客人就已经在心里计算这一口该怎么品；等菜盘转到面前，品鉴也快完成。传送带的转动（通信）与品尝（计算）同时进行，谁也不等谁。

Ring Attention 的关键工程技巧正是计算与通信重叠。设备在计算当前 KV 块的同时，把下一个 KV 块提前预取到通信缓冲区；等当前计算结束，下一个块已经“在门口”了。整条传送带不减速，通信延迟因此被计算时间完全遮挡。

如果单个分块的计算时间 t_calc 不小于单块传输时间 t_comm，那么通信完全免费——总时间近似等于 m 个分块的计算时间之和；反之，总时间受通信限制。实践中通过调整分块大小，让计算成为主导方，通信就被“藏”到计算背后。

传送带永不停歇，客人也就永远不会干等。正因为重叠，Ring Attention 才能在多卡集群上接近线性加速——加机器，序列长度和吞吐一起涨。

Ttotal≈m⋅max⁡(tcalc,tcomm)T_{\text{total}} \approx m \cdot \max(t_{\text{calc}}, t_{\text{comm}})
含义：通信和计算重叠后，瓶颈只取决于二者中较慢的一个；只要计算不慢于传输，传输就被完全隐藏。
  1. 单块计算时间一个 KV 分块的注意力计算（含在线 Softmax 合并）耗时。
    tcalct_{\text{calc}}
  2. 单块传输时间KV 块经环传到下一台设备的耗时。
    tcommt_{\text{comm}}
  3. 重叠取最大重叠后总耗时取两者的较大者，而不是相加——这就是“免费通信”的来源。
    max⁡(tcalc,tcomm)\max(t_{\text{calc}}, t_{\text{comm}})
  4. 乘 m 个分块每台设备串行处理 m 个 KV 分块（包含自己的），总共 m 个计算周期。
    m⋅max⁡(tcalc,tcomm)m \cdot \max(t_{\text{calc}}, t_{\text{comm}})

显存与扩展

改革之后，每位客人面前只有一个小碟子：自己初始端上的那盘菜，以及传送带上正在旋转的菜。以前需要一整张台面，现在只需要一个餐位加一个小碟——这就是 Ring Attention 把显存需求从“台面级”降到“小碟级”的秘密。

每台设备只需存储自己的 Q、K、V 分块，各占 n/m × d 的空间；注意力计算采用分块在线 Softmax，不需要保存完整得分矩阵。因此单卡显存占用从 O(n²) 降为 O(n/m)——台面不再是瓶颈，碟子大小才是。

更关键的是扩展关系：最大序列长度 n_max = m × b，其中 b 是单设备分块长度。设备数翻倍，能处理的序列长度就近似翻倍。这就是“百万级 token”可行性的数学来源：不是某个单卡变大了，而是整条环形传送带把无数个小碟子拼接成了一张无限长的大台面。

小碟子能承接大宴会。这也是“显存天花板被打穿”的真正含义：不是单卡变大了，而是整个环形餐厅的台面合在一起，变成了一张可以无限拼接的大桌。

Mper GPU=O ⁣(nm⋅d)M_{\text{per GPU}} = \mathcal{O}\!\left(\frac{n}{m} \cdot d\right)
含义：序列分布到 m 台设备后，每台设备的 KV 显存只随总序列长度线性增长，且设备越多、单卡压力越小。
  1. 本设备分块每台设备持有 n/m 个 token 的 Q/K/V，每个 token 的向量维度为 d。
    nm⋅d\frac{n}{m} \cdot d
  2. 线性关系显存与 n 成正比而非 n²，长序列从“不可能”变为“可分摊”。
    O ⁣(nm⋅d)\mathcal{O}\!\left(\frac{n}{m} \cdot d\right)
  3. 设备数反比m 越大单卡显存越小，加机器即可扩展上下文容量。
    nmax⁡=m⋅bn_{\max} = m \cdot b

工程实现

开分店光有理论还不够，还得管好流程：谁负责哪段菜单、传送带速度怎么调、盘子碎了怎么办。工程实现就是把“环形传菜”变成可落地的生产线。

第一个工程要点是与 FlashAttention 结合。FlashAttention 擅长在单个 KV 块内部做高效融合计算（分块在线 Softmax + 反向传播重计算），Ring Attention 负责跨设备的块调度，两者天然互补。第二个要点是负载均衡：每个设备分到的序列块大小应当一致，保证所有设备的计算时间对齐，避免“木桶效应”——一个慢设备拖垮整个环。

第三个要点是因果掩码。解码器训练时，token i 只能“看到”编号不超过 i 的 token，即 j ≤ i。在分块计算中，对角线以上的块（j > i 的 KV 块）可以直接跳过，节省约一半的通信与计算。第四个要点是框架支持：Ring Attention 原始论文基于 JAX 实现，社区也有 PyTorch 移植，可配合 FSDP / ZeRO 使用。

流程理顺，传送带才能高速运转。工程实现的每个细节——融合算子、负载均衡、掩码跳过——都是为了让“环形餐厅”在多卡集群上安全、高效地跑起来。

Si,j=QiKj⊤dk,j≤i （因果掩码）S_{i,j} = \frac{Q_i K_j^{\top}}{\sqrt{d_k}}, \qquad j \leq i \ \text{（因果掩码）}
含义：因果注意力中，第 i 个查询块只与编号不大于 i 的键块计算得分，环上遇到超出的块可直接跳过。
  1. 分块得分第 i 个查询块与第 j 个键块的相似度矩阵。
    Si,j=QiKj⊤dkS_{i,j} = \frac{Q_i K_j^{\top}}{\sqrt{d_k}}
  2. 因果约束保证未来信息不泄漏，token 只能 attend 到自己及之前的 token。
    j≤ij \leq i
  3. 跳过掩码块环上传递时遇到 j > i 的 KV 块，设备直接跳过该块计算。
    Si,j→−∞(j>i)S_{i,j} \to -\infty \quad (j > i)

应用与展望

环形餐厅一旦跑顺，就能承接各种大型宴席：整本书的阅读理解、整部电影的视频理解、整个代码库的分析——菜单从几道菜变成一百万道菜，照样转得开。

应用上，Ring Attention 最直接的价值是超长上下文训练。要把大模型的上下文从 4K / 128K 推到 1M token，单卡显存无法容纳，必须靠环上多卡分摊。推理侧同样受益：超长对话的 KV cache 可以分布式存放在多张卡上，查询块按环轮转读取，支撑百万 token 的原生文档问答。

多模态方向，长视频可以抽帧成数万到数十万 token，音频、视频、文本的联合注意力都能用 Ring Attention 跑起来。未来方向包括：与稀疏注意力结合、动态负载均衡、跨机柜甚至跨数据中心的环形通信优化——宴席越来越大，环形餐厅的桌子也会越拼越长。

从“一张台面摆不下”到“环形传菜永不掉队”，Ring Attention 把长序列的大门彻底推开。百万 token 的上下文，从此从不可能变为可行。

nmax⁡=m⋅bn_{\max} = m \cdot b
含义：Ring Attention 的可扩展性公式——设备数 m 乘以单设备分块长度 b，就是系统能支撑的最大序列长度，这正是百万 token 可行性的数学表达。
  1. 单设备分块 b一台设备最多容纳的分块 token 数，由显存大小决定。
    bb
  2. 设备数 m环上 GPU 数量，可不断加机器扩容。
    mm
  3. 线性扩展设备翻倍、序列容量翻倍，这是长序列扩展的最终答案。
    nmax⁡=m⋅bn_{\max} = m \cdot b

AI 应用场景

超长上下文模型训练

阶段：分布式训练 / 序列并行策略

解决的问题：训练 1M token 上下文的 LLM 时，标准注意力得分矩阵在单卡上需要 TB 级显存。Ring Attention 把序列切成 KV 块沿环传递，配合在线 Softmax 精确合并结果，让超长序列训练在常见多卡集群上即可进行，不再依赖超大显存单卡。

具体案例：某团队要在 8×A100 集群上训练 1M 上下文模型。使用 Ring Attention 将序列切成 8 块，每块 128K token，KV 块沿环单向传递；块内计算交给 FlashAttention 融合算子，训练吞吐接近线性扩展，显存峰值仅为单块规模。

超长序列推理与 KV Cache 分发

阶段：推理部署 / KV Cache 管理

解决的问题：百万 token 对话或长文档问答时，KV cache 超过单卡显存导致 OOM。Ring Attention 的环式 KV 分发同样适用于推理：每卡只存一段 KV cache，查询块按环轮转读取全部 KV，支撑超长上下文服务。

具体案例：面向法律文档的问答系统需要一次读完 50 万字卷宗。部署 4 卡推理服务，KV cache 按卷宗章节分片存在 4 张卡上，环形传递完成全部注意力计算，无显存溢出，且支持用户对任意段落追问。

多模态长视频理解

阶段：多模态特征融合 / 长序列建模

解决的问题：一小时视频抽帧产生数万 token，与文本指令一起构成超长序列。Ring Attention 让视频帧的 KV 分布式流转，实现跨帧全局注意力，突破单卡对视觉 token 数量的限制。

具体案例：视频问答模型读取 60 分钟影视剧，每秒抽 1 帧得 3600 帧视觉 token，加字幕文本共约 5 万 token。使用 Ring Attention 在 4 卡上完成训练，模型能回答“主角在第三幕为什么换了衣服”这类跨场景问题。

Python 演示

python66 行
import numpy as np  def naive_attention(Q, K, V):    # 标准完整注意力: 全量 softmax 后加权求和    d = Q.shape[-1]    scores = Q @ K.T / np.sqrt(d)    exp_s = np.exp(scores - scores.max(axis=-1, keepdims=True))    weights = exp_s / exp_s.sum(axis=-1, keepdims=True)    return weights @ V  def ring_attention(Q, K, V, device, num_devices):    # 模拟 Ring Attention: 设备 device 持有一个 Q 分块,    # 按环序接收全部 KV 分块, 用在线 softmax 精确合并结果    n, d = Q.shape    b = n // num_devices    q_block = Q[device * b:(device + 1) * b]     row_max = np.full(b, -np.inf)   # 记账本: 行最大值 m    row_sum = np.zeros(b)           # 记账本: 指数和 l    out = np.zeros((b, d))     for step in range(num_devices):        # 第 step 步, 环上到达的是源设备 (device - step) 的 KV 分块        src = (device - step) % num_devices        k_block = K[src * b:(src + 1) * b]        v_block = V[src * b:(src + 1) * b]         # 当前分块的注意力得分        scores = q_block @ k_block.T / np.sqrt(d)        cur_max = scores.max(axis=-1)        new_max = np.maximum(row_max, cur_max)         # 数值稳定化的指数与行和        exp_s = np.exp(scores - new_max[:, None])        cur_sum = exp_s.sum(axis=-1)         # 旧统计量按最大值变化缩放        rescale = np.exp(row_max - new_max)        old_weight = row_sum * rescale        new_weight = old_weight + cur_sum         # 加权合并输出        out = out * (old_weight / new_weight)[:, None]        out = out + (exp_s @ v_block) / new_weight[:, None]         row_sum = new_weight        row_max = new_max     return out  if __name__ == "__main__":    np.random.seed(42)    n, d, num_devices = 16, 8, 4    b = n // num_devices    Q = np.random.randn(n, d)    K = np.random.randn(n, d)    V = np.random.randn(n, d)     ref = naive_attention(Q, K, V)    for dev in range(num_devices):        got = ring_attention(Q, K, V, dev, num_devices)        err = np.abs(got - ref[dev * b:(dev + 1) * b]).max()        print(f"device {dev} max err: {err:.2e}")
目的：用 NumPy 模拟 4 台设备上的 Ring Attention，验证环式 KV 传递 + 在线 Softmax 的结果与标准完整注意力几乎完全一致。
  1. src = (device - step) % num_devices环形传递的核心：第 step 步设备拿到的是哪个源设备的 KV 分块
  2. scores = q_block @ k_block.T / np.sqrt(d)当前 KV 分块的注意力得分，对应公式 S_b
  3. new_max = np.maximum(row_max, cur_max)在线 Softmax 的“最高纪录”更新
  4. rescale = np.exp(row_max - new_max)最大值变化后旧统计量的缩放修正
  5. out = out + (exp_s @ v_block) / new_weight[:, None]把新分块的贡献合并进最终输出

常见误区

误区“分块分散到多张卡上算，中间还要传来传去，结果肯定跟完整注意力不一样，会有精度损失吧？”

正解不会。Ring Attention 用的是在线 Softmax，它在数学上精确合并每个分块的统计量（行最大值 m 和指数和 ℓ），最终结果与一次性计算完整注意力在浮点精度内完全一致。就像回转寿司的客人用记账本精确加权每盘菜的贡献，而不是简单平均——账算得准，最终“综合体验”和一次吃完一模一样。

为何常见：因为“分布式”通常让人联想到近似（如梯度压缩、量化），而分块 Softmax 容易被误认为是对完整 Softmax 的近似。

误区“Ring Attention 不就是把一个大模型拆开放在多张 GPU 上跑吗？跟张量并行差不多。”

正解不是。Ring Attention 切的是序列维度（序列并行），不是模型参数。每张卡持有完整模型权重，但只持有序列的一段 Q/K/V；KV 块在环上传递，让每张卡都能看到全部序列。类比：不是把厨房切成几块，而是把菜单切成多盘菜在环形传送带上轮流上，每位客人都能尝到全部菜。

为何常见：大模型并行技术很多（数据并行、张量并行、流水线并行），初学者容易把“多卡协作”笼统理解为“把模型拆开”。

误区“每张卡都要把 KV 块传给其他卡，环越大传递次数越多，通信开销肯定拖垮训练。”

正解关键在于计算与通信重叠。设备计算当前 KV 块时，下一个 KV 块已在路上传输；只要单块计算时间 ≥ 单块传输时间，通信就被完全隐藏，总时间近似等于计算时间。像回转寿司：传送带一直在转，客人边吃边等，吃和转互不耽误。实践中通过调大分块尺寸，计算时间很容易超过传输时间。

为何常见：直觉上“通信要花时间”是对的，但容易忽略流水线化后通信可以和计算并行；也容易忽略分块大小这一关键旋钮。

误区“推理时模型参数固定，Ring Attention 这种训练技巧应该用不上。”

正解推理同样需要。长上下文推理中，KV cache 随序列增长而线性膨胀，百万 token 的 KV cache 远超单卡显存。Ring Attention 的环式 KV 分发同样适用于推理：每卡只存一段 KV cache，查询块沿环读取全部 KV，支持超长对话和文档问答。

为何常见：Ring Attention 论文主要展示训练场景（吞吐优化、计算通信重叠），但 KV cache 的分布式存储机制天然适用于推理，很多人只看到了前一半。

面试题

Q1. Ring Attention 主要解决什么问题？

单选题 · easy

  • A.加速单卡矩阵乘法
  • B.突破单卡显存限制← 正确答案
  • C.提升注意力数值精度
  • D.缩减模型参数量

答案：B。Ring Attention 把长序列切块分布到多张 GPU 上，用环形传递 KV 块加在线 Softmax，突破单卡显存对上下文长度的限制。它不改变计算结果，也不减少总计算量，更与模型参数量无关。就像回转寿司把大菜单切成小盘，让台面（显存）摆得下。

Q2. Ring Attention 中“环”指的是什么？

单选题 · easy

  • A.模型参数的循环结构
  • B.多头注意力的环状排列
  • C.KV块单向传递的拓扑← 正确答案
  • D.训练数据的循环使用

答案：C。“环”指设备间的通信拓扑：每台设备只向下一台设备发送 KV 块、从上一台设备接收 KV 块，形成单向环。这样通信量均衡、无广播瓶颈，类似回转寿司的传送带只有一个方向。

Q3. 标准注意力中 QK^T 得分矩阵的空间复杂度是？

单选题 · mid

  • A.O(n)线性增长
  • B.O(n log n)增长
  • C.O(n²)平方增长← 正确答案
  • D.O(1)常数不变

答案：C。标准注意力中 QK^T 得到 n×n 得分矩阵，每对 token 都有一个得分，空间复杂度 O(n²)。序列翻倍、显存变四倍。Ring Attention 正是为了绕过这张“大台面”而设计。

Q4. 关于分块注意力的在线 Softmax，哪些说法正确？

多选题 · mid

  • A.需维护全局行最大值← 正确答案
  • B.分块独立softmax直接平均
  • C.旧统计量随最大值缩放← 正确答案
  • D.结果与标准算法完全不同

答案：AC。在线 Softmax 需要维护全局行最大值 m（防止指数溢出）和指数和 ℓ（softmax 分母）。新分块到达时旧统计量要按 m 的变化缩放，再并入新块贡献，结果与标准 Softmax 完全一致。B 错在“直接平均”——各分块权重不同不能简单平均；D 错在结果不一致。

Q5. Ring Attention 实现计算通信重叠的关键是？

单选题 · mid

  • A.利用多线程并行计算
  • B.计算当前块同步传输下一块← 正确答案
  • C.通过稀疏化减少计算量
  • D.使用更高带宽的互联

答案：B。Ring Attention 的关键是流水线重叠：设备计算当前 KV 块的同时，下一个 KV 块已在环上传输（预取）。只要计算时间 ≥ 传输时间，通信完全被隐藏。A 是单卡内优化，C 改变算法结构，D 只缓解不解决。

Q6. 每个设备的 Query 分块需要处理多少个 KV 分块？

单选题 · mid

  • A.只处理自己的本地分块
  • B.处理一个其他设备分块
  • C.处理包含自身的m个分块← 正确答案
  • D.处理全部两倍m个分块

答案：C。每台设备的 Query 分块要与所有 KV 分块计算注意力，包括自己的那块。环上共 m 个 KV 分块（每设备一个），所以每个 Query 分块要处理 m 个 KV 分块。就像客人要尝遍传送带上的所有 m 盘菜。

Q7. 关于 Ring Attention 相比标准注意力的变化，正确的说法有？

多选题 · hard

  • A.单卡显存从O(n²)降为O(n)← 正确答案
  • B.总计算量大幅减少
  • C.序列长度随设备数线性扩展← 正确答案
  • D.注意力结果存在近似误差

答案：AC。分块在线 Softmax 使每卡无需保存完整得分矩阵，显存从 O(n²) 降为 O(n)（每卡 O(n/m)）。总计算量不变——注意力仍是每个 token 对所有 token 算；序列容量 n = m·b 随设备数线性扩展；结果精确一致，无近似误差。

Q8. 分块注意力中在线 Softmax 的主要目的是？

单选题 · easy

  • A.减少浮点运算次数
  • B.无需存储完整得分矩阵← 正确答案
  • C.提高模型最终精度
  • D.加速反向传播过程

答案：B。在线 Softmax 的核心价值是无需保存完整得分矩阵就能精确合并各分块的注意力结果。它不减少浮点计算总量，不改变模型精度，也不专门加速反向传播——只是让“分块计算 + 精确合并”成为可能。

Q9. 将设备数从 m 增加到 2m（分块大小不变），Ring Attention 的容量与显存如何变化？

单选题 · hard

  • A.单卡显存减半，序列容量翻倍← 正确答案
  • B.单卡显存翻倍，序列容量减半
  • C.单卡显存不变，序列容量翻倍
  • D.单卡显存减半，序列容量不变

答案：A。n_max = m × b，设备数翻倍后序列容量 2m × b 翻倍；每台设备只存自己那份 KV，单卡显存 O(n/m)，m 翻倍则单卡显存减半。其他选项把两个变量的变化方向搞反了。

Q10. 以下哪些是 Ring Attention 工程实现中的常见做法？

多选题 · hard

  • A.与FlashAttention融合计算← 正确答案
  • B.因果掩码跳过部分分块← 正确答案
  • C.每卡持有全部KV减少通信
  • D.环上单向传递KV分块← 正确答案

答案：ABD。Ring Attention 工程上常与 FlashAttention 融合做块内高效计算；因果注意力下 j > i 的块可直接跳过；KV 块沿单向环传递是核心拓扑。C 错——每卡持有全部 KV 恰恰是它要避免的显存爆炸方案。