1.1 绝对位置编码#

原始 Transformer 使用正弦/余弦位置编码：

$PE_{(pos, 2i)} = \sin(pos / 10000^{2i/d})$ $PE_{(pos, 2i+1)} = \cos(pos / 10000^{2i/d})$

问题：

• 泛化能力差：训练长度外的位置无法准确编码
• 不适用于 Linear Attention

1.2 相对位置编码#

T5、Shaw 等人提出相对位置编码：

$Attention(Q, K, V) = \text{softmax}(QK^T + R)^T V$

其中 $R$ 是相对位置偏置矩阵。

改进：

• 更好泛化到任意长度
• 更适合自然语言任务

1.3 RoPE 的创新#

RoPE 通过旋转矩阵将位置信息融入 Query 和 Key：

核心洞察：如果能让 Query 和 Key 的内积仅依赖于相对位置，就能实现旋转不变性。

1.4 位置编码演进时间线#

2.1 从复数视角理解旋转#

RoPE 的核心思想可以从复数乘法角度优雅地理解。在复平面上，一个二维向量 $(x, y)$ 可以表示为复数 $z = x + iy$。

复数乘以 $e^{i\theta} = \cos\theta + i\sin\theta$ 等价于在复平面上旋转角度 $\theta$：

$z' = z \cdot e^{i\theta} = (x + iy)(\cos\theta + i\sin\theta) = (x\cos\theta - y\sin\theta) + i(x\sin\theta + y\cos\theta)$

这恰好对应实数域中的旋转矩阵变换：

$\begin{pmatrix} x' \\ y' \end{pmatrix} = \begin{pmatrix} \cos\theta & -\sin\theta \\ \sin\theta & \cos\theta \end{pmatrix} \begin{pmatrix} x \\ y \end{pmatrix}$

复数乘法的关键性质是角度可加：$e^{i\theta_1} \cdot e^{i\theta_2} = e^{i(\theta_1 + \theta_2)}$，这使得旋转具有群结构，是 RoPE 表达相对位置关系的数学基础。

2.2 二维旋转与相对位置#

在二维空间中，旋转矩阵为：

$\mathbf{R}(\theta) = \begin{pmatrix} \cos\theta & -\sin\theta \\ \sin\theta & \cos\theta \end{pmatrix}$

旋转具有性质： $\mathbf{R}(\theta_1 + \theta_2) = \mathbf{R}(\theta_1) \cdot \mathbf{R}(\theta_2)$

设 Query 向量 $\mathbf{q} = (q_1, q_2)^T$ 位于位置 $m$，Key 向量 $\mathbf{k} = (k_1, k_2)^T$ 位于位置 $n$。分别对它们施加旋转：

$\mathbf{q}_m = \mathbf{R}(m\theta)\mathbf{q}, \quad \mathbf{k}_n = \mathbf{R}(n\theta)\mathbf{k}$

则它们的内积为：

$\langle \mathbf{q}_m, \mathbf{k}_n \rangle = \mathbf{q}^T \mathbf{R}(m\theta)^T \mathbf{R}(n\theta) \mathbf{k} = \mathbf{q}^T \mathbf{R}((n - m)\theta) \mathbf{k}$

关键结论：内积仅依赖于相对位置 $(n - m)$，而非绝对位置 $m$ 或 $n$。这正是 RoPE 实现相对位置编码的核心机制。

2.3 旋转可视化#

2.4 位置编码融入与多维扩展#

对于 $d_{model}$ 维向量，RoPE 将其分成 $d/2$ 个二维子空间，在每个子空间进行旋转：

$\mathbf{q}_m = \mathbf{R}_d(m) \cdot \mathbf{q}, \quad \mathbf{k}_n = \mathbf{R}_d(n) \cdot \mathbf{k}$

其中旋转矩阵为块对角形式：

$\mathbf{R}_d(m) = \begin{pmatrix} \cos(m\theta_1) & -\sin(m\theta_1) & & & \\ \sin(m\theta_1) & \cos(m\theta_1) & & & \\ & & \cos(m\theta_2) & -\sin(m\theta_2) & \\ & & \sin(m\theta_2) & \cos(m\theta_2) & \\ & & & & \ddots \\ & & & & & \cos(m\theta_{d/2}) & -\sin(m\theta_{d/2}) \\ & & & & & \sin(m\theta_{d/2}) & \cos(m\theta_{d/2}) \end{pmatrix}$

