OpenMythos 完全解析：22 岁开发者用公开论文"猜出"了 Claude Mythos 的架构？循环深度 Transformer 原理与实践全拆解

本文由 莫潇羽@源码七号站（www.fuyuan7.com）撰写，转载请注明出处。

快速摘要

OpenMythos 是一个开源项目，由 22 岁的开发者 Kye Gomez 用纯 PyTorch 实现。它的核心假设是：Anthropic 封锁不对外发布的前沿模型 Claude Mythos，底层用的是一种叫"循环深度 Transformer（Recurrent-Depth Transformer，RDT）"的架构——和传统大模型靠堆层数提升能力不同，RDT 让同一组权重反复跑多遍，每跑一遍就是更深一层的推理。UCSD 和 Together AI 的 Parcae 论文（2026 年 4 月）用实验证明：770M 参数的循环模型在效果上能追平 1.3B 的传统 Transformer，参数量省了将近一半。OpenMythos 项目结合了混合专家系统（MoE）、DeepSeek-V2 风格的多潜变量注意力（MLA）、自适应计算时间（ACT）和线性时不变（LTI）稳定注入，提供了从 1B 到 1T 参数的七种配置，代码已在 GitHub 以 MIT 协议开源，短短数周内收获超过 1.1 万 Star。

需要说清楚的是：这个项目目前没有经过训练的权重，也没有发布任何 benchmark 数据。它是一个基于公开论文的架构假设代码实现，不是可以直接用的产品。它的价值在于：提供了一套可被证伪的技术假设，以及一个干净、可运行、可扩展的循环深度 Transformer 研究基线。

想看完整拆解，往下翻。

一、那个被"封印"的模型

2026 年 3 月，Anthropic 的一份草稿文件意外流出，里面把一个叫 Claude Mythos 的内部模型描述为"迄今为止最强大的 AI 模型"。4 月 7 日，Anthropic 正式宣布了这个模型，并同时推出了一个叫 Project Glasswing 的限制访问计划。

Mythos 有多强？官方红队博客的描述颇为震撼：测试期间，Mythos Preview 在没有任何人类介入的情况下，自主发现并利用了 FreeBSD 中一个存在了 17 年的远程代码执行漏洞（CVE-2026-4747）——任何人只要连接互联网，就能用它获得目标服务器的 root 权限，全程自动完成。对于 Firefox，Mythos 在测试中找到了 271 个漏洞。它还能把多个看似无关的漏洞串联起来，构造出四五步、甚至三十多步的攻击链，单独拿出来每个漏洞都危害有限，组合在一起却是致命的。在 CTF（夺旗赛）这类专家级安全挑战中，成功率达到了 73%。

还有一个让安全研究者特别警惕的细节：Mythos Preview 在 OpenBSD 的代码库里找到了一个存在了 27 年的 bug——只需要发几个网络数据包，就能让任何一台运行 OpenBSD 的服务器直接崩溃。这类漏洞过去需要顶尖安全研究员花费数周时间才可能发现，现在 Mythos 自主完成了全过程，从扫描代码到构造 PoC（概念验证利用代码），期间不需要人类介入。

Anthropic 红队的研究员 Nicholas Carlini 在介绍 Project Glasswing 的一段视频里说了句让不少人印象深刻的话：过去几周他找到的漏洞，比他职业生涯之前所有时间加起来还多。这话来自一个专业安全研究员之口，说明 Mythos 带来的不是效率上的边际提升，而是量级上的跨越。

Anthropic 的结论很直接：这个模型的能力已经"远超目前所有 AI 模型"，如果公开发布，意味着大规模自动化网络攻击的门槛会大幅降低。所以他们选择不对外开放——这在 AI 发展史上属于相当罕见的决定。Anthropic 甚至私下向美国政府官员发出了预警，称 Mythos 的出现大幅提升了今年内发生大规模 AI 驱动网络攻击的可能性。

