大集市上有个账房先生,每天给掌柜回答“哪种货最好卖”之类的问题。老账房先生事必躬亲:每被问一次,就把所有账本从头到尾翻一遍,一笔一笔和问题比较。集市小的时候没问题,可当客人越来越多、账本摞到几千本,翻账本的速度就彻底跟不上了。另一位年轻伙计倒是轻快,只记最近一笔账,随问随答,可时间一长,上午卖爆的货到晚上就忘得一干二净。 这时来了位新账房先生——RetNet(保留网络)。他一边记账,一边随身带着一本薄薄的“汇总簿”:每来一笔新账,就把旧汇总打个折扣再加进去。回答问题时,他可以摊开账本批量核算,也可以只扫一眼汇总簿就报出答案。最神奇的是,这本小簿子永远只有固定大小,无论集市开张多久、账本多厚,他都能轻松应对。 本文就带你认识这位账房先生:讲讲他为什么诞生、他的“记账折扣”规则、三种工作模式(并行、循环、分块循环)、如何分门别类地打折,以及他在真实工程中的表现与局限。

岗位关联

搞懂 RetNet,你就掌握了在 Transformer 架构洪流中另辟蹊径的关键思路——它把并行训练与常数级推理同时装进口袋,是大模型推理加速与长序列建模的实用武器。

目录
  1. 可视化演示
  2. 诞生背景:Transformer的痛点与RetNet的目标
  3. 核心机制:保留分数与指数衰减
  4. 并行表征:训练时的摊开算
  5. 循环表征:推理时的滚账本
  6. 分块循环:折中的工作方式
  7. 多尺度保留:分门别类的折扣
  8. 性能优势:不变的内存与恒定的开销
  9. 工程实践:落地技巧与局限
  10. AI 应用场景
  11. Python 演示
  12. 常见误区
  13. 面试题

可视化演示

展示系统处理流水线、实时性能指标曲线及多方案对比分析,包含数据流转、吞吐延迟监控与方案评估。

本节配有交互动效(进入视口后自动加载,约 3KB)。

系统可视化 处理流程:输入→处理→模型→输出 性能监控:实时指标 P=L×T

诞生背景:Transformer的痛点与RetNet的目标

集市越开越大,老账房先生(Transformer)的麻烦来了。他回答“最近哪个货卖得好”,得把所有账本从头到尾翻一遍,每一笔账都要和当前问题比较一次。账本有 n 本,每回答一次就要比较大约 n×n 次——客人一多,账房门口就排起了长队。

这个“所有历史账目和当前问题两两比较”的环节,术语叫自注意力(self-attention)。它的时间成本是 O(n²):序列长度翻倍,计算量变成原来的 4 倍。更头疼的是,推理时每生成一个字都要把前面所有字的 K、V 缓存留在手边,生成长文时内存也线性膨胀。另一类模型 RNN 则像只记“最近一笔账”的伙计,内存虽省,却记不住久远信息,也没法并行训练。

RetNet 的设计目标非常明确:既保留 Transformer 并行训练的高效,又拿到 RNN 常数级推理的成本优势。它不让每个问题去翻全部账本,而是把历史“浓缩”进一个固定大小的状态里。

新账房先生的初心,就是同时拥有“白天摊开账本批量核算”和“晚上只翻汇总簿”这两种本事——这正是 RetNet 被称为 Transformer 继承者的原因。

Tattn=O(n2),Tretn=O(1)T_{\text{attn}} = O(n^2), \qquad T_{\text{retn}} = O(1)
这条式子对比两种模型每步的时间成本:Transformer 随序列长度平方增长,RetNet 的循环推理则是常数。
  1. 注意力开销Transformer 自注意力中每个 token 都要与全部 n 个历史 token 比较,总成本按平方增长。
    Tattn=O(n2)T_{\text{attn}} = O(n^2)
  2. 恒定开销RetNet 循环推理时每一步只需更新固定大小的状态,与序列长度无关。
    Tretn=O(1)T_{\text{retn}} = O(1)