每个子空间的旋转频率不同，$\theta_i = b^{-2i/d}$，其中 $b$ 是基数（通常取 10000）。低维度子空间旋转慢（捕捉远距离关系），高维度子空间旋转快（捕捉近距离关系）。

用复数表示更简洁——将 $\mathbf{q}$ 按 $(q_1, q_2), (q_3, q_4), \ldots$ 配对，写成复数 $\tilde{\mathbf{q}} = (q_1 + iq_2, q_3 + iq_4, \ldots)$，则：

$\tilde{\mathbf{q}}_m = \tilde{\mathbf{q}} \odot e^{im\boldsymbol{\theta}}$

其中 $\boldsymbol{\theta} = (\theta_1, \theta_2, \ldots, \theta_{d/2})$，$\odot$ 为逐元素乘法。

2.5 远程衰减特性#

RoPE 的一个关键特性是远程衰减：

内积仅依赖于相对位置 $m-n$： $\langle \mathbf{q}_m, \mathbf{k}_n \rangle = \langle \mathbf{R}(m)\mathbf{q}, \mathbf{R}(n)\mathbf{k} \rangle = \langle \mathbf{R}(m-n)\mathbf{q}, \mathbf{k} \rangle$

展开可得：

$\langle \mathbf{R}(m-n)\mathbf{q}, \mathbf{k} \rangle = \sum_{i=1}^{d/2} \left[ q_{2i-1}k_{2i-1}\cos((m-n)\theta_i) + q_{2i}k_{2i}\cos((m-n)\theta_i) + (q_{2i-1}k_{2i} - q_{2i}k_{2i-1})\sin((m-n)\theta_i) \right]$

当 $|m-n|$ 增大时，由于不同维度的 $\theta_i$ 不同（高频分量旋转快），$\cos$ 和 $\sin$ 项在多个维度上趋于相互抵消，使得内积趋近于零。这与正弦位置编码的远程衰减性质类似，但 RoPE 更为自然和可控。

2.6 代码实现#

1
import torch
2
import math
3

4
def precompute_freqs_cis(dim: int, end: int, theta: float = 10000.0):
5
    """预计算旋转位置编码的频率（复数形式）"""
6
    freqs = 1.0 / (theta ** (torch.arange(0, dim, 2).float() / dim))
7
    t = torch.arange(end)
8
    freqs = torch.outer(t, freqs)  # [seq_len, dim/2]
9
    return torch.polar(torch.ones_like(freqs), freqs)
10

11
def apply_rotary_emb(q, k, freqs_cis):
12
    """应用旋转位置编码"""
13
    q_complex = torch.view_as_complex(q.float().reshape(*q.shape[:-1], -1, 2))
14
    k_complex = torch.view_as_complex(k.float().reshape(*k.shape[:-1], -1, 2))
15

16
    q_rot = torch.view_as_real(q_complex * freqs_cis).flatten(-2)
17
    k_rot = torch.view_as_real(k_complex * freqs_cis).flatten(-2)
18
    return q_rot.type_as(q), k_rot.type_as(k)

3.1 特性对比#

*注：RoPE 原生长度外推能力中等，但通过 PI/NTK/YaRN 等方法可显著增强。

3.2 RoPE vs ALiBi vs Learned 深度对比#

选择建议：

• 新项目推荐 RoPE：理论优雅，社区支持好，扩展方案丰富
• 需要极长上下文：RoPE + NTK/YaRN，或考虑 ALiBi
• 快速原型：Learned 足够用，但限制了外推能力

4.1 Position Interpolation (PI)#

由 Meta 在 2023 年提出，核心思想是将位置索引线性压缩到训练范围内，而非外推到更远的位置。

$\text{position\_new}(i) = \frac{i \times L_{train}}{L_{target}}$

其中 $L_{train}$ 是训练时的最大长度，$L_{target}$ 是目标长度。

1
def position_interpolation_freqs(base_freqs, train_len, target_len):
2
    """Position Interpolation: 线性压缩位置索引"""
3
    scale = train_len / target_len
4
    # 原始频率不变，但位置索引被缩放
5
    positions = torch.arange(target_len) * scale
6
    # 重新计算频率矩阵
7
    freqs = 1.0 / (10000.0 ** (torch.arange(0, base_freqs.shape[-1]).float() / base_freqs.shape[-1]))