取而代之的是 Project Glasswing，一个让精选合作伙伴能够访问 Mythos Preview 的封闭计划。目前加入的有 AWS、Apple、Cisco、CrowdStrike、Google、JPMorganChase、Microsoft、NVIDIA 等十余家大公司，以及额外约 40 个负责维护重要软件基础设施的组织。Anthropic 为此承诺投入 1 亿美元的模型使用额度，同时向 Linux 基金会旗下的 Alpha-Omega 和 OpenSSF 捐出 250 万美元，向 Apache 软件基金会捐出 150 万美元，帮助开源软件维护者应对这个急剧变化的安全环境。

Project Glasswing 的工作重心是：让这些机构抢在攻击者拿到类似能力之前，先把关键系统的漏洞找出来打上补丁。预期的任务类型包括本地漏洞检测、二进制黑盒测试、端点安全加固和渗透测试。Anthropic 估计，其他 AI 实验室开发出类似能力模型的时间窗口在 6 到 18 个月之间——也就是说，留给防御方"抢先跑一圈"的时间并不多。

能力定价方面，Mythos Preview 对参与计划的机构收费为每百万输入 token 25 美元、每百万输出 token 125 美元，可通过 Claude API、Amazon Bedrock、Google Cloud Vertex AI 和 Microsoft Foundry 接入，但对普通开发者而言，这个模型形同不存在。

Anthropic 从来没有发表任何关于 Mythos 的技术报告，没有论文，没有架构细节，连"这个模型到底用了什么架构"都没有任何官方说法。安全研究社区的一部分人批评这种做法，认为不发技术报告会妨碍学术界独立评估模型的真实能力和风险；Anthropic 的立场是：在这个阶段公开架构细节可能加速恶意使用能力的扩散，封锁是一种负责任的选择。

这两种立场各有其合理之处，站在不同的位置上都说得通。这里不做评判，只是提一下这个背景——因为正是这种"信息封锁"，才给了 OpenMythos 出现的土壤。

这就是 OpenMythos 出现的背景。

二、Kye Gomez 其人：一个周末的逆向推断

Kye Gomez 在 AI 开源圈不算陌生，他是多智能体编排框架 Swarms 的创始人，GitHub 上已有不少已经积累了相当关注度的开源项目。2026 年 4 月 19 日，他在 Twitter 上发了一条推文：

"Introducing OpenMythos: An open-source, first-principles theoretical reconstruction of Claude Mythos, implemented in PyTorch."

配套的 GitHub 仓库里是满满的方程、引用和一句简洁的免责声明——和 Anthropic 没有任何关系。

据报道，他在一个周末完成了整个项目的核心代码。材料来源全部是公开的学术论文：循环深度 Transformer 的相关研究（Geiping et al., 2025）、Parcae 稳定训练方案（Prairie et al., 2026）、DeepSeek-V2 的多潜变量注意力机制、连续潜在空间推理的理论分析（Saunshi et al., 2025）、COCONUT（2024）框架，等等。

他的逻辑是：Mythos 表现出来的两个特征，结合在一起，在现有架构里只有循环深度 Transformer 能解释。第一，它在处理从未见过的新型复合推理问题时表现异常出色，远超其他模型；第二，它的知识记忆并不特别均衡，有时候会在一些"常识"问题上翻车。这种组合——推理组合能力极强、但机械记忆相对普通——正是循环深度架构的典型特征：它更擅长"组合已知知识"而不是"死记知识本身"。

当然，这个推断链条本质上是一种"架构侦探"工作：从外部可观测的行为特征倒推内部结构。这类工作需要对各种架构的"行为指纹"有深入的了解，才能从模糊的外部表现里提炼出有意义的假设。Kye Gomez 在 README 里把这个过程称为"first principles reconstruction"——不是从泄露的代码推断，而是从基本原理出发，用公开的研究文献拼出一个足够具体的假设，具体到可以写成可运行的代码，具体到可以被证伪。

4 天内，仓库收获了将近 7000 个 Star。截至目前，已经超过 1.1 万，fork 数量超过 2700，不少学术机构直接把代码拉下去当课程材料用了。项目的 MIT 协议意味着任何人都可以在此基础上自由修改和使用。

