Ahead of AI

Understanding Positional Embeddings in Modern LLMs

8.5内容质量
Understanding Positional Embeddings in Modern LLMs

TL;DR · AI 摘要

现代大语言模型通过多种方法(如 RoPE)处理位置信息,本文详细解析了这些机制并提供 PyTorch 实现。

核心要点

  • RoPE 是一种相对位置编码方法,被现代 LLM 广泛采用。
  • 2026 年的开放权重模型中,不同架构使用了多种位置编码方式。
  • 本文包含 PyTorch 实现和数学推导,适合深入学习位置编码机制。

结构提纲

按章节快速跳转。

  1. 本文解释了现代大语言模型如何编码和处理位置信息,并介绍了 RoPE 等方法。

  2. 从输入文本到 token ID 的过程,以及位置信息如何进入模型。

  3. 详细解析 RoPE 方法,并提供数学推导和实现示例。

  4. 2026 年开放权重模型中不同架构的位置编码方法对比。

  5. ›PyTorch 实现

    提供 RoPE 的 PyTorch 实现代码,便于读者实践。

思维导图

用一张图看清主题之间的关系。

查看大纲文本(无障碍 / 无 JS 友好)
  • 位置编码在 LLM 中的应用
    • 经典方法
      • 绝对位置编码
      • 相对位置编码 (RoPE)
    • 现代架构
      • 2026 年开放模型的位置编码选择
      • PyTorch 实现

金句 / Highlights

值得收藏与分享的关键句。

#LLMs#位置编码#RoPE#PyTorch#AI
打开原文

理解现代大语言模型中的位置嵌入

大语言模型如何表示标记位置的方法

Sebastian Raschka,博士

2026年11月15日

本文将解释大语言模型如何通过经典和现代方法(如RoPE)对标记位置信息进行编码和处理。这实际上是一次全面的探索,我们将通过视觉示例、一些数学知识和一个小型的PyTorch实现来逐步了解这些机制。当然,我们还将探讨现代架构如何适应或省略显式的位置编码。

下面,你可以看到2026年开放权重模型中使用的位置嵌入选择的预览。在介绍这些选择之前,我们将先讨论其背后的机制。

图1:2026年架构的预览,按位置编码进行分组。架构图来自我的大语言模型画廊。

但为什么花这么多时间来写/读这个相对次要的构建模块呢?大语言模型持续演进,而当我准备撰写一篇关于今年最新大语言模型架构趋势的新文章时,我意识到自己之前从未在任何文章中覆盖过大语言模型中使用的位置信息方法。因此,为了避免让那篇文章变得过于冗长,我认为发布这篇作为即将来临的大语言模型架构和趋势分析的独立构建模块是有意义的。

此外,多年来,许多读者一直要求我提供一个关于相对位置嵌入(即RoPE)的教程,以跟进GPT中使用的已学习的绝对嵌入。这一直在我待办事项列表中,所以我终于重新审视了我之前的草稿,并整理了这篇指南,内容将涵盖:

  • 大语言模型中的不同位置方法;
  • (终于)RoPE的工作原理;
  • 最近开放的大语言模型使用的方法。

请注意,本文假设读者对基本的大语言模型架构有一定的了解,并适合作为《从零开始构建大型语言模型》的后续阅读。如果对注意力机制内部的计算,特别是查询、键和值向量的概念有些模糊,我建议查看我的自注意力指南作为复习:

#### 理解和实现大语言模型中的自注意力、多头注意力、因果注意力和交叉注意力

2024年1月14日

阅读完整故事

本文也非常技术性,可能对某些人来说过于详细。然而,我真的希望为未来文章提供这个基础作为参考。不用担心,下一篇文章将回到更舒适的风格。

PS:我开始尝试Substack的新“特权”系统。作为对支持者的感谢,我为你们添加了架构画廊中的图像导出和元数据,供你们在自己的分析中使用。

PPS:如果你已经了解位置嵌入的工作原理,可以直接跳到第6节,现代架构中的位置选择。

请注意,这篇文章可能更适合在网页浏览器中阅读,而不是电子邮件客户端。我建议在这里查看网页版本,它还有左侧的导航栏。

1. 位置信息如何进入大语言模型

让我们从整体架构开始。一个分词器将输入文本编码为标记 ID。接下来,LLM 的输入标记嵌入层将这些 ID 映射为数字向量。我们通常将这些向量中的条目称为“特征”(类似于经典机器学习)。LLM 内部的变压器块然后使用注意力和前馈层修改这些向量。最后,模型的输出层生成下一个标记的对数几率分数(转换为概率)。

以下展示了 GPT-2(一个相对经典的 LLM)和 MiniMax-M3(今年发布的一个较新的 LLM;大多数其他较新 LLM 的占位符)中的这一路径。正如我们所看到的,这些架构彼此之间的差异并不太大,但在我们讨论位置信息部分之前,让我们先关注橙色块(标记嵌入层)以及它们上方的变压器块;其他架构差异在此解释中并不需要。

图 2:GPT-2 和 MiniMax-M3 中的标记嵌入层,用橙色突出显示。(备注:M3 的前三个(共 60 个)前馈层是密集层,而不是 MoE 层。)

如上图所示,标记嵌入层将每个标记 ID 映射为一个向量。随后添加位置信息。具体来说,正如我们稍后将更详细地讨论,GPT-2 在修改后的嵌入进入第一个变压器块之前,为每个标记嵌入添加一个位置向量。另一方面,MiniMax-M3 使用一种称为 RoPE 的方法,在每个变压器块中添加位置信息。

我们将在后面更详细地讨论这些方法,但首先,让我们从整体信息开始,解释为什么需要或添加显式位置信息。

1.1 为什么添加位置信息?

考虑以下两个输入句子作为简单示例:

  • “The red fox jumps over the gray fox.”
  • “The gray fox jumps over the red fox.”

改变词语顺序会改变哪只狐狸在跳跃,如下图所示。

图 3:改变词语顺序会改变哪只狐狸跳跃。

在本文的示例中,为了简化,我们将每个词视为一个标记。(如你所知,实际的分词器可以将词拆分为更小的子词标记。)那么,第一句话有八个标记位置,从 0 到 7。

图 4:玩具句子中的标记 ID 和位置。

code
# 假设以下小型词表。
# 实际词表通常有 50k 到 200k 个条目
vocab = {
    "The": 0,
    "red": 1,
    "fox": 2,
    "jumps": 3,
    "gray": 4,
    "over": 5,
    "the": 6,
}

(如果你对词表是如何构建的感兴趣,可以查看我在 GitHub 上的分词器资料。)

请注意,在输入句子中出现两次的“fox”在两种情况下都得到相同的标记 ID 2。由于它们的标记 ID 相同,无论在输入句子中的位置如何,它们都将从嵌入层获得相同的嵌入向量。

