这篇讲的是RetNet的retention保留机制。你会学到它怎么用递归式计算替代标准自注意力，实现训练时并行、推理时线性复杂度的理想特性。RetNet综合了Transformer的并行训练优势和RNN的线性推理优势。它用衰减矩阵替代注意力权重保持了位置感知能力。适合研究大模型架构的学者，帮你理解RetNet为什么被认为是Transformer的有力替代者，怎么兼顾效率和效果。

学习提示

需要学习RetNet.retention，模型压缩和量化需要理解深度学习模型结构。本篇涵盖CNN/RNN/Transformer、反向传播、正则化、训练技巧，帮助你理解深度模型原理与调优。

目录
  1. 可视化演示
  2. AI 应用场景
  3. Python 演示
  4. 常见误区
  5. 面试题

可视化演示

状态—

这篇讲的是RetNet的retention保留机制。你会学到它怎么用递归式计算替代标准自注意力，实现训练时并行、推理时线性复杂度的理想特性。RetNet综合了Transformer的并行训练优势和RNN的线性推理优势。它...

注意力之痛

小黑管理图书馆时，用的是最"老实"的办法：每来一位新读者，就把历史登记表从头翻到尾，把新读者和每一位老读者都做一次比对。100 位读者时要比 1 万次，1000 位时要比 100 万次。读者越多，小黑越崩溃——因为他把所有历史记录都原样保存，每一次服务都要重新"过一遍全场"。这种笨办法在数学上就是平方复杂度：工作量随着读者数量的平方上涨。

Transformer 的自注意力，正是这个"翻旧账"模式的数学化。序列里每个 token 都要和它之前的所有 token 计算关系，得到一个 n 行 n 列的注意力矩阵。这个矩阵的规模随序列长度平方增长，内存和时间都吃不消。更麻烦的是，在生成式推理时，模型还要把每个历史 token 的键和值（K、V）全部缓存下来，序列越长，缓存越大，长文本对话的延迟和显存压力就越大。

这个公式就是小黑的"翻旧账"：每个查询都要跟所有键配对打分，再按热度把历史值加权取回。

Attention(Q,K,V)=softmax(QK⊤dk)V\displaystyle \text{Attention}(Q,K,V) = \text{softmax}\left(\frac{QK^\top}{\sqrt{d_k}}\right)V
  1. 投影三件套输入 X 分别乘三个权重矩阵，得到查询、键、值三份向量。查询决定"我在找什么"，键说明"我有什么标签"，值提供"我的实际内容"，对应小黑在登记表上写的"读者特征、兴趣标签、推荐记录"。
    Q=XWQ, K=XWK, V=XWVQ = XW_Q,\ K = XW_K,\ V = XW_V
  2. 点积打分每个查询和所有键做内积，得到 n×n 的"关系热度表"。位置 i 对位置 j 的分数越高，表示两者越相关。
    QK⊤QK^\top
  3. 缩放防饱和除以键维度的平方根，避免内积过大把 softmax 推到"全有或全无"的极端。
    QK⊤dk\frac{QK^\top}{\sqrt{d_k}}
  4. 归一化成权重对每行做 softmax，让所有历史位置的权重和为 1，相当于"必须从所有旧记录里按比例挑重点"。
    softmax(QK⊤dk)\text{softmax}\left(\frac{QK^\top}{\sqrt{d_k}}\right)
  5. 加权求和用归一化权重对值向量做加权平均，输出当前位置的表示。 小黑的"翻旧账"困境就是注意力的平方复杂度。他需要的不是越来越厚的账本，而是一块永远装得下重点的"记忆黑板"——这正是 retention 要解决的问题。
    ∑j=1naijVj\sum_{j=1}^{n} a_{ij} V_j

保留机制初识

