王欣怡*加州大学圣塔芭芭拉分校xinyi.wang@ucsb.eduWilliam Yang Wang加州大学圣塔芭芭拉分校william@cs.ucsb.edu

Shawn TanMIT-IBM Watson AI 实验室shawntan@ibm.comRameswar PandaMIT-IBM Watson AI 实验室rpanda@ibm.com

金明宇罗格斯大学mingyu.jin@rutgers.edu沈亦康MIT-IBM Watson AI 实验室yikang.shn@gmail.com

摘要

大型语言模型（LLMs）在需要复杂推理的各种任务中展示了显著的能力。然而，扩展对它们推理能力的影响尚未得到充分理解。在本文中，我们引入了一个合成的多跳推理环境，旨在密切复制现实世界大规模知识图谱的结构和分布。我们的推理任务涉及完成图中的缺失边，这需要高级的多跳推理并模拟现实世界的推理场景。为了评估这一点，我们从头开始预训练语言模型（LMs），仅使用来自不完整图的三元组，并评估它们推断缺失边的能力。有趣的是，我们观察到过度参数化可能由于过多的记忆而导致推理性能下降。我们研究了影响这种U形损失曲线的不同因素，包括图结构、模型大小和训练步数。为了预测特定知识图谱的最佳模型大小，我们发现了一种经验性扩展规律，可以将知识图谱搜索熵线性映射到最佳模型大小。这项工作为LLMs中扩展与推理之间的关系提供了新的见解，并阐明了优化其推理任务性能的可能方法。

1 引言

大型语言模型（LLMs）在广泛的任务中展示了显著的能力。最近，LLMs的推理能力引起了广泛关注，因为它与其在许多复杂现实任务中的表现高度相关（Wei et al., 2022a; Guo et al., 2025）。虽然推理能力通常在后训练阶段得到增强，但合理假设LLMs已经在预训练阶段获得了这种能力，因为后训练规模远小于预训练。一些近期的研究探讨了LLMs通过下一个标记预测预训练学习推理的可能机制（Zhu et al., 2024; Wang et al., 2024a,b）。然而，预训练扩展对LLMs推理能力的影响仍然不足为外人道。

语言模型的一般扩展行为已被研究，包括Kaplan等人（2020）提出的测试损失和计算的著名指数扩展规律以及Hoffmann等人（2022a）研究的训练计算最优扩展。近期的研究还考察了特定能力如机器翻译（Ghorbani et al., 2022）和知识容量/记忆（Allen-Zhu & Li, 2025; Lu et al., 2024）的扩展。根据这些现有的扩展规律，通常认为更大的模型在训练更多数据时会带来更小的测试损失或更好的任务表现。

[^0] [^0]: *大部分工作是在MIT-IBM Watson AI Lab实习期间完成的。 然而，在本文中，我们发现在简化的预训练环境中，语言模型在预训练扩展下的推理能力可能会表现出不同于正常幂律扩展的行为。更具体地说，当提供足够的计算资源时，我们发现测试损失扩展曲线呈现U形，并且存在一个产生最佳推理性能/测试损失的最佳模型大小。这意味着过度参数化可能会在预训练期间损害推理能力。我们首先在真实世界的知识图谱数据中观察到这一现象，然后通过合成生成的数据系统地研究它。

我们选择用合成知识图谱（KGs）来模仿真实世界的知识结构和分布。我们将基于世界知识的推理定义为在不完整的知识图谱中完成缺失边，这需要根据某些预先编码到图生成过程中的规则进行多次跳跃。为了分析这一点，我们仅使用不完整图中的三元组从头开始预训练语言模型，并评估它们推断缺失连接的能力。

我们研究了影响推理损失与语言模型大小之间U形扩展的重要因素。我们的主要发现可以总结如下：

• 无论训练步骤和模型大小如何，语言模型可达到的最小推理损失/最大推理准确率受到训练数据的限制。
• 当训练步数足够大时，训练语料库的最佳模型大小基本固定，不受训练步数的影响。
• 当底层知识图谱固定时，从图中采样更多数据进行训练会增加最佳模型大小和推理性能。
• 更复杂的知识图谱意味着更大的最佳模型大小。

由于我们观察到最佳模型大小可能完全由训练知识图谱决定，我们接下来的目标是找到一种可以用知识图谱统计数据预测最佳模型大小的经验扩展规律。然后我们发现最佳模型大小与新提出的图搜索熵之间存在线性关系，后者衡量在知识图谱上进行随机搜索的熵值。大致上，每增加1比特的知识图谱搜索熵，最佳模型大小需要额外增加124个参数。

我们的工作通过揭示扩展与推理能力之间复杂的关联，为更广泛地理解LLM推理做出了贡献。我们提出的经验推理扩展规律为优化LLMs在预训练时间内的推理能力提供了可能的实际见解。

2 基础知识

尽管现实世界的LLMs是在大规模文本语料库上进行预训练的，但该语料库可以被视为编码了广泛的全球知识。LLMs的强大之处在于它们不仅可以记住全球知识并在查询时提取这些知识，还可以基于全球知识进行推理并得出新颖的结论。在本文中，我们提议直接从知识图谱构建简化的预训练语料库。知识图谱由一组三元组组成，我们使用每个知识三元组作为训练示例。我们通过测试其在从未见过但在图结构中隐含规则下可以推导出的三元组上的准确性，来评估在该语料库上训练的语言模型的推理能力。例如，如果我们知道A是B的父亲，而B是C的父亲，那么我们可以推断A是C的祖父。

正式地，知识图谱 包含 个三元组 ，其中 是头实体， 是尾实体， 是关系。一个简单的知识三元组例子是 (DC, is the capital of, USA)。这些知识三元组自然形成一个图，节点为实体，每条边标注有关系类型。我们表示总