从社区反应来看，真正被这个项目吸引的人主要分两类：一类是对 Mythos 本身好奇、想知道"那个被封锁的模型到底是什么样的"；另一类则更务实，他们关注的不是 Mythos，而是循环深度 Transformer 这个架构方向本身——OpenMythos 恰好提供了一个整合了最新研究成果的干净代码库，省去了从头复现多篇论文的功夫。

三、循环深度 Transformer：换一种方式"变聪明"

在讲 OpenMythos 的架构细节之前，有必要先把"循环深度 Transformer"这个概念说清楚——因为理解了它，后面所有的设计选择才能看出逻辑。

传统大模型的扩展思路

GPT、LLaMA、Mistral 这些主流大模型，用的都是固定深度的 Transformer。所谓"固定深度"，意思是：模型有 N 层，每一层都有自己独立的一套参数，输入进来之后，从第 1 层走到第 N 层，走一遍就完事了。

你想让模型更聪明？加层数。100 层不够就 200 层，200 层不够就 400 层。GPT-4 据估计有几百层。每一层都有自己的权重，参数量随层数线性增长，模型越强，存储和显存需求就越大。

这个方向已经被撑得很撑了。莫潇羽自己折腾过一些小规模的模型，亲身体会到参数量一旦上去，不光训练贵，推理时光是把权重加载到显存就是一个门槛。业界也有人开始想：参数越多一定越好吗？还是说，其实是"思考的方式"更重要？

一个有意思的类比：同样是"增强一个人的能力"，一种方式是让他学更多的知识（参数增加），另一种方式是让他在回答之前多思考几遍（循环增加）。前者的瓶颈是"记得住多少"，后者的瓶颈是"想得有多深"。对于现在的大模型来说，"记得住多少"已经相当可观了，真正的短板越来越集中在"能不能把这些知识灵活地组合和推理"——这正好是循环深度架构在设计上重点强化的部分。

循环深度的不同做法

循环深度 Transformer（Recurrent-Depth Transformer，简称 RDT，也叫 Looped Transformer）的思路完全不同。

它不堆层数，而是取一个相对紧凑的核心层（称为"循环块"），然后让这个循环块在一次前向传播中跑 T 遍。每一遍都把上一遍的隐藏状态和原始输入混合进去，继续计算，得到新的隐藏状态，再进入下一遍。

用一个直白的比喻：传统模型像一条流水线，零件经过 200 道工序，每道工序只走一遍；循环深度模型像是让一个工人对着同一个零件反复打磨 T 遍，每遍都在上一遍的基础上继续深化。

传统 Transformer：
输入 → 层1 → 层2 → 层3 → ... → 层N → 输出
(每层独立参数，走一遍)

循环深度 Transformer（RDT）：
输入 → 前奏层 → [循环块] × T 次 → 尾声层 → 输出
(循环块同一套权重，跑 T 遍)

关键推论有两个：

第一，参数量不随推理深度增长。传统模型 200 层就得存 200 组权重，RDT 只需要存一组循环块的权重，推理跑多少遍都不增加存储开销。

第二，推理深度可以在运行时动态调整。遇到简单问题，少跑几遍；遇到难题，多跑几遍。不需要重新训练，改一个参数就行。这在传统固定深度模型里是做不到的——你不能让一个 GPT 对简单问题少过几层。

下面这张表格对比了两种架构的关键特性，方便快速参考：

在连续潜在空间里推理

这里有一个细节很重要，也常常被误解。

RDT 的多轮循环不是"Chain-of-Thought（思维链）"——后者是让模型把中间推理步骤以文字 token 的形式输出出来，然后再读回去继续推理。RDT 的每一轮循环都在连续隐藏状态空间里进行，全程不生成任何中间 token，只在最后一轮结束之后才输出答案。

Saunshi et al.（2025）在论文里做了形式化证明：RDT 的每一次循环迭代，在功能上等价于 Chain-of-Thought 里的一步推理，但是它运行在实值向量空间里而非离散 token 序列里。连续潜在空间的好处是：一个隐藏状态向量能同时编码多条可能的推理方向，而不是像 Chain-of-Thought 那样一次只能走一条路径。这有点像在脑子里同时"想几种可能"再做决定，而不是一开口就固定了方向。

