RLT是Recurrent Looped Transformer的缩写，是一种通过跨token循环的潜变量状态实现无限时间深度的Transformer模型。

RLT如何实现无限时间深度？

RLT通过递归路径累计经过的block数量随着序列增长而伸长，实现随序列无限伸长的有效计算路径，从而实现无限时间深度。

RLT的仓库在哪里？

RLT的仓库地址是yifanzhang-pro/recurrent-looped-tranformer，截至2026年9月已经获得约743个star和77个fork。

技术拆解 009｜RLT：给 Transformer 接一条时间回路，潜变量推理与「无限时间深度」的真面目

技术拆解：解析 AI 技术框架——说明、分析、技术评估、价值判断、落地使用。作者：永亮

Transformer 有一个很少被直视的约束：不管序列多长，每个 token 路过的层数是固定的。序列从 100 个 token 涨到 10 万个，单 token 的计算深度纹丝不动——模型变「宽」了，但没有变「深」。2026 年 9 月，Yifan Zhang 发布了一份技术报告 Recurrent Looped Transformer（RLT），主张把深度从层数里解放出来：用一个跨 token 循环的潜变量状态，让「有效计算路径」随着序列增长而伸长，他把这个性质叫作 infinite temporal depth——无限时间深度。仓库创建仅三天，截至 2026 年 9 月已经拿到约 743 个 star、77 个 fork。这篇文章拆六件事：它是什么、核心机制一直拆到状态与缓存的定义、技术评估、值不值得追、怎么落地，以及——如果你想自己写一份极简的循环反馈 Transformer，最小骨架是什么。

一、这是什么

一句话定位：RLT 是一个研究论文类项目，核心主张是 latent reasoning with infinite temporal depth——用潜变量推理换取随序列无限伸长的有效计算路径，而不是靠堆层数换深度。

关键事实先摆清楚。仓库 yifanzhang-pro/recurrent-looped-tranformer（注意仓库名就是 tranformer，少一个 s 的原始拼写），作者 Yifan Zhang，单作者技术报告，2026 年 9 月发布，仓库内容以 Apache-2.0 许可开源。截至 2026 年 9 月约 743 星、77 fork，创建于 2026 年 9 月 12 日——三天前。GitHub 给这个仓库标的主语言是 HTML，原因是仓库主体目前是项目主页，没有官方代码实现；报告里引用的实验数字来自一位独立贡献者约 79K 参数的小型第三方实现。仓库里附了论文 PDF（Recurrent_Looppped_Transformer.pdf，文件名里的三个 p 也是原始拼写）和一份 Prefill-Decode kernel mismatch 笔记，放在作者的 Pretraining-RL-Science 仓库里。

先把「无限时间深度」这句话的精确含义钉死，因为全项目的价值都压在这几个字上：走过 t 个 token 之后，递归路径累计经过了 t×L_D 个 block（L_D 是解码器层数），但每个 token 实际执行的 block 数是固定的。换句话说，这是一条随序列增长的可扩展时间计算路径——深度长在「时间上」，不是一个 token 内部获得无限计算。作者自己在报告里反复强调这个区分，这篇文章后面所有评估都按这个口径来。

二、核心机制

2.1 总体结构：encoder 管全局记忆，decoder 管局部记忆加时间反馈

RLT 把传统 decoder-only 的层堆切成两个角色分明的堆栈。encoder 是因果的，跑一遍 prompt，构建一份全局 KV 记忆（global KV memory）——序列里所有位置的信息都压缩在这份记忆里，供 decoder 随时取用。decoder 是递归的：48 层 encoder 对 48 层 decoder，注意力与 FFN 权重跨阶段共享。这里有一个容易看错的账：decoder 的每个 block 除了自注意力，还要额外做一次对 encoder 记忆的 cross-attention，所以「层数相等」不等于「FLOPs 相等」——decoder 单层的实际开销高于 encoder 单层，这个不对称是架构自带的。

2.2 注意力模式：三种记忆各管一段

decoder 的每一步要同时面对三种记忆，分工很干净。