现在,让我们考虑一个没有位置编码(也没有因果掩码)的常规自注意力机制,其中每个输入标记都可以关注输入中的每个其他标记。在这种情况下,交换任何两个词,例如“red”和“gray”,仍然会导致每个标记对之间的嵌入和注意力分数保持不变。

GPT-style 模型确实使用了因果(自回归)掩码,该掩码将每个标记限制为自身和之前的标记。有趣的是,这种因果掩码为计算提供了一些隐式的顺序信息。在我们的例子中,“jumps” 可以在第一句话中关注到 “red”,在第二句话中关注到 “gray”。因此,理论上,一个因果的大型语言模型(LLM)即使没有显式的 positional embeddings 也能够区分这些句子。(我们之后在讨论 “NoPE” 概念时会再回到这个想法。)

尽管如此,GPT-2 和大多数较新的大型语言模型(LLM)都包含显式的 positional 信息,因为这为注意力机制提供了关于位置的直接信号。这是因为,尽管因果掩码决定了哪些标记是可访问的,并提供了隐式的顺序信息,但它无法区分一个位置的分离和十个位置的分离。因此,显式的 positional 方法仍然有用(甚至必不可少),因为它们提供了这些信息。

如果以上内容听起来有些令人困惑,不用担心,这只是一个概述,我们将在文章的其余部分更详细地逐步讲解这些概念。

2. 为每个标记嵌入添加位置向量

我们简要地讨论了通过因果注意力掩码实现的隐式 positional 信息(我们之后会再次详细讨论这一点)。然而,我们现在转变话题,讨论显式添加 positional 信息的方法。

也许最简单和直接(但不是“最便宜”的)方法是为每个序列位置提供一个独特的位置向量。我们将这个向量添加到标记嵌入中,因此,得到的修改后的嵌入向量将被传递到第一个 Transformer 块中。以下小节将详细讨论这一确切的步骤。

2.1 GPT-2 中学习到的绝对位置嵌入

为了说明如何将一个显式学习到的位置向量添加到输入嵌入中,我们以 GPT-2 作为具体例子。GPT-2 在训练过程中学习一个位置向量的表格。下图展示了这些向量在架构中的使用位置,即在标记嵌入查找之后,第一个 Transformer 块之前。

图 5:GPT-2 在 Transformer 块之前添加了绝对位置信息,如图中紫色部分所示。图中显示的维度是针对 GPT-2 XL 的。

图中所示的位置嵌入层的实现方式与标记嵌入层相同,即它们的输出维度完全相同,这样得到的输入向量可以相加。下面的代码展示了 GPT-2 实现的一个代码片段:

code
class GPTModel(nn.Module):
    def __init__(self, cfg):
        super().__init__()
        self.tok_emb = nn.Embedding(cfg["vocab_size"], cfg["emb_dim"])
        self.pos_emb = nn.Embedding(cfg["context_length"], cfg["emb_dim"])
        self.drop_emb = nn.Dropout(cfg["drop_rate"])
        
        self.trf_blocks = nn.Sequential(
            *[TransformerBlock(cfg) for _ in range(cfg["n_layers"])])
        
        self.final_norm = LayerNorm(cfg["emb_dim"])
        self.out_head = nn.Linear(
            cfg["emb_dim"], cfg["vocab_size"], bias=False
        )
python
    def forward(self, in_idx):
        batch_size, seq_len = in_idx.shape
        tok_embeds = self.tok_emb(in_idx)
        pos_embeds = self.pos_emb(torch.arange(seq_len, device=in_idx.device))
        x = tok_embeds + pos_embeds  # Shape [batch_size, num_tokens, emb_size]
        x = self.drop_emb(x)
        x = self.trf_blocks(x)
        x = self.final_norm(x)
        logits = self.out_head(x)
        return logits

从数学角度来看,我们可以这样表示。设 $ m $ 是一个位置索引,$ x_m $ 是该位置的标记 ID。第一个块的输入是

其中,

  • $ E_{\text{token}} $ 是嵌入层,
  • $ P_m $ 是由 $ m $ 选择的位置信息向量,
  • $ h_m $ 是得到的嵌入和位置向量的总和。

这两个向量的宽度相同,因此我们对它们的元素进行逐项相加。下图 6 通过一个小的数值示例直观地展示了这一点。

图 6:标记嵌入和位置嵌入是逐项相加的。(此处我遵循了神经网络图示通常从下到上阅读的惯例。)

在上图中,位置 0 处,将标记嵌入 [1, 1, 1] 加到位置嵌入 [1.1, 1.2, 1.3] 上,得到 [2.1, 2.2, 2.3]。顺便说一下,图中的数值是为了保持示例的简单性而选择的;在实际示例中,两个嵌入层(表格)都会用小的随机值初始化,并在训练过程中进行学习。

因此,我们在本节中所涵盖的方法被称为所谓的绝对位置方法,因为位置嵌入 $ P_m $ 依赖于标记自己的位置 $ m $。在前面的示例句子中,两个“fox”标记最初具有相同的标记嵌入,但由于我们添加了不同的位置向量 $ P_2 $ 和 $ P_7 $,在进入第一个 Transformer 块之前,它们具有不同的值。因此,注意力机制内部的查询、键和值向量也会接收到已经包含位置信息的表示。

请注意,原始 GPT-2 实现有 1024 个学习到的位置向量。这意味着它只能处理最多 1024 个标记的输入。如果我们想要扩展上下文窗口,就必须扩展这个嵌入表。由于嵌入表(层)在训练过程中与其他层一样进行更新,因此上下文长度必须在训练开始之前决定。

扩展上下文将非常昂贵,因为表可能会变得非常大。例如,在 GPT-2 Medium 的情况下,位置嵌入层权重在 1024 个位置时仅占总权重的 0.30%。然而,如果我们增加上下文长度到如今常见的 100k 范围,它们将占总模型权重的 >22%,这将非常不经济。

2.2 原始 Transformer 中的固定正弦位置编码

2017 年的原始“Attention Is All You Need”Transformer(早于 GPT)使用相同的加法机制,但使用固定的正弦和余弦函数来计算其位置向量。下图 7 展示了在编码器和解码器堆栈之前添加这些正弦位置编码的情况。编码器处理输入序列,解码器生成输出序列。(之所以在此处引入,是因为在讨论 RoPE 时,正弦和余弦函数将再次变得相关。)

图 7:以紫色突出显示的正弦位置编码被添加到标记嵌入中。

原始的 Transformer 在添加位置向量之前,会将其 token 嵌入向量按 √(d_model) 进行缩放,其中 d_model 是嵌入的宽度。

因此,虽然上一节中的 GPT-2 使用了以下公式:

但原始 Transformer(如图 7 所示)使用的公式是:

这种按 √(d_model) 进行的缩放是一个小的技术细节,但对于那些感兴趣的人来说,这种缩放因子的动机在 Transformer 论文中并没有解释。不过,正如我多年前在 Twitter 上与同事讨论过的一样,这种缩放很可能是为了在初始化时将 token 嵌入和正弦位置编码放在可比较的数值尺度上,从而避免在添加位置向量时,位置向量主导总和。

在 GPT-2 的情况下,这种缩放是不必要的,因为原始的 GPT-2 代码将 token 嵌入初始化为初始标准差为 0.02,而位置嵌入初始化为初始标准差为 0.01,这样它们已经在大致相同的尺度上。

现在,更有趣的问题是,位置嵌入 P_m 是如何计算的。

具体来说,每个位置向量的条目如下:

如前所述,m 表示位置。索引 i 用于索引向量中的一个特征对。

在这里,一个特征是指位置向量中的一个数字。例如,假设我们有一个小的向量,包含 8 个值(d_model = 8),其条目编号为 0 到 7。(在原始论文中,小型模型是 512,大型模型是 1024,而不是 8,但那样很难可视化。)我们将这些分组成四对,使得 i 从 0 到 3。

图 8:每个特征对的正弦和余弦条目。

在这里,索引 2i 和 2i + 1 分别选择与第 i 对对应的两个条目。

如前面的公式所示,位置 m 的角度,随后被输入到正弦或余弦函数中以得到 P_m, 2i 或 P_m, 2i+1,计算方式如下:

图 9:正弦和余弦中的角度是 token 位置乘以该对的角频率。

图 10 展示了我们 8 个特征示例中所有四对在位置 m = 2 处的计算。

图 10:位置 2 处的四个正弦和余弦对。

对于一个八特征嵌入,四个频率是每位置 1、0.1、0.01 和 0.001 弧度。在位置 2,第一行中的第一对是 (sin 2, cos 2) ≈ (0.909, −0.416)。

第二对,在第二行中变化更慢,给出 (sin 0.2, cos 0.2) ≈ (0.199, 0.980)。

下面的图示展示了不同对的正弦和余弦计算,然后将它们收集到一个位置向量中。

图 11:采样正弦和余弦函数以形成一个位置向量。

简而言之,与前面讨论的 GPT-2 方法相比,这是一种(更复杂的)获取位置嵌入向量的替代方法。

与 GPT-2 的嵌入类似,这些也是绝对嵌入,因为每个向量都是根据其自己的位置计算的。然而,与 GPT-2 的方法不同,正弦和余弦函数在训练期间保持不变。(此外,它们可以扩展并评估到训练位置之外,例如超出 1024 的上下文长度,尽管这本身并不能保证模型在这些位置表现良好,因为它在训练期间没有见过这些位置。)

总结一下,图 12 对比了我们迄今为止讨论的两种获取位置向量的方法。

图 12:固定的正弦和学习的绝对位置嵌入。

这种正弦方法看起来可能像是获得位置嵌入的一种过于复杂的方式,然而,理解它在下一节讨论 RoPE 时会很有帮助。

此外,这种方法背后也有一些原理。作者选择使用正弦和余弦,是因为它们在某个偏移量下进行平移时,会产生一个确定性的差异。例如,位置 2 到 5 的差异与位置 102 到 105 的差异都是 3,这会导致相同的旋转。

根据《Attention Is All You Need》论文:

“...可以轻松地学习到相对位置,因为对于任何固定的偏移量 $ k $,$ PE_{pos + k} $ 可以表示为 $ PE_{pos} $ 的线性函数。”

或者用不太技术性的语言来说,作者假设这种特性会使注意力机制更容易学习像“三个 token 之前”这样的关系。

下面的图 13 展示了这一点,适用于一对正弦/余弦。旋转是一种线性变换,三个位置的偏移都使用相同的旋转。

图 13:对于角频率为每位置 0.1 弧度的一对,三个位置的偏移总是将这对旋转 0.3 弧度。

3. 使用 RoPE 编码相对位置

因此,上面的正弦方法仍然被视为一种绝对位置编码,因为添加到每个 token 嵌入的向量代表了该 token 从序列开始处计算的位置。

如上图所示,例如,位置 2 和 5 的 token 接收到位置向量 $ P_2 $ 和 $ P_5 $。如果我们把这些 token 移动到位置 102 和 105,它们仍然相隔三个位置。但由于它们的绝对位置 $ m $ 发生了变化,每个 token 会得到不同的位置向量。

因此,即使 token 嵌入保持不变,它们的注意力得分也可能发生变化。正弦结构仍然为模型提供了一种学习相对关系的方法。

无论如何,我们将在下面讨论的 RoPE 直接将这种相对关系构建到注意力计算中。RoPE 是 Su 等人在 2021 年的 RoFormer 论文中引入的,全称是 Rotary Position Embedding,被认为是一种相对位置方法。

3.1 在 RoPE 中将旋转移入注意力机制

在注意力机制中,每个 token 的当前表示会被投影到查询(query)、键(key)和值(value)向量。查询-键点积决定了注意力得分。在掩码和 softmax 之后,得到的权重决定了值向量如何混合。如需复习,请参阅我的文章《Understanding and Coding Self-Attention, Multi-Head Attention, Causal-Attention, and Cross-Attention in LLMs》:

RoPE 使用 token 的位置在查询和键向量的点积之前对其旋转。值向量则绕过这种旋转。下图 14 展示了 RoPE 在较新的 MiniMax-M3 中的应用概览,其中 QK-Norm 在 RoPE 之前对查询和键进行归一化。

图 14:MiniMax-M3 在注意力机制内部对查询和键应用 RoPE。

如上图所示,LLM 架构中没有在初始 token 嵌入旁边显式添加位置向量。它的显式位置信号是在注意力机制内部注入的。

附注:MiniMax-M3 仅对每个查询和键头的一部分进行旋转,这种变体被称为“部分 RoPE”,我们将在第 6.1 节中详细讨论。但为了先理解基本的 RoPE 操作,让我们通过一个小型示例逐步介绍该方法。

3.2 从 token 表示到 RoPE 中的特征对

注意力机制通常将查询、键和值特征划分为多个头,并行处理。因此,完整的机制通常被称为多头注意力(注意,分组查询注意力也使用多个头)。在此,每个注意力头都会计算自己的注意力分数和加权和。RoPE 然后对每个查询和键头内的数字对进行操作。

为了更具体地说明这一点,下面图 12 展示了一个 token 表示如何通过学习到的查询和键投影进行处理,这些投影是通过权重矩阵 $ W_Q $ 和 $ W_K $ 计算得到的。在这个玩具示例中,每个投影生成 16 个特征,这些特征被重新塑造成两个头,每个头有 8 个特征。在下面的图中,每个小单元格包含一个标量特征,意味着向量中的一个数值条目(由于空间原因,数字未显示)。