核心机制:保留分数与指数衰减

汇总簿要想好用,打折规则最关键。集市上的账目越久远越不重要,RetNet 因此规定:距离当前第 n 笔账的第 j 笔旧账,权重是 γ 的 n−j 次方。γ 是 0 到 1 之间的“折旧率”,账龄每远一步,影响力就打一次折。

这个打折权重同时干了两件事:一是当“位置编码”——它天然告诉模型“谁离我近、谁离我远”;二是当“注意力权重”——它决定每笔旧账值多少分量。Transformer 里要用 softmax 算权重、还要另外加位置向量,RetNet 一笔合并了。

具体地,所有折扣权重拼成一个矩阵,叫衰减掩码(decay mask)。矩阵中第 n 行第 j 列的值就是 γ^{n−j};当 n<j 时(未来位置)直接置 0,保证因果性——账房先生不可能看到还没发生的事。

就这样,账房先生不需要和每笔账较劲——先算相似度、按账龄打折、再加权汇总,一本薄薄的汇总簿便有了灵魂。

Mn,j={γ n−j,n≥j0,n<jM_{n,j} = \begin{cases} \gamma^{\,n-j}, & n \geq j \\ 0, & n < j \end{cases}
衰减掩码既承担相对位置编码,又承担注意力加权,是 RetNet 一切特性的源头。
  1. 衰减掩码 M一个 n×n 的矩阵,记录“第 j 笔历史账对当前第 n 笔的影响权重”。
    Mn,jM_{n,j}
  2. 指数折扣当 n≥j 时权重为 γ^{n−j},距离越远指数越小,旧账迅速贬值。
    γ n−j\gamma^{\,n-j}
  3. 未来屏蔽当 n<j 时代表未来的账,权重直接为 0,保证模型只看过去。
    0,n<j0, \quad n < j

并行表征:训练时的摊开算

白天账目堆成山,账房先生把账本全部摊开,在大长桌上一性次核算。这就是并行模式(parallel form):所有位置同时计算,谁也不用等谁,GPU 的成千上万个核心可以一起干活。

术语上这叫并行表征,也叫训练模式。它把查询、键、值三个矩阵(Q、K、V)直接拿来相乘:先算每个查询和每个键的相似度,再乘上衰减掩码,最后对值向量做加权汇总。整个过程是一次干净的矩阵运算,和 Transformer 的训练效率平起平坐。

需要强调一点:这一步虽然长得像注意力,却去掉了 softmax。少了软归一化,矩阵乘才能保持纯粹线性,后面的循环形式才能严格推导出来,这是 RetNet 最关键的设计取舍。

摊开账本批量核算,让 RetNet 的训练速度和 Transformer 不相上下——这是它敢自称“继承者”的第一重底气。

Retention(X)=(QK⊤⊙M)V\mathrm{Retention}(X) = (Q K^{\top} \odot M) V
三矩阵相乘:Q 与 K 打分、M 打折、V 汇总,一气呵成。
  1. 查询与键打分Q 和 K^T 相乘,得到所有“问题”与“历史账”的相似度矩阵。
    QK⊤Q K^{\top}
  2. 按折扣掩码⊙M 表示逐元素乘以衰减掩码,给每个相似度盖上“折旧章”。
    ⊙M\odot M
  3. 加权聚合最后乘 V,把值向量按折扣权重汇总成当前输出。
    (QK⊤⊙M)V(Q K^{\top} \odot M) V

循环表征:推理时的滚账本

晚上打烊,账房先生合上所有历史账本,只带那本汇总簿。新账进来:先把旧汇总打一个 γ 折,再把新账加进去。掌柜问什么,直接拿查询在汇总簿上查。整个过程与集市开了多久完全无关。

这就是循环表征(recurrent form),也叫推理模式。状态 S 是一个固定大小的矩阵,从前一步滚到下一步:S 里浓缩了从开业到现在的全部账目。每步成本 O(1)、内存 O(1)——不需要缓存任何历史 K、V,历史已经“溶进”了状态里。

数学上,把并行模式按位置逐项展开,得到的恰好是这条递推式。两种形式表达的是同一个公式,只是计算顺序不同:并行是一口气算完,循环是一步步累积。

汇总簿永远是那么厚,集市开了十年还是百天都一样——这就是 O(1) 的承诺。

Sn=γSn−1+Kn⊤Vn,On=QnSnS_n = \gamma S_{n-1} + K_n^{\top} V_n, \qquad O_n = Q_n S_n
循环形式是 RetNet 推理时的“滚账本”公式:旧状态打折,新账累加,查询即答案。
  1. 旧状态打折上一步的汇总状态 S_{n−1} 整体乘 γ,历史信息随时间衰减。
    γSn−1\gamma S_{n-1}
  2. 写入新账当前 token 的 K_n^T 与 V_n 做外积,把“新账”累加进状态。
    Kn⊤VnK_n^{\top} V_n
  3. 查询输出当前查询 Q_n 与状态 S_n 相乘,从汇总簿中取出答案。
    QnSnQ_n S_n

分块循环:折中的工作方式

集市实在太大,账房先生把账本分成一摞一摞(chunk),每摞内部摊开批量算,摞与摞之间用汇总簿衔接。这样既不用一次性摊开所有账本,又能保持很高的并行度。

这就是第三种形态:分块循环(chunkwise recurrent form)。块大小 b 是个可调旋钮:b 越大,块内并行越多、GPU 利用越充分;b 越小,内存越省。极端情况下 b=1 退化为纯循环,b=n 退化为纯并行,两种极端都能覆盖。

细节上,块间传递状态 S 时要用 γ^b 整体打折,因为跨过整整一块的距离;每块的输出 = 块内并行结果 + 跨块的老账记忆。训练时用分块形式,可以在不牺牲太多并行度的情况下控制显存。

分摞记账让账房先生能在“累不累(显存)”和“忙不忙(并行度)”之间自由调节——工程上这是最常用的形态。

A(i)=(Q(i)K(i)⊤⊙M)V(i),S(i)=γbS(i−1)+K(i)⊤V(i)A_{(i)} = (Q_{(i)} K_{(i)}^{\top} \odot M) V_{(i)}, \qquad S_{(i)} = \gamma^{b} S_{(i-1)} + K_{(i)}^{\top} V_{(i)}
O(i)=A(i)+Q(i)S(i−1)O_{(i)} = A_{(i)} + Q_{(i)} S_{(i-1)}
块内并行、块间循环:既快又省的混合记账法。
  1. 块内并行第 i 块内部用并行注意力一次算完所有位置,等价于小规模的(QK^T⊙M)V。
    A(i)=(Q(i)K(i)⊤⊙M)V(i)A_{(i)} = (Q_{(i)} K_{(i)}^{\top} \odot M) V_{(i)}
  2. 块间滚动状态在块与块之间传递,γ^b 表示跨过一整块的距离折扣。
    S(i)=γbS(i−1)+K(i)⊤V(i)S_{(i)} = \gamma^{b} S_{(i-1)} + K_{(i)}^{\top} V_{(i)}
  3. 合并结果块内注意力结果加上跨块记忆,得到第 i 块最终输出。
    O(i)=A(i)+Q(i)S(i−1)O_{(i)} = A_{(i)} + Q_{(i)} S_{(i-1)}

多尺度保留:分门别类的折扣

不同商品的保质期完全不同:豆腐要当天卖完,老酒却越陈越香。让所有账目共用同一个 γ 打折显然太粗暴——短期信息需要快速遗忘,长期信息需要慢慢记住。

所以 RetNet 把多头注意力(multi-head)的每个头当成一个“分柜伙计”,各自配不同的折旧率。论文采用指数分布的设定:靠前的头 γ 大(衰减慢,负责长期记忆),靠后的头 γ 小(衰减快,负责短期细节)。这样模型同时拥有了“长程依赖”和“局部精度”两种能力。

从直觉上,这类似卷积神经网络里的多尺度感受野:有的卷积核看全局、有的看局部,组合起来才能同时抓住大结构与小细节。多尺度保留就是把这个思想搬进了状态空间。

几个伙计各管一摊,有的记老客户、有的算新订单——多尺度的妙处就在于,总有一个头恰好适合眼前的账。

γh=e−α⋅2 h/H,h=1,2,…,H\gamma_h = e^{-\alpha \cdot 2^{\,h/H}}, \qquad h = 1, 2, \dots, H
每个头一个衰减率:编号越大,γ 越小,记性越短。
  1. 头编号 h多头注意力中第 h 个头的索引,H 是总头数。
    h=1,2,…,Hh = 1, 2, \dots, H
  2. 指数缩放2^{h/H} 让编号越大的头拿到越小的 γ,衰减越来越快。
    2 h/H2^{\,h/H}
  3. 衰减率区间所有 γ_h 落在 (0,1),α 控制整体衰减尺度,保证数值稳定。
    e−α⋅2 h/He^{-\alpha \cdot 2^{\,h/H}}

性能优势:不变的内存与恒定的开销

集市规模翻倍,老账房先生的内存占用跟着翻倍——Transformer 推理时要缓存每层每个 token 的 K、V,序列越长显存越吃紧。新账房先生的汇总簿却永远只有一张纸大小,无论账本多厚。

具体对比:Transformer 的 KV 缓存复杂度是 O(n),n 是序列长度;RetNet 的循环状态是 d×d 的矩阵,d 是模型维度,与 n 无关。因此在长文本生成、流式输出场景里,RetNet 的显存占用恒定,吞吐量领先。论文在 7B 规模上报告,推理吞吐约为同规模 Transformer 的数倍,显存省出一个量级。

训练方面,并行形式同样可以在 GPU 上充分并行,配合分块循环还能压住长序列训练的显存水位。可以说,RetNet 把“训练像 Transformer 一样快、推理像 RNN 一样省”的愿景第一次变成了现实。

内存恒定、长序列友好、流式生成流畅——这是新账房先生最亮眼的招牌。

Memoryattn=O(n),Memoryretn=O(1)\text{Memory}_{\text{attn}} = O(n), \qquad \text{Memory}_{\text{retn}} = O(1)
推理内存的对比:一个随序列增长,一个恒为常数。
  1. 缓存所有历史Transformer 推理要保存每层每个 token 的 K、V,内存随长度线性增长。
    Memoryattn=O(n)\text{Memory}_{\text{attn}} = O(n)
  2. 固定账本RetNet 只保存一个 d×d 的状态矩阵,不随序列长度变化。
    Memoryretn=O(1)\text{Memory}_{\text{retn}} = O(1)

工程实践:落地技巧与局限

好工具还要好用法。账房先生发现,汇总簿的格式也有很多讲究:状态 S 一直累加容易产生数值漂移,需要周期性归一化(通常用 GroupNorm);γ 太接近 1 会让梯度不稳定,通常要有温度参数或精心初始化。

工程上最常见的组合是“三形态切换”:训练用并行形式,长序列微调用分块形式控制显存,部署时切换成循环形式。实现时还可以把状态 S 直接替代 KV 缓存,省掉整套缓存管理逻辑,代码更简洁、延迟更稳定。

当然,RetNet 也有短板:去掉 softmax 之后,它失去了“锐化检索”能力——像“从长文档里精确复制某串号码”这类强定位任务,Transformer 仍然更稳。这也是为什么 RetNet 之后,Mamba 等新架构继续在“状态空间”这条路上探索,互相启发。

新账房先生并非万能,但他带来的“一簿两用”记账思路,正在悄悄改变大账房(Transformer 架构)的传统做法——这就是架构变体的意义。

Cchunk=O(n⋅b),b=n  ⟹  O(n3/2)C_{\text{chunk}} = O(n \cdot b), \qquad b = \sqrt{n} \implies O(n^{3/2})
分块形式的训练成本:块大小取平方根时,复杂度介于线性和平方之间。
  1. 块大小 b每个块内的 token 数,块内并行计算成本与 b 相关。
    bb
  2. 总成本n 个 token 分为 n/b 块,每块成本约 O(b²),总计 O(n·b)。
    O(n⋅b)O(n \cdot b)
  3. 平方根折中b=√n 时总成本为 O(n^{3/2}),在并行度与显存之间取得平衡。
    O(n3/2)O(n^{3/2})

AI 应用场景

大模型长文本流式生成

阶段:模型推理与部署优化

解决的问题:传统 Transformer 在生成长文本时,KV 缓存不断膨胀,显存吃紧、延迟变高。RetNet 的循环形式每次都只更新固定大小的状态,让长文本生成像“翻汇总簿”一样轻快。

具体案例:某智能写作助手接入 70B 参数 RetNet 模型后,万字长文生成的显存占用从约 40GB 降到 6GB,吞吐提升约 3 倍,且不再需要复杂的缓存管理逻辑。

端侧实时语音交互

阶段:模型压缩与边缘部署

解决的问题:手机、耳机等端侧设备内存小,装不下随对话增长的注意力缓存。RetNet 状态恒定,可以在低功耗设备上维持长时间对话记忆。

具体案例:某智能音箱厂商用 RetNet 改造流式语音交互管线,在 2GB 内存的嵌入式设备上实现了 30 分钟连续对话不重置上下文,唤醒响应延迟降低一半。

超长序列金融时序预测

阶段:模型训练与特征建模

解决的问题:分钟级 K 线、传感器日志等序列动辄上万步,Transformer 的 O(n²) 训练成本难以承受。分块循环形式可以在控制显存的同时保留长期依赖。

具体案例:某量化团队用分块形式(块大小取 √n)在 6 万步的金融时序上训练预测模型,训练显存下降约 40%,而长周期趋势特征被循环状态完整保留。

Python 演示

python40 行
import numpy as np  def retention_parallel(q, k, v, gamma):    """并行形式:一次矩阵运算算出所有位置的保留输出。"""    n = q.shape[0]    scores = q @ k.T  # 所有查询与键的相似度    dists = np.arange(n)[:, None] - np.arange(n)[None, :]  # n - j    mask = np.where(dists >= 0, np.power(gamma, np.maximum(dists, 0)), 0.0)    return (scores * mask) @ v  def retention_recurrent(q, k, v, gamma):    """循环形式:逐个 token 更新固定状态 S,O(1) 内存。"""    dim = q.shape[1]    state = np.zeros((dim, dim))    outputs = []    for t in range(q.shape[0]):        state = gamma * state + np.outer(k[t], v[t])        outputs.append(q[t] @ state)    return np.stack(outputs)  def main():    np.random.seed(42)    n, dim, gamma = 8, 6, 0.9    x = np.random.randn(n, dim)    wq = np.random.randn(dim, dim)    wk = np.random.randn(dim, dim)    wv = np.random.randn(dim, dim)    q, k, v = x @ wq, x @ wk, x @ wv    out_p = retention_parallel(q, k, v, gamma)    out_r = retention_recurrent(q, k, v, gamma)    err = np.abs(out_p - out_r).max()    print("并行与循环最大误差: %.2e" % err)    assert err < 1e-8, "两种保留形式并不等价!"  if __name__ == "__main__":    main()
目的:用 NumPy 从零实现 RetNet 的并行与循环两种保留形式,并验证它们在数学上完全等价。
  1. scores = q @ k.T先算出所有“查询与键”的相似度分数,对应账房先生先比较每笔账。
  2. mask = np.where(dists >= 0, np.power(gamma, np.maximum(dists, 0)), 0.0)构建 γ 指数衰减的因果掩码:过去打折、未来清零。
  3. return (scores * mask) @ v并行保留:相似度按账龄打折后聚合值向量,一次算完。
  4. state = gamma * state + np.outer(k[t], v[t])滚账本:旧状态整体打 γ 折,再加当前这笔新账。
  5. outputs.append(q[t] @ state)查汇总簿:用当前查询从状态中取出答案。
  6. assert err < 1e-8, "两种保留形式并不等价!"用数值验证并行与循环形式严格一致,误差仅在浮点精度内。

常见误区

误区“我以为 RetNet 就是把 Transformer 的自注意力乘一个指数衰减系数,本质上还是两个 token 之间算相似度,和普通注意力差不多嘛。”

正解衰减不只是“位置偏好”,它让掩码矩阵 M 可以被因式分解(γ^{n−j} = γ^n·γ^{−j}),从而把“两两比较”改写成“状态累积”。这是数学结构上的质变——推理从 O(n) 缓存降到 O(1) 状态。就像账房先生从“每次翻整本账”变成“随身带汇总簿”,是记账方式的改变,而不只是多打一个折扣。

为何常见:并行形式的公式 (QK^T⊙M)V 和注意力长得太像,人们容易只看到表面差异,忽略了背后可分解的数学结构。

误区“训练用并行、推理用循环,两种模式结果肯定只是近似吧?毕竟 RNN 的循环常常是有损压缩。”

正解数学上两者完全等价:把循环递推式逐项展开,恰好得到并行矩阵乘的结果。上面的 Python 演示中,两种形式的输出误差在 1e-8 量级,纯粹是浮点精度问题。区别只是计算顺序——并行一次算完所有位置,循环一步一步累积。

为何常见:RNN 的循环通常是“编码”而非“精确复述”,Transformer 又习惯了并行计算,人们默认两种形式不可能严格相等。

误区“RetNet 去掉了 softmax,那它不就不是注意力了?质量肯定不如 Transformer。”

正解softmax 的作用是把分数归一化成概率分布,RetNet 用 γ 衰减加 GroupNorm 归一化来替代。衰减本身就能做“加权”,只是权重分布没有 softmax 的锐化效果。这确实带来取舍:在摘要、翻译、连续文本生成这类场景 RetNet 表现优秀;但在“从长文中精确检索某个电话号码”这类强定位任务上,softmax 的锐化更有利。

为何常见:大众认知里“注意力=softmax 加权求和”,忽略了注意力的本质是“按相关性加权聚合信息”,softmax 只是实现方式之一。

误区“推理时内存是常数,那 RetNet 是不是能记住无限长的信息?”

正解O(1) 指的是“每算一个 token 的开销固定”,状态 S 是 d×d 矩阵,容量有限。γ 衰减意味着旧信息被“打折压缩”进固定大小的状态,时间一长细节必然有损。这更像账房先生的汇总簿:能回答“大概趋势”,但想精确回忆三个月前某天的一笔小账就难了。

为何常见:把“计算复杂度 O(1)”误解成“记忆容量无穷大”,混淆了计算开销与信息容量两个概念。

面试题

Q1. RetNet 在推理阶段每一步的计算量约为多少?

单选题 · easy

  • A.O(n²),随长度平方增长
  • B.O(n),随长度线性增长
  • C.O(1),固定开销不增长← 正确答案
  • D.O(logn),对数缓慢增长

答案:C。循环推理只更新固定大小的状态 S,与历史长度无关。就像账房先生查汇总簿,集市开了多久都不影响翻本子的时间。A 是 Transformer 训练/推理注意力的成本,B 是普通 RNN 逐 token 的成本,D 没有对应依据。

Q2. 保留机制中 γ 的作用是什么?

单选题 · easy

  • A.控制梯度裁剪的强度
  • B.控制历史信息衰减速率← 正确答案
  • C.控制学习率的大小
  • D.控制正则化的权重

答案:B。γ 是“折旧率”,决定旧账在汇总簿中衰减多快。γ 越接近 1 记住的越久远,越接近 0 忘得越快。A、C、D 分别是优化器和正则化相关概念,与衰减机制无关。

Q3. 并行形式与循环形式的关系是?

单选题 · mid

  • A.两者结果近似,循环较快
  • B.循环是并行的低精度版
  • C.两者在数学上完全等价← 正确答案
  • D.并行只适合小批量任务

答案:C。把循环递推式逐项展开,恰好还原出并行矩阵乘的结果,二者严格等价。Python 演示中两种形式的误差仅有 1e-8 量级。A、B 误以为循环是有损近似,D 说法无依据。

Q4. RetNet 中掩码 M_{n,j} 在 n<j 时的取值是?

单选题 · mid

  • A.无穷大,表示纳入未来信息
  • B.负数,表示对未来的惩罚
  • C.零,保证只能看到过去← 正确答案
  • D.一,表示当前信息不衰减

答案:C。n<j 表示“未来位置”,权重置 0 保证因果性——账房先生不可能看到还没发生的账。这正是衰减掩码的关键作用:未来屏蔽、过去打折。A、B 会引入未来信息,D 是 n=j 时对角线的情形。

Q5. RetNet 相比 Transformer 的核心改进方向是?

单选题 · easy

  • A.提升图像分类的精度
  • B.降低推理阶段的成本← 正确答案
  • C.增加训练时的学习率
  • D.减小模型的参数量

答案:B。RetNet 用固定状态替代随序列增长的 KV 缓存,把推理内存降到 O(1),主战场是推理成本与长序列部署。A 是卷积模型的领域,C 是训练技巧,D 不是它的设计目标。

Q6. 下列哪些是 RetNet 支持的保留表征形式?

多选题 · mid

  • A.并行形式,适合训练← 正确答案
  • B.循环形式,适合推理← 正确答案
  • C.分块循环,折中方案← 正确答案
  • D.对抗形式,适合生成

答案:ABC。三种形态对应账房先生的三种工作方式:白天摊开算(并行)、晚上滚账本(循环)、分摞记账(分块循环)。D“对抗形式”是虚构概念,RetNet 与生成对抗网络无关。

Q7. 多尺度保留中,不同注意力头的衰减率有什么特点?

单选题 · mid

  • A.全部相同,便于并行实现
  • B.按指数分布,头越大衰减越快← 正确答案
  • C.随机初始化,训练中保持不变
  • D.只保留最大值,其余置为零

答案:B。γ_h = e^{−α·2^{h/H}},头编号越大 γ 越小、衰减越快,从而有的头管长期、有的头管短期。A 是单尺度设定,C 与“学习的多尺度”矛盾,D 描述的是稀疏化不是多尺度。

Q8. 关于 RetNet 的循环表征,下列说法正确的有?

多选题 · hard

  • A.每个 token 只更新一次状态← 正确答案
  • B.推理内存与序列长度无关← 正确答案
  • C.状态矩阵大小为 d×d← 正确答案
  • D.需要缓存所有键值对

答案:ABC。循环形式逐 token 更新固定状态,d×d 的内存与序列长度 n 无关,因此 A、B、C 正确。D 是 Transformer 的 KV 缓存做法,RetNet 恰恰靠状态 S 取代了它。

Q9. RetNet 去掉 softmax 的直接原因是什么?

单选题 · extreme

  • A.为了降低训练时的采样复杂度
  • B.使循环形式能够严格等价推导← 正确答案
  • C.为了防止梯度消失增加深度
  • D.为了让注意力分数可以取负值

答案:B。softmax 引入非线性后,无法把并行求和改写成线性递推;去掉它才能让 (QK^T⊙M)V 因式分解成 S_n = γS_{n−1}+K_n^T V_n 的滚动形式。A 是采样相关概念,C 与深度训练无直接关系,D 是副作用而非目的。

Q10. 分块循环中,块大小 b 增大时通常会?

单选题 · mid

  • A.并行度提高,但内存占用上升← 正确答案
  • B.并行度降低,推理速度变慢
  • C.模型精度没有任何变化
  • D.状态矩阵维度随之变大

答案:A。块内并行计算的显存成本约 O(b²),b 越大 GPU 并行越充分、但显存越吃紧,所以 A 正确。B 说反了,C 忽略折中程度会影响长程信息传递,D 中状态维度由模型维度 d 决定,与 b 无关。