图1：在真实世界知识图谱FB15K-237上训练的不同大小语言模型在未见三元组上的多项选择准确率/损失。左侧面板（训练10k步）显示测试准确率在某个模型大小之后下降。中间面板显示不同步数训练的语言模型的U形损失曲线。右侧面板显示注意模型大小在轴上是对数尺度。 实体或节点数量为 ，总边或关系类型数量为 。然后从这个知识图谱构造的语料库将包含 个数据点。训练在这个语料库上的语言模型的目标函数为：

为了消除实体和关系名称的词汇形式和信息带来的混淆变量，我们用随机ID标记每个实体和关系，并按字符分词。我们使用LlaMA（Touvron等，2023）模型架构通过调整隐藏维度和层数实现不同大小的语言模型。具体的参数方案可以在附录A中找到。 为了评估语言模型在知识图谱上的推理能力，我们在训练过程中未见过的三元组保留集上测试语言模型。注意，所有实体和关系类型在训练过程中都应该见过，语言模型的任务只是连接缺失的边。为了消除生成正确的关系和实体ID形式的需求，并处理存在多个正确答案的情况，我们设计测试集为10选项的多项选择题：给定头实体和关系，语言模型的任务是从给定的10个选项中选择正确的尾实体。我们确保在给定的10个选项中只有一个正确答案。假设测试集中有 个问题。对于一个真实的三元组 ，我们设计9个干扰选项 。然后我们使用测试准确率 和测试损失 来评估语言模型 在知识图谱 上的推理能力：

3 真实世界实验

在我们的初步实验中，我们使用真实世界的知识图谱FB15K-237（Toutanova & Chen, 2015）来研究推理扩展效应。FB15K-237是从FB15K（Bordes et al., 2013）中采样的，而FB15K是一个从Freebase知识库（Bollacker et al., 2007）改编的数据集，这是一个由Google发布的网络规模的知识库。FB15K-237包含 个实体， 种关系，和 个知识三元组。

[^0] [^0]: 我们在所有实验中固定 。 在图1中，我们展示了在不同步数下训练的FB15K-237上的不同大小语言模型。当以相同步数训练时，我们观察到使用更大模型时推理性能略有下降。因此，我们随后查看这些数据集上的测试损失，并观察到关于模型大小的U形趋势。这一观察结果与之前认为更大模型会产生更小测试损失的信念相矛盾。训练损失随着模型大小单调递减。

这意味着当语言模型对于底层推理结构过度参数化时，可能会过拟合到训练数据。这种偏离传统扩展规律的现象也在破裂的神经扩展规律（Caballero et al., 2023）中被报道过，该研究提出了一个双降形式而非单调幂律形式。此外，也有观察到大型语言模型在某些任务上存在逆向扩展（Wei et al., 2023）。

在本文中，我们主要关注模型大小的扩展。我们不仅扩展训练数据的大小，还探索生成知识图谱的不同方法，并研究整体图复杂性对模型推理性能的影响。在接下来的部分中，我们将主要关注推理损失的“转折点”。更具体地说，我们希望理解能够获得最小可能推理测试损失的最佳模型大小是什么。

如图1和第5节所示，我们发现当模型训练足够步数时，这个最佳模型大小非常稳定。注意，在训练时，我们重复训练三元组很多轮次（例如，对于FB15K-237重复30次）以找到最佳模型大小。这个图周期不同于真实世界情况下重复整个预训练语料库的周期。因为我们可以将图中的每个三元组视为一件事实知识（例如，巴拉克·奥巴马的妻子是米歇尔·奥巴马），这种知识通常会在预训练文本语料库中以多种形式多次重复出现。因此，尽管我们的模型在训练期间多次看到相同的三元组，同样的事实知识也可能在一个真实世界预训练语料库的一次遍历中被重复几次。

4 合成数据构建

为了研究底层知识结构如何影响语言模型的推理性能，我们提出了一种算法来生成模拟真实世界知识图谱的合成知识图谱。更具体地说，我们假设知识图谱生成过程是由一组逻辑规则控制的。 例如，用于推导位于关系的规则可以是 , locatedIn, , neighborOf, , locatedIn, 。正式地，对于目标关系 ，我们考虑具有合取形式的逻辑规则。对于 ，

其中 。我们缩写这样的规则为 。我们随机生成一组逻辑规则 并确保集合中没有循环。为了生成遵循这些规则的图，我们强制执行连接到和分支出每个实体的可能关系类型的稀疏性

图2：由两条逻辑规则生成的九种可能节点类型。规则中的每个实体位置会创建一个新的实体类型。两个规则共享的每个关系也会创建两种新的实体类型。 连接到和分支出每个实体的可能关系类型，基于生成的规则，如图2所示。这种稀疏性也在真实世界知识图谱中被观察到。 我们的随机图生成过程受优先依附过程（Barabási & Albert, 1999）启发，该过程用于生成具有幂律分布度数的无标度网络。直观上，优先依附意味着图中边放置的一种“富者愈富”方法。每次向图中添加新节点时，都有一个“偏好”连接到已经高度连接的节点，概率与目标节点的度数成正比。由于我们在真实世界知识图谱和互联网中观察到了无标度属性，我们采用基于优先依附的图生成过程。为了适应分配给每个边的不同关系类型，我们维护每个关系的度数分布，并根据优先依附添加新边。 我们的随机图生成算法代码在附录B中展示。总的来说，我们首先随机生成一组规则 ，规则数量 和规则长度范围 作为超参数。然后我们根据图2生成所有可能的节点类型，每节点最大关系数 作为超参数。我们通过实例化每条规则的一组新实体生成种子图。在此基础上，我们通过先随机分配一个节点类型给它，然后从节点类型定义的关系集中随机抽样 种关系类型，逐步添加新实体直到实体数量达到 。我们通过优先依附选择这 条新边的目标。每添加 个实体后，我们通过当前图中能通过 中定义的逻辑规则推导出的任何边进行搜索。我们将可以通过逻辑规则推导出的三元组称为可推导三元组，否则为原子三元组。 最后，我们将训练三元组的数量限制为 并通过子采样生成的图确保可推导三元组与原子三元组的比例为 。我们进一步确保测试集中的三元组都可以通过训练三元组推导出来。这样，我们可以生成具有特定大小和复杂性的合成知识图谱。