图 15:将隐藏状态投影,重新塑造成头,并为 RoPE 配对特征。

对于第一个 8 个特征的头,[1, 2, 3, 4, 5, 6, 7, 8],我们将前一半的每个特征与后一半的相应特征配对。这给出 (1, 5)、(2, 6)、(3, 7) 和 (4, 8)。这种将一半拆分的惯例在 LLM 实现中使用,包括我的 Qwen3 实现。(在实现基本操作后,我们将会将其与原始的、替代的相邻特征配对方法进行比较。)

每个配对根据 token 位置 $ m $ 和该配对的频率 $ \theta_i $ 获得一个旋转角度。相应的查询和键配对使用相同的频率。下面图 16 展示了我们如何旋转这些配对,将更新后的特征放回它们原来的位置,并计算查询-键点积。

图 16:成对旋转产生用于计算注意力分数的旋转后的查询和键向量。

下一节将更缓慢地逐步讲解这些图。

3.3 RoPE 中旋转一对

在以下示例中,我们将使用与之前相同的两个位置。查询来自位置 $ m = 5 $ 的“the”,键来自位置 $ n = 2 $ 的第一个“fox”。由于在这个示例中,键在查询之前,因果掩码允许查询关注它。

为了说明位置的影响,并保持其他因素不变,让我们假设这两个配对都从相同的两个值 (1, 5) 开始。

图 17:第一个特征对 (1, 5) 从查询头的两半中各取一个条目。

此外,对于这个示例,我们使用每个 token 位置 $ \theta = 20^\circ $(每个位置 $ \pi/9 $ 弧度)。在位置 2,我们将键的箭头逆时针旋转 $ 2 \times 20^\circ = 40^\circ $。在位置 5,我们将查询的箭头旋转 $ 5 \times 20^\circ = 100^\circ $。

图 18:从 (1, 5) 开始,RoPE 将位置 2 的键对旋转 40°,将位置 5 的查询对旋转 100°。

为了说明图中发生的情况,例如,将 $ \cos 40^\circ \approx 0.766 $ 和 $ \sin 40^\circ \approx 0.643 $ 代入图 16 的旋转公式,可以得到新的键坐标:

然后,将 40° 改为 100°,使用与上述相同的公式,旋转后的查询对变为 $ q' \approx (-5.098, 0.117) $。但重要的是,两个箭头的长度仍然是 $ \sqrt{26} $。只有旋转发生了变化,但变换后向量的长度保持不变。

因此,对于位置 $ m $ 的查询对 $ (a, b) $,这里的两个操作是:

对于位置 $ n $ 的键对,我们使用相同的方程,用 $ n\theta $ 替代。

(第 4 节将展示 RoPE 如何为每个特征对计算角频率。)

为了结束本节,对于那些更习惯阅读代码的读者,到目前为止关于 RoPE 的所有内容都可以用以下代码表示:

code
import torch

query_head = torch.tensor([1., 2., 3., 4., 5., 6., 7., 8.])
key_head = query_head.clone()

# 分半配对得到 (1, 5), (2, 6), (3, 7), 和 (4, 8)。
query_pairs = torch.stack(query_head.chunk(2), dim=-1)
key_pairs = torch.stack(key_head.chunk(2), dim=-1)

# 从每个头中取第一个特征对。
q = query_pairs[0]
k = key_pairs[0]

m = 5  # 查询位置(在我们的例子中是 "the")
n = 2  # 键位置(在我们的例子中是第一个 "fox")
theta = torch.deg2rad(torch.tensor(20.0))  # 每个 token 位置的弧度

def rotate_pair(pair, angle):
    a, b = pair
    c, s = torch.cos(angle), torch.sin(angle)
    return torch.stack((a * c - b * s, a * s + b * c))

k_rot = rotate_pair(k, n * theta)  # 2 × 20° = 40°
q_rot = rotate_pair(q, m * theta)  # 5 × 20° = 100°

print(f"原始键:   ({k[0]:g}, {k[1]:g})")
print(f"原始查询: ({q[0]:g}, {q[1]:g})")
print(f"旋转后的键:    ({k_rot[0]:.3f}, {k_rot[1]:.3f})")
print(f"旋转后的查询:  ({q_rot[0]:.3f}, {q_rot[1]:.3f})")

得到的值如下:

code
原始键:   (1, 5)
原始查询: (1, 5)
旋转后的键:    (-2.448, 4.473)
旋转后的查询:  (-5.098, 0.117)

如果我们对 8 个特征查询(和键)向量中的所有 4 对进行旋转,我们将得到下面的向量。(我们稍后再讨论如何从旋转一对到旋转所有对。)

code
原始键:   (1, 2, 3, 4, 5, 6, 7, 8)
原始查询: (1, 2, 3, 4, 5, 6, 7, 8)
旋转后的键:    (-2.448, 1.577, 2.951, 3.994, 4.473, 6.125, 7.021, 8.003)
旋转后的查询:  (-5.098, 0.928, 2.877, 3.986, 0.117, 6.256, 7.051, 8.007)

3.4 RoPE 中相对偏移如何改变注意力得分

请注意,如上所述,查询和键头各有 8 个特征,我们之前将它们分组为 4 对,每对包含两个元素,例如 (1, 5)、(2, 6) 等。为了简化,这里我们只关注每个头中的第一对 (1, 5),这对由索引 0 和 4 处的条目组成:

如上所述,在我们的例子中,旋转之前,这两个条目在两个头中都有值 (1, 5)。

同样,如上面的代码所示,我们使用符号 q = (q₁, q₂) 和 k = (k₁, k₂) 来表示这两个对。为了计算它们的点积,使用标准的点积公式,我们将对应的坐标相乘并相加:

在旋转之前,这对的点积为 1 × 1 + 5 × 5 = 26。使用上一个图 18 中四舍五入后的坐标,可以得到旋转后第一对的贡献:

我们可以通过将点积表示为两个向量(图 18 中的箭头)的长度和它们之间的角度 ϕ 来理解这一点。

在这两种情况下,向量的长度都是 √26。查询(位置 5)旋转了 100°,键(位置 2)旋转了 40°。向量(箭头)从相同的方向开始,因此旋转后它们之间的角度变为 60°。它们的点积正好是 26 × cos(60°) = 13。

现在,让我们看看如果我们只将键从位置 2 移动到位置 3,但保持其起始坐标 (1, 5) 不变会发生什么。键的旋转现在从 2 × 20° = 40° 变为 3 × 20° = 60°。查询仍然旋转了 100°,因此箭头之间的角度缩小到 40°,点积从 13 变为 26 × cos(40°) ≈ 19.92。因此,即使我们从相同的特征值开始,将键移动一个位置更近也改变了点积。