全局上下文靠 cross-attention：decoder 只能通过当前位置去读 encoder 记忆，而不是每个位置都重扫一遍完整历史。局部记忆靠滑动窗口注意力（SWA）：窗口 W 包含当前 token，缓存里保留 W-1 条历史，窗口之外的历史不驻留在 decoder 里，想要就得从 encoder 记忆里重新取。时间反馈靠递归：上一步的最终 decoder 输出，作为潜变量进入下一个 token 的计算。三种机制叠加，模型既有长程全局视图，又有本地上下文，还带着一条贯穿整条序列的隐式时间状态。

2.3 状态与缓存：H_t 的完整定义

这套设计里最值得逐字读的是解码器状态的定义。完整的解码器状态写作 H_t = (s_t, C_t^D)：s_t 是递归输出（上一步的最终隐状态），C_t^D 是各层的 SWA KV 缓存，初始状态 H_0 = (s_*, ∅)——递归输出从一个特殊初值出发，缓存从空集出发。两个工程细节最能体现设计意图：第一，prompt 与 response 的边界处，递归输出和 SWA 缓存都不重置，训练样本和生成序列共享同一条状态轨迹；第二，「无限深度」就是从这个状态定义里长出来的——每个 token 只在固定层数里前向一次，但 s_t 把上一步的信息带了进来，递归路径的总长度随 t 线性累乘。

2.4 一个 token 的完整旅程

把三种记忆串起来看一个 token 怎么走。第 t 个 token 进场，先和上一代的递归输出合并——s_{t-1} 经过反馈投影，与当前 token 的 embedding 合成 decoder 的输入。这个输入随后穿过 48 层权重共享的 decoder block：每层先在宽度为 W 的滑动窗口里做自注意力，从 C_t^D 里取本层的 KV 缓存，再对 encoder 的全局记忆做一次 cross-attention，最后过 FFN。走完 48 层，最终隐状态一分为二：一路规整后成为 s_t，顶替 s_{t-1} 进入下一轮递归；另一路接输出头给出当前 token 的预测。全程没有一次「重扫完整历史」——全局信息只从 encoder 记忆里按需取，本地信息只从窗口里取，再往前的事都在潜变量 s 里。这就是「深度长在时间上」的具体样子：单 token 的前向还是 48 层，但每个 token 都站在上一步 48 层的肩膀上。

2.5 一套执行语义贯穿训练与推理

RLT 报告里最工程化的主张，是预训练、SFT、采样、RL 用同一套 complete-state transition，状态定义里同时包含 prompt 递归和 SWA 缓存。四种场景各自的样子是：prefill 按因果 batch 编码，逐 prompt token 递归构建 SWA KV；generation 增量编码，从前序状态采样，每个 token 只被消费一次；预训练用 full BPTT，监督每一个合法的 next-token 预测，梯度穿过整条递归轨迹；SFT 只监督 assistant 目标，但状态沿全序列持续更新。传统方案里训练按teacher forcing展开、推理按自回归展开，两边状态语义不一致，prompt 边界处最容易出隐性偏差；RLT 的做法是从定义上把这条缝填平。

2.6 RL 章节：比架构更硬核的是训练目标的诚实

报告的 RL 章节密度相当高，四条结论值得原样记住。第一，current-policy replay 在权重更新之后必须重建参数相关缓存——状态里缓存的 KV 是旧参数算出来的，不重建，replay 的状态就是错的。第二，完整梯度要穿过递归输出、decoder KV 缓存和 encoder 记忆，任何 detach 都是梯度近似，不是精确反传。第三，行为 log-prob 必须描述真实的采样分布；要算精确的 importance sampling，还得满足 support coverage——策略更新后旧轨迹里出现的动作在新策略下概率为零，权重就没有定义。第四，共享执行语义消除的是 prompt 边界的结构性 mismatch，它不保证数值层面的 kernel parity，也不自动给你一个无偏的 off-policy 目标。这几条读起来像给后续研究者立的施工规范：哪些坑是定义层面已经填掉的，哪些坑还原样留在那里。

2.7 模型与硬件、模型与算法的协同