5 扩展规律

在本节中，我们研究在不同合成知识图谱上训练的语言模型的扩展规律。我们进行对照实验以展示数据生成过程各个组件的效果。我们还提出了一种信息理论方法来测量知识图谱的整体推理复杂性，我们称之为图搜索熵，并将其线性关联到最佳模型大小，即可以获得最低可能测试损失的模型大小。

5.1 图生成消融研究

我们研究以下四个超参数对图数据生成的影响：三元组数量 、实体数量 、关系数量 和规则数量 。我们固定所有训练超参数如附录A所述，但研究训练步数的影响，因为根据我们的初步实验，这对最佳模型大小有最大影响。每组实验的详细数据生成配置也可以在附录A中找到。 相对于训练步数的稳定最佳模型大小。在图3(a)中，我们展示了在相同知识图谱上用不同数量的训练步数训练语言模型的效果。正如在第2节最后一部分提到的，当训练步数增加时，最佳模型大小变小，然后在4k步后变得稳定。另一个观察是无论训练步数多少，最大准确率或最小损失都是稳定的。虽然我们已确保所有测试三元组都可以通过训练三元组推导出来，似乎有一个仅由知识图谱数据决定的性能上限，不受模型大小影响。在所有后续实验中，我们训练所有模型10k步。 更多三元组意味着更大的最佳模型大小。在图3(b)中，我们展示了在相同知识图谱生成过程后采样不同数量的独特三元组 的效果。这种设置可以说是最接近现实世界语言模型预训练的：所有预训练语料库的底层世界知识图谱基本上是

图3：我们展示了合成知识图谱生成过程不同超参数的效果。在每次实验中，我们保持所有其他参数不变，只改变一个超参数。我们用测试准确率（左）和测试损失（右）作为y轴，用不同模型大小作为x轴的对数尺度展示效果。 稳定，训练数据是底层知识图谱的实现，因此不同语料库的大小仅仅是现有图中知识的子采样/上采样的结果。我们可以看到更多的训练三元组会导致更大的最佳模型大小和更好的推理性能。这一观察与经典扩展规律一致。然而，完整知识图谱存在一个最佳模型大小：在超出完整知识图谱的大小采样后，你只能采样之前见过的知识。在这种情况下，无论训练数据大小如何，最佳模型大小都会保持稳定。 规则数量不影响最佳模型大小。在图3(c)中，我们展示了生成相同大小但不同规则数量 的知识图谱的效果。更多的规则意味着测试三元组需要以更多方式解决。规则数量对最佳模型大小没有显著影响，但会影响推理性能。似乎存在一个最佳规则数量（20个）可以产生最佳性能。这是因为更多的规则增加了测试集的解决复杂性，而较少的规则增加了训练集的模糊性。也就是说，一个关系可能通过预定义规则之外的相关性推导出来。规则数量不影响最佳模型大小的原因可能是它对图搜索熵没有显著影响。这将在第5.2节详细讨论。 更多关系意味着更大的最佳模型大小。在图3(d)中，我们展示了生成相同大小和相同规则数量但不同关系数量 的知识图谱的效果。虽然用于推导测试集的规则在所有实验中保持不变，但可能存在一些规则未使用的额外关系。我们通过添加额外关系模式构建具有过多关系的知识图谱。总体而言，更多的关系提高了最佳推理性能，同时增加了最佳模型大小。更多的关系增加了知识图谱的复杂性，从而增加了最佳模型大小。另一方面，正如前面实验所讨论的，少量规则加上少量关系增加了训练集的模糊性。通过添加未用于推理的虚拟关系，语言模型可以更好地区分逻辑规则和关系之间的虚假相关性。因此，随着关系数量的增加，推理性能得到了提升。

当比例较小时，最佳模型大小随可推导比例增加。在图3(e)中，我们在保持实体数量和三元组数量不变的情况下，展示了生成具有不同可推导三元组与原子三元组比例 的知识图谱的效果。较大的比例意味着语言模型在训练时可以看到更多的规则模式，从而提高推理性能。当比例超过阈值后，性能和最佳模型大小的增长停止。 更多实体意味着更大的最佳模型大小。在图3(f)中，我们展示了生成具有不同节点/实体数量 的知识图谱的效果。在这项实验中，我们也按比例增加三元组数量以保持所有其他超参数不变。增加实体数量会增加最佳模型大小，同时也会增加测试损失。更多的实体意味着更大的图，这增加了图的复杂性，从而增加了最佳模型大小。在这项实验中，我们使用少量规则 和关系 ，过多的实体和三元组会增加模糊性，从而损害推理性能。

5.2 最佳模型大小与图搜索熵

从我们之前的消融研究中，我们假设最佳模型大小与知识图谱的整体复杂性呈正相关。因此，我们提出通过量化通过随机搜索探索图谱所能获得的信息量来衡量知识图谱的复杂性。根据我们的任务定义，为了在知识图谱上进行推理，语言模型需要（a）通过观察重复模式识别逻辑规则集；（b）使用一个或多个特定逻辑规则遍历图谱以定位尾部实体。因此，我们将图搜索熵定义为在随机遍历图谱时可以获得的最大信息量。 为了简化问题，我们首先关注在图的一个节点上可以观察到的平均信息量。如果我们在知识图谱上进行随机游走，那么我们将无限长随机游走中每个步骤/节点产生的熵称为该随机游走的熵率。对于图 ，最大熵率等于邻接矩阵 的最大特征值的对数。请注意，我们仅考虑关于实体的熵率，而不考虑关于关系的熵率。我们可以利用由最大熵率随机游走诱导的平稳分布和转移矩阵计算关系熵率。如果我们将主特征值记为 ，相应的特征向量记为 ， 那么平稳分布 可以写为：