这个特性可以解释一个关于 Mythos 的观察：在那些需要把几个不太相关的知识点"拼"起来才能回答的新型问题上，Mythos 的表现远超其他模型，而这类问题并不需要死记硬背，需要的是推理组合。

还有另一个具体的能力优势值得展开讲：深度外推（Depth Extrapolation）。对固定深度的传统 Transformer 来说，训练时的"推理深度"（层数）就是推理时能用的最大深度，无法在不改变模型的情况下让它"想得更深"。RDT 则不同——哪怕训练时只跑了 16 轮循环，推理时你可以让它跑 24 轮甚至 32 轮，模型依然能从中受益，精度不会崩。这意味着你可以用推理时的算力换质量，在部署时灵活调整——要速度的时候少跑几轮，要精度的时候多跑几轮，硬件不变，效果可以动态调节。

这和近几年 AI 圈里讨论很多的"推理时扩展（Test-Time Scaling）"一脉相承，但 RDT 的实现方式更内敛：没有额外的 token 生成，没有 context window 的占用，全在模型内部的隐藏状态里完成。

四、三段式架构全拆解

OpenMythos 的整体架构分三段：前奏层（Prelude）、循环块（Recurrent Block）、尾声层（Coda）。

graph TD
    A[输入 Token 序列] --> B[词嵌入 + 位置编码]
    B --> C[前奏层 Prelude\n标准 Transformer 层 × L_pre]
    C --> D{循环块 Recurrent Block\n同一套权重 × max_loop_iters 次}
    D -->|每轮| E[MoE Feed-Forward 层]
    D -->|每轮| F[MLA 或 GQA 注意力层]
    D -->|每轮| G[LTI 稳定注入]
    D -->|ACT 判断| H{是否提前退出?}
    H -->|否| D
    H -->|是| I[尾声层 Coda\n标准 Transformer 层 × L_post]
    I --> J[最终输出]

三段结构中，前奏和尾声是普通 Transformer 层，只走一遍。核心在中间的循环块——同一套权重，最多循环 16 次（可配置，推理时可以超过训练轮次）。

前奏层和尾声层

这两部分没有太多特别的地方，就是普通的 Transformer block。前奏层负责把原始 token 嵌入向量转化成更好的"初始隐藏状态"，让循环块有一个质量更高的起点；尾声层在循环结束后，把最终隐藏状态"解码"成合理的输出表示，再接 LM head 预测下一个 token。

这个设计来自 Geiping et al.（2025）提出的三段式框架，目的是避免让循环块既要处理原始输入、又要处理最终输出，分工明确，减少每个部分的压力。

莫潇羽在读这部分的时候有一个直觉性的理解：你可以把前奏层想象成"准备工作"——把原始 token 嵌入从一个相对简单的空间映射到一个循环块更容易处理的表示空间；循环块就是"反复思考"的过程；尾声层是"整理输出"——把深度循环之后的隐藏状态收拢成语言模型头（LM head）能用的形式。三段分工让每个部分都只需要做好一件事，比把所有事情都丢给同一个模块要清爽得多。

前奏和尾声的层数是可配置的，一般从 1 到 4 层不等。层数太少（比如 0 层）相当于直接把词嵌入送进循环块，效果往往不好；层数太多会浪费参数，因为这部分没有权重共享的优势，每增加一层都是纯参数增量。实践中，前奏 2 层、尾声 2 层是比较常见的平衡点。

循环块的核心：每轮在做什么

循环块在每一次迭代里，会做以下几件事：

h_t+1 = f(h_t, x_enc)

其中：
- h_t  : 第 t 轮结束时的隐藏状态
- x_enc: 原始输入的编码（每轮都重新注入，避免信息衰减）
- f(·) : 注意力层 + LTI 注入 + MoE FFN 的组合变换

