分享好友 行业资讯首页 行业资讯分类 切换频道

理解大模型中的 Positional Embeddings

2026-11-16 00:4270human five
图片

本文将介绍 RoPE 等经典和现代方法,解释 LLM 如何编码和处理 token 的位置信息。我们将结合可视化示例、少量数学知识和一个简短的 PyTorch 实现,全面了解这些方法背后的机制。当然,之后我们还会看看现代架构如何调整显式位置编码,或者将其省略。

下图预览了 2026 年开放权重模型所采用的位置嵌入方法。在介绍完底层机制之后,我们会进一步讨论这些选择。

Figure 1 — gallery 2026 collage

图 1:按位置编码方法分组的 2026 年模型架构预览。架构图来自我的 LLM gallery。

但为什么要花这么多时间写作和阅读这样一个相对次要的组成部分?LLM 仍在不断演进。今年,在准备一篇关于最新 LLM 架构趋势的新文章时,我意识到自己此前从未在任何文章中介绍过 LLM 使用的位置信息处理方法。因此,为了避免另一篇文章篇幅失控,我认为可以把这部分单独发布,为即将推出的 LLM 架构与趋势分析提供基础。

此外,多年来,许多读者一直希望我在介绍 GPT 使用的可学习绝对位置嵌入之后,再写一篇关于相对位置嵌入,也就是 RoPE 的教程。这件事已经在我的待办清单上放了很久,所以我终于重新整理了旧草稿,写成这篇教程,内容包括:

1. 位置信息从哪里进入 LLM

我们先从整体架构讲起。Tokenizer 将输入文本编码为 token ID。接着,LLM 的输入 token 嵌入层将每个 ID 映射为一个由数字组成的向量。我们通常将向量中的这些数值称为“特征”,这与传统机器学习中的术语类似。随后,LLM 内部的 Transformer 块使用 attention 和前馈层修改这些向量。最后,模型的输出层为下一个 token 生成 logit 分数,再将其转换为概率。

下图展示了这一过程在 GPT-2 和 MiniMax-M3 中的实现。GPT-2 是一个相对经典的 LLM,而 MiniMax-M3 是今年发布的较新 LLM,在这里可以作为大多数近期 LLM 的代表。如图所示,两者的架构差别并不算太大。在讨论位置信息之前,我们暂时先关注橙色模块,也就是 token 嵌入层,以及它们上方的 Transformer 块;其他架构差异与这里的解释无关。

Figure 2 — token embedding architectures

图 2:GPT-2 和 MiniMax-M3 中的 token 嵌入层,以橙色标出。(补充说明:M3 的 60 个前馈层中,最初的 3 层是稠密层,而非 MoE 层。)

如上图所示,token 嵌入层将每个 token ID 映射为一个向量,位置信息随后才会加入。具体来说,正如我们稍后会详细讨论的,GPT-2 会先将一个位置向量加到每个 token 嵌入上,再将修改后的嵌入送入第一个 Transformer 块。而 MiniMax-M3 则在每个 Transformer 块的 attention 内部,使用一种名为 RoPE 的方法加入位置信息。

我们稍后会更详细地介绍这些方法。首先,让我们从整体上了解为什么需要添加显式位置信息。

1.1 为什么要加入位置信息?

考虑下面两个简单的输入句子:

The red fox jumps over the gray fox.

红狐狸从灰狐狸上方跳过。

The gray fox jumps over the red fox.

灰狐狸从红狐狸上方跳过。

改变单词顺序,也就改变了哪只狐狸在跳跃,如下图所示。

Figure 3 — word order

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

为了简化说明,在本文的示例中,我们将每个单词视为一个 token。(正如你所知道的,真正的 tokenizer 可以将单词拆分成更小的子词 token。)这样,第一个句子就有 8 个 token 位置,编号从 0 到 7。

图片

图 4:示例句子中的 token ID 和位置。

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

(如果你对词表的构建方式感兴趣,可以查看我在 GitHub 上的 tokenizer 相关资料。)

请注意,输入句子中出现了两次的“fox”,在两处都获得相同的 token ID:2。由于它们的 token ID 相同,无论其在输入句子中的位置如何,它们都会从嵌入层获得相同的嵌入向量。

现在,考虑一个没有位置编码、也没有因果掩码的普通 self-attention 机制:每个输入 token 都可以关注输入中的所有其他 token。在这种情况下,交换任意两个单词,例如“red”和“gray”,各 token 获得的嵌入,以及每一对 token 之间的 attention 分数,仍然相同。

GPT 风格的模型确实会使用因果掩码,也就是自回归掩码,将每个 token 可以关注的范围限制为它自身以及更早出现的 token。有意思的是,这种因果掩码为计算过程提供了一些隐式的顺序信息。在我们的例子中,第一个句子里的“jumps”可以关注“red”,而第二个句子里的“jumps”可以关注“gray”。因此,从理论上说,即使没有显式位置嵌入,因果 LLM 也已经能够区分这两个句子。(稍后讨论“NoPE”概念时,我们还会回到这一点。)

尽管如此,GPT-2 和大多数较新的 LLM 仍然包含显式位置信息,因为它能向 attention 提供关于位置的直接信号。虽然因果掩码决定了哪些 token 可以被访问,并提供了隐式顺序信息,但它无法区分相隔 1 个位置和相隔 10 个位置这样的情况。因此,显式位置方法仍然有用,甚至可能不可或缺,因为它们提供了这类信息。

如果这些内容听起来有些令人困惑,也不用担心。这里主要是对整体思路做一个概览,在文章的其余部分,我们会放慢速度,逐步讲解这些概念。

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