最大熵随机游走的转移矩阵 可以写为：

然后，我们可以将实体到实体的转移矩阵 转换为实体到关系的转移矩阵 ，通过合并具有相同关系的条目：

最后，关系熵率 可以写为：

整体图搜索熵 可以写为实体熵率和关系熵率之和乘以节点数量：

我们通过在图4中绘制它们并进行线性回归，经验性地研究最佳模型与图搜索熵之间的关系。最佳模型大小来自于消融研究中的合成实验。在消融研究中，我们只为清晰起见报告了指数增长模型大小的结果。在这项研究中，为了更好地捕捉最佳模型大小，我们使接近最佳模型大小的模型大小更加精细。在所有实验中，我们保持训练超参数相同，训练步数为10k。 我们发现最佳模型大小与图搜索熵之间存在强线性关系，。注意，定位特定知识图谱的最佳模型大小有几个噪声来源。首先，由于计算和时间限制，我们只能训练选定大小的语言模型，模型大小的量化会破坏扩展规律的平滑性。其次，最佳模型大小的确切位置取决于训练步数，我们并未彻底遍历而是选择了10k步进行检查。 在使用来自我们合成实验的数据拟合线性回归线后，我们针对我们的真实世界知识图谱FB15K-237验证了这一经验性扩展规律的有效性。我们计算了FB15K-237的图搜索熵，发现预测的最佳模型大小非常接近观察到的最佳模型大小，如图4中的绿色点所示。 从我们的扩展规律来看，每增加1比特的知识图谱熵，最佳模型大小需要额外增加约124个参数。也就是说，一个语言模型只能可靠（但不完美）地对每参数0.008比特信息进行推理。这与Allen-Zhu & Li (2025)得出的知识容量扩展规律非常不同，后者表明语言模型可以存储每参数2比特的知识。我们认为这种差异有两个原因：首先，我们的扩展规律不仅涉及记住知识，还涉及对所学知识进行推理，这要难得多。其次，我们计算图搜索熵的方式与Allen-Zhu & Li (2025)计算知识熵的方式根本不同。Allen-Zhu & Li (2025)描述了知识生成过程的熵，而我们的图搜索熵描述了随机遍历固定知识图谱的熵。通过这种方式，我们并未直接测量语言模型需要记住的信息量，而是测量遍历图谱的复杂性，因此也是推理的复杂性。很难甚至不可能获得真实世界数据的数据生成过程，但通过自动构建知识图谱的算法（Zhong et al., 2023），可以估算语料库的基础知识图谱。因此，通过首先从预训练语料库构建知识图谱，然后计算其图搜索熵，最后使用类似的扩展规律计算最佳模型大小，可以预测真实世界预训练的最佳推理模型大小。

5.3 局限性

我们要强调，这项研究仅在从知识图谱简化来的预训练数据上进行，结果很可能不直接适用于使用大规模文本语料库的真实世界语言模型预训练。我们的研究设置为真实世界语言模型预训练提供了一个合理的类比，当计算资源充足、模型和数据集都非常庞大并详尽遍历基础知识图谱时，所获得的洞察可能会在现实世界中发挥作用。由于其资源密集型性质，我们把在现实中验证我们的扩展规律的工作留给了未来的研究。

6 相关工作

语言模型扩展规律 Kaplan等人（2020）首次观察到LLM困惑度、模型参数数量和训练数据大小之间的幂律关系，奠定了扩展规律研究的基础。随后，Hoffmann等人（2022b）探索了在受限计算资源下的最佳训练策略，发现LLM参数大小和训练令牌数量应按比例扩展，以在固定预算下实现最佳计算效率。除了预训练性能，研究人员进一步证实下游任务性能也可以基于模型大小和训练数据量可靠预测（Hernandez等人，2021；Isik等人，2024）。Allen-Zhu & Li（2025）；Lu等人（2024）转向探索更具体的维度能力，特别关注LLM事实记忆的扩展规律及其在记忆不同类型事实时的行为模式。最近，Roberts等人（2025）确认扩展规律依赖于技能，并发现知识密集型任务更需要参数，而推理密集型任务更需要数据。Springer等人（2025）挑战了扩展研究的核心假设——更多的预训练不可避免地导致更好的下游性能。我们的论文在特定的知识图谱推理情景下识别出不同的U形扩展曲线，并揭示知识图谱的搜索复杂性决定了最佳模型大小。这与Pandey（2024）和Yin等人（2024）的发现相呼应，他们认为经典扩展规律高度依赖于数据复杂性或数据的压缩比。Havrilla & Liao（2024）也从理论和实证角度确认了幂律扩展的力量取决于训练数据的内在维度。

语言模型推理 我们的论文专注于语言模型的推理能力，这最近引起了广泛关注（Zhang等人，2023；Chen等人，2023；Yao等人，2023a,b；Wang等人，2023；Guo等人，2025；Jin等人，2024；Yeo等人，2025；Team等人，2025；Li等人，2025）。LLM通常在现实任务中以逐步方式进行推理，例如数学文字问题（Wei等人，2022b）。在我们的实验中，我们不要求语言模型为其答案生成逐步解决方案，而是要求语言模型从给定选项中直接选择正确答案，因为我们的仅预训练语言模型没有经过训练以给出查询的逐步解决方案。我们的合成推理环境最类似于Wang等人（2024b），他们同样使用知识图谱完成任务作为测试平台，以了解语言模型在预训练期间如何学习推理。他们提出语言模型能够聚合从知识图谱中采样的随机游走路径。Wang等人（2024a）；Zhu等人（2024）还使用图结构来支持他们的合成推理任务，以解释LLM如何推理，但他们的推理被定义为关系的串联：A是B的，B是C的，则A是C的。我们使用的知识图谱完成任务比简单的关系串联更复杂，因为语言模型需要从知识图谱中找出哪个关系对应。

