我们很高兴分享这些初步成果，来自我们的内部自动研究系统 @Recursive_SI。该系统在同一底层系统下，无需针对特定任务做适配，便在 nanochat / nanogpt 速度竞赛 / 内核基准测试中达到了当前最优水平。博客文章：https://recursive.com/articles/first-steps-toward-automated-ai-research…

迈向自动化AI研究的第一步 – Recursive

来源: https://www.recursive.com/articles/first-steps-toward-automated-ai-research

今天，我们发布 Recursive 自动化 AI 研究系统的早期结果。在三个基准测试中，该系统均达到了当前最优水平：固定预算语言模型训练、小模型训练速度以及 GPU 内核优化。该系统针对目标目标自动完成研究循环：提出想法、实现、运行实验、验证结果，并利用所学知识选择下一个实验。它在长时间跨度内运行多条研究线程，保留先前实验的有用上下文，合并有前景的分支，并在将改进性能视为真正进步之前，通过验证来排除奖励黑客行为和高方差。它旨在扩展并利用开放式算法的原理，基于我们团队及其他团队先前在递归自我改进 AI 方面的工作。

我们选择的基准测试既具有实际重要性，又能提供紧密的反馈循环。它们强调了 AI 进步的三个核心杠杆：更好的训练算法、更快的训练以及更高效的硬件利用。这些基准测试也特别适合自动化研究，因为它们具有明确的指标、相对较低的方差，以及可被加固以抵御奖励黑客行为的评估器。

我们正在开源这些运行产生的工件（https://github.com/recursive-org/first-steps-toward-automated-ai-research），以便他人检查并基于系统的输出进行构建。

案例研究 1: NanoChat 自动研究

Andrej Karpathy 的 NanoChat 自动研究仓库（https://github.com/karpathy/autoresearch）是自动研究系统的一个流行起点。任务是在单 GPU 上，固定五分钟预算内，训练一个小语言模型以达到最低验证损失（以每字节比特数 BPB 衡量）。这对我们的系统来说是一个自然的测试，因为实验速度快、方差低，并且奖励黑客行为相对容易检测。可能正是因为这些原因，围绕这个设置已经形成了一个公开的协作努力。autoresearch@home（https://www.ensue-network.ai/lab/autoresearch）将原始设置扩展为一个协作环境，其中数十名人类和数百个他们的代理共同提升性能。这为我们提供了比 Karpathy 的单次过夜运行更强的比较基准。我们想测试我们的系统是否能改进由一个由人类和代理组成的整个社区产生的解决方案。

我们的系统从与 Autoresearch 代码相同的初始种子解开始。我们最初在 NVIDIA H100 GPU 上进行搜索，然后将发现的解决方案移植到 NVIDIA B200 GPU 上运行，以便与公开结果进行公平比较。在移除先前最优 autoresearch@home 解决方案中的微小奖励黑客行为，并在 10 个随机种子下进行评估后，其平均性能为 0.9372 BPB。我们的系统找到了一个达到 0.9109 BPB 的解决方案，改进了 0.0263 BPB。换一种方式衡量，我们的解决方案达到 Karpathy 原始过夜自动研究 BPB 质量所需的训练时间比最优的 autoresearch@home 解决方案大约少 1.3 倍。

NanoChat 自动研究：随着墙钟时间变化的最佳验证 BPB

图 1

自动研究从一个已经优化过的模型开始，其中嵌入了一些非琐碎的设计决策。为此，我们测试了我们的系统是否也能从一个更弱的起点——一个朴素的初始实现（一个带有 AdamW 的 vanilla Transformer）——做出改进。我们的系统将模型从 1.059 BPB 改进到 0.9344 BPB（在 NVIDIA B200 GPU 上评估），再次超越了 autoresearch@home 社区产生的最佳解决方案。这并不一定证明是独立重新发现，因为底层模型可能知道许多公开的技术，包括由 autoresearch@home 社区使用或创建的技术，但它确实表明搜索过程可以从一个更弱的起点组装出一个有竞争力的训练栈。最终解决方案与公开最佳解决方案在几个方面也存在差异。

NanoChat 自动研究：按解决方案划分的最终验证 BPB

图 2

NanoChat 自动研究：随着墙钟时间变化的训练损失

图 3

我们的系统提出了哪些修改？最佳解决方案并非由单一技巧驱动。它们结合了架构变化、短上下文记忆、辅助损失、注意力机制、优化器行为、权重衰减调度、编译器设置等等。最大的收益之一来自于一个更丰富的短上下文记忆机制。基线已经使用了值嵌入；我们的系统通过使用哈希二元模型和三元模型嵌入表扩展了这个想法，并通过学习得到的门控将它们混合到注意力值路径中。这为模型提供了一种廉价的方式来利用局部 n-gram 信息，而无需支付更慢的卷积或重注意力替代方案的时间成本。这与近期的工作如 DeepSeek Engram（https://arxiv.org/abs/2601.07372）有联系，后者探索了哈希表作为稀疏性轴。在我们的设置中，哈希表可以为大约 50M 参数的模型添加 1-2 十亿的稀疏参数：大多数条目在任何给定批次中都是非活跃的，并且查找成本很低。类似的哈希表和 n-gram 想法也出现在顶级的 NanoGPT 速度竞赛提交中。该系统通过将哈希二元和三元嵌入注入到跨多层的注意力值向量中，并每层使用不同的哈希以减少重复碰撞，将这类想法适应到了固定预算的设置中。我们不知道有先前的工作使用这种确切的变体。