我们刚刚简要讨论了因果 attention 掩码如何提供隐式位置信息,稍后也会更详细地回到这个话题。不过,现在我们先换一个方向,讨论添加显式位置信息的方法。

最简单直接的方法或许是为序列中的每个位置分配一个独立向量,尽管它并不是成本最低的方法。我们将该向量加到 token 嵌入上,然后将得到的、经过修改的嵌入向量传入第一个 Transformer 块。接下来的几个小节将详细介绍这一过程。

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

为了说明如何向输入嵌入添加显式的可学习位置向量,我们以 GPT-2 为例。GPT-2 在训练过程中学习一张位置向量表。下图展示了这些向量在架构中的使用位置:紧接在 token 嵌入查找之后、第一个 Transformer 块之前。

Figure 5 — gpt2 architecture

图 5:GPT-2 在 Transformer 块之前加入绝对位置信息,如紫色部分所示。图中所示维度对应 GPT-2 XL。

上图中的位置嵌入层与 token 嵌入层采用相同的实现方式。也就是说,它们的输出维度完全相同,因此得到的输入向量可以相加。下面从 GPT-2 的代码实现中截取了一段,展示这一过程:

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
        )

    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  # 形状:[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

用数学语言表示如下。设  为位置索引, 为该位置的 token ID,则第一个 Transformer 块的输入为:

公式 1:

其中:

这两个向量具有相同的宽度,因此我们将它们的对应元素逐个相加。下图通过一个简单的数值示例直观展示了这一过程。

Figure 6 — absolute embeddings

图 6:token 嵌入和位置嵌入按元素相加。(这里我遵循神经网络示意图通常从下往上阅读的惯例。)

在上图中,位置 0 的 token 嵌入  与位置嵌入  相加,得到 。顺便说明一下,图中的数值是为了简化说明而选取的;在真实场景中,两个嵌入层,也就是两张表,都会使用较小的随机值进行初始化,并在训练过程中学习。

因此,本节介绍的是一种所谓的绝对位置方法,因为位置嵌入  取决于 token 自身的位置 。在前面的示例句子中,两个“fox” token 最初具有相同的 token 嵌入,但由于我们分别加上了不同的位置向量  和 ,它们在进入第一个 Transformer 块之前就具有了不同的值。因此,attention 机制内部的 query、key 和 value 向量接收到的表示也已经包含了位置信息。

请注意,原始 GPT-2 实现包含 1,024 个可学习位置向量。这意味着它只能处理长度不超过 1,024 个 token 的输入。如果想要扩展上下文窗口,就必须扩展这张嵌入表。由于嵌入表,也就是嵌入层,会像其他层一样在训练过程中更新,因此必须在训练开始之前确定上下文长度。

扩展上下文的成本会非常高,因为这张表可能变得非常大。以 GPT-2 Medium 为例,在上下文长度为 1,024 时,位置嵌入层的权重仅占全部权重的 0.30%。但如果将上下文长度增加到如今常见的 10 万左右,位置嵌入层就会占据模型总权重的 22% 以上,这将非常不经济。

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

2017 年提出的原始 Transformer,出自论文 Attention Is All You Need,早于 GPT。它使用相同的相加机制,但通过固定的正弦和余弦函数计算位置向量。下图展示了在 encoder 和 decoder 堆叠模块之前分别加入位置向量的过程。Encoder 处理输入序列,decoder 生成输出序列。(之所以在这里介绍这种方法,是因为稍后讨论 RoPE 时还会再次涉及正弦和余弦函数。)

Figure 7 — original transformer architecture

图 7:正弦位置编码被加入 token 嵌入,如紫色部分所示。

原始 Transformer 在加入位置向量之前,还会将 token 嵌入乘以 ,其中  是嵌入向量的宽度。

因此,上一节中 GPT-2 使用的公式为:

公式 2:

而原始 Transformer 使用的公式,如图 7 所示,为:

公式 3:

乘以  只是一个较小的技术细节。对于好奇的读者,Transformer 论文并未解释使用这一缩放因子的动机。但正如我多年前在 Twitter 讨论串中与同事们讨论的,它很可能是为了让 token 嵌入与正弦位置编码在初始化时处于相近的数值尺度,从而在两者相加时,位置向量不会占据主导。

在 GPT-2 中,这种缩放并非必要,因为原始 GPT-2 代码将 token 嵌入初始化为标准差 0.02,将位置嵌入初始化为标准差 0.01,两者本来就处于大致相同的尺度。

接下来,更有意思的问题是:位置嵌入  是如何计算的?

具体来说,每个位置向量中的元素由下式给出:

公式 4:

和前面一样, 表示位置。索引  指向向量中的一对特征。

这里,一个特征就是位置向量中的一个数值。例如,假设我们有一个包含 8 个数值的小向量,即 ,其中的元素编号为 0 到 7。(在原始论文中,小模型的维度为 512,大模型为 1,024,而不是 8,但那样很难进行可视化。)我们将这 8 个元素分成 4 对,因此  的取值范围为 0 到 3。

图片

图 8:每对特征对应的正弦和余弦元素。

这里,索引  和  分别选出与第  对特征对应的两个元素。

如前面的公式所示,位置  处的角度计算如下。这个角度随后会分别输入正弦或余弦函数,得到  或 。

Figure 9 — angle and frequency

图 9:正弦和余弦函数中的角度等于 token 位置乘以对应特征对的角频率。

图 10 展示了在位置  时,上述 8 维示例中全部 4 对特征的计算过程。

图片

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

对于一个包含 8 个特征的嵌入向量,这 4 个频率分别为每个位置 1、0.1、0.01 和 0.001 弧度。在位置 2,第一行的第一对特征为:

。

第二行的第二对特征变化得更慢,其结果为:

。

下图直观展示了不同特征对的正弦和余弦计算结果,这些结果随后被组合成一个位置向量。

Figure 11 — sinusoidal encoding

图 11:对正弦和余弦函数进行采样,构成位置向量。

简单来说,与前面介绍的 GPT-2 方法相比,这是一种用于获得位置嵌入向量的替代方法,只是更加复杂。

与 GPT-2 的位置嵌入类似,这里得到的也是绝对位置嵌入,因为每个向量都根据它自己的位置计算。不过,与 GPT-2 的方法不同,正弦和余弦函数在训练过程中保持固定。(此外,它们可以扩展到训练时未出现过的位置并进行计算,例如超出 1,024 的上下文长度。不过,仅凭这一点无法保证模型在这些位置上表现良好,因为模型在训练期间没有见过它们。)

下图对比了我们目前讨论过的两种获取位置向量的方法。

Figure 12 — fixed vs learned positions

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

这种正弦方法看起来或许是一种过于复杂的位置嵌入获取方式,但理解它有助于我们在下一节讨论 RoPE。

这种设计也有其理由。作者选择正弦和余弦函数,是因为按某个偏移量移动位置时,会产生确定性的变化。例如,位置 2 到位置 5 的偏移量,以及位置 102 到位置 105 的偏移量,都等于 3,因此两者会产生相同的旋转。

根据 Attention Is All You Need 论文:

这使模型能够容易地学会根据相对位置进行 attention,因为对于任意固定偏移量 , 都可以表示为  的线性函数。

换成更容易理解的说法,作者假设这种性质可以让 attention 更容易学会“三个 token 之前”这样的关系。

下图以一对正弦和余弦值为例,展示了这一过程。旋转是一种线性变换,而两次偏移 3 个位置使用的是相同的旋转。

Figure 13 — sinusoidal relative shift

图 13:对于角频率为每个位置 0.1 弧度的特征对,偏移 3 个位置始终会使该特征对旋转 0.3 弧度。

3. 使用 RoPE 编码相对位置

上面介绍的正弦方法仍然被视为一种绝对位置编码,因为加到每个 token 嵌入上的向量表示的是该 token 从序列起点开始计算的位置。

例如,如上一张图所示,位置 2 和位置 5 的 token 分别获得位置向量  和 。如果我们将这些 token 移动到位置 102 和位置 105,它们之间仍然相隔 3 个位置。但由于它们的绝对位置  发生了变化,每个 token 获得的位置向量也会不同。

因此,即使 token 嵌入保持不变,它们之间的 attention 分数仍可能发生变化。正弦结构依然为模型提供了一种学习相对关系的途径。

接下来要讨论的 RoPE 则将这种相对关系直接融入 attention 的计算过程。RoPE 由 Su 等人在 2021 年的论文 RoFormer 中提出,全称为 Rotary Position Embedding,被视为一种相对位置方法。

3.1 在 RoPE 中将旋转移入 attention

在 attention 中,每个 token 当前的表示都会被投影为 query、key 和 value 向量。Query 和 key 的点积决定 attention 分数。

RoPE 根据 token 的位置,在计算点积之前旋转它的 query 和 key 向量。Value 向量则不经过这一旋转。下图概览了 RoPE 在相对较新的 MiniMax-M3 中的应用位置:QK-Norm 会先对 query 和 key 进行归一化,然后再应用 RoPE。

Figure 14 — minimax m3 architecture

图 14:MiniMax-M3 在 attention 内部对 query 和 key 应用 RoPE。

如上图所示,该 LLM 架构并未在初始 token 嵌入旁边加入显式位置向量。相反,它在 attention 内部注入显式位置信号。

补充说明:MiniMax-M3 只旋转每个 query head 和 key head 的部分维度。这是一种名为“Partial RoPE”的变体,我们将在第 6.1 节介绍。不过,为了先理解 RoPE 的基本操作,我们先通过一个简单示例,逐步讲解这一方法。

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

Attention 通常将 query、key 和 value 的特征划分为多个并行处理的 head。因此,完整机制通常称为 Multi-head Attention。请注意,Grouped Query Attention 也使用多个 head。在这里,每个 attention head 分别计算自己的 attention 分数和加权求和结果。随后,RoPE 作用于每个 query head 和 key head 内部成对的数值。

为了更具体地说明这一点,下图展示了一个 token 表示如何经过可学习的 query 和 key 投影,这些投影通过权重矩阵  和  计算。在这个简单示例中,每次投影都会产生 16 个特征,再被重塑为两个 head,每个 head 包含 8 个特征。在下图中,每个小单元格都包含一个标量特征,也就是向量中的一个数值。由于空间有限,图中没有显示这些数值。

Figure 15 — inputs and pairs

图 15:对隐藏状态进行投影,将其重塑为多个 head,并为 RoPE 组成特征对。

对于第一个包含 8 个特征的 head,即 ,我们将前半部分的每个特征与后半部分的对应特征配对,得到 、、 和 。这种前后半部分配对方式,也称为 split-half,应用于多种 LLM 实现,包括我的 Qwen3 实现。(在实现基本操作之后,我们会将其与原始的另一种方法,也就是相邻特征配对方式进行比较。)

每对特征都会得到一个旋转角度,该角度由 token 位置  和该特征对的频率  决定。对应的 query 特征对和 key 特征对使用相同的频率。下图展示了我们如何旋转这些特征对、将更新后的特征放回原来的位置,并计算 query 与 key 的点积。

Figure 16 — position rotations

图 16:逐对旋转产生旋转后的 query 和 key 向量,用于计算 attention 分数。