7 结论

本文研究了在知识图谱上训练的语言模型的推理扩展。我们的结果揭示了模型大小与推理性能之间的U形关系，其中过度参数化导致过多记忆和推理能力下降。我们确定了决定最佳模型大小的关键因素，如训练三元组数量和图复杂性。值得注意的是，我们提出了一种将最佳模型大小与图搜索熵联系起来的经验扩展规律，为模型设计提供了定量指南。尽管我们的实验是在受控环境中进行的，但这些见解为未来在真实世界预训练场景和改进LLMs推理能力方面的工作铺平了道路。

参考文献

Zeyuan Allen-Zhu 和 Yuanzhi Li。语言模型物理学：第三部分3.3，知识容量扩展规律。在第十三届国际学习表征会议，2025。URL https://openreview.net/forum?id=FxNNiUgtfa.

Albert-László Barabási 和 Réka Albert。随机网络中规模出现的规律。科学，286(5439):509-512，1999年。

Kurt Bollacker，Robert Cook 和 Patrick Tufts。Freebase：共享的结构化通用人类知识数据库。在第二十二届全国人工智能会议 - 第二卷会议记录，AAAI’07，第1962-1963页。AAAI出版社，2007年。ISBN 9781577353232。

Antoine Bordes，Nicolas Usunier，Alberto Garcia-Duran，Jason Weston 和 Oksana Yakhnenko。嵌入式翻译用于建模多关系数据。在C.J. Burges，L. Bottou，M. Welling，Z. Ghahramani 和 K.Q. Weinberger（编辑），神经信息处理系统进展，第26卷。Curran Associates, Inc., 2013年。URL https://proceedings.neurips.cc/paper_files/paper/2013/file/1cecc7a77928ca8133fa24680a88d2f9-Paper.pdf。

Ethan Caballero，Kshitij Gupta，Irina Rish 和 David Krueger。破裂的神经扩展定律。在第十一届国际学习表征会议，2023年。URL https://openreview.net/forum?id=sckjveq1CZ。

陈文虎，马雪光，王欣怡 和 William W Cohen。思维程序提示：分离计算与推理以进行数值推理任务。机器学习研究交易，2023年。

Behrooz Ghorbani，Orhan Firat，Markus Freitag，Ankur Bapna，Maxim Krikun，Xavier Garcia，Ciprian Chelba 和 Colin Cherry。神经机器翻译的扩展规律。在国际学习表征会议，2022年。

郭岱亚，杨德健，张浩伟，宋俊晓，张若宇，徐润鑫，朱启豪，马世荣，王培毅，毕晓 等。Deepseek-R1：通过强化学习激励LLMs的推理能力。arXiv预印本 arXiv:2501.12948，2025年。

Alexander Havrilla 和 Wenjing Liao。用统计和逼近理论理解低维数据上的变压器神经网络扩展规律。在第三十八届年度神经信息处理系统会议，2024年。URL https://openreview.net/forum?id=N2wYPMpifA。

Danny Hernandez，Jared Kaplan，Tom Henighan 和 Sam McCandlish。迁移的扩展规律。arXiv预印本 arXiv:2102.01293，2021年。

Jordan Hoffmann，Sebastian Borgeaud，Arthur Mensch，Elena Buchatskaya，Trevor Cai，Eliza Rutherford，Diego de Las Casas，Lisa Anne Hendricks，Johannes Welbl，Aidan Clark 等。训练计算最优的大语言模型。arXiv预印本 arXiv:2203.15556，2022a年。

Jordan Hoffmann，Sebastian Borgeaud，Arthur Mensch，Elena Buchatskaya，Trevor Cai，Eliza Rutherford，Diego de Las Casas，Lisa Anne Hendricks，Johannes Welbl，Aidan Clark 等。训练计算最优的大语言模型。在第36届神经信息处理系统国际会议记录，第30016-30030页，2022b年。

Berivan Isik，Natalia Ponomareva，Hussein Hazimeh，Dimitris Paparas，Sergei Vassilvitskii 和 Sanmi Koyejo。大型语言模型下游任务性能的扩展规律。在ICLR 2024 Workshop on Navigating and Addressing Data Problems for Foundation Models，2024年。

金明宇，俞勤凯，舒东，赵海燕，华文悦，孟延达，张永峰 和 杜梦楠。推理步骤长度对大型语言模型的影响。在计算语言学协会ACL 2024年发现，第1830-1842页，2024年。

Jared Kaplan，Sam McCandlish，Tom Henighan，Tom B Brown，Benjamin Chess，Rewon Child，Scott Gray，Alec Radford，Jeffrey Wu 和 Dario Amodei。神经语言模型的扩展规律。arXiv预印本 arXiv:2001.08361，2020年。

李仲志，张杜真，张明良，张嘉欣，刘增彦，姚玉轩，许昊天，郑俊浩，王佩杰，陈秀义 等。从系统1到系统2：大型语言模型推理综述。arXiv预印本 arXiv:2502.17419，2025年。

卢星宇，李晓楠，程沁媛，丁凯，黄轩靖 和 邱锡鹏。大型语言模型事实记忆的扩展规律。在计算语言学协会EMNLP 2024年发现，第11263-11282页，2024年。

Preetum Nakkiran，Gal Kaplun，Yamini Bansal，Tristan Yang，Boaz Barak 和 Ilya Sutskever。深度双重下降：更大模型和更多数据有害的情况。在国际学习表征会议，2020年。URL https://openreview.net/forum?id=B1g5sA4twr。

Rohan Pandey。gzip预测数据依赖的扩展规律。arXiv预印本 arXiv:2405.16684，2024年。

Nicholas Roberts，Niladri Chatterji，Sharan Narang，Mike Lewis 和 Dieuwke Hupkes。技能计算最优扩展：知识与推理。arXiv预印本 arXiv:2503.10061，2025年。