为什么这些点积如此重要?在注意力机制中,我们会将所有特征对的贡献相加,以得到查询-键的点积。RoPE 可以改变这些点积,从而影响 softmax 分配给值向量的权重。

在上面的注意力公式中,Q′ 和 K′ 是包含一个头的旋转后的查询 q′ 和键 k′ 的矩阵,V 包含值,d 是头的维度。

3.5 为什么在 RoPE 中同时移动位置可以保持注意力分数

现在我们已经展示了点积的计算方式,这是注意力机制的核心,让我们回到位置 m = 5 和 n = 2。如果我们同时将这两个位置向右移动三个位置,得到 m = 8 和 n = 5。每个旋转增加了 60°(查询从 100° 变为 160°,键从 40° 变为 100°),但向量之间的角度保持不变。这对特征对的点积仍然是 13。

图 19:第一对在三种不同位置设置下的点积。

关键在于旋转角度之间的差值是:

如果我们保持原始查询和键向量不变,同时将两个标记的位置移动相同的量,RoPE 会向这两个向量添加相同的旋转。它们之间的角度保持不变,因此它们的点积也保持不变。请注意,下面的图 20 使用了比实际示例(每个位置 20°)更小的角度,以保持图像的可读性。

图 20:共享的位置移动保持了固定查询和键特征之间的相对角度和点积。

上述示例和图 20 说明了 RoPE 的主要思想。我们使用每个标记的位置来旋转注意力模块中对应的查询和键。在查询-键点积中,重要的是一个向量相对于另一个向量旋转了多少。对于每对特征,这种旋转差异只取决于两个标记之间的偏移。

为了在整体上说明这一点,在图 21 中,每一行收集了一个查询的分数。如果我们考虑第 5 行,“the”的查询,以及第 2 列,“fox”的键,这两个之间的注意力分数是通过查询和键向量的旋转版本之间的点积计算得出的。

图 21:softmax 之前的单个头的注意力分数。灰色单元格标记了被因果掩码排除的未来键。

再次说明重点是什么?让我们再次考虑句子“The red fox jumps over the gray fox.”。如果我们在这句话前面添加 100 个标记(例如系统提示),第一个“fox”和第二个“the”将从位置 2 和 5 移动到 102 和 105。然而,任何长度的前缀都会等量地移动这两个位置,因此它们仍然保持恰好三个位置的距离。这意味着,每个向量(箭头)都会获得完全相同的额外旋转,这保持了它们之间的角度和点积(假设我们保持未旋转的查询和键向量不变;在实际模型中,100 个标记的新前缀可能会通过改变标记的注意力对象来改变这些向量)。

图 22 跟踪了注意力分数矩阵中的这一比较。右侧面板显示了添加前缀后的句子的行和列。在我们的玩具示例中,第一对仍然对点积贡献了 13。

图 22:高亮的分数从第 5 行、第 2 列移动到第 105 行、第 102 列。如果在旋转之前保持查询和键向量不变,分数值保持不变。

如你所知,在原始 transformer 的正弦编码中,一个固定的偏移量也对应于每对正弦/余弦中的一个固定旋转。但这种共享的旋转仅适用于位置向量(添加到输入向量中),而不是注意力机制内部的键和查询向量。

图 23 比较了这种偏移在我们到目前为止介绍的三种方法中所带来变化。

图 23:在正弦编码、GPT-2 的学习位置嵌入和 RoPE 中相同的位置偏移。

3.6 附加内容:在 RoPE 中将这些对组合成一个完整的注意力头

为了了解相对偏移如何影响点积,我们关注了查询和键中的一个特征对。现在,让我们将所有四个对组合在一起,看看 RoPE 如何在一个注意力头中旋转完整的八个特征向量。(如果你觉得这部分技术细节太多,可以跳过这一节。)

图 24 接续了图 17 的内容。我们对每个四个对进行旋转,然后将结果放回查询的原始特征顺序中。

图 24:RoPE 以各自的角度旋转每个查询特征对。(同样的方法也可以应用于键,但为了图示的简洁性,这里没有显示。)

图 24 上方展示了旋转后的查询 q′(位于底部)。同样,我们也可以通过在键的位置重复相同的步骤,得到旋转后的键 k′。

回想一下第 3.3 节中的两个公式。对于查询对 i,其输入值为 ( a i , b i ),令 c i = cos( mθ i ) 和 s i = sin( mθ i )。这些是查询位置 m 上该对的旋转角度的余弦和正弦:

图 25 展示了图 24 中的四个旋转,以一个矩阵乘法的形式表示为 q′ = R m q。

图 25:将图 24 中的四个旋转写成一个矩阵乘法。配对标签显示了每个旋转在完整矩阵中的位置。

4. 在 RoPE 中计算旋转频率?

一个完整的注意力头使用多个频率,使得某些特征对随着位置的变化更加剧烈(在 RoPE 中称为“快速”),而其他特征对变化则更加缓慢(在 RoPE 中称为“缓慢”)。这与原始 transformer 中正弦编码的多个频率具有相同的目的。

然而,我们并不手动分配这些频率,对于一个具有 d 个特征的头,标准的完整 RoPE 会为它的 d / 2 对分别计算一个频率,具体如下:

  • d 是头的维度(它必须是偶数,以便所有特征可以成对排列)。
  • i 是对的索引;它的范围是从 0 到 d / 2 − 1。
  • b 是一个选定的基数值(超参数),它决定了频率之间的间隔。
  • θ i 是第 i 对的频率,以弧度/位置为单位。

原始 RoFormer 论文使用 b = 10,000,借鉴了原始 transformer 的频率公式,用头维度 d 替代了嵌入宽度 d model。

例如,当头维度 d = 8,基数 b = 10,000 时,我们得到的频率是 [1, 0.1, 0.01, 0.001] 弧度/位置。

5. 附加内容:在 PyTorch 中实现 RoPE

如果你想在一个完整的模型中看到 RoPE,我建议你查看我从零开始实现的端到端 Qwen3。

由于代码可以是解释和理解概念的有效媒介,以下小节将带你逐步了解我们到目前为止所涵盖的核心部分,如果你感兴趣的话。否则,请随意跳到第 6 节,关于现代架构中的位置选择。

因此,对于以下代码片段,我们将使用与之前提到的相同的一半分割旋转约定(不用担心,我们也会涵盖交错约定)。首先,我们将它应用于一个查询向量,然后将其应用于注意力机制中的查询和键。

5.1 计算和应用旋转

首先,让我们重新使用图24中的8个特征查询。为了方便起见,下面列出了旋转前的四个特征对。

图24的细节。8个查询特征在分割一半的布局中形成四个对。

在之前的非编码示例中,我们为第一个对选择了每个标记位置20°的频率,以保持数学计算简单。在这里,我们将使用上面第4节中原始RoPE公式 θ i = b −2 i / d ,其中头维度 d = 8 和基础 b = 10,000。