注意一点：每一轮循环结束后，原始输入会被重新注入，而不是只靠隐藏状态传递信息。这避免了一个典型问题——如果只靠 h_t 传递，循环很多遍之后原始输入的信息会被稀释，导致"想了半天忘了题目是什么"。

MoE 混合专家系统：让同一套权重"一专多能"

循环块的 Feed-Forward 层用的是混合专家系统（Mixture-of-Experts，MoE）。

简单解释一下 MoE：传统 FFN 对每个 token 都激活全部参数；MoE 把 FFN 拆成若干个"专家"子网络，每次只激活其中几个。这样模型可以有很大的总参数量，但每次推理实际计算的参数只是一小部分，计算效率更高。

OpenMythos 采用的是 DeepSeekMoE 的细粒度路由机制。DeepSeek 在这方面有比较扎实的工程实践——把专家数量做得比较多（默认 8 个路由专家 + 1 个共享专家），每次激活 2 个路由专家和 1 个共享专家，共享专家始终参与计算，保证了基础能力的稳定性，路由专家则负责处理更具专业性的子任务。

更有意思的是，循环块里的 MoE 在不同循环轮次之间激活的专家子集可以不同。这意味着同一组权重在第 3 轮循环和第 12 轮循环里实际上走的是不同的计算路径，相当于用一套参数模拟了多套不同的处理逻辑。

从工程角度看，这个设计有一个让人满意的性质：随着循环深度的增加，模型在不同轮次里自然地"专业化"了。前几轮可能激活的是偏向语法和基础语义理解的专家，后几轮则更多激活处理复杂逻辑和抽象推理的专家——当然这只是直觉上的推测，实际的专家激活模式需要对训练好的模型做可解释性分析才能确认。但这种潜力是结构上存在的，不是凭空假设的。

另外，DeepSeekMoE 的细粒度路由和"共享专家 + 路由专家"的组合设计在工程上有一个明显的好处：共享专家保证了模型在任何输入上都有稳定的基础能力，路由专家负责处理更专业化的子任务，两者互不干扰，降低了"某个 token 运气不好被分配到完全不匹配的专家"的风险。

# MoE 路由的简化示意
class SparseMoE(nn.Module):
    def __init__(self, n_experts=8, n_shared=1, n_active=2, dim=512, expert_dim=256):
        super().__init__()
        self.router = nn.Linear(dim, n_experts)
        self.shared_experts = nn.ModuleList([Expert(dim, expert_dim) for _ in range(n_shared)])
        self.routed_experts = nn.ModuleList([Expert(dim, expert_dim) for _ in range(n_experts)])
        self.n_active = n_active

    def forward(self, x):
        # 路由分数
        scores = self.router(x)  # [B, T, n_experts]
        topk_scores, topk_idx = scores.topk(self.n_active, dim=-1)
        topk_weights = topk_scores.softmax(dim=-1)

        # 共享专家：始终参与
        shared_out = sum(e(x) for e in self.shared_experts)

        # 路由专家：只激活 top-k
        routed_out = torch.zeros_like(x)
        for i in range(self.n_active):
            expert_out = torch.stack([self.routed_experts[idx](x[b]) 
                                       for b, idx in enumerate(topk_idx[..., i])])
            routed_out += topk_weights[..., i:i+1] * expert_out

        return shared_out + routed_out

两种注意力后端：MLA 和 GQA

注意力层支持两种后端，可以在配置时切换：

Multi-Latent Attention（MLA），来自 DeepSeek-V2，核心思路是把 KV cache 从全尺寸的 key-value 张量压缩成低维潜变量，只缓存潜变量，推理时再还原出完整的 K 和 V。这让 KV cache 的显存占用缩小了 10 到 20 倍，在长文本推理时优势明显。缺点是需要多一步"潜变量→KV"的解压计算，延迟略有增加。

Grouped Query Attention（GQA），更主流的方案，把多个 query 头共享一组 key/value 头，显存占用比标准多头注意力少，但没有 MLA 压缩得那么极端。这个选项支持 Flash Attention 2 加速，在有 CUDA 环境时速度更快。