报告还列了两组协同设计原则。模型-硬件侧：encoder 做并行批处理，decoder 跨序列 batching，记忆复用，activation checkpointing 换显存。模型-RL 算法侧：就是 2.5 那套共享状态转移。需要冷静看待的是，作者自己声明推理改进、硬件加速、RL 扩展是研究目标，不是这份报告已经测出来的结果——2.7 这一节描述的是设计原则，不是性能数据。

三、技术评估

先说证据形态：这个项目只有 README 记录的初步合成实验，数字全部来自约 79K 参数的小实现、3 个随机种子，作者明确写了 FLOPs 未匹配、这是独立合成概念验证，不是大规模推理或 RL 扩展的验证。评估只能在这个框里做。

实验设定：两个合成任务，训练用 32 步长度的操作序列，评测外推到 128 步——4 倍于训练长度，每个任务每个长度用 2048 个测试程序。第一个 parity 任务，训练长度内 RLT 接近 100%，对照的常规 Transformer 是 72%；外推到 128 步，RLT 60.8%，对照组 48%，而随机基线是 50%——也就是说对照组在 4 倍外推长度上已经跌穿随机水平，RLT 还能维持在随机线以上。第二个 five-state transitions 任务，训练长度内 RLT 同样接近 100%，对照组只有 24%；但外推到 128 步，RLT 回落到 20.7%，随机基线就是 20%——这个任务上，4 倍外推之后大家全都回到随机猜。合起来读：循环反馈确实给模型带来了训练长度之外的泛化余量，parity 任务上余量明显；但这个余量高度依赖任务，five-state 任务上它撑不过 4 倍外推。两个任务、79K 参数、FLOPs 不对等——这组数字能证明「机制可行、值得继续研究」，证明不了「这条路一定走通」。

和同方向的头部工作比，RLT 的差异在状态的设计粒度：它显式定义了完整的解码器状态（递归输出加逐层 SWA 缓存），并且坚持训练与推理共用同一套状态转移语义，这条纪律在 latent reasoning 方向里并不常见——多数方案的训练形态和部署形态是两套代码。代价也清楚：状态定义越完整，实现时越没有一个环节能偷懒，2.5 节那四条施工规范就是代价清单。

热度必须泼冷水。单作者、仓库三天、主语言 HTML（没有官方代码，实验是第三方小实现）——截至 2026 年 9 月的约 743 个 star，反映的是「无限时间深度」这个想法的吸引力，不是工程的成熟度。把它当设计文档和研究议程读，价值很高；把它当可用模型或框架读，目前什么都没有。

四、价值判断

真问题是真的：Transformer 的单 token 计算深度被层数钉死，长序列上模型「见过」的总计算在涨，「每步思考」的深度却没涨，latent reasoning 这条线就是想补上这个缺口。RLT 给出的回答是明确的状态定义加共享执行语义——尤其训练与推理一套状态转移这一点，是这个方向里少见的纪律性设计。

边界同样明确。第一，没有官方实现，想看代码的人目前只能读第三方的小实验。第二，实验是 79K 参数级的合成任务，FLOPs 未匹配，大规模语言建模上的表现完全没有数据。第三，作者自己划了线：推理改进、硬件加速、RL 扩展是研究目标，不是已测结果——任何把这三件事写成「RLT 已经做到」的转述都是过度解读。第四，five-state 任务 4 倍外推跌回随机水平，说明循环反馈带来的余量有任务边界，不是普适能力。什么时候值得追：做 latent reasoning、长序列状态建模、训练推理一致性研究的人，这份报告的状态定义和施工规范值得逐条读。什么时候不该追：想要一个开箱可用模型的人，这个仓库目前只有论文和项目页。

五、如何落地

严格说这一节没有传统意义的「安装」——没有官方代码可装。能落地的有三件事。其一，读论文：仓库内附了 PDF，状态定义、执行语义、RL 章节的完整论证都在里面。其二，读配套笔记：作者在 Pretraining-RL-Science 仓库里放了 Prefill-Decode kernel mismatch 笔记，讲的是预填充与解码两阶段在数值和调度上的不一致——这正是 RLT 用共享执行语义想填的那类缝，两篇对着读，才能看懂设计动机。其三，复现实验：README 里的合成实验规模很小（约 79K 参数），按 2.4 的执行语义自己写一份，用 parity 任务对照常规 Transformer，一个熟悉 PyTorch 的人一两周能交出初版。仓库内容以 Apache-2.0 开源，论文和文档可自由引用与改写。