下一节会放慢速度,更详细地讲解这些图。

3.3 在 RoPE 中旋转一对特征

在下面的示例中,我们继续使用之前的两个位置。Query 来自位置  的“the”,key 来自位置  的第一个“fox”。由于在这个示例中 key 位于 query 之前,因果掩码允许 query 关注它。

为了说明位置产生的影响,同时保持其他条件不变,我们假设这两对特征的初始值都是 。

Figure 17 — query pair closeup

图 17:第一对特征  分别从 query head 的前半部分和后半部分取出一个元素。

此外,在这个示例中,假设  为每个 token 位置 ,即每个位置  弧度。在位置 2,我们将 key 的箭头逆时针旋转 。在位置 5,我们将 query 的箭头旋转 。

Figure 18 — rotations at positions 2 and 5

图 18:以  为起点,RoPE 将位置 2 的 key 特征对旋转 ,将位置 5 的 query 特征对旋转 。

为了说明上图中发生了什么,我们将  和  代入图 16 中的旋转公式,可以得到 key 的新坐标:

公式 5:

然后,将  改为 ,使用上面的同一个公式,可以得到旋转后的 query 特征对 。但关键在于,两支箭头的长度仍然都是 。发生变化的只有旋转角度,向量在变换后保持相同的长度。

因此,对于位置  处的 query 特征对 ,这里的两个操作为:

公式 6:

对于位置  处的 key 特征对,我们使用相同的公式,但将角度换成 。

公式 7:

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

在本节结束之前,对于更习惯阅读代码的读者,目前为止图中展示的 RoPE 操作都可以写成如下代码:

import torch

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

# Split-half 配对得到 (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)

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

m = 5# Query 的位置(在示例中为 "the")
n = 2# Key 的位置(在示例中为第一个 "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"Original key:   ({k[0]:g}, {k[1]:g})")
print(f"Original query: ({q[0]:g}, {q[1]:g})")
print(f"Rotated key:    ({k_rot[0]:.3f}, {k_rot[1]:.3f})")
print(f"Rotated query:  ({q_rot[0]:.3f}, {q_rot[1]:.3f})")

得到的数值为:

原始 key:       (1, 5)
原始 query:     (1, 5)
旋转后的 key:   (-2.448, 4.473)
旋转后的 query: (-5.098, 0.117)

如果我们旋转包含 8 个特征的 query 和 key 向量中的全部 4 对特征,就会得到下面的向量。(稍后我们会回到如何从旋转一对特征扩展到旋转全部特征对。)

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

3.4 相对偏移如何改变 RoPE 中的 attention 分数

请注意,如上所示,query head 和 key head 各自包含 8 个特征。我们之前将它们各自分为 4 对,每对包含两个元素,例如 、,以此类推。为了简化说明,这里我们只关注每个 head 中的第一对特征 ,它由索引 0 和索引 4 处的元素组成:

原始 key:       (1, 5)
原始 query:     (1, 5)
旋转后的 key:   (-2.448, 4.473)
旋转后的 query: (-5.098, 0.117)

如上所示,在我们的示例中,旋转之前,这两个 head 中对应元素的值都是 。

另外,与上面的代码一样,我们用  和  表示这两对特征。使用标准点积公式计算它们的点积时,我们将对应坐标相乘,再将乘积相加:

公式 8:

旋转之前,这两对特征的点积为 。使用前面图 18 中经过四舍五入的坐标,可以得到第一对特征旋转后对点积的贡献:

公式 9:

如果用两个向量的长度,也就是图 18 中箭头的长度,以及它们之间的夹角  来表示点积,我们就能理解其中的原因。

公式 10:

在这两个例子中,向量的长度都是 。Query 位于位置 5,旋转了 ;key 位于位置 2,旋转了 。这两个向量,也就是两支箭头,最初指向相同的方向,因此旋转后的夹角为 。它们的精确点积为 。

现在,我们看看只将 key 从位置 2 移动到位置 3、但保持其初始坐标  不变时会发生什么。Key 的旋转角度从  变为 。Query 仍然旋转 ,因此两支箭头之间的夹角缩小到 ,点积也从 13 变为 。因此,即使初始特征值相同,将 key 移近一个位置也改变了点积。

为什么这些点积很重要?在 attention 中,我们将所有特征对的贡献相加,得到 query 与 key 的点积。RoPE 可以改变这些点积,进而改变 softmax 分配给 value 向量的权重。

公式 11:

在上面的 attention 公式中, 和  是包含某个 head 中旋转后 query  和 key  的矩阵, 包含 value, 是 head 的维度。

3.5 为什么同时移动两个位置会保持 RoPE 的 attention 分数不变

现在,我们已经展示了 attention 机制核心部分——点积——的计算过程。让我们回到位置  和 。如果将两个位置都向右移动 3 个位置,就会得到  和 。每个旋转角度都会增加 :query 从  变为 ,key 从  变为 。但两个向量之间的夹角保持不变,这对特征的点积仍然是 13。

图片

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

关键在于,两个旋转角度之差为:

公式 12:

如果我们保持原始 query 和 key 向量不变,并将两个 token 的位置移动相同的距离,RoPE 就会对两个向量施加相同的额外旋转。它们之间的夹角保持不变,因此点积也保持不变。请注意,为了让图像更易于阅读,下图使用的角度小于实际示例中每个位置  的角度。

Figure 20 — relative position

图 20:当 query 和 key 的特征保持固定时,相同的位置偏移会保持相对角度和点积不变。

上面的例子和图 20 展示了 RoPE 的核心思想。我们使用每个 token 的位置,在 attention 模块中旋转对应的 query 和 key。在 query 与 key 的点积计算中,重要的是一个向量相对于另一个向量旋转了多少。对于每对特征,这个旋转差只取决于两个 token 之间的位置偏移。