下面的可展开框包含了系统解决方案中选定的技术细节。我们手动检查了这些输出，并使用 AI 辅助分析来理解这些技术并筛选奖励黑客行为。在并非我们专长的内核优化方面，我们可能仍然遗漏了错误，但这恰恰是重点所在：这里展示的想法来自于系统，而非我们之前的专业知识。

哈希表（https://www.recursive.com/articles/first-steps-toward-automated-ai-research#）

在起始解决方案中标准的单字值嵌入之上，我们的最佳解决方案中，模型将每个二元组和三元组哈希到固定大小的表中，并通过学习得到的、依赖于输入的逐头门控，将查找出的向量混合到注意力值路径中——实际上是将经典的 n-gram 模型折叠进 transformer 的值流中。

for j, layer_i in enumerate(ve_layers):
    self.bigram_ves[str(layer_i)] = nn.ModuleList([
        nn.Embedding(self.bigram_table_size, half_kv_dim),
        nn.Embedding(self.bigram_table_size, half_kv_dim),
    ])
    self.bigram_hash_primes_per_layer[layer_i] = _decorr_bigram_primes[j]
for j, layer_i in enumerate(sorted(self.trigram_ve_layers)):
    self.trigram_ves[str(layer_i)] = nn.ModuleList([
        nn.Embedding(self.trigram_table_size, half_kv_dim),
        nn.Embedding(self.trigram_table_size, half_kv_dim),
    ])
    self.trigram_hash_primes_per_layer[layer_i] = _decorr_trigram_primes[j]

v = v + gate.unsqueeze(-1) * ve                ## standard value embedding
v = v + bg_gate.unsqueeze(-1) * bigram_ve      ## additional bigram embedding from lookup table
v = v + tg_gate.unsqueeze(-1) * trigram_ve     ## additional trigram embedding from lookup table

该解决方案还给不同的 transformer 层提供了不同的哈希函数（使用不相交的哈希质数对）。

self.bigram_hash_primes_per_layer[layer_i] = _decorr_bigram_primes[j]
self.trigram_hash_primes_per_layer[layer_i] = _decorr_trigram_primes[j]

这意味着碰撞仍然会发生，但不太可能以相同的方式跨层发生。

优化 vanilla Transformer 的运行使用了与最佳解决方案相同的一些技术，包括哈希表和平方 ReLU MLP。但它也收敛到了一个不同的（同样具有竞争力的）最终栈，包括 token 移位、评估前的权重平均、以及字节级特征嵌入。这表明系统并非仅仅重复了它在另一次运行中发现的相同结果。下面的可展开框展示了 vanilla Transformer 运行中独有的一些修改。

优化 vanilla Transformer（https://www.recursive.com/articles/first-steps-toward-automated-ai-research#）

vanilla Transformer 解决方案中的许多改动也出现在我们的最佳解决方案中（该方案来自让我们的系统从 Autoresearch 初始种子代码开始），例如将 AdamW 替换为 Muon 并添加哈希表。还有一些其他改进并未出现在我们产生最佳解决方案的主要运行中，但它们引起了我们的注意。第一个是因果 token 移位，它将前一个 token 的注意力投影 Q 和 K 与当前 token 的混合，每个维度有一个学习到的系数。

B, T, C = x.size()
x_prev = F.pad(x[:, :-1, :], (0, 0, 1, 0))
q = self.c_q(x + self.q_shift_beta * x_prev).view(B, T, self.n_head, self.head_dim)
k = self.c_k(x + self.k_shift_beta * x_prev).view(B, T, self.n_head, self.head_dim)
v = self.c_v(x).view(B, T, self.n_head, self.head_dim)

第二个是一组字节级特征，在 token 嵌入之后立即注入。字节级特征代表了 token 由哪些字节（例如，单个字符）组成的信息。由相似字节组成的 token 将获得相似的字节级嵌入。字节特征嵌入矩阵构建如下：

combined = torch.zeros(vocab_size, 769)
for token_id in range(vocab_size):
    raw_bytes = tokenizer_enc.decode_single_token_bytes(token_id) # variable length
    if len(raw_bytes) > 0:
        for b in raw_bytes[:max_bytes]:                 # max_bytes=16
            combined[token_id, b] += 1.0 / len(raw_bytes)         # [0:256] byte-frequency histogram
        combined[token_id, 256 + raw_bytes[0]] = 1.0    # first byte one-hot
        combined[token_id, 512 + raw_bytes[-1]] = 1.0   # last byte one-hot
        combined[token_id, 768] = len(raw_bytes) / max_bytes  # length feature
torch.manual_seed(1337)
proj = torch.randn(769, embed_dim) * 0.01
init_emb = combined @ proj                               # [vocab, embed_dim]
self.embed = nn.Embedding(vocab_size, embed_dim)
self.embed.weight.data.copy_(init_emb)                   # used only as the INIT