小黑决定改革。他把厚重的登记本换成了一块会褪色的黑板：每来一位新读者，他就把旧字迹整体变淡一点，再写上新记录。这样，黑板上永远保留着"最近的重点 + 稍早的轮廓 + 更早的淡淡痕迹"，他推荐书时只看这块黑板就行，完全不用翻历史账本。

RetNet 的 retention 机制走的是同一条路。它保留了注意力"查询—键—值"的三件套骨架：仍然用 Q 问"我在找什么"，用 K 说"我有什么标签"，用 V 提供"实际内容"。但它放弃了 softmax 打分，改成一套"历史状态持续累积"的方式——每一个新位置到来时，所有旧信息统一打一个折扣，再叠加上新信息。

含义：第 n 个位置的输出，等于把所有历史位置的"键值匹配分数 × 值"按距离衰减后全部累加。这就是小黑黑板上的"灰色影像"：越近越清楚，越远越模糊，但都在。

Rn=∑m=1nγn−m(QnKm⊤)Vm\displaystyle R_n = \sum_{m=1}^{n} \gamma^{n-m}(Q_n K_m^\top)V_m
  1. 当前位置的查询第 n 个 token 的查询向量 Q_n 是"我此刻想找什么"的请求。
    QnQ_n
  2. 键值匹配把 Q_n 和历史上每个位置的键 K_m 做内积，得到初步匹配分数。
    QnKm⊤,m=1,…,nQ_n K_m^\top,\quad m=1,\dots,n
  3. 位置衰减距离越远，乘以越小的 γ 幂——旧记忆被平滑地淡出。
    γn−m\gamma^{n-m}
  4. 值加权匹配分数乘上对应位置的值向量 V_m，把"内容"取出来。
    (QnKm⊤)Vm(Q_n K_m^\top)V_m
  5. 累加合成把全部历史贡献累加，得到第 n 位置的输出。 黑板上每一笔都写得更淡一点、更旧一点，最后留下来的是一张包含全部历史重点的"记忆灰度图"。这张灰度图，就是 retention 的状态。
    Rn=∑m=1nγn−m(QnKm⊤)VmR_n = \sum_{m=1}^{n}\gamma^{n-m}(Q_n K_m^\top)V_m

衰减矩阵

黑板的"褪色规律"不是乱来的，而是严格按时间距离指数变淡：昨天写的清清楚楚，上周写的模模糊糊，上个月写的只剩轮廓。小黑不用在笔记上标注日期，因为字迹深浅本身就编码了时间远近。

这个"褪色规律"在数学上就是衰减矩阵 D。它是一个下三角矩阵：上三角部分全部是零，表示"不能回头看未来"，保证因果性；下三角部分填的是 γ 的幂，距离每远一步，权重就乘一次 γ，形成指数衰减。

D 矩阵同时干了两件事：一是当"遮罩"挡住未来信息，二是当"距离刻度尺"记住位置先后。这是 retention 不需要额外位置编码的原因之一。