从更整体的角度看,在图 21 中,每一行汇集了一个 query 对应的分数。如果我们观察第 5 行,即“the”对应的 query,以及第 2 列,即“fox”对应的 key,那么两者之间的 attention 分数就是旋转后的 query 向量与 key 向量的点积。

Figure 21 — query key score map

图 21:一个 head 在 softmax 之前的 attention 分数。灰色单元格表示被因果掩码排除的未来 key。

这有什么意义?让我们再次考虑这个句子:“The red fox jumps over the gray fox.” 如果我们在句子前面添加 100 个 token,例如一段 system prompt,第一个“fox”和第二个“the”就会从位置 2 和位置 5 移动到位置 102 和位置 105。不过,无论前缀有多长,两个位置都会移动相同的距离,因此它们仍然恰好相隔 3 个位置。这意味着每个向量,也就是每支箭头,都会增加完全相同的旋转角度,从而保持它们之间的夹角和点积不变。

这里假设我们保持旋转之前的 query 和 key 向量不变。在真实模型中,新增的 100 个前缀 token 可能会改变这些 token 能够关注的内容,从而改变 query 和 key 向量本身。

图 22 在 attention 分数矩阵中展示了这一对比。右图显示了添加前缀后,该句子对应的行和列。在我们的简单示例中,第一对特征对点积的贡献仍然是 13。

Figure 22 — shifted query key score map

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

你可能还记得,在原始 Transformer 的正弦编码中,固定的位置偏移也对应每对正弦和余弦值中的固定旋转。但这种共同旋转仅作用于加到输入向量上的位置向量,而不是 attention 机制内部的 key 和 query 向量。

图 23 比较了相同的位置移动在目前介绍过的三种方法中会带来什么变化。

Figure 23 — position shift comparison

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

3.6 补充:在 RoPE 中将特征对组合成完整的 head

为了了解相对偏移如何影响点积,我们之前只关注了 query 和 key 中的一对特征。现在,我们将全部 4 对特征组合起来,看看 RoPE 如何在一个 attention head 中旋转完整的 8 维向量。(如果你认为技术细节过多,可以直接跳过这一节。)

图 24 接续图 17 的内容。我们旋转 4 对特征中的每一对,然后将结果按照 query 原始的特征顺序放回。

Figure 24 — four pair rotation

图 24:RoPE 使用各自的角度旋转每对 query 特征。同样的操作也可以应用于 key;为了简化示意,图中没有展示 key。

上图底部展示了旋转后的 query 。类似地,我们可以在 key 所在的位置重复相同的步骤,得到旋转后的 key 。

回顾第 3.3 节中的两个公式。对于输入值为  的第  对 query 特征,令 ,。它们分别是位置  处该 query 特征对旋转角度的余弦值和正弦值:

公式 13:

下图将 4 对特征的 4 次旋转表示为一次矩阵乘法:。

Figure 25 — full rotation matrix

图 25:将图 24 中的 4 次旋转写成一次矩阵乘法。特征对标签表明每次旋转在完整矩阵中的位置。

4. 如何计算 RoPE 中的旋转频率?

一个完整的 attention head 会使用多个频率,使一些特征对随位置变化得更明显,也就是在 RoPE 中变化得更“快”;另一些特征对则变化得更平缓,也就是变化得更“慢”。这与原始 Transformer 的正弦编码使用多个频率的目的相同。

不过,我们不需要手动指定这些频率。对于包含  个特征的 head,标准的完整 RoPE 会为其中的  对特征分别计算一个频率,公式如下:

公式 14:

其中:

原始 RoFormer 论文使用 ,沿用了原始 Transformer 的频率公式,但将嵌入宽度  替换为 head 维度 。

例如,当 head 维度 、基数  时,我们得到的频率为每个位置  弧度。

5. 补充:使用 PyTorch 实现 RoPE

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

代码可以有效地帮助我们解释和理解概念。如果你感兴趣,接下来的小节将通过代码带你回顾目前介绍过的核心内容。否则,你可以直接跳到第 6 节“现代架构中的位置方法选择”。

在下面的代码片段中,我们将使用前面提到的 split-half 旋转方式。不用担心,我们也会介绍交错配对方式。首先,我们会将其应用于一个 query 向量,然后再将其应用于 attention 机制中的 query 和 key。

5.1 计算并应用旋转

首先,让我们再次使用图 24 中包含 8 个特征的 query。为方便起见,下图展示了它旋转之前的 4 对特征。

Detail from Figure 24 — original query pairs

图 24 的局部:在 split-half 排列方式下,8 个 query 特征组成 4 对。

在前面不涉及代码的示例中,为了简化数学计算,我们为第一对特征选择了每个 token 位置  的频率。这里,我们将使用上一节介绍的原始 RoPE 公式 ,其中 head 维度 ,基数 。

图 26 展示了两个函数如何协同完成这些旋转。

Figure 26 — pytorch walkthrough

图 26:rope_params 返回 token 位置 2 对应的余弦表和正弦表。rope_split_half 接收这两张表和原始 query,返回旋转后的 query。

如上图所示,rope_params 首先确定每对特征需要旋转多少,并返回两张“表”,分别存储这些角度的余弦值和正弦值。换句话说,rope_params 计算每个旋转角度的余弦值和正弦值,而旋转角度取决于 token 的位置和特征对的频率。

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 节频率公式中的  值:

公式 15:

对于我们这个包含 8 个特征的 query,indices 为 ,也就是每对特征对应一个  值。假设我们使用常见的基数 ,并沿用前面的示例,将较小的 head 维度设为 。在这种情况下,inv_freq 按如下方式计算 4 对特征的频率 :

公式 16:

如上所示,得到的 inv_freq 为 4 对特征中的每一对提供一个频率 ,单位为每个 token 位置对应的弧度数。

接下来,angles 将每对特征的频率  乘以 token 位置 ,从而计算旋转角度 。在我们的示例中,当 positions = [2] 时,得到:

公式 17:

最后,rope_params 计算每个角度的余弦值和正弦值,并将它们作为两张余弦表和正弦表输出,即 cos 和 sin。在这两张表中,每一行对应一个 token 位置,每一列对应一对特征。由于这里只使用 token 位置 2,因此每张表的形状都是 ,唯一的一行如下所示:

公式 18:

对于图 26 中的示例,每张表都包含一行,对应 token 位置 2;包含 4 列,分别对应 4 对特征。图 27 展示了每对特征的旋转角度,以及两张表中对应的元素。

Figure 27 — cos sin tables

图 27:rope_params 为 token 位置 2 返回的两张表。高亮列给出了用于旋转第一对特征  的余弦值和正弦值。

简单来说,rope_params 计算每个旋转角度的余弦值和正弦值,而旋转角度取决于 token 的位置和特征对的频率。

在真实场景中,如果上下文长度为 1,024,我们向 rope_params 传入 1,024 个 token 位置,并将 head 维度设为 128,那么它会返回两个张量 cos 和 sin,每个张量的形状都是 ,因为包含 128 个特征的 head 有 64 对特征。

这些表没有 batch 维度或 head 维度,我们会沿着 batch 和 head 维度广播每张  的表。因此,如果 Multi-head Attention 或 Grouped Query Attention 有 32 个 head,那么在全部 32 个 head 中,token 位置 2 的第 0 对特征都会使用相同的旋转角度。每个 head 旋转的都是自己的特征值,因此旋转后的 query 仍然可能因 head 而异。此外,使用相同位置和频率的 query、key 和各个 head 可以复用相同的表项。简而言之,对于每个模型,我们只需要针对最大支持上下文长度内的所有位置,预先计算一次这些表。

从技术上说,也可以将这些表与模型权重一起存储;但它们的计算成本极低,将其存储在磁盘上反而有些小题大做。

接下来,rope_split_half 使用这些余弦值和正弦值,旋转 attention 中 query 和 key 向量的实际特征。

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 将 query 拆分为  和 ,并将每对特征中的两个元素对齐。例如,前后两部分的第一个位置对应 ,第二个位置对应 ,以此类推。torch.cat 内部的两个表达式使用第 3.3 节中的公式,分别计算旋转后的两个部分:

公式 19:

请注意,这里所有用  表示的值都对应 query 的前半部分,所有用  表示的值都来自后半部分。torch.cat 内部的第一个表达式计算所有  值,第二个表达式计算所有  值。

然后,我们通过 torch.cat 将两个部分拼接起来,使每个值回到原来的索引位置。

下面的代码生成了前面图 26 中旋转后的 query。这里使用的 reshape(1, 1, 1, 8) 只是将这个简单示例数组转换为预期格式:一个 batch 项、一个 head、一个 token 和 8 个特征。

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 可以在所有 batch 项和 attention head 之间复用这些表。

5.2 在因果 attention 中使用 RoPE

到目前为止,我们已经编写了 RoPE 的辅助函数。现在,让我们在实际场景中使用它,也就是将它用于 attention 机制。这里,我们为两个包含 8 个特征的 head 和 4 个 token 位置使用标准的频率设置。为了让示例自包含,我们使用随机生成的 query、key 和 value 张量。不过,如前所述,你也可以查看从零开始实现的端到端 Qwen3,其中使用了由预训练模型生成的真实 query、key 和 value。

torch.manual_seed(123)

q = torch.randn(1, 2, 4, 8)  # 1 个 batch、2 个 head、4 个 token、head 维度为 8
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

请注意,只有 q 和 k 经过 RoPE,v 不经过 RoPE。得到的原始 attention 分数存储在一个形状为  的张量中。其中,每个 query 位置对应一行,每个 key 位置对应一列;由于有 4 个 token,且每个 token 都与其他 token 计算 attention,因此最后两个维度为 。

接下来,按照常规的 attention 代码实现,因果掩码将未来 key 的分数替换为负无穷,使它们在经过 softmax 后变为零。得到的 context 张量形状为 ;其中 4 对应 4 个 token,8 对应原本的嵌入维度。

我们还可以验证前面关于相对偏移的说法:将每个位置都加 3,应当改变绝对位置,但保持 query 与 key 之间的相对偏移不变:

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)
# 断言应当通过

5.3 另一种特征配对方式

我在本文中多次提到了 split-half 配对方式。原始 RoPE 论文使用的是另一种交错配对方式,即 interleaved;原始 LLaMA 实现也是如此。不过,如前所述,现在大多数代码实现都使用 split-half,因为它更容易在代码中通过逐元素的正弦和余弦运算,一次性旋转所有特征对。

为了说明两种排列方式之间的区别,图 28 的两行使用了相同的 8 维特征向量。

Figure 28 — feature pairing

图 28:Split-half 将前半部分的每个特征与后半部分的对应特征配对;interleaved 则将相邻特征配对。

Interleaved 实现使用相同的两个公式,但它会交替选取特征,并将输出交错排列。

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)

但从数学上说,考虑特征顺序之后,这两种排列方式是等价的。因此,将元素  重新排列为 ,就会使 split-half 形成的特征对相邻排列,即 、,以此类推。如果对 query 和 key 都应用相同的重排,得到的点积相同。

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)
# 这些断言都应当通过