8
    freqs_cis = torch.polar(
9
        torch.ones(target_len, base_freqs.shape[-1]),
10
        torch.outer(positions, freqs)
11
    )
12
    return freqs_cis
13

14
# 示例：从 4096 扩展到 32768
15
freqs_pi = position_interpolation_freqs(base_freqs, train_len=4096, target_len=32768)

优点：实现简单，少量微调即可生效 缺点：所有维度的缩放比例相同，可能丢失高频信息

4.2 NTK-aware Scaling#

由 Reddit 用户 bloc97 提出，核心洞察是：PI 对所有维度一视同仁，但 RoPE 的高频维度对位置更敏感。NTK-aware Scaling 通过调整基数 $\theta$ 来实现非线性缩放：

$\theta_{new} = \theta \cdot s^{d/(d-2)}$

其中 $s = L_{target} / L_{train}$ 是缩放因子。

1
def ntk_aware_freqs(dim, train_len, target_len, base_theta=10000.0):
2
    """NTK-aware Scaling: 调整基数实现非线性缩放"""
3
    scale = target_len / train_len
4
    # 调整基数
5
    base_theta_new = base_theta * (scale ** (dim / (dim - 2)))
6

7
    freqs = 1.0 / (base_theta_new ** (torch.arange(0, dim, 2).float() / dim))
8
    t = torch.arange(target_len)
9
    freqs_cis = torch.polar(torch.ones_like(torch.outer(t, freqs)), torch.outer(t, freqs))
10
    return freqs_cis
11

12
# 示例：从 4096 扩展到 32768
13
freqs_ntk = ntk_aware_freqs(dim=128, train_len=4096, target_len=32768)

优点：高频维度保持分辨率，低频维度平滑外推；无需微调或少量微调即可生效 缺点：缩放因子较大时仍可能不稳定

4.3 YaRN#

YaRN（Yet another RoPE extensioN method）结合了 PI 和 NTK 的优点，对不同频率分量采用不同策略：

• 低频分量（$\theta_i < \theta_{threshold}$）：使用 PI 线性插值
• 高频分量（$\theta_i > \theta_{threshold}$）：使用 NTK-aware 缩放
• 注意力温度调整：补偿缩放带来的注意力分布变化

1
def yarn_freqs(dim, train_len, target_len, base_theta=10000.0, beta=0.1, alpha=1.0):
2
    """YaRN: 混合插值策略"""
3
    scale = target_len / train_len
4

5
    # 原始频率
6
    freqs = 1.0 / (base_theta ** (torch.arange(0, dim, 2).float() / dim))
7

8
    # 频率相关的缩放因子
9
    freqs_scaled = torch.zeros_like(freqs)
10
    for i, freq in enumerate(freqs):
11
        # 高频部分用 NTK 缩放
12
        if freq > 1e-4:  # 高频阈值
13
            freqs_scaled[i] = freq / (scale ** alpha)
14
        else:
15
            # 低频部分用 PI 插值
16
            freqs_scaled[i] = freq / scale
17

18
    t = torch.arange(target_len)