Jacob Mitchell Springer，Sachin Goyal，Kaiyue Wen，Tanishq Kumar，Xiang Yue，Sadhika Malladi，Graham Neubig 和 Aditi Raghunathan。过度训练的语言模型更难微调。https://arxiv.org/abs/2503.19206，2025年。

Kimi Team，杜昂刚，高波飞，邢博文，姜昌久，陈成，李成，肖晨军，杜陈庄，廖崇华 等。Kimi K1.5：使用LLMs扩展强化学习。arXiv预印本 arXiv:2501.12599，2025年。

Kristina Toutanova 和 Danqi Chen。观察特征与潜在特征：知识库和文本推理。在Alexandre Allauzen，Edward Grefenstette，Karl Moritz Hermann，Hugo Larochelle 和 Scott Wen-tau Yih（编辑），第三届连续向量空间模型及其组合性研讨会记录，第57-66页，中国北京，2015年7月。计算语言学协会。doi: 10.18653/v1/W15-4007。URL https://aclanthology.org/W15-4007/。

Hugo Touvron，Thibaut Lavril，Gautier Izacard，Xavier Martinet，Marie-Anne Lachaux，Timothée Lacroix，Baptiste Rozière，Naman Goyal，Eric Hambro，Faisal Azhar 等。Llama：开放且高效的基语言模型。arXiv预印本 arXiv:2302.13971，2023年。

王博时，许翔，苏宇 和 孙欢。Transformer中隐式推理的掌握：通往泛化的机制之旅。在第三十八届年度神经信息处理系统会议，2024a年。URL https://openreview.net/forum?id=D4QgSWxiOb。

王磊，徐万宇，兰义怀，胡志强，蓝云石，李家伟 和 林义鹏。计划与解决提示：通过大型语言模型改进零样本链式思维推理。在计算语言学协会第六十一届年会记录（第一卷：长论文），第2609-2634页，2023年。

王欣怡，Amayuelas Alfonso，张克勋，潘良明，陈文虎 和 William Yang Wang。从推理路径聚合的角度理解语言模型的推理能力。在第四十一届国际机器学习会议，2024b年。

Jason Wei，Yi Tay，Rishi Bommasani，Colin Raffel，Barret Zoph，Sebastian Borgeaud，Dani Yogatama，Maarten Bosma，Denny Zhou，Donald Metzler，Ed H. Chi，Tatsunori Hashimoto，Oriol Vinyals，Percy Liang，Jeff Dean 和 William Fedus。大型语言模型的新兴能力。机器学习研究交易，2022a。ISSN 2835-8856。URL https://openreview.net/forum?id=yzkSU5zdw0。调查认证。

Jason Wei，Xuezhi Wang，Dale Schuurmans，Maarten Bosma，Fei Xia，Ed Chi，Quoc V Le，Denny Zhou 等。链式思维提示在大型语言模型中引发推理。在神经信息处理系统进展，第35卷，第24824-24837页，2022b。

Jason Wei，Najoung Kim，Yi Tay 和 Quoc V Le。逆向扩展可以变成U形。在2023年经验方法自然语言处理会议，2023年。URL https://openreview.net/forum?id=19sGqVUxQw。

姚顺宇，余电，赵杰夫，Izhak Shafran，Thomas L Griffiths，曹远 和 Karthik R Narasimhan。树思维：利用大型语言模型进行深思熟虑的问题解决。在第三十七届神经信息处理系统会议，2023a。

姚顺宇，赵杰夫，余电，杜楠，Izhak Shafran，Karthik Narasimhan 和 曹远。React：在语言模型中协同推理和行动。在国际学习表示会议（ICLR），2023b。

Edward Yeo，童玉轩，牛茉莉，Graham Neubig 和 袁祥。揭秘大型语言模型中的长链思维推理。arXiv预印本 arXiv:2502.03373，2025年。

尹明佳，吴楚涵，王宇飞，王浩，郭伟，王雅胜，刘勇，唐瑞明，连德福 和 陈恩红。熵律：数据压缩和大语言模型性能背后的故事。arXiv预印本 arXiv:2407.06645，2024年。

张卓盛，张 Aston，李穆 和 Alex Smola。大型语言模型中的自动链式思维提示。在第十一届国际学习表征会议，2023年。

钟灵峰，吴嘉，李倩，彭浩 和 吴信东。自动知识图谱构建的综合调查。ACM计算调查，56(4):1-62，2023年。

朱汉林，黄百禾，张少伦，Jordan Michael，Jiao Jiantao，Tian Yuandong 和 Russell Stuart J。通过训练动力学理论理解“反转诅咒”。神经信息处理系统进展，37:90473-90513，2024年。 # A 实验细节

批量大小	学习率	学习率调度器	预热比例	权重衰减	最大长度
1024		余弦	0.2	0	128

表1：语言模型预训练的超参数设置。

	100 k	10 k	100	50	0.5
(b)		10 k	100	50	0.5
(c)	100 k	10 k	100		0.5
(d)	100 k	10 k		50	0.5
(e)	100 k	10 k	100	50
(f)			10	5	0.5

表2：图3实验的知识图谱超参数设置。我们在所有实验中保持和不变。这里表示三元组数量，表示实体数量，表示关系数量，表示规则数量，表示可推导三元组与原子三元组的比例，表示最小规则长度，表示最大规则长度。

B 合成知识图谱生成代码

import networkx as nx
import numpy as np
import random
from collections import defaultdict
def add_edge(G, h, t, r):
num_edges = 0
if G.has_edge(h, t):
if r not in G[h][t]['id']
G[h][t]['id'].append(r)
num_edges += 1
else:
print('edge already exists')
else:
G.add_edge(h, t, id=[r])
num_edges += 1
print('add edge: ', (h, r, t), 'num edges: ', num_edges)
return num_edges
def generate_rules(relations, num_rules, L_min, L_max, weighted=False, temperature=0.25):
# Generate K acyclic logic rules with varying lengths
dependency_graph = defaultdict(set)
rules = []
weights = []
if weighted:
for l in range(L_min, L_max + 1):
weights.append(np.exp(-temperature*l))
probs = np.array([w / sum(weights) for w in weights])
else:
weights = [1] * (L_max - L_min + 1)