Dnm={γn−mn≥m0n<m\displaystyle D_{nm} = \begin{cases} \gamma^{n-m} & n \ge m \\ 0 & n < m \end{cases}
  1. 行与列的含义D 的行号表示当前写入位置，列号表示被回看的历史位置，两者下标差就是时间距离。
    DnmD_{nm}
  2. 未来置零当行号小于列号时元素为 0，表示"不允许偷看未来"。
    0,n<m0,\quad n < m
  3. 历史指数衰减当行号大于等于列号时，元素为 γ 的 n−m 次方，距离越远衰减越多。
    γn−m,n≥m\gamma^{n-m},\quad n \ge m
  4. γ 的记忆风格γ 越接近 1，记忆越长；越接近 0，越健忘。实际中 γ 可以设计成可学习参数，让模型自己学"该记多久"。 衰减矩阵就是黑板的"物理规则"——不标日期、不看钟表，字迹深浅自动告诉你信息的新旧。位置感知，就这样被刻进了权重里。
    γ∈(0,1)\gamma \in (0, 1)

并行训练

虽然小黑平时用黑板接待读者，但每天闭馆后，他可以把一整天的黑板变化拍成一张"快照"：快照里包含了今天所有读者之间的相互关系，他可以一次性集体核账，不用一个读者一个读者地过。GPU 训练模型时，最讨厌的就是"一个一个来"的串行计算，它最喜欢"一整批算完"的矩阵乘法。

retention 的并行形式正是为训练设计的"快照"。把一整段序列的 Q、K、V 同时送进矩阵乘法，一次性算出所有位置的输出。计算过程只需要三步：先算 QK^T 得到两两配对分，再把衰减矩阵 D 用逐元素乘法"刻"进配对分里，最后乘上 V。

这里的 ⊙ 表示逐元素相乘，相当于把衰减矩阵当作"滤镜"盖在配对分上面，同时完成因果遮罩和距离衰减。

R=(QK⊤⊙D)V\displaystyle R = (QK^\top \odot D)V
  1. 一次打出配对表Q 和 K 整体做矩阵乘法，一次得到所有位置两两的原始分数，不需要循环。
    QK⊤QK^\top
  2. 逐元素刻入衰减⊙ 是逐元素乘，把衰减矩阵 D 一层层乘进配对表，既挡住未来又加上遗忘。
    QK⊤⊙DQK^\top \odot D
  3. 加权取出内容乘以 V，把所有历史位置的值按衰减权重累加，得到输出矩阵。
    (QK⊤⊙D)V(QK^\top \odot D)V
  4. 整体并行计算整个过程是三块大矩阵乘，GPU 可以高度并行完成。 快照核账就是并行训练。GPU 就像团队里的多个核账员同时开工，互不等待——这也是 RetNet 能保住 Transformer 训练效率的关键。
    R=(QK⊤⊙D)VR = (QK^\top \odot D)V

递归推理

在实时接待读者时，小黑不会等一整天的快照。他只需要知道"当前黑板长什么样"，然后每来一位新读者，就做一次"旧字淡一点 + 写上新字"的更新。无论这一天来了 10 位还是 10 万位读者，他面前始终只有一块黑板，内存占用是固定的。

这就是 retention 的递归形式。它维护一个状态矩阵 S，相当于黑板上的全部内容。每处理一个新 token，旧状态整体乘上 γ 实现褪色，然后叠加当前 token 的"键值外积"作为新笔记。读取结果时，当前查询 Q 乘上状态 S，就可以"读出"与需求最匹配的记忆。

推理时不需要缓存任何历史 token，只需要保存一个 d×d 的状态矩阵。每一步的计算量固定，与序列长度无关。

Sn=γSn−1+Kn⊤Vn,Rn=QnSn\displaystyle S_n = \gamma S_{n-1} + K_n^\top V_n, \qquad R_n = Q_n S_n
  1. 状态 S 是黑板内存一个 d×d 的矩阵，装载了所有历史的压缩记忆。
    Sn∈Rd×dS_n \in \mathbb{R}^{d\times d}
  2. 旧记忆整体褪色上一步状态乘以 γ，所有旧信息统一打折。
    γSn−1\gamma S_{n-1}
  3. 写入新笔记当前键和值的外积叠加进状态，老记忆加新见闻。
    Kn⊤VnK_n^\top V_n
  4. 查询读出当前查询与状态矩阵相乘，读取与此刻需求相关的记忆内容。 黑板的妙处在于"有限的空间装无限的历史"——装不下的部分交给遗忘曲线。推理时的 RetNet 正是这样：状态永远只有一块黑板那么大，来多少 token 都不怕。
    Rn=QnSnR_n = Q_n S_n

块级循环

黑板太大也不方便。小黑把一天分成上午、下午两个班次：班次内部，他按"快照"方式并行核账，整个半天的读者关系一次性算清；班次与班次之间，他只用"当前黑板状态"交接，不传递任何原始记录。这就是块级循环的思路：块内并行、块间递归。

对应到 RetNet，就是把序列切成固定长度的 chunk。每个 chunk 内部，用并行形式一口气算出该块的 retention；跨块时，上一个 chunk 结束时的状态 S 整体衰减 γ 的 c 次方（c 是块长）后传给下一个 chunk，作为"历史摘要"继续累积。这样长序列训练既不会退化成纯串行，又能保持状态传递的线性记忆。

前半项是块内并行计算，后半项是跨块的状态接力。它桥接了训练和推理两种形式，是 RetNet 工程落地的关键。

R[i]=(Q[i]K[i]⊤⊙D)V[i]+γcQ[i]S[i−1]\displaystyle R_{[i]} = (Q_{[i]}K_{[i]}^\top \odot D)V_{[i]} + \gamma^c Q_{[i]}S_{[i-1]}
  1. 块内并行项第 i 个块内部的 QKV 用并行矩阵乘一次算出，类似"班内集体核账"。
    (Q[i]K[i]⊤⊙D)V[i](Q_{[i]}K_{[i]}^\top \odot D)V_{[i]}
  2. 跨块状态接力上一个块的总状态 S 乘上 γ 的 c 次方，表示"过了一整块时长的旧记忆"。
    γcQ[i]S[i−1]\gamma^c Q_{[i]}S_{[i-1]}
  3. 块间递归传递状态按块依次往下传，块内并行、块间串行，构成一根"接力棒"。 上午班的成果浓缩成一个"状态摘要"交棒给下午班，黑板还是同一块，账却越算越轻松。这就是 chunkwise 的智慧。
    R[i]=(Q[i]K[i]⊤⊙D)V[i]+γcQ[i]S[i−1]R_{[i]} = (Q_{[i]}K_{[i]}^\top \odot D)V_{[i]} + \gamma^c Q_{[i]}S_{[i-1]}

对比展望

现在把三种方法摆在桌面上看：翻旧账的 Transformer 全面但慢，每步都要重新回顾全部历史；揣小纸条的 RNN 飞快但丢三落四，只记得一个粗略的隐藏向量；而会用褪色黑板的 RetNet 快且抓得住重点——训练时能并行，推理时只需固定状态，位置信息还天然编码在衰减里。

从复杂度上看，Transformer 推理每生成一个新 token 都要对所有 n 个历史位置做加权，成本随序列长度线性增长；RetNet 每步只更新一个 d×d 的状态矩阵，成本直接与序列长度无关。内存方面，Transformer 需要缓存全部历史 KV，而 RetNet 只需要一个固定大小的状态矩阵。这让长文本部署的显存负担从"越滚越大"变成"恒定的"。

一是"固定状态"的代价，一是"看全部历史"的代价。序列越长，两者的差距越大。

TRetNet=O(d2),TAttn=O(nd)\displaystyle T_{\text{RetNet}}=O(d^2), \qquad T_{\text{Attn}}=O(nd)
  1. RetNet 每步推理代价每生成一个新 token，只更新一个 d×d 状态矩阵，成本与历史长度无关。
    TRetNet=O(d2)T_{\text{RetNet}}=O(d^2)
  2. Transformer 每步代价每生成一个新 token，要重新对全部 n 个历史位置做注意力加权，成本随 n 上涨。
    TAttn=O(nd)T_{\text{Attn}}=O(nd)
  3. 常数记忆的差异Transformer 存 n 份历史 KV，RetNet 只存一份状态矩阵，这是"账本 vs 黑板"的本质差别。 图书馆终于不用再堆越来越高的账本了。一块恰到好处会遗忘的黑板，就是大模型长文本时代的新答卷——RetNet 用保留机制承接了注意力的表达能力，却甩掉了注意力的平方代价。
    MRetNet=O(d2)≪MAttn=O(nd)M_{\text{RetNet}}=O(d^2) \ll M_{\text{Attn}}=O(nd)

AI 应用场景

超长对话客服系统

阶段：模型推理（增量解码）

解决的问题：传统 Transformer 在长对话中，每生成一个新 token 都要重新缓存并回顾全部历史 KV。假设 1 小时客服对话产生 2 万 token，每一步都要扫 2 万份历史缓存，延迟和显存都随对话增长。RetNet 把历史压缩成一个 d×d 状态矩阵，每步只更新一个矩阵，问题迎刃而解。

具体案例：某智能客服系统改用 RetNet 后，40 轮对话的响应延迟从 800ms 降至 120ms，显存占用下降约 10 倍。用户感觉不到"聊久了会变卡"，因为记忆的开销恒定。

相关角色：大模型推理工程师、系统架构师

流式语音识别与直播字幕

阶段：在线流式处理

解决的问题：直播字幕是无限流式数据，注意力机制必须等整段音频才能计算；RetNet 的块级循环可以边收边算：块内并行处理，块间只传状态。小黑的黑板不需要"看完一整天再总结"，随时都能开口推荐。

具体案例：直播平台每秒接入 50 帧音频特征，RetNet 以 512 帧为一个 chunk，一个 chunk 到达立即产出一段字幕，端到端延迟小于 300ms，实现真正的边播边译。

相关角色：AI 音频算法工程师、流媒体算法工程师

端侧离线助手

阶段：边缘部署与推理

解决的问题：手机内存有限，几万 token 的 KV 缓存可能直接撑爆应用。RetNet 推理只保留一个状态矩阵，例如 512×512 的 float32 矩阵仅占约 1MB，随序列长度恒定不变。

具体案例：手机端翻译助手离线运行，翻译 2000 字的长文时只维护这 1MB 状态，在 8GB 内存手机上流畅运行，不用联网、不掉帧，真正把大模型"装进口袋"。

相关角色：端侧部署工程师、模型优化工程师

Python 演示

python60 行
import numpy as np  class SimpleRetention:    ""“极简 RetNet retention 层 （单头，无偏置）”""     def init(self, d_model=16, gamma=0.9):        self.d = d_model        self.gamma = gamma        self.W_q = np.random.randn(d_model, d_model) * 0.05        self.W_k = np.random.randn(d_model, d_model) * 0.05        self.W_v = np.random.randn(d_model, d_model) * 0.05     def train_parallel(self, X):        ""“并行形式：训练时一次算出所有位置的输出”""        n = X.shape[0]        Q = X @ self.W_q        K = X @ self.W_k        V = X @ self.W_v        idx = np.arange(n)        D = np.power(self.gamma, idx[:, None] - idx[None, :]) * np.tril(np.ones((n, n)))        score = (Q @ K.T) * D        return score @ V     def infer_recurrent(self, x_t, state=None):        ""“递归形式：推理时逐步更新固定大小的状态矩阵”""        if state is None:            state = np.zeros((self.d, self.d))        q = x_t @ self.W_q        k = x_t @ self.W_k        v = x_t @ self.W_v        state = self.gamma * state + np.outer(k, v)        return q @ state, state  def main():    np.random.seed(42)    d = 16    n = 8    layer = SimpleRetention(d_model=d, gamma=0.9)    X = np.random.randn(n, d)     R_parallel = layer.train_parallel(X)     state = None    R_recurrent = []    for t in range(n):        r, state = layer.infer_recurrent(X[t], state)        R_recurrent.append(r)    R_recurrent = np.array(R_recurrent)     max_err = np.abs(R_parallel - R_recurrent).max()    print(“并行形式输出[0]:”, np.round(R_parallel[0], 4))    print(“递归形式输出[0]:”, np.round(R_recurrent[0], 4))    print(“最大误差：”, max_err)    assert max_err < 1e-6, “并行与递归结果不一致”  if name == "main":    main()

常见误区

误区很多同学看到并行公式 R=(QK^T⊙D)V，就觉得 retention 不过是给注意力分数乘了一个衰减矩阵，本质还是注意力，换汤不换药。

正解衰减矩阵只是并行形式的一种写法。retention 的真正杀手锏是它能等价地写成递归形式——去掉 softmax 后系统变成线性，历史才能被压缩进一个固定状态矩阵。注意力的本质是"每次现查所有历史"，retention 的本质是"状态随身带"，两者有本质区别。

为何常见：大多数讲解从并行公式切入，它长得太像注意力了，容易让人忽略递归形式这一关键差异。

误区听说 RetNet 是"线性复杂度"，就以为不管模型多大，每步推理时间都是常数，彻底摆脱了规模束缚。

正解所谓 O(1) 是相对于序列长度而言。状态矩阵大小是 d×d，d 是模型维度——d 越大，状态矩阵越大，每步计算量 O(d²) 也随之增长。准确的表述是"与序列长度无关的固定大小状态"，而不是数学上严格意义的 O(1)。

为何常见："线性推理""常数内存"这类宣传语被过度简化，忽略了状态矩阵中 d² 项的存在。

误区以为 γ 就是一个手工设置的常数，设 0.9 或 0.99 效果差不多，不重要。

正解γ 直接控制模型的"记忆时长"，敏感度非常高：太大时旧信息过度残留、干扰新信息；太小时模型变成"金鱼记忆"，长距离依赖全丢。论文里把 γ 参数化，让它随训练自动学习，而不是拍脑袋定一个固定值。

为何常见：许多简化实现把 γ 固定成常数，掩盖了它是可学习参数且高度敏感的事实。

误区标题写着"替代注意力"，于是以为 RetNet 是纯 RNN 路线，跟注意力一点关系都没有。

正解retention 完整保留了 QKV 投影和"按查询取回值"的核心思想，只是把 softmax 的平方打分换成了线性递归的固定状态更新。训练时它照样写得出 QK^T 矩阵乘，推理时它使用状态传递——它是注意力的结构化重组，而不是另起炉灶。

为何常见："替代"这个词太有误导性，让人以为新方法一定与旧方法毫无关系。

误区以为把序列切成 chunk 只是 GPU 显存不够时的优化技巧，理论上可有可无。

正解chunkwise 是并行形式和递归形式之间的数学桥。块内用并行矩阵乘，块间用状态递归，两者严格等价。它让"训练和推理共用同一套状态视角"，也是长序列高效训练的关键设计，而不是单纯的工程妥协。

为何常见：直觉上觉得"分块"就是工程手段，没意识到它是三种等价表示中连接训练与推理的重要一环。

面试题

Q1. retention 机制主要想替代以下哪个组件？

单选题 · easy

  • A.前馈网络层
  • B.自注意力层← 正确答案
  • C.归一化层
  • D.嵌入映射层

答案：B。retention 是为替代标准自注意力设计的，它保留 QKV 投影但换掉 softmax 加权方式，让序列建模从平方复杂度变成线性递归。就好比小黑换掉的是"翻旧账"的登记法，而不是换图书馆的桌椅或书架。

Q2. retention 递归推理时，状态矩阵的大小特征是？

单选题 · easy

  • A.随序列线性增长
  • B.固定为 d×d 大小← 正确答案
  • C.和词表大小一致
  • D.每处理一步翻倍

答案：B。递归形式只维护一个 d×d 的状态矩阵 S，与序列长度 n 完全无关。无论处理 100 个 token 还是 10 万个 token，黑板始终只有那么大，这正是 RetNet 推理内存恒定的原因。

Q3. 衰减矩阵 D 中，当行号 n 大于等于列号 m 时，D 的值为？

单选题 · mid

  • A.γ 的 n 减 m 次方← 正确答案
  • B.γ 的 m 减 n 次方
  • C.1 减去 γ 的差值
  • D.γ 除以下标差值

答案：A。D 是下三角衰减矩阵，n≥m 时值为 γ^(n−m)，距离越远衰减越厉害；n<m 时为 0。这就像黑板字迹的深浅由时间距离决定——昨天清楚，上周模糊。

Q4. retention 的并行矩阵形式最适合应用于哪个阶段？

单选题 · mid

  • A.解码推理阶段
  • B.模型训练阶段← 正确答案
  • C.模型压缩阶段
  • D.数据增强阶段

答案：B。并行形式把整段序列的 Q、K、V 一次性送入矩阵乘法，在 GPU 上高度并行，适合训练时"批量核账"；推理时则切换到递归形式，用固定状态逐 token 更新。

Q5. 关于 retention 机制，下列说法正确的有哪些？

多选题 · mid

  • A.训练时可用并行矩阵运算← 正确答案
  • B.推理时状态大小固定← 正确答案
  • C.必须使用 softmax 归一化
  • D.衰减矩阵是上三角矩阵

答案：AB。retention 训练用并行矩阵乘，推理维护固定状态矩阵，A、B 正确。它刻意去掉了 softmax，C 错；衰减矩阵是下三角（未来置零），D 错。这就像小黑的黑板不需要"所有历史权重和为 1"的规矩。

Q6. 当衰减因子 γ 等于 1 时，retention 会退化为哪种情况？

单选题 · mid

  • A.标准注意力机制
  • B.无衰减线性注意力← 正确答案
  • C.普通循环网络
  • D.简单卷积网络

答案：B。γ=1 表示旧记忆完全不褪色，所有历史权重相等，retention 退化为无衰减的线性注意力。这时小黑的黑板永远不会淡出旧字，所有内容一样清楚，反而失去位置感知和重点区分能力。

Q7. RetNet 块级循环（chunkwise）的计算方式是？

单选题 · hard

  • A.块内外全部递归
  • B.块内并行块间递归← 正确答案
  • C.块内递归块间并行
  • D.块内外全部并行

答案：B。chunkwise 把序列切成块：块内部用并行矩阵乘一次算完，块与块之间用状态矩阵递归传递。就像小黑上午、下午分班次：班内集体核账，班间只交"状态摘要"。

Q8. 相比标准 Transformer，RetNet 的优势体现在哪些方面？

多选题 · hard

  • A.推理时无需保存 KV 缓存← 正确答案
  • B.训练时保持并行加速← 正确答案
  • C.推理精度一定超过注意力
  • D.不需要维护任何隐状态

答案：AB。RetNet 推理只维护一个 d×d 状态矩阵，无需 KV 缓存，A 对；训练时仍用矩阵乘并行计算，B 对。精度取决于数据和训练，C 错；它恰恰需要维护状态矩阵，D 错。这是"用固定黑板代替越堆越高的账本"的架构优势。

Q9. retention 递归形式的状态更新公式是？

单选题 · mid

  • A.状态乘 γ 后加新键值外积← 正确答案
  • B.状态直接加上新键值外积
  • C.状态乘 γ 后减新键值
  • D.状态乘 γ 后加新查询

答案：A。正确更新为 S_n = γS_{n−1} + K_n^T V_n：旧状态整体衰减后叠加当前键值外积。B 缺少衰减，C 符号错误，D 把键值换成了查询。就像黑板先整体淡一点，再写上新人记录。

Q10. 关于衰减矩阵 D 的功能，正确的表述有哪些？

多选题 · hard

  • A.为模型提供位置感知← 正确答案
  • B.强制时序因果信息← 正确答案
  • C.本身是可训练参数
  • D.替代残差连接机制

答案：AB。D 的下三角结构保证因果性，γ 的幂提供距离位置感知，A、B 正确。D 由 γ 推导而来，不是独立的可训练参数矩阵，C 错；残差连接是另一个组件，D 错。黑板的"字迹深浅"编码时间远近，同时挡住未来信息。