图26展示了这两个函数如何协同工作以应用这些旋转。

图26:rope_params 返回标记位置2的余弦和正弦表。rope_split_half 接受这些表和原始查询,并返回旋转后的查询。

如上图所示,首先,rope_params 确定每个对旋转多远,返回两个“表”,这些表存储了这些角度的余弦和正弦。换句话说,rope_params 计算每个旋转角度的余弦和正弦,这些角度取决于标记的位置和特征对的频率。

python
import torch

def rope_params(head_dim, positions, base=10_000):
    assert head_dim % 2 == 0
    indices = torch.arange(0, head_dim, 2, device=positions.device)
    inv_freq = base ** (-indices.float() / head_dim)
    angles = positions.float()[:, None] * inv_freq[None, :]
    return angles.cos(), angles.sin()

rope_params 函数中的 indices 数组包含第4节中频率公式中的 2 i 值:

对于我们的8个特征查询,indices 是 [0, 2, 4, 6],即每个特征对的一个 2 i 值。假设我们使用常见的基础 b = 10,000。并按照我们之前的示例,我们选择一个较小的头维度 d = 8。在这种情况下,inv_freq 计算四个对的频率 θ i = b −2 i / d 如下:

如上所述,得到的 inv_freq 对于每个标记位置的四个特征对(以弧度为单位)都有一个频率 θ i。

接下来,angles 将每个对的频率 θ i 与标记位置 m 相乘,计算旋转角度 mθ i。在我们的示例中,positions = [2],我们得到:

最后,rope_params 计算每个角度的余弦和正弦,并将它们作为两个所谓的余弦和正弦表输出,分别为 cos 和 sin。在两个表中,每一行是一个标记位置,每一列是一个特征对。由于我们在这里只使用标记位置2,每个表的形状都是 (1, 4),如下所示的单行:

在图26的示例中,每个表对于标记位置2有一行,有四列,每列对应一个特征对。图27展示了每个对的旋转角度以及两个表中对应的条目。

图27:rope_params 对于标记位置2返回的两个表。突出显示的列给出了用于旋转第一个特征对(1, 5)的余弦和正弦。

简而言之,rope_params 计算每个旋转角度的余弦和正弦,这些角度取决于标记的位置和特征对的频率。

在现实场景中,如果我们为上下文大小为 1024 的 1,024 个 token 位置传递 rope_params,并且头维度为 128,它会返回两个张量 cos 和 sin,每个张量的形状为 (1024, 64),因为一个具有 128 个特征的头有 64 对。

这些表没有批次或头维度,我们将每个 (1024, 64) 表广播到批次和头维度。因此,如果我们有 32 个头的多头注意力或分组查询注意力,token 位置 2 的特征对 0 在所有 32 个头中使用相同的旋转角度。每个头旋转自己的特征值,因此旋转后的查询在不同头之间仍然可以不同。此外,相同的条目可以被重复使用在使用相同位置和频率的查询、键和头中。简而言之,我们只需要为模型的所有位置(直到最大支持的上下文大小)预先计算这些表一次。

从技术上讲,也可以将这些表与模型权重一起存储;但它们的计算成本非常低,将它们存储在磁盘上会显得过于复杂。

接下来,rope_split_half 使用这些余弦和正弦来旋转注意力中查询和键向量的实际特征。

code
def rope_split_half(x, cos, sin):
    first, second = x.float().chunk(2, dim=-1)
    return torch.cat((
        first * cos - second * sin,
        first * sin + second * cos,
    ), dim=-1).to(x.dtype)

再次考虑这个简单的 8 个特征示例,上面代码片段中的 .chunk 将查询分割为 [1, 2, 3, 4] 和 [5, 6, 7, 8],并将每对中的两个条目对齐。例如,每个半部分的第一个槽位给出 (1, 5),第二个槽位给出 (2, 6),依此类推。torch.cat 中的两个表达式使用第 3.3 节中的方程来计算旋转后的半部分:

请注意,这里用 i 表示的每个项对应查询的第一部分,而用 b i 表示的每个项来自第二部分。torch.cat 中的第一个表达式计算所有 a i ′ 值,第二个表达式计算所有 b i ′ 值。

然后,我们通过 torch.cat 将两部分连接起来,这将每个值放回其原始索引位置。

以下是生成前面图 26 中旋转查询的代码。所示的 reshape (1, 1, 1, 8) 仅将简单的玩具数组转换为预期的格式:一个批次项、一个头、一个 token 和八个特征。

code
positions = torch.tensor([2])
cos, sin = rope_params(8, positions)

q = torch.arange(1., 9.).reshape(1, 1, 1, 8)
q_rot = rope_split_half(q, cos, sin)
print(q_rot[0, 0, 0])

对于多个位置,每个 token 仅从 cos 和 sin 表中获取自己的行。通过广播,PyTorch 在所有批次项和注意力头中重用这些表。

5.2 在因果注意力中使用 RoPE

到目前为止,我们已经编写了 RoPE 的实用函数。现在,让我们在实际的上下文中使用它,即注意力机制。在这里,我们使用标准频率计划为两个 8 个特征的头和四个 token 位置。我们使用随机的查询、键和值张量来保持示例的自包含性,但如前所述,您也可以选择检查使用预训练模型生成的真实查询、键和值的端到端 Qwen3 从零开始实现。

code
torch.manual_seed(123)

q = torch.randn(1, 2, 4, 8) # 1 batch, 2 heads, 4 tokens, 8 head dim
k = torch.randn(1, 2, 4, 8)
v = torch.randn(1, 2, 4, 8)
positions = torch.arange(4)

cos, sin = rope_params(8, positions) q_rot = rope_split_half(q, cos, sin) k_rot = rope_split_half(k, cos, sin) scores = q_rot @ k_rot.transpose(-2, -1) / q.shape[-1] ** 0.5

future_mask = positions[None, :] > positions[:, None] masked_scores = scores.masked_fill(future_mask, -torch.inf) weights = torch.softmax(masked_scores, dim=-1) context = weights @ v

code

请注意,只有 q 和 k 会经过 RoPE,而 v 不会。生成的原始注意力得分存储在一个形状为 (1, 2, 4, 4) 的张量中,即每个查询位置一行,每个键位置一列,因为有四个 token,每个 token 都会与其他 token 相互作用,所以是 4x4。

然后,使用传统的注意力代码实现,因果掩码会将未来键的得分替换为负无穷,因此在 softmax 之后这些得分会被置零。得到的 context 张量的形状为 (1, 2, 4, 8);其中 4 是因为有四个 token,而 8 是因为嵌入维度最初是 8。

我们也可以验证我们关于相对偏移的主张,即每个位置加上 3 应该改变位置但保持查询-键偏移不变:

cos_shifted, sin_shifted = rope_params(8, positions + 3) q_shifted = rope_split_half(q, cos_shifted, sin_shifted) k_shifted = rope_split_half(k, cos_shifted, sin_shifted) scores_shifted = ( q_shifted @ k_shifted.transpose(-2, -1) / q.shape[-1] ** 0.5 ) torch.testing.assert_close(scores, scores_shifted)

应该返回 True

code

### 5.3 另一种特征配对约定

在本文中,我多次提到了 split-halves 约定。原始 RoPE 论文使用了另一种交错的约定,原始 LLaMA 实现也是如此(但如前所述,目前大多数代码实现都使用 split-halves,因为它在代码中更容易通过逐元素的正弦和余弦操作一次性旋转所有配对)。

为了说明这两种布局之间的差异,下图 28 在两行中都使用了相同的 8 个特征向量。

图 28:Split-half 将第一部分的每个特征与第二部分的相应特征配对。交错将相邻的特征配对。

交错实现使用相同的两个方程,但选择交替的特征并交错输出。

def rope_interleaved(x, cos, sin): even, odd = x.float()[..., 0::2], x.float()[..., 1::2] return torch.stack(( even * cos - odd * sin, even * sin + odd * cos, ), dim=-1).flatten(-2).to(x.dtype)

code

但从数学上讲,当考虑到特征顺序时,这两种布局是等价的。因此,将条目 [1, 2, 3, 4, 5, 6, 7, 8] 重新排列为 [1, 5, 2, 6, 3, 7, 4, 8],会使 split-half 配对相邻,如 (1, 5)、(2, 6) 等。如果对查询和键都应用相同的重新排列,将得到相同的点积。

order = torch.tensor([0, 4, 1, 5, 2, 6, 3, 7], device=q.device) q_rot_interleaved = rope_interleaved(q[..., order], cos, sin) k_rot_interleaved = rope_interleaved(k[..., order], cos, sin) scores_interleaved = ( q_rot_interleaved @ k_rot_interleaved.transpose(-2, -1) / q.shape[-1] ** 0.5 )

torch.testing.assert_close(q_rot[..., order], q_rot_interleaved) torch.testing.assert_close(k_rot[..., order], k_rot_interleaved) torch.testing.assert_close(scores, scores_interleaved)

这些都应该返回 True

code

输出保留了重新排序的特征,因此我们按照相同的顺序将它们与分半输出进行比较。然而,将这两种布局应用于原始向量时,会得到不同的分数。

## 6. 现代架构中的位置选择

自原始 LLaMA 模型以来,RoPE 已成为大多数(开放权重)大语言模型中的标配。当然,专有模型也可能使用它,但对专有模型的任何说法都很难达到 100% 的确定性。

然而,近年来,许多架构正在逐步减少在每个 Transformer 块中使用完整的 RoPE。在以下小节中,我们将讨论其中的一些变体。

例如,我们在前面章节中讨论并实现的完整 RoPE 实现方式,会在每个查询和键头中旋转每一对特征。

在下面小节中的示例中,我们将看到一些模型仅在每个头中旋转部分特征,其他模型在某些 Transformer 块中跳过 RoPE,还有一些模型采用不同的方法,直接将位置信息添加到它们的注意力得分中。

### 6.1 部分 RoPE

如文章中所讨论的,常规的“完整”RoPE 会旋转每个查询和键头中的所有维度。部分 RoPE 是一种变体,它仅旋转一部分维度,而保持其余维度不变。

例如,MiniMax-M3 的配置在每个 128 维的头中使用 64 个旋转维度。这提供了 32 对旋转特征和 64 个未改变的维度。下图展示了这种配置的外观。

图 29:128 维头中的完整 RoPE 和部分 RoPE。

请注意,如果我们查看第一个 Transformer 块之后的部分,未旋转的特征仍然可能包含从早期 Transformer 块继承的位置信息。

无论如何,部分 RoPE 的目的是什么?它节省了一些内存。例如,在上面的 MiniMax-M3 示例中,旋转一半的特征会将预计算的余弦和正弦表的大小也减少一半。因此,使用部分 RoPE 时,每个表只需要 32 列,而不是 64 列。然而,需要注意的是,KV 缓存仍然为每个缓存的标记存储完整的键和值向量。

对于 MiniMax-M3 的 1M 标记上下文,旋转 128 个特征中的 64 个,会将预计算的余弦和正弦表的大小减半。如果表以 BF16 存储,可以节省 0.134 GB(128 MiB)。如果表本身以 NVFP4 存储,包括块尺度,节省的内存为 0.038 GB(36 MiB)。

请注意,在对 1B 到 8B 模型进行的实验中,《Fractional Rotation, Full Potential?》论文发现,旋转每个头中约 10% 的特征通常可以提供与完整 RoPE 相似的训练损失和基准准确率。然而,完整 RoPE 在某些评估中表现更好。

因此,我认为部分 RoPE 几乎不值得。

### 6.2 NoPE 层

NoPE 这个术语首次出现在论文《The Impact of Positional Encoding on Length Generalization in Transformers》中,意思是“没有显式的位置编码”。其思想或观察是,即使没有任何显式的位置方法,注意力层仍然具有因果掩码,其中查询只能关注自身和之前的标记。这种因果掩码隐式地提供了位置信息。

让我们以我们之前示例中的前四个标记“The red fox jumps”为例。在图 30 中,位置 2 的“fox”查询可以关注“The”、“red”和它自己。位置 1 的“red”查询可以关注“The”和它自己。

图 30:注意力机制中因果掩码的示例。

那么,接下来的问题是,模型如何将因果掩码用作位置信号?这里有一个改编自论文的玩具示例。

假设值向量的一个特征对于“The”是1,对于其他三个标记是0。由于输入中只包含一个“The”,每个可见的前缀都恰好包含一个1。如果所有未被掩码的键都获得相同的注意力分数,softmax会为每个可见的标记分配相等的权重。

因此,在“fox”处,注意力对1、0和0取平均,结果为1/3。在“jumps”处,它对四个值取平均,结果为1/4。换句话说,这个输出特征等于前缀长度的倒数,后续层可以将其用作位置的信号。

图31:在均匀注意力下,随着前缀的增长,“The”的贡献逐渐减少。“fox”的查询为“The”分配了1/3的权重。

NoPE在实践中是否有效?NoPE论文的研究人员在包括复制、排序和加法等任务上,从头开始训练了一个小型的107M参数的仅解码器变压器模型,以进行一些消融实验。

当他们在训练过程中未见过的更长示例上测试这个小型模型时,有趣的是,NoPE在十个任务中总体排名第一,甚至优于RoPE。NoPE论文的研究人员还进行了一项独立的实验,使用一个在代码上训练的更大的1.3B参数模型。在这里,NoPE同样处理了超出训练长度的上下文,然而,在最长的测试长度上,它的下一个标记预测效果变差。