两种可以通过配置里的 attn_type 字段切换：

# 使用 MLA（省显存）
config = mythos_3b()
config.attn_type = "mla"

# 使用 GQA（速度更快，支持 Flash Attention 2）
config = mythos_3b()
config.attn_type = "gqa"
config.n_kv_heads = 8  # GQA 的 KV 头数

实际使用时怎么选？我自己折腾下来的感受是：如果跑的是长文本场景（context 超过 8K），MLA 的显存优势非常明显，省下的显存可以换更大的 batch size 或者更长的序列；如果主要跑短到中等长度的任务，GQA + Flash Attention 2 的组合吞吐量更高，延迟更低。两个选项不存在谁绝对更好，看场景。

值得一提的是，MLA 这个机制是 DeepSeek-V2 在 2024 年提出来的，当时发表的时候让不少人眼前一亮——KV cache 是大模型长文本推理里的主要显存杀手，MLA 的压缩思路从根子上缓解了这个问题，后来也成为了业界新模型里比较流行的技术选择之一。OpenMythos 把它直接引入 RDT 架构里，是一个相当自然的工程组合。

ACT 自适应计算时间：聪明的"早退"机制

ACT（Adaptive Computation Time）是让模型自己决定"够了"的机制。

循环深度模型有一个潜在问题：如果对所有输入都强制跑满 T 轮，那简单的 token 也在做冗余计算。ACT 通过给每个 token 学习一个"停止概率"，让模型在觉得当前 token 已经推理充分的时候提前退出，不必等到最后一轮。

具体实现是：在每一轮循环结束时，给每个位置的 token 计算一个 (\hat{h}_t \in [0, 1]) 的停止概率，当累积停止概率超过阈值（通常是 0.99），该 token 就退出循环，后续轮次里它保持最后一轮的隐藏状态不再更新。

对每个 token 位置 p：
  - N=0，累积停止概率 R=0
  - 每轮结束：计算停止概率 h_N = sigmoid(W_stop · hidden_state)
  - 当 R + h_N >= 1-epsilon 时，停止
  - 最终输出 = 各轮隐藏状态的加权平均

这意味着同一个 batch 里，简单 token 可能只跑了 3 轮，复杂 token 跑满了 16 轮，全在同一次前向传播里完成。不需要对不同难度的输入分批处理。

ACT 机制最早由 Graves（2016）提出，用在 RNN 上。在 RDT 里，它的意义更加直接：不是所有的推理都需要同等深度，强制每个 token 都跑满最大轮次是一种浪费。一句简单的问候语"你好"不需要跑 16 轮才能回答，一个复杂的多步推理问题才需要。ACT 让模型自己学会做这个判断，而不是由开发者在外部硬编码一个固定的循环次数。

从训练的角度来看，ACT 会引入一个额外的"思考效率"正则项，鼓励模型在能够给出正确答案的前提下尽量减少循环次数。这防止了模型对简单问题也"过度思考"，也帮助控制推理时的平均延迟。在部署时，你可以通过设置 ACT 的停止阈值来控制精度和速度之间的权衡——阈值调低，模型更容易提前停止，速度更快但可能在难题上差一点；阈值调高，模型更倾向于跑满轮次，效果更稳定但速度慢一些。

# 推理时调整 ACT 阈值（epsilon）
output = model.generate(
    input_ids,
    n_loops=16,
    act_epsilon=0.01  # 越小 = 越谨慎停止 = 跑更多轮
)

深度方向的 LoRA 适配器

OpenMythos 还在每一轮循环里加了一个轻量的深度方向 LoRA（Low-Rank Adaptation）适配器。

纯粹的权重共享（每轮完全一样的参数）虽然参数最省，但表达能力相对受限——每一轮的计算方式完全相同，很难让模型的"行为"在不同轮次之间自然分化。LoRA 适配器是一个低秩矩阵对（A、B 两个矩阵，rank 远小于原始维度），把少量可训练参数叠加到共享权重上，让每一轮循环都能根据当前深度"微调"自己的行为。