输出保留了重新排列后的特征顺序,因此我们要按照相同顺序将它们与 split-half 的输出进行比较。不过,如果直接对原始向量分别应用这两种排列方式,则会得到不同的分数。

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

自最初的 LLaMA 模型以来,RoPE 一直是大多数开放权重 LLM 的常用组成部分。当然,闭源模型也可能使用 RoPE,但我们很难对闭源模型的内部实现作出百分之百确定的判断。

不过,近年来,许多架构开始不再对每个 Transformer 块都使用完整的 RoPE。在接下来的小节中,我们将讨论其中的一些变体。

例如,我们在前面几节中讨论和实现的完整 RoPE,会旋转每个 query head 和 key head 中的每一对特征。

在接下来的例子中,我们会看到,一些模型只旋转 head 内的部分特征;另一些模型在某些 Transformer 块中跳过 RoPE;还有一些模型采用不同的方法,直接将位置信息加入 attention 分数。

6.1 Partial RoPE

正如本文前面讨论的,常规的“完整”RoPE 会旋转每个 query head 和 key head 中的所有维度。Partial RoPE 是一种变体,它只旋转其中一部分维度,保持其余维度不变。

例如,MiniMax-M3 的配置在每个 128 维 head 中使用 64 个旋转维度。这意味着有 32 对特征会被旋转,另有 64 个维度保持不变。下图展示了这一过程。

Figure 29 — partial

图 29:128 维 head 中的完整 RoPE 与 Partial RoPE。

请注意,在第一个 Transformer 块之后,即使某些特征没有被旋转,它们仍然可能包含从前面 Transformer 块继承的位置信息。

那么,Partial RoPE 的作用是什么?它可以节省一些内存。例如,在上面的 MiniMax-M3 示例中,只旋转一半特征,也会使预先计算的余弦表和正弦表大小减半。因此,使用 Partial RoPE 时,每张表只需要 32 列,而不是 64 列。不过请注意,KV cache 仍然会为每个缓存的 token 存储完整的 key 和 value 向量。

对于 MiniMax-M3 的 100 万 token 上下文,在 128 个特征中旋转 64 个,可以使预计算的余弦表和正弦表大小减半。如果这些表以 BF16 存储,可以节省 0.134 GB,即 128 MiB。如果这些表本身以 NVFP4 存储,那么包括 block scales 在内,可以节省 0.038 GB,即 36 MiB。

论文 Fractional Rotation, Full Potential? 在对 1B 至 8B 参数模型进行实验时发现,只旋转每个 head 大约 10% 的特征,通常可以获得与完整 RoPE 相近的训练损失和 benchmark 准确率。不过,在某些评测中,完整 RoPE 的表现更好。

所以,在我看来,Partial RoPE 带来的收益很难说值得。

6.2 NoPE 层

NoPE 这一术语由论文 The Impact of Positional Encoding on Length Generalization in Transformers 提出,表示不使用显式位置编码。其思路或观察结果是:即使一个 attention 层没有使用任何显式位置方法,它仍然具有因果掩码,使 query 只能关注自身和更早的 token。而这种因果掩码会隐式提供位置信息。

让我们使用前面示例中的前 4 个 token:“The red fox jumps”。在图 30 中,位置 2 的“fox”对应的 query 可以关注“The”、“red”和它自身;位置 1 的“red”对应的 query 可以关注“The”和它自身。

Figure 30 — nope prefix mask

图 30:attention 机制中因果掩码的示例。

接下来的问题是:模型如何将因果掩码用作位置信号?下面是一个根据论文改编的简单示例。

假设 value 向量中的某个特征对于“The”而言为 1,对于其他 3 个 token 而言都为 0。由于输入中只有一个“The”,每个可见前缀都恰好包含一个 1。如果所有未被掩盖的 key 获得相同的 attention 分数,softmax 就会为每个可见 token 分配相等的权重。

因此,在“fox”处,attention 对 1、0 和 0 求平均,得到 ;在“jumps”处,它对 4 个值求平均,得到 。换句话说,这个输出特征等于前缀长度的倒数,后续层可以将它用作位置信号。

Figure 31 — nope prefix average

图 31:在均匀 attention 下,随着前缀变长,“The”的贡献逐渐减小。“fox”对应的 query 为“The”分配的权重为 。

NoPE 在实践中有效吗?NoPE 论文的研究者从零开始训练了一个仅含 1.07 亿参数的小型 decoder-only Transformer,并在复制、排序和加法等任务上进行了消融实验。

有意思的是,当他们使用比训练时见过的示例更长的输入测试这个小模型时,NoPE 在 10 项任务中的总体表现排名第一,超过了 RoPE。NoPE 论文的研究者还单独使用一个更大的 13 亿参数模型进行了实验,该模型在代码数据上训练。在这一实验中,NoPE 同样能够处理超过训练长度的上下文;但在测试的最长序列上,它的下一个 token 预测表现有所下降。

如今,一些开放权重 LLM 甚至在所有层中都使用 NoPE。不过,更常见的做法是在至少部分层中省略 RoPE,这里的“层”指 Transformer 块。

举个具体例子,参数量为 3B 的 SmolLM3 在连续 3 层中应用 RoPE,在第 4 层跳过,然后在全部 36 层中重复这一模式。有意思的是,SmolLM3 的作者提到,这种层间模式改善了长上下文性能。

还要注意,在第一层之后,即使某个后续层跳过了旋转,它仍然会接收前面 Transformer 块的输出作为输入,因此它的 query 和 key 仍然会从前面的层获得某种形式的位置信息。

Figure 32 — smollm3 layer pattern