今天的一些开源大语言模型甚至在所有层中都使用NoPE。然而,如今,模型通常至少在某些层中省略RoPE,这里的“层”指的是变压器块。

为了给出一个具体的例子,SmolLM3(3B参数)在三层中使用RoPE,在第四层跳过RoPE,并在36层中重复这一模式。有趣的是,SmolLM3的作者提到,这种层模式提高了长上下文的性能。

(请注意,任何后续层,即使跳过了旋转,仍然会从前面的变压器块接收输入,因此其查询和键仍然会从前面的层获得某种位置信息。)

图32:SmolLM3的架构(左)和其36个变压器块中使用的每个位置方法(右)。每四个块跳过RoPE。架构图来自我的LLM架构画廊。

### 6.3 学习的相对位置偏置

在我们概述现代架构之前,还有另一种方法需要介绍。例如,Thinky的Inkling在其滑动窗口和全局注意力层中都使用了学习的相对位置偏置。它计算查询和键之间的常规缩放点积,然后在注意力分数计算的softmax之前,将某个数值加到该分数上。该数值取决于查询标记的隐藏状态以及键距离查询的位置数。

让我们再次使用示例句子,“The red fox jumps over the gray fox。”(这是最后一次,我保证!)在下图中,位置5的“the”是查询,位置2的“fox”是键。Inkling然后使用查询和键之间的三个位置间隔以及“the”的隐藏状态来计算偏置,并将其加到缩放点积上。

图33:在softmax之前,Inkling将学习的相对位置偏置添加到缩放的查询-键点积中。这些数字是示意性的。

这并不是一个全新的想法。你们中的一些人可能还记得 2019 年 Google 流行的 T5(Text-to-Text Transfer Transformer),它使用了这个想法的一个更简单的版本。

图 34:原始 Inkling(975B)架构。学习到的相对位置偏差输入到注意力模块中。LLM 架构画廊

### 6.4 这些选择在近期模型中的体现

现在,在经过这么多铺垫之后,有趣的问题是:哪种架构使用了哪种方法?近期的趋势又是什么?

为了回答这个问题,我根据我的 LLM 架构画廊中列出的发布日期对条目进行了分组,并将 2025 年的发布与 2026 年快照中的早期和后期发布进行了比较。每个画廊卡片只计算一次,因此一个架构的多个变体可以对结果做出贡献。LLM 架构画廊

图 35:架构图说明了哪些注意力层使用了 RoPE,条形图显示了每个类别中画廊条目的占比。图示来自我的 LLM 架构画廊。

如上图 35 所示,每层 softmax 注意力都使用 RoPE 仍然是最常见的选择。然而,从 2025 年到 2026 年,它的使用率有所下降,然后在 2026 年的后半段也出现了下降,这可能是一个趋势。

因此,越来越多的模型开始混合使用 RoPE 和 NoPE。这些组别仍然较小,因此很难判断这些趋势是否会持续下去。

NoPE 仅条目全部是使用 softmax 注意力层且不使用任何显式位置编码的循环混合模型。这里的“其他”类别指的是 xLSTM 7B(2025)和 Inkling(2026)。xLSTM 没有 softmax 注意力层。Inkling 在 softmax 之前向注意力分数添加了一个学习到的偏差,如第 6.3 节中所见。

在使用 RoPE 的模型中,从 2025 年到 2026 年,部分 RoPE 的使用变得更为普遍。它从 2025 年 RoPE 模型中的少数,变成了 2026 年两个组中的多数,如图 36 所示。

图 36:在使用 RoPE 的画廊条目中,部分 RoPE 在至少一个注意力层中旋转一部分查询和键特征。全宽条目在每个使用 RoPE 的层中旋转所有查询和键特征。

如果你想查找 2026 年组中的某个具体模型,图 37 下面展示了 2026 年画廊概览,其中每个架构都按位置类型进行了标注。你也可以在这里交互式地浏览画廊。

图 37:图 35 中两个 2026 条中的 2026 年画廊条目。

## 7. 最后的一些想法

综上所述,我们讨论了 GPT-2 和原始 Transformer,它们在第一个 Transformer 块之前向每个 token 嵌入添加位置向量。然后,现代 LLM 转而使用 RoPE,它通过旋转查询和键在注意力中编码相对位置。令人惊讶的是,RoPE 仍然是今天最受欢迎的位置嵌入方法。

然而,最近 Inkling 从 T5 中借鉴了一个想法,在 softmax 之前向注意力分数添加一个学习到的相对位置偏差。此外,我们还有 NoPE-RoPE 架构,它们在某些层中省略了 RoPE。

这可能是个无聊的消息,但如前所述,RoPE 仍然是主要的位置嵌入方法,我认为这在 2027 年肯定还会继续下去。不过,也许在 2027 年我们会看到更多类似 Inkling 设计的架构出现。

虽然这听起来可能“无聊”,但我很高兴终于在多年之后完成了这篇关于 RoPE(以及其他位置信息方法)的文章,这样我就可以把它添加到我的 LLM “基础”解释系列中了。

如果你对大型语言模型(LLMs)的其他架构构建模块感兴趣,我仍然强烈建议你从一个 GPT-2 风格的模型开始,这将帮助你以最小的摩擦力获得对构建模块的扎实理解。然后,你可以在此基础上添加其他方法(如 RoPE)。

如果你想自己构建这样一个 GPT-2 风格的模型,我的第一本《从零开始构建大型语言模型》书籍将逐步讲解下图中所示的所有构建模块。

图 38:GPT-2 XL 为观察更新的架构变化提供了一个基线。大型语言模型架构画廊

对于从 GPT-2 基线分支出来的方法,我在下面收集了一些相关的博客文章,首先从自注意力的回顾开始:

- 自注意力、因果掩码和多头注意力:理解并编码大型语言模型中的自注意力、多头注意力、因果注意力和交叉注意力

- 现代注意力变体(GQA、MLA、滑动窗口注意力、稀疏注意力和混合变体):现代大型语言模型注意力变体的视觉指南

- KV 缓存:从零开始理解并编码大型语言模型中的 KV 缓存

- SwiGLU 前馈层和归一化(LayerNorm 和 RMSNorm):从 GPT-2 到 gpt-oss:分析架构上的进步

- 混合专家层和专家路由:大型语言模型架构比较

- 残差连接和 DeepSeek 的流形约束超连接(mHC):大型语言模型架构的最新进展:KV 共享、mHC 和压缩注意力

- 在 Qwen3 中整合一些组件:《从零开始理解并实现 Qwen3》逐步讲解如何在 PyTorch 中实现密集和混合专家版本。

感谢阅读并支持我的工作!