这是 Relaxed Recursive Transformers（Bae et al., 2024）提出的思路：在纯权重共享和完全独立层之间找一个平衡点，用极少的额外参数换取每层的行为差异化能力。

打个简单的比方：纯权重共享就像让同一个人用完全相同的思维方式反复处理问题，16 次循环只是重复 16 遍同样的操作；加了深度 LoRA 之后，这个人虽然核心知识和技能不变（共享权重），但每一遍他都会根据当前是"第几遍思考"微调自己的分析角度和侧重点（LoRA 适配器）——第一遍可能先把题目结构搞清楚，第五遍开始验证假设，第十遍在细节上做校验。

具体实现上，深度 LoRA 的参数量通常设置得很小（rank 一般是 8 到 16），相对于主体权重来说几乎可以忽略不计。但它对模型质量的提升是可以测量到的，尤其是在需要循环推理轮次较多的任务上效果更明显。这也是 OpenMythos 把它设计成可配置参数（lora_rank）的原因——你可以根据实际任务需求和硬件预算调整这个值。

五、最难的坎：训练稳定性与 LTI 注入

循环深度 Transformer 这个思路其实不新鲜，早在 2019 年前后就有研究者提出过类似想法，但一直没有大规模落地，核心原因就一个：训练非常不稳定。

为什么循环模型训练容易崩

同一套权重反复跑 T 遍，从梯度反向传播的角度来看，这相当于一个展开了 T 步的 RNN（循环神经网络）。RNN 训练不稳定的问题研究者折腾了很多年——梯度要么爆炸（越来越大，最后 loss 变成 NaN），要么消失（越来越小，靠前的层几乎得不到有效梯度）。

标准 Transformer 之所以能扩展到数千亿参数，很大程度上是因为它是固定深度的，梯度流通路径是确定的，用残差连接、层归一化等技术可以比较可靠地解决稳定性问题。一旦引入循环，情况就复杂多了。

历史上有多个团队尝试训练循环 Transformer，多数都卡在了训练稳定性上。一个典型的失败模式是"残差状态爆炸"（residual state explosion）：随着循环轮次增加，隐藏状态的数值越来越大，超出了浮点数的正常表示范围，loss 突然变成 NaN，整个训练崩掉。另一个模式是训练初期看起来很稳定，但在某个 checkpoint 之后突然出现 loss spike（损失骤增），然后就再也降不回来了。这些问题让循环 Transformer 在很长一段时间里只是一个有趣但不实用的研究方向。

Huginn-3.5B 是目前唯一发布了公开结果的实际训练过的循环深度模型（3.5B 参数），它证明了这类架构在一定规模下是可以稳定训练的，但更大规模的系统性实验结果仍然稀缺。这也是为什么 OpenMythos 的 README 对超大规模训练的效果持谨慎态度——有了理论保证是一回事，真正跑通是另一回事。

Parcae 的解法：线性时不变（LTI）稳定注入

2026 年 4 月，UCSD 和 Together AI 发表了 Parcae 论文，从数学上给出了一个优雅的解决方案。

OpenMythos 直接采用了这套机制，叫做 LTI（Linear Time-Invariant）稳定注入。核心思想是：把每一轮循环的隐藏状态更新过程建模为一个线性时不变离散动力系统：

[

h_{t+1} = A \cdot h_t + B \cdot x_{enc}

]

其中：

• (A) 是状态转移矩阵，通过"零阶保持离散化"（Zero-Order Hold）方法构造；
• (B) 是输入注入矩阵；
• (x_{enc}) 是原始输入的编码。

关键在于 (A) 矩阵的构造方式：OpenMythos 把 (A) 设计成谱半径（spectral radius）严格小于 1 的矩阵。谱半径是矩阵最大特征值的绝对值，谱半径 < 1 在数学上保证了这个动力系统是渐近稳定的——不管初始状态是什么，随着迭代次数增加，系统最终会收敛而不会爆炸。

这不是靠调参调出来的经验性稳定，而是靠数学结构保证的。即使你把学习率设大一点、批量大小调奇怪，训练过程在数学层面仍然是稳定的。