def has_cycle(start, visited, stack):
"""Detects if adding a new dependency introduces a cycle."""
if start not in visited:
visited.add(start)
stack.add(start)
print('visited: ', visited)
print('stack: ', stack)
for neighbor in dependency_graph[start]:
if neighbor in stack:
return True
elif has_cycle(neighbor, visited, stack):
return True
if start in stack:
stack.remove(start)
return False
for _ in range(num_rules):
while True:
if weighted:
length = random.choices(range(L_min, L_max + 1), weights=weights)[0]
else:
length = random.randint(L_min, L_max)
rule_relations = random.choices(relations, k = length + 1) # the first element is the implied relation
valid_rule = True
for i in range(1, len(rule_relations)):
dependency_graph[rule_relations[0]].add(rule_relations[i])
# Check for cycles
if has_cycle(rule_relations[i], set(), set()):
valid_rule = False
for j in range(1, i + 1):
dependency_graph[rule_relations[0]].remove(rule_relations[j])
break
if valid_rule:
rules.append(tuple(rule_relations))
break
print('rules: ', rules)
return rules
def get_node_types(rules, max_num_relations_per_node=3):
# map node types to out relations
node_types = {}
# map out relations to node types
r2node_types = defaultdict(list)
for rule in rules:
for i in range(len(rule)):
node_type = len(node_types)
if i == 0:
node_types[node_type] = [rule[i], rule[1]]
r2node_types[rule[i]].append(node_type)
r2node_types[rule[1]].append(node_type)
elif i == len(rule) - 1:
node_types[node_type] = ['-' + rule[i], '-' + rule[0]]
r2node_types[''-' + rule[i]].append(node_type)
r2node.types['-' + rule[0]].append(node.type)
else:
node_types[node_type] = ['-' + rule[i], rule[i+1]]

r2node_types[ \({ }^{\prime}-\) + rule[i]].append(node.type)
r2node_types [rule[i+1]].append(node.type)
print(node.types)
print(r2node.types)
for num.rs in range(2, max.num.relations.per.node):
possible_new.node.types = []
for r in r2node.types:
alt.rs = []
for node.type in r2node.types[r]:
for .r in node.types[node.type]:
if .r != r:
alt.rs.append(.r)
alt.rs = list(set(alt.rs))
for node.type in r2node.types[r]:
if len(node.types [node.type]) == num.rs:
for .r in alt.rs:
if .r not in node.types [node.type]:
possible_new.node.types.append(tuple(sorted([.r] + list(node.types [node.type]))))
print(possible.new.node.types)
possible_new.node.types += list(set(possible.new.node.types))
possible_new.node.types = list(set(possible.new.node.types))
print(possible.new.node.types)
for rs in possible.new.node.types:
new.node.type = len(node.types)
node.types [new.node.type] = list(rs)
for .r in rs:
r2node.types[.r].append(new.node.type)
return node.types
def get_adj.out_relations(rules):
adj = defaultdict(list)
for rule in rules:
for i in range(len(rule)):
if i == 0:
adj [rule[i]].append(rule [1])
adj [rule [1]].append(rule [i])
elif i == len(rule) - 1:
adj [ \({ }^{\prime}-\) + rule[i]].append( \({ }^{\prime}-\) + rule [0])
adj [ \({ }^{\prime}-\) + rule [0]].append( \({ }^{\prime}-\) + rule[i])
else:
adj [ \({ }^{\prime}-\) + rule[i]].append(rule[i+1])
adj [rule[i+1]].append( \({ }^{\prime}-\) + rule[i])
return adj
def latent.rule.graph(num.rules=50, L_min=2, L_max=4, n=10000, m=10, n_r=200,
num_test=1000, num_train=150000, check_frequency=100,
power_law=False, initial_graph=None,
length.weighted=False, mcmc=0.2, temperature=0.25,
deductible_ratio=0.5):
# Generate relations and entities
print("mcmc: ", mcmc)
relations = ['P' + str(i) for i in range(n.r)]
all.rules = generate.rules(relations, max(n.r//L_min, num.rules), L_min, L_max)
r2rules = {}
for rule in all.rules:

if rule[0] not in r2rules:
r2rules[rule[0]] = []
r2rules[rule[0]].append(rule[1:])
num_triples = 0
repeated_entities = defaultdict(list) # map in relation to entities
child_relations = []
for rule in all.rules:
child_relations += rule[1:]
child_relations = list(set(child_relations))
child_relations += [ }\mp@subsup{}{}{-1}+\mathrm{r}\mathrm{ for }r\mathrm{ in child_relations]
deductible-rules = random.sample(all.rules, num.rules)
if length-weighted:
weights = [int(100*np.exp(-temperature*len(rule))) for rule in all.rules]
else:
weights = [1 for . in all.rules]
repeated.rules = []
for rule, weight in zip(all.rules, weights):
for . in range(weight):
repeated.rules.append(rule)
random.shuffle(repeated.rules)
adj = get_adj.out_relations(repeated.rules)
all_deductibles = {}
if initial_graph is None:
# Default initial graph
G = nx.DiGraph()
node_id = 0
min_repeated_entities = 0
while min_repeated_entities < m:
for rule in all.rules:
source = 'Q' + str(node_id)
node_id += 1
h = source
for r in rule[1:]:
t = 'Q' + str(node_id)
node_id += 1
num_triples += add_edge(G, h, t, r)
repeated_entities[r].append(t)
repeated_entities[ }\mp@subsup{}{}{-1}+\mathrm{r}\mathrm{ ].append(h)
h = t
num_triples += add_edge(G, source, t, rule[0])
repeated_entities[rule[0]].append(t)
repeated_entities[ }\mp@subsup{}{}{-1}+\mathrm{ rule[0]].append(source)
min_repeated_entities = min([len(set(repeated_entities[r])) for r in child_relations])
else:
if len(initial_graph) < m or len(initial_graph) > n:
raise nx. NetworkXError(
f*Initial graph needs between m={m} and m={n} nodes"
)
G = initial_graph.copy()
node_id = len(G)
if not power_law:
repeated_entities = {r: list(set(repeated_entities[r])) for r in repeated_entities}
# Start adding the other nodes.
while node_id < n:
source = 'Q' + str(node_id)

node_id += 1
possible-relations = [.r for .r in adj if .r in child.relations]
if len(possible.relations) == 0:
print( }\mp@subsup{\textrm{no adj relations}}{}{\prime}
break
print( }\mp@subsup{\textrm{add child edge}}{}{\prime}
chosen_edges = []
stop = False
for . in range(m):
it = 0
while (r, t) in chosen_edges:
r = random.choice(possible.relations)
t = random.choice(repeated.entities[r])
it += 1
if it> 100:
print( }\mp@subsup{\textrm{failed to find edge}}{}{\prime}
stop = True
break
if stop or len(possible.relations) == 0:
break
possible_relations = [.r for .r in adj[r] if .r in child_relations]
chosen_edges.append((r, t))
if r[0] == \'~'
num_triples += add_edge(G, t, source, r[1:])
repeated.entities[r[1:]].append(source)
else:
num_triples += add_edge(G, source, t, r)
repeated.entities[ \'~ + r].append(source)
repeated.entities[r].append(t)
if len(possible.relations) == 0:
print( }\mp@subsup{\textrm{no adj relations}}{}{\prime}
break
if not power_law:
repeated.entities = {r: list(set(repeated.entities[r])) for r in repeated.entities}
if node_id % check_frequency == 0 or node_id == n-1:
# add deductibles
all_nodes = list(G.nodes)
random.shuffle(all_nodes)
for h in all_nodes:
for rule in deductible.rules:
head_list = [h]
r = rule[0]
for .r in rule[1:]:
next_head_list = []
for e_h in head_list:
if e_h not in G.nodes:
continue
for e_t in G[e_h]:
if .r in G[e_h][e_t][ \id ^ { \prime } ]:
if random.random() < mcmc:
next_head_list.append(e_t)
head_list = next_head_list
for t in head_list:
if (h, r, t) not in all_deductibles:

all_deductibles[(h, r, t)] = [rule]
elif rule not in all_deductibles[(h, r, t)]:
all_deductibles[(h, r, t)].append(rule)
if not G.has_edge(h, t) or r not in G[h][t]['id']:
print('add deductible edge')
add_edge(G, h, t, r)
num_triples += 1
repeated_entities[r].append(t)
repeated_entities[^] + r].append(h)
atomic_triples = []
deductible_triples = []
for h, t in G.edges:
for r in G[h][t]['id']
if (h, r, t) not in all_deductibles:
atomic_triples.append((h, r, t))
else:
deductible_triples.append((h, r, t))
random.shuffle(atomic_triples)
random.shuffle(deductible_triples)
assert len(atomic_triples) >= int(num_train * (1-deductible_ratio))
assert len(deductible_triples) >= int(num_train * deductible_ratio) + 2 * num_test
remove_triples = []
train_atomic_triples = atomic_triples[:int(num_train * (1-deductible_ratio))]
remove_triples += atomic_triples[int(num_train * (1-deductible_ratio)):]
train_deductible_triples = deductible_triples[:int(num_train * deductible_ratio)]
remove_triples += deductible_triples[int(num_train * deductible_ratio):]
for h, r, t in remove_triples:
.t = t
rs = G[h][.t]['id']
if r in rs:
if len(rs) == 1:
G.remove_edge(h, .t)
else:
G[h][.t]['id'].remove(r)
train_triples = train_deductible_triples + train_atomic_triples
random.shuffle(train_triples)
print("num train triples: ", len(train_triples))
r2rule = {}
for rule in deductible_rules:
if rule[0] in r2rule:
r2rule[rule[0]].append[rule[1:]]
else:
r2rule[rule[0]] = [rule[1:]]
def check_deductible(triple):
h, r, t = triple
alt.ts = []
for rule in r2rule[r]:
head_list = [h]
for .r in rule:
next_head_list = []
for e.h in head_list:
for e.t in G[e.h]:
if .r in G[e.h][e.t]['id']:

next_head.list.append(e_t)
head_list = next_head_list
alt_ts += head_list
if t in alt_ts:
return True
return False
id_test_triples = []
for i in range(int(num_train * deductible_ratio), len(deductible_triples)):
if check_deductible(deductible_triples[i]):
id_test_triples.append(deductible_triples[i])
if len(id_test_triples) == num_test:
break
id_test_rules = [all_deductibles[triple] for triple in id_test_triples]
print("num id test triples: ", len(id_test_triples))
rule2triples = defaultdict(list)
for triple in deductible_triples[i+1:]:
for rule in all_deductibles[triple]:
rule2triples[rule].append(triple)
# uniformly sample testing triples from each rule
uniform_test_triples = []
for rule in rule2triples:
triples = []
for triple in rule2triples[rule]:
if check_deductible(triple):
triples.append(triple)
if len(triples) > num_test//len(rule2triples):
uniform_test_triples += random.sample(triples, num_test//len(rule2triples))
else:
uniform_test_triples += triples
random.shuffle(uniform_test_triples)
uniform_test_rules = [all_deductibles[triple] for triple in uniform_test_triples]
print("num uniform test triples: ", len(uniform_test_triples))

return G, deductible_rules, train_triples, id_test_triples, id_test_rules, uniform_test_triples, uniform_test_rules