然后这些嵌入在训练期间通过梯度下降进行更新，并在 token 嵌入之后与二元组和三元组嵌入一起添加：

x_base = self.wte(idx)                                         # token embedding
gates = self.embed_mixer(x_base)                               # per-token gates over 4 sources [B,T,4]
x = x_base
x = x + gates[:,:,0:1] * bi_raw                               # bigram hash
x = x + gates[:,:,1:2] * tri_raw                               # trigram hash
x = x + gates[:,:,2:3] * self.byte_embed.get_raw(idx)           # byte-content
x = x + gates[:,:,3:4] * self.byte_boundary.get_raw(idx)         # byte-boundary
x = x + self.ssm_light(x)
x = self.embed_ctx_norm(x)

这些只是我们的系统在这次运行中所做修改的一小部分。NanoChat 展示了要求我们的系统改进固定预算训练如何导致了许多复合的、预算感知的改进的发现。下一个测试是，同样的过程是否能在经过公众多年优化之后仍然在基准测试中找到收益。我们在 NanoGPT 速度竞赛上进行了测试，该基准测试的最佳公开解决方案已经过社区两年多的高度优化。

案例研究 2: NanoGPT 速度竞赛

NanoGPT 速度竞赛（https://github.com/KellerJordan/modded-nanogpt）是一个类似的任务，但击败当前最优水平要困难得多，因为一个庞大的社区已经为此优化解决方案超过两年。该基准测试不是问在固定时间预算内可以达到多低的验证损失，而是问多快可以将一个小型 GPT 风格模型训练到 FineWeb 文本数据集上固定的 3.28 验证损失，使用单个 HGX H100 8-GPU 节点。这是一项成熟的社区努力，迄今为止已有 83 项人类创纪录的贡献提交到排行榜，以及数百个提议的 PR。自 2024 年中以来，训练时间已从大约 45 分钟压缩至 79.7 秒，这得益于一系列主要手工编制的提交。鉴于当前解决方案已经过如此充分的优化，几乎没有明显的改进空间。

从当前领先的解决方案开始，我们的系统找到了一组额外的优化，将训练时间从 79.7 秒减少到 77.5 秒，同时仍然满足排行榜的验证损失显著性要求（平均验证损失 ≤ 3.28，p < 0.01）。¹(https://www.recursive.com/articles/first-steps-toward-automated-ai-research#footnote-1) 这与近期人类贡献的改进幅度相似或更大。

77.5 秒解决方案：FP8 注意力、探索噪声和谨慎的嵌入（https://www.recursive.com/articles/first-steps-toward-automated-ai-research#）

以下是它创造并组合以达到 77.5 秒（在训练脚本和内核文件中大约修改了 200 行）的创新示例。

FP8 注意力投影。 人类纪录保持者运行注意力 QKV（查询、键和值）和输出投影层使用 bf16（bfloat16，一种 16 位浮点格式），并且仅在 LM head（预测下一个 token 的最终层）中使用 FP8（8 位浮点）。该系统将 FP8 推入注意力路径（注意力层内部的计算）——一个自定义操作，它在前向矩阵乘法中使用 float8_e4m3（一种 FP8 格式，具有 4 个指数位和 3 个尾数位）以获得 2 倍的张量核心吞吐量，同时保持反向传播在 bf16 中以保持稳定，并且仅在训练期间（验证前向传播时恢复为 bf16）：

class FP8LinearFunction(torch.autograd.Function):
    @staticmethod
    def forward(ctx, x, w):
        x_f8, w_f8 = x.to(torch.float8_e4m3fn), w.to(torch.float8_e4m3fn)
        y = torch._scaled_mm(x_f8, w_f8.T, out_dtype=torch.bfloat16,
                             scale_a=ones, scale_b=ones, use_fast_accum=True)
        ctx.save_for_backward(x, w)
        return y
    @staticmethod
    def backward(ctx, grad_output):
        # backward stays in bf16 for precision
        x, w = ctx.saved_tensors
        return grad_output @ w, grad_output.T @ x
# applied to the attention projections, training only:
if self.training:
    qkv = fp8_linear_fn(x.view(-1, self.dim), qkv_w)
else:
    q, k, v = F.linear(x, ...) # bf16 at eval

优化器中退火探索噪声（Langevin/SGLD）(https://www.semanticscholar.org/paper/aeed631d6a84100b5e9a021ec1914095c66de415)。该系统修改了 NorMuon(https://arxiv.org/abs/2510.05491) 更新，向正交化、方差缩减的更新中注入零均值高斯噪声，噪声标准差按行缩放为更新自身的均方根（因此在参数之间是尺度不变的）。噪声在前 50 步中预热，然后在训练大约四分之一时线性退火到零，以便最终解决方案能干净地稳定在一个（希望是更平坦的）盆地中：

def _add_exploration_noise(v_chunk, noise_t, red_dim):
    sigma = noise_t.to(v_chunk.dtype)   # annealed scale (0-D CPU tensor)
    row_rms = v_chunk.float().square().mean(red