图 32:SmolLM3 的架构,左图,以及其 36 个 Transformer 块各自使用的位置方法,右图。每隔 4 个块就有一个跳过 RoPE。架构图来自我的 LLM Architecture Gallery。

6.3 可学习的相对位置偏置

在概览现代架构所使用的方法之前,还有一种方法需要介绍。例如,Thinky 的 Inkling 在滑动窗口 attention 层和全局 attention 层中都使用了可学习的相对位置偏置。它先计算 query 与 key 之间常规的缩放点积,然后在 attention 分数计算过程中、softmax 之前,向该分数加上一个数值。这个数值取决于 query token 的隐藏状态,以及 key 位于 query 之前多少个位置。

让我们再次使用示例句子“The red fox jumps over the gray fox.”,我保证这是最后一次!在下图中,位置 5 的“the”是 query,位置 2 的“fox”是 key。Inkling 利用 query 和 key 之间相隔 3 个位置这一信息,以及“the”的隐藏状态,计算偏置,再将其加到缩放点积上。

Figure 33 — relative position bias

图 33:Inkling 在 softmax 之前,将可学习的相对位置偏置加到缩放后的 query-key 点积上。图中的数值仅用于示意。

这并非一个全新的想法。有些读者可能还记得 Google 于 2019 年推出的热门模型 T5,即 Text-to-Text Transfer Transformer,它使用了这一思路的一个更简单的版本。

Figure 34 — inkling architecture

图 34:原始 Inkling,即 975B 参数版本,的架构。可学习的相对位置偏置被输入 attention 模块。图来自 LLM Architecture Gallery。

6.4 这些选择在近期模型中的应用情况

铺垫了这么多,现在有趣的问题来了:哪些架构使用了哪些方法?近期又有哪些趋势?

为了回答这个问题,我按照 LLM Architecture Gallery 中列出的发布日期对模型条目进行分组,将 2025 年发布的模型与 2026 年样本中前期和后期发布的模型进行比较。图库中的每张卡片计数一次,因此同一架构的多个变体可能都会被计入结果。

图 35:架构图展示了哪些 attention 层使用 RoPE,柱状图展示了图库条目在各类别中的占比。架构图来自我的 LLM Architecture Gallery。

如上图 35 所示,在每个 softmax attention 层中都使用 RoPE,仍然是最常见的选择。不过,这种选择的占比从 2025 年到 2026 年有所下降,并在 2026 年后半段继续下降,这可能代表一种趋势。

相应地,混合使用 RoPE 和 NoPE 的模型越来越多。不过,各组样本量仍然较小,因此很难判断这些趋势是否会持续。

仅使用 NoPE 的条目都是循环混合架构,其 softmax attention 层不使用显式位置编码。这里的“其他”类别指 xLSTM 7B,即 2025 年的模型,以及 Inkling,即 2026 年的模型。xLSTM 没有 softmax attention 层;如第 6.3 节所示,Inkling 在 softmax 之前向 attention 分数添加可学习偏置。

在使用 RoPE 的模型中,Partial RoPE 从 2025 年到 2026 年变得更加常见。如图 36 所示,它从 2025 年 RoPE 模型中的少数选择,变成 2026 年两个分组中的多数选择。

图 36:在使用 RoPE 的图库条目中,Partial RoPE 至少在一个 attention 层中只旋转部分 query 和 key 特征。Full-width 条目则在每个使用 RoPE 的层中旋转全部 query 和 key 特征。

如果你想查看 2026 年分组中的某个具体模型,下图展示了 2026 年图库概览,并按位置方法类型标注了各个架构。你也可以在图库中进行交互式浏览。

Figure 37 — gallery 2026 collage

图 37:图 35 中 2026 年两组柱状数据对应的各个模型条目。

7. 最后的思考

回顾一下,我们讨论了 GPT-2 和原始 Transformer:它们在第一个 Transformer 块之前,向每个 token 嵌入添加一个位置向量。随后,现代 LLM 转向 RoPE,通过旋转 query 和 key,在 attention 内部编码相对位置。令人意外的是,RoPE 至今仍然是最受欢迎的位置嵌入方法。

不过,最近 Inkling 借鉴了 T5 的一个思路,在 softmax 之前向 attention 分数添加可学习的相对位置偏置。此外,还有 NoPE-RoPE 架构,它们在部分层中省略 RoPE。

这可能算不上什么激动人心的消息,但如前所述,RoPE 仍然是占主导地位的位置嵌入方法,我认为这一情况肯定会延续到 2027 年。不过,或许我们会在 2027 年看到更多采用类似 Inkling 设计的架构。

尽管这听起来可能有些“无聊”,但经过这么多年,我很高兴终于写出了这篇关于 RoPE 以及其他位置信息处理方法的文章,这样我就可以把它加入自己的 LLM“基础知识”讲解系列。

如果你对 LLM 架构中的其他组成部分感兴趣,我仍然强烈建议从 GPT-2 风格的模型入手。它能让你以相对轻松的方式,扎实理解这些基本组成部分。在此基础上,你可以再逐步加入其他方法,例如 RoPE。

如果你想自己构建这样一个 GPT-2 风格的模型,我的第一本书 Build a Large Language Model (From Scratch) 逐一介绍了下图所示的所有组成部分。

图 38:GPT-2 XL 提供了一个基线,可以帮助我们观察较新的架构做出了哪些改变。图来自 LLM Architecture Gallery。

对于从 GPT-2 基线进一步发展出来的方法,我在下面整理了一些相关博客文章,首先是一篇复习 self-attention 的文章:

来源:human five

点赞 0
举报
收藏 0
评论 0
分享 1