六、如何自己做一套类似的方案

「自己写一套」在这个题目上格外可行，因为 RLT 的核心就是一个状态定义加一条训练纪律。最小骨架六步：

切开两个角色：拿一个标准 Transformer block，复制成两份权重共享的堆栈。encoder 堆栈因果地编码整段输入，把每层的 K、V 留下来当全局记忆；decoder 堆栈负责逐 token 生成。层数不必 48，4 层对 4 层就能验证机制。
定义完整状态：decoder 的状态写成二元组 H_t = (s_t, C_t)，s_t 是上一步的最终隐状态，C_t 是各层滑动窗口的 KV 缓存（窗口 W 含当前 token，留 W-1 条历史）。初始 H_0 = (s_, ∅)，s_ 可以学成参数。
接上时间反馈：每个新 token 的输入，由它的 embedding 与上一步 s_{t-1} 合并而成（过一个小的投影层再相加即可），然后进 decoder 堆栈：每层先对窗口内做 SWA，再对 encoder 记忆做 cross-attention，最后过 FFN。
守住边界不重置：prompt 与 response 的边界处，s 和 SWA 缓存都保持原样——这一条是整套机制的灵魂，重置了就退化成普通 Transformer。
full BPTT 训练：teacher forcing 展开，每一步都监督下一个合法 token，梯度穿过整条递归轨迹。想 detach 提速度可以，但记住那是梯度近似，按近似的结论下判断。
RL 时重建缓存：策略每更新一次，参数相关缓存全部重算；行为 log-prob 用真实的采样分布算，importance sampling 前检查 support coverage。

核心循环用伪代码压缩就是：

H = (s_star, empty_cache)                     # 初始状态
for t in 序列:
    x = embed(token[t]) + W_fb @ H.s          # 时间反馈：上一步最终隐状态
    for l in 1..L_D:                          # decoder 各层各用各的权重（与 encoder 跨阶段共享）
        x = SWA(x, H.cache[l], window=W)      # 局部记忆：只留 W-1 条历史
        x = cross_attention(x, enc_kv)        # 全局记忆：只从当前位置读
        x = FFN(x)
        H.cache[l].push(KV(x))
    H.s = final_norm(x)
    loss += CE(head(H.s), token[t+1])         # full BPTT，不中途切断
# prompt/response 边界：H.s 与 H.cache 都不重置

六步加起来，机制验证级别的复现，一到两个人一个月内有结果。真正难的不是写出来，是第 4、5 步的纪律——边界不重置和梯度不切断看着只是两行代码，它们才是「无限时间深度」的全部来源。

结论

RLT 把 Transformer 的计算深度从层数里解耦出来：48 层 encoder 供全局记忆，48 层权重共享的 decoder 靠滑动窗口加时间反馈，让有效计算路径随序列线性伸长，并用一套贯穿训练与推理的完整状态定义堵住了 prompt 边界的结构性偏差。它目前是单作者、三天、约 743 星的研究报告，没有官方代码，实验只是 79K 参数级的合成概念验证，FLOPs 未匹配——星数买的是想法，不是工程。但对关心 latent reasoning 的人来说，它的状态定义和那份施工规范式的 RL 章节，是目前这个方向里最值得逐条读的设计文档之一。

参考来源

Recurrent Looped Transformer GitHub 仓库（README master 分支、项目主页、论文 PDF Recurrent_Looppped_Transformer.pdf）：https://github.com/yifanzhang-pro/recurrent-looped-tranformer
GitHub 仓库元数据（star/fork/创建时间/主语言/许可，api.github.com，截至 2026 年 9 月）
初步合成实验数据（README「Preliminary synthetic experiments」一节，独立贡献者 @AradhyeAgarwal 的约 79K 参数实现）
Prefill-Decode kernel mismatch 笔记（yifanzhang-pro/Pretraining-RL-Science 仓库）