class LTIInjection(nn.Module):
    """线性时不变稳定注入层"""
    def __init__(self, dim: int):
        super().__init__()
        # A 矩阵通过零阶保持离散化构造，保证谱半径 < 1
        log_A = torch.randn(dim) - 3.0  # 初始化在负数区，确保 e^A < 1
        self.log_A = nn.Parameter(log_A)
        self.B = nn.Linear(dim, dim, bias=False)

    def get_A(self):
        # 谱半径构造性地保证 < 1
        return torch.exp(-torch.exp(self.log_A))

    def forward(self, h: torch.Tensor, x_enc: torch.Tensor) -> torch.Tensor:
        A = self.get_A()
        # 在对数空间计算，防止 float32 精度溢出
        return A * h + self.B(x_enc)

所有的计算都在对数空间里进行，再加了 clamp 操作防止 float32 的数值溢出。这是 OpenMythos README 里特别强调的一个工程细节——做循环模型时数值精度问题比普通 Transformer 更棘手，需要专门处理。

验证稳定性的方法

代码里提供了一个验证谱半径的接口，可以在初始化模型之后直接检查：

import torch
from open_mythos.main import OpenMythos, MythosConfig

config = MythosConfig(dim=512, max_loop_iters=16, ...)
model = OpenMythos(config)

# 检查 A 矩阵的谱半径，必须严格小于 1
A = model.recurrent.injection.get_A()
print(f"谱半径 ρ(A): {A.max().item():.4f}")  # 期望值：< 1.0
# 正常输出类似：谱半径 ρ(A): 0.9127

如果这个数 ≥ 1，说明构造出了问题，训练过程将不稳定。

这个稳定性保证对做研究的人来说是个解放：过去训循环模型，很多时间花在"调参调稳"上，而不是在真正的研究问题上。有了 LTI 注入，你可以先确认谱半径，再放心地训练，不必像面对一个不可预测的系统那样小心翼翼。训练崩了大概率是数据或别的问题，而不是循环本身造成的。

另外，Parcae 论文还发现 LTI 注入有一个额外的好处：它天然地给隐藏状态提供了一种"衰减"效果。越久之前的循环轮次贡献的信息，在当前状态里权重越小，最近轮次的推理结果权重越大。这类似于循环神经网络里遗忘门的作用，让模型能自然地"聚焦在最近的推理结论上"，而不是被早期的中间状态拖累。

六、Parcae 论文与参数效率的实证

莫潇羽在梳理这些技术材料的时候，花了不少时间仔细读了 Parcae 论文（Prairie et al., 2026）。这篇论文是 OpenMythos 整个技术栈里最扎实的实验支撑，值得单独讲一讲。

从发表时间看，Parcae 论文和 OpenMythos 几乎同期出现（Parcae 是 4 月 16 日，OpenMythos 是 4 月 19 日），不知道是巧合还是 Kye Gomez 在看到论文之后立刻动手写代码。但有一点可以确定：OpenMythos 的很多核心技术选择（LTI 注入、Scaling Law 参考数字）都直接来自 Parcae，两者是深度绑定的关系。Parcae 解决了循环模型最难的问题，OpenMythos 把解决方案组合进了一个更完整的架构框架里。

770M 打平 1.3B

最核心的实验结论：在同样的训练数据（FineWeb-Edu 数据集）和同样的计算预算下，770M 参数的 Parcae 模型在效果指标（Core 基准得分）上与 1.3B 参数的标准 Transformer 相当。

770M 的 Parcae 和 1.3B 的标准 Transformer 之间的差距只有 0.38 个点（Core），在实际应用里可以视为基本持平。同等参数量下，Parcae 比标准 Transformer 高出约 1.27 个点。

研究团队把这个效率量化为：Parcae 实现了同等效果模型参数量减少约 41%，或者说达到了"参数量两倍大的模型约 87.5% 的质量提升幅度"。

循环是一个独立的扩展维度

Parcae 论文里另一个重要发现是：循环次数是一个独立的 Scaling 维度，和参数量、训练数据