19
    freqs_cis = torch.polar(
20
        torch.ones(target_len, dim // 2),
21
        torch.outer(t, freqs_scaled)
22
    )
23

24
    # 注意力温度补偿
25
    attention_scale = 1.0 + beta * math.log(scale)
26
    return freqs_cis, attention_scale
27

28
# 示例：从 4096 扩展到 131072
29
freqs_yarn, attn_scale = yarn_freqs(dim=128, train_len=4096, target_len=131072)

优点：在极大扩展比（32x+）下表现最佳，兼顾高低频信息 缺点：实现复杂，需要调节超参数

4.4 三种方案对比#

5.1 主流模型 RoPE 配置一览#

趋势观察：

1. 新模型倾向于使用更大的基数 θ（从 10000 到 1000000 甚至更大），延缓远程衰减
2. 直接在长序列上训练（如 LLaMA 3.1 的 131072）正成为主流，减少对后处理缩放的依赖
3. YaRN 是目前最流行的外推方案，被 Qwen 2.5、DeepSeek V2 等采用

5.2 LLaMA#

LLaMA 采用的 RoPE 配置：

1
# LLaMA 默认配置
2
theta = 10000.0
3
max_position_embeddings = 2048  # LLaMA 1
4
# 4096 / 8192 / 32768  # LLaMA 2 / 3 / 3.1

LLaMA 3 的关键变化是将基数从 10000 提升到 500000，这使得在相同长度下高频分量的分辨率更高，同时低频分量的衰减更慢。

5.3 Mistral#

Mistral 7B 使用 RoPE + GQA 的组合：

1
config = {
2
    "hidden_size": 4096,
3
    "num_attention_heads": 8,
4
    "num_key_value_heads": 2,  # GQA
5
    "rope_theta": 10000.0,
6
    "max_position_embeddings": 32768,
7
    "sliding_window": 4096,  # 滑动窗口优化
8
}

滑动窗口与 RoPE 结合：

• 局部注意力：使用滑动窗口（4096 tokens）
• 全局 RoPE：保持对所有历史位置的感知能力

5.4 Code Llama#

Code Llama 在 RoPE 基础上针对长代码做了优化：

1
# Code Llama 扩展
2
freqs_cis = precompute_freqs_cis(
3
    dim=128,
4
    end=100000,  # 支持 100k token 上下文
5
    theta=500000.0  # 增大 theta 延缓远程衰减
6
)

5.5 Qwen 2#

Qwen 2 采用大基数方案，原生支持 131072 长度：

1
# Qwen 2 配置
2
config = {
3
    "hidden_size": 8192,
4
    "num_attention_heads": 64,
5
    "num_key_value_heads": 8,  # GQA
6
    "rope_theta": 1000000,     # 大基数
7
    "max_position_embeddings": 131072,
8
}

6.1 注意力计算中的 RoPE#

1
class RotaryEmbedding(torch.nn.Module):
2
    def __init__(self, dim, max_position_embeddings=2048, theta=10000.0):
3
        super().__init__()
4
        self.dim = dim
5
        self.max_position = max_position_embeddings
6
        self.theta = theta
7

8
        # 预计算频率
9
        self.freqs_cis = self._precompute_freqs()
10

11
    def _precompute_freqs(self):
12
        freqs = 1.0 / (self.theta ** (torch.arange(0, self.dim, 2).float() / self.dim))
13
        t = torch.arange(self.max_position)
14
        freqs = torch.outer(t, freqs)
15
        return torch.polar(torch.ones_like(freqs), freqs)
16

17
class Attention(nn.Module):
18
    def __init__(self, config):
19
        super().__init__()
20
        self.rotary = RotaryEmbedding(
21
            dim=config.hidden_size // config.num_attention_heads,
22
            max_position_embeddings=config.max_position_embeddings,
23
            theta=config.rope_theta
24
        )
25

26
    def forward(self, x, start_pos=0):
27
        # x: [batch, seq_len, hidden]
28
        bsz, seqlen, _ = x.shape
29

30
        q, k, v = self.W_q(x), self.W_k(x), self.W_v(x)
31
        q = q.view(bsz, seqlen, self.num_heads, self.head_dim)
32
        k = k.view(bsz, seqlen, self.num_kv_heads, self.head_dim)
33

34
        # 应用 RoPE
35
        freqs_cis = self.rotary.freqs_cis[start_pos:start_pos+seqlen]
36
        q, k = apply_rotary_emb(q, k, freqs_cis)
37

38
        # 扩展 KV（如果使用 GQA/MQA）
39
        k = k.repeat_interleave(self.n_rep, dim=2)
40
        v = v.repeat_interleave(self.n_rep, dim=2)
41

42
        # Flash Attention
43
        output = F.scaled_dot_product_attention(q.transpose(1,2), ...)
44
        return output

6.2 外推策略实现对比#

1
def rope_interleave_freqs(base_freqs, extend_len):
2
    """RoPE 频率插值/外推"""
3
    # 方案1：位置插值（PI）
4
    # 将位置索引缩放到训练范围
5
    extended_freqs = base_freqs[:extend_len] * (base_freqs.size(0) / extend_len)
6

7
    # 方案2：YaRN 动态缩放
8
    # 基于位置动态调整频率
9
    scale = (1 + torch.arange(extend_len) / base_freqs.size(0)) ** 0.5
10
    extended_freqs = base_freqs[:extend_len] / scale

7.1 Q1： RoPE 为什么只作用于 Q 和 K，不作用于 V？#

RoPE 的目的是让 $Q^T K$ 的结果编码相对位置信息。注意力权重 $\text{softmax}(QK^T/\sqrt{d})$ 决定了每个 token 对其他 token 的关注程度，位置信息只需影响”关注谁”，而不需要影响”关注的内容”。V 保持不变，确保注意力加权后的输出值不受位置编码干扰。

7.2 Q2： RoPE 的基数 θ 为什么通常选 10000？#

10000 的选择沿用了原始 Transformer 的 Sinusoidal 编码。它确保了：

• 最低频率的分量在位置 0-10000 范围内有约一个完整周期
• 最高频率的分量在相邻位置间有显著变化
• 实践中，10000 对大多数任务效果好，但超长上下文（100K+）场景下增大 θ（如 500K、1M）效果更好

7.3 Q3： RoPE 能否直接用于 Encoder-Decoder 架构？#

可以，但需要注意：RoPE 通常应用于 Encoder 侧的自注意力和 Decoder 侧的自注意力。对于 Cross-Attention（Decoder 关注 Encoder），由于 Q 和 K 来自不同序列，需要确保它们的位置索引在同一个坐标系下，或者分别施加旋转。

7.4 Q4： NTK-aware Scaling 和直接增大 θ 有什么区别？#

直接增大 $\theta$（如从 10000 增到 100000）是在训练阶段的选择，模型会学习适应新的频率分布。NTK-aware Scaling 是在推理阶段的缩放技巧，通过公式 $\theta_{new} = \theta \cdot s^{d/(d-2)}$ 非线性调整频率，不需要重新训练模型。两者可以结合使用。

7.5 Q5： RoPE 和 ALiBi 在长度外推上哪个更好？#

• ALiBi 原生外推能力更强，因为线性偏置天然不受位置范围限制
• RoPE + 缩放方案（如 YaRN）在实践中可达到 128K 甚至更长的外推效果
• 当前趋势是 RoPE + 大基数 + 长序列训练，而非依赖后处理外推

7.6 Q6： RoPE 在 Flash Attention 中如何高效实现？#

Flash Attention 的关键是将注意力计算分块（tiling）以减少 HBM 访问。RoPE 可以在 Q/K 投影后、分块前应用，这样频率矩阵只需计算一次。在 HuggingFace Transformers 等框架中，RoPE 通常在 attention_forward 函数的最开始应用，与 Flash Attention 完全兼容。

7.7 Q7： 为什么 RoPE 的实现用复数乘法而不是矩阵乘法？#

虽然数学上等价，但复数乘法的实现效率更高：

• 矩阵乘法：一个 $d \times d$ 块对角矩阵乘以 $d$ 维向量，需要 $O(d^2)$ 操作（虽然块对角可优化到 $O(d)$）
• 复数乘法：将向量 reshape 为 $(d/2)$ 个复数，逐元素乘以 $e^{im\theta}$，仅 $O(d)$ 操作
• GPU 上复数乘法可高度并行化，内存占用更少

7.8 Q8： 多模态模型如何处理 RoPE？#

多模态模型（如 Qwen-VL、LLaVA）面临不同模态序列长度差异大的问题。常见方案：

• 统一位置索引：图像 token 和文本 token 共享同一个位置序列
• 视觉 token 压缩：通过 Pooling 或线性投影减少视觉 token 数量
• 独立位置范围：文本和图像使用不同的位置偏移（如文本从 0 开始，图像从 10000 开始）

8.1 RoPE 和 ALiBi 哪个更好？#

RoPE 更灵活（支持长度外推），在大多数基准上略优于 ALiBi。ALiBi 优势是无需修改注意力计算、外推更简单，但表达能力不如 RoPE。目前主流模型（LLaMA、Mistral）都选择了 RoPE。

8.2 如何将 RoPE 模型扩展到更长上下文？#

三种主流方法：① Position Interpolation (PI)：缩放位置索引，简单但损失性能；② NTK-aware Scaling：调整 RoPE 基频 θ，保持局部分辨率；③ YaRN：结合 NTK scaling 和注意力温度调整，效果最好。推荐使用 YaRN。

8.3 RoPE 的 base 频率 θ 如何选择？#

原始论文建议 θ=10000。LLaMA 2 使用 10000（4K 上下文），LLaMA 3 使用 500000（8K+ 上下文）。更大 θ → 更好处理长距离关系，但短距离精度可能下降。

8.4 RoPE 对推理速度有影响吗？#

RoPE 的旋转操作计算量极小，对推理速度几乎没有影响。但长上下文场景下，RoPE 的远程衰减特性可能导致远处 token 注意力权重过低，需要通过调整 θ 或使用 scaling 策略缓解。