RoPE位置编码理论

Rotary Position Embedding (RoPE)¹ 是目前主流大语言模型（LLaMA、Qwen、Mistral、DeepSeek 等）的标准位置编码方式。本文从群论出发，深入分析 RoPE 的数学本质，并介绍 2025-2026 年的最新理论进展：相位调制视角、频率熵分析、长上下文扩展理论。

---

1. 为什么需要位置编码

1.1 自注意力的排列不变性

关键观察：标准自注意力对 token 排列不变。

证明：

• 设 $\pi$ 为任意排列
• $Q_{\pi (i)}=(X_{\pi (i)})W_Q$，同理 $K_{\pi (j)}=(X_{\pi (j)})W_K$
• 注意力分数：$(Q{K}^T{)}_{\pi (i),\pi (j)}=Q_i{K}_j^T$（仅重新排列）
• softmax 输出重新排列

结论：自注意力无法区分”我爱中国”和”中国爱我”。

1.2 解决方案

核心思想：将位置信息注入 token 表示，使得不同位置的 token 在注意力中有不同行为。

主流方案对比：

方案	加性/乘性	实现复杂度	长度外推
Sinusoidal (2017)	加性	低	较好
Learned (BERT)	加性	中	差
ALiBi (2022)	加性偏置	低	好
RoPE (2021)	乘性	中	好
CoPE (2024)	条件性	高	好

---

2. RoPE 的数学形式

2.1 核心思想

RoPE 的关键洞察：位置信息应通过旋转注入，而非加性偏置。

数学形式：
对 query $q$ 在位置 $m$，应用旋转矩阵 $R_m$：

$${\tilde{q}}_m=R_{m}q$$

对 key $k$ 在位置 $n$：

$${\tilde{k}}_n=R_{n}k$$

注意力分数：

$${\tilde{q}}_m^T{\tilde{k}}_n=q^T{R}_m^T{R}_{n}k=q^T{R}_{n-m}k$$

关键性质：仅依赖于相对位置 $n-m$！

2.2 分组旋转

实现：RoPE 不旋转完整 $d$ 维向量，而是将维度分成 $d/2$ 组，每组 2D 旋转：

$$R_m=\left(\begin{array}{ccc}R({\theta }_{1}m)& 0& \cdots \\ 0& R({\theta }_{2}m)& \cdots \\ ⋮& ⋮& \ddots \end{array}\right)$$

其中每组旋转：

$$R({\theta }_{i}m)=\left(\begin{array}{cc}\cos (m{\theta }_i)& -\sin (m{\theta }_i)\\ \sin (m{\theta }_i)& \cos (m{\theta }_i)\end{array}\right)$$

不同维度对使用不同频率 ${\theta }_i$。

2.3 频率选择

标准频率：

$${\theta }_i=b^{-2i/d},i=0,1,...,d/2-1$$

其中 $b=10000$（原始 Transformer）或 $b=500000$（LLaMA 3 改进）。

直观解释：

• 低维度（$i$ 小）：高频，能区分近邻位置
• 高维度（$i$ 大）：低频，能编码远距离

2.4 完整数学表达

对 query $q=(q_0,q_1,...,q_{d-1})$ 在位置 $m$：

$${\tilde{q}}_{2i}=q_{2i}\cos (m{\theta }_i)-q_{2i+1}\sin (m{\theta }_i)$$ $${\tilde{q}}_{2i+1}=q_{2i}\sin (m{\theta }_i)+q_{2i+1}\cos (m{\theta }_i)$$

类似地应用于 key。

2.5 PyTorch 实现

import torch
import torch.nn as nn
 
 
class RotaryPositionalEmbedding(nn.Module):
    """RoPE 实现"""
    
    def __init__(self, d_k, base=10000, max_seq_len=2048):
        super().__init__()
        self.d_k = d_k
        self.base = base
        
        # 计算频率
        # theta_i = base^{-2i/d}, i = 0, 1, ..., d/2-1
        inv_freq = 1.0 / (base ** (torch.arange(0, d_k, 2).float() / d_k))
        self.register_buffer('inv_freq', inv_freq)
        
        # 预计算 cos 和 sin
        self._build_cache(max_seq_len)
    
    def _build_cache(self, max_seq_len):
        t = torch.arange(max_seq_len, device=self.inv_freq.device)
        freqs = torch.einsum('i,j->ij', t, self.inv_freq)  # [max_seq_len, d_k/2]
        emb = torch.cat([freqs, freqs], dim=-1)  # [max_seq_len, d_k]
        self.register_buffer('cos_cached', emb.cos(), persistent=False)
        self.register_buffer('sin_cached', emb.sin(), persistent=False)
    
    def forward(self, x, seq_len=None):
        # x: [B, h, n, d_k]
        if seq_len is None:
            seq_len = x.shape[-2]
        
        cos = self.cos_cached[:seq_len].unsqueeze(0).unsqueeze(0)
        sin = self.sin_cached[:seq_len].unsqueeze(0).unsqueeze(0)
        
        # 应用旋转
        # q_rot = q * cos + rotate_half(q) * sin
        x_rot = self._apply_rotary(x, cos, sin)
        return x_rot
    
    def _apply_rotary(self, x, cos, sin):
        # x: [B, h, n, d_k]
        # cos, sin: [1, 1, n, d_k]
        
        # rotate_half: (-x_1, x_0, -x_3, x_2, ...)
        x_rot = torch.cat([-x[..., 1::2], x[..., ::2]], dim=-1)
        
        return x * cos + x_rot * sin
 
 
class RopeAttention(nn.Module):
    """使用 RoPE 的注意力"""
    
    def __init__(self, d_model, num_heads, max_seq_len=2048, base=10000):
        super().__init__()
        self.num_heads = num_heads
        self.d_k = d_model // num_heads
        
        self.W_q = nn.Linear(d_model, d_model, bias=False)
        self.W_k = nn.Linear(d_model, d_model, bias=False)
        self.W_v = nn.Linear(d_model, d_model, bias=False)
        self.W_o = nn.Linear(d_model, d_model)
        
        self.rope = RotaryPositionalEmbedding(self.d_k, base, max_seq_len)
    
    def forward(self, x, mask=None):
        B, n, _ = x.shape
        
        Q = self.W_q(x).view(B, n, self.num_heads, self.d_k).transpose(1, 2)
        K = self.W_k(x).view(B, n, self.num_heads, self.d_k).transpose(1, 2)
        V = self.W_v(x).view(B, n, self.num_heads, self.d_k).transpose(1, 2)
        
        # 应用 RoPE
        Q = self.rope(Q)
        K = self.rope(K)
        
        # 标准注意力
        scores = (Q @ K.transpose(-2, -1)) / (self.d_k ** 0.5)
        if mask is not None:
            scores = scores.masked_fill(mask == 0, -1e9)
        
        attn = torch.softmax(scores, dim=-1)
        out = attn @ V
        
        out = out.transpose(1, 2).contiguous().view(B, n, -1)
        return self.W_o(out)

---

3. RoPE 的群论视角

3.1 旋转群 $SO(2)$

关键观察：每对维度 $(2i,2i+1)$ 上的旋转构成 $SO(2)$ 群。

群作用：位置 $m\in \mathbb{Z}$ 通过：

$$m\mapsto R({\theta }_{i}m)=\left(\begin{array}{cc}\cos (m{\theta }_i)& -\sin (m{\theta }_i)\\ \sin (m{\theta }_i)& \cos (m{\theta }_i)\end{array}\right)$$

构成从 $(\mathbb{Z},+)$ 到 $(SO(2),\cdot )$ 的群同态。

3.2 关键性质

性质 3.1（相对位置编码）：

$${\tilde{q}}_m^T{\tilde{k}}_n=q^{T}R((n-m)\theta )k$$

证明：

$${\tilde{q}}_m^T{\tilde{k}}_n=(R_{m}q{)}^T(R_{n}k)=q^T{R}_m^T{R}_{n}k=q^T{R}_{n-m}k$$

性质 3.2（长程衰减）：
随 $|n-m|$ 增加，$q^T{R}_{(n-m)\theta }k$ 的值在不同频率上振荡，平均幅度衰减。

性质 3.3（远程衰减率）：

$$|q^T{R}_{m}k|\le \frac{C}{|m|}$$

（依赖于 $q,k$ 的频谱结构）

3.3 与其他位置编码的群论对比

方案	群	数学结构
Sinusoidal	$(\mathbb{R},+)$	加性编码
Learned	离散位置	查表
ALiBi	$(\mathbb{R},+)$	线性偏置
RoPE	$(SO(2),\cdot )$	旋转群作用
CoPE	上下文条件	软选

RoPE 的独特性：通过群作用实现相对位置编码，这是 Transformer 表达长程依赖的关键。

---

4. 相位调制视角

4.1 核心论文

Liu (2026). Rotary Positional Embeddings as Phase Modulation: Theoretical Bounds on the RoPE Base for Long-Context Transformers. arXiv:2602.10959.²

4.2 复数表示

关键洞察：2D 旋转等价于复数乘法。

设 $z_{2i,2i+1}=q_{2i}+i{q}_{2i+1}$，则：

$$R_{m}z=z\cdot e^{im{\theta }_i}$$

复数旋转 = 相位调制：位置 $m$ 通过 ${\theta }_{i}m$ 的相位调制。

4.3 频率混合的相位图

每个头 $h$ 使用不同频率集合 $\{{\theta }_1^{(h)},...,{\theta }_{d/2}^{(h)}\}$。

相位图：

位置 m -> 复平面上的旋转
        ↑
        |
        e^{i m θ_max}    (低频)
        |
        ⋮
        |
        e^{i m θ_min}    (高频)
        +---→ 实部

4.4 关键定理

定理 4.1（Liu 2026，简化）：RoPE 的有效编码能力由频率集合决定。

最优频率选择：给定目标长度 $L$，最优基 $b$ 满足：

$${\theta }_{\min }\cdot L\le 2\pi \cdot N\text{(完整周期)}$$

其中 $N$ 是所需完整周期数。

实际含义：

• $L=128k$ 时，$b$ 应选择更大（如 500000）
• 高频（${\theta }_{\max }$）不应超过 $2\pi /1$（每个位置旋转超 1 周期会混叠）

4.5 实践指引

长度 $L$ 与基 $b$ 的关系：

目标长度	推荐 $b$
4K	10000
32K	100000
128K	500000
1M	1000000+

---

5. RoPE 频率熵分析

5.1 核心论文

Oka, Hanafusa, Hasegawa, Nishida, Saito (2026). Probing Rotary Position Embeddings through Frequency Entropy. ICLR 2026.³

5.2 频率熵的概念

定义 5.1（频率熵）：给定模型在某 head 上的注意力分布 $A\in {\mathbb{R}}^{n\times n}$，定义频率使用度：

$$u_i=\frac{1}{n}\sum _{m=1}^n\left|\sum _{j=1}^n{A}_{mj}{e}^{i(m-j){\theta }_i}\right|$$

频率熵：

$$H_{\text{freq}}=-\sum _i{p}_i\log p_i$$

其中 $p_i=u_i/{\sum }_j{u}_j$。

5.3 关键发现

实验观察：

1. 不同头的频率使用模式差异巨大

   • 一些头高度依赖高频（局部依赖）
   • 另一些头主要使用低频（全局依赖）

2. 频率熵随训练演化

   • 早期：高频占主导（学习局部模式）
   • 后期：低频比重增加（学习长程依赖）

3. 频率使用与任务相关

   • 复制任务：需要特定频率
   • 算术任务：依赖低频

5.4 测量频率熵

def compute_frequency_entropy(attn_matrix, base=10000, d_k=64):
    """计算注意力矩阵的频率熵"""
    n = attn_matrix.shape[-1]
    
    # 计算频率
    inv_freq = 1.0 / (base ** (torch.arange(0, d_k, 2).float() / d_k))
    
    # 位置差
    positions = torch.arange(n).float()
    diff = positions.unsqueeze(0) - positions.unsqueeze(1)  # [n, n]
    
    # 每个频率的"激活度"
    frequency_activations = []
    for i in range(d_k // 2):
        theta_i = inv_freq[i]
        phase = diff * theta_i  # [n, n]
        
        # 加权注意力矩阵
        weighted = attn_matrix * torch.exp(1j * phase)
        activation = weighted.abs().mean().item()
        frequency_activations.append(activation)
    
    activations = torch.tensor(frequency_activations)
    probs = activations / activations.sum()
    entropy = -(probs * torch.log(probs + 1e-10)).sum()
    
    return entropy.item(), frequency_activations

5.5 启示

对架构设计的指导：

1. 频率集合应丰富：低频和高频都需要
2. 头应该多样化：不应所有头使用相似频率
3. 初始化重要：合理初始化可加速训练

---

6. “什么让 RoPE 有用”：理论分析

6.1 核心论文

Barbero, Vitvitskyi, Perivolaropoulos, Pascanu, Veličković (2025). Round and Round We Go! What Makes Rotary Positional Encodings useful? ICLR 2025.⁴

6.2 实验发现

作者通过 ablation 研究 RoPE 的哪些特性对性能至关重要：

1. 平移不变性：相对位置编码 vs 绝对位置编码 → RoPE 关键
2. 远程衰减：随距离衰减 vs 周期振荡 → 都重要
3. 正交性：每对维度的旋转矩阵正交 → 重要

6.3 理论结论

关键论点：

RoPE 的成功源于三个特性的组合：(a) 相对位置编码、(b) 长程衰减、(c) 频率多样性。

6.4 简化变体的对比

变体	相对位置	长程衰减	频率多样性	性能
RoPE	✓	✓	✓	基准
无 RoPE	✗	✗	✗	极差
仅相对位置	✓	✗	✗	差
仅频率	✗	✓	✓	中等
简化 RoPE	✓	✓	✗	中等

---

7. 长上下文扩展方法

7.1 核心问题

RoPE 的限制：训练时上下文长度 $L_{\text{train}}$，推理时超过此长度性能下降。

原因：

• 高频位置编码在外推时混淆
• 模型未见过 “远距离” 的注意力模式

7.2 主要扩展方法

7.2.1 位置插值（Position Interpolation, PI）

核心思想：将位置 $m$ 缩放到 $\alpha m$（$\alpha <1$），使其落在训练范围内。

$${\tilde{\theta }}_i={\theta }_i/\alpha$$

优点：简单
缺点：高频信息损失

7.2.2 YaRN（Yet another RoPE extensioN）

核心论文：Peng et al. (2023). YaRN. arXiv:2309.00071.

核心思想：分频率处理

• 高频：保留原始（短距离精度）
• 低频：插值（长距离扩展）

$${\tilde{\theta }}_i=\{\begin{array}{ll}{\theta }_i& \text{if }{\theta }_i>{\theta }_{\text{threshold}}\\ {\theta }_i/s& \text{if }{\theta }_i<{\theta }_{\text{threshold}}\end{array}$$

其中 $s$ 是缩放因子。

NTK-aware scaling：

$${\theta }_i^{\text{new}}={\left(\frac{1}{{\theta }_i}\cdot \frac{1}{s}+\frac{1}{{\theta }_{\max }}\right)}^{-1}$$

7.2.3 LongRoPE

核心论文：Ding et al. (2024). LongRoPE.

核心思想：通过搜索找到每个维度的最优缩放因子（非均匀）。

优点：比 YaRN 更灵活
缺点：搜索成本高

7.2.4 ABF (Adjusted Base Frequency)

核心思想：直接调整基 $b$：

$$b_{\text{new}}=b\cdot {\alpha }^{(d/(d-2))}$$

其中 $\alpha =L_{\text{target}}/L_{\text{train}}$。

7.2.5 Continual Pre-training (CPT)

方法：在更长序列上继续预训练。

优点：性能最好
缺点：计算昂贵

7.3 各种方法的对比

方法	复杂度	性能损失	计算成本
PI	低	中等	0
YaRN	中	小	0
LongRoPE	高	小	高（搜索）
ABF	低	中等	0
CPT	高	极小	极高

class ExtendedRoPE(nn.Module):
    """支持多种扩展方法的 RoPE"""
    
    def __init__(
        self,
        d_k,
        max_seq_len=4096,
        base=10000,
        extension_method='yarn',  # 'pi', 'yarn', 'longrope', 'abf'
        original_max_seq_len=4096,
        target_max_seq_len=32768,
    ):
        super().__init__()
        self.d_k = d_k
        self.original_max_seq_len = original_max_seq_len
        self.target_max_seq_len = target_max_seq_len
        self.scaling_factor = target_max_seq_len / original_max_seq_len
        
        # 计算基础频率
        inv_freq = 1.0 / (base ** (torch.arange(0, d_k, 2).float() / d_k))
        
        # 应用扩展方法
        if extension_method == 'pi':
            inv_freq = inv_freq / self.scaling_factor
        elif extension_method == 'yarn':
            # NTK-aware scaling
            beta_fast = 32  # 高频阈值
            beta_slow = 1   # 低频阈值
            
            # 高频不变，低频插值
            scale = self.scaling_factor
            inv_freq = self._yarn_scale(inv_freq, scale, beta_fast, beta_slow)
        elif extension_method == 'abf':
            new_base = base * (self.scaling_factor ** (d_k / (d_k - 2)))
            inv_freq = 1.0 / (new_base ** (torch.arange(0, d_k, 2).float() / d_k))
        
        self.register_buffer('inv_freq', inv_freq)
        self._build_cache(max_seq_len)
    
    def _yarn_scale(self, inv_freq, scale, beta_fast, beta_slow):
        """YaRN 分频率缩放"""
        wavelengths = 2 * torch.pi / inv_freq
        # 短波长（高频）：保持
        # 长波长（低频）：插值
        new_inv_freq = torch.where(
            wavelengths < beta_fast,
            inv_freq,
            inv_freq / scale
        )
        return new_inv_freq
    
    def _build_cache(self, max_seq_len):
        t = torch.arange(max_seq_len, device=self.inv_freq.device).float()
        freqs = torch.einsum('i,j->ij', t, self.inv_freq)
        emb = torch.cat([freqs, freqs], dim=-1)
        self.register_buffer('cos_cached', emb.cos(), persistent=False)
        self.register_buffer('sin_cached', emb.sin(), persistent=False)

---

8. N 维 RoPE

8.1 核心论文

Liu, Lin, Sun, Shangguan, Alvarez, Zhou (2025). Rethinking RoPE: A Mathematical Blueprint for N-dimensional Rotary Positional Embedding. arXiv:2504.06308.⁵

8.2 核心思想

传统 RoPE：1D 序列，每对维度独立旋转。

N 维 RoPE：每个位置编码多维信息（如 2D 图像、3D 点云）。

8.3 数学形式

2D RoPE：每个位置 $(x,y)$，不同维度组使用不同频率：

$$R_{m_x,m_y}^{(i)}=R({\theta }_i^{(x)}{m}_x)\oplus R({\theta }_i^{(y)}{m}_y)$$

应用：图像、视频、多模态等。

---

9. RoPE 与其他位置编码的统一

9.1 统一视角

位置编码可视为对位置 $m$ 的群作用：

方案	群	表示
Sinusoidal	$(\mathbb{R},+)$	$\sin ,\cos$
Learned	离散	查表
ALiBi	$(\mathbb{R},+)$	线性偏置
RoPE	$SO(2)$	旋转
CoPE	上下文	软选

9.2 设计原则

好的位置编码应满足：

1. 相对位置信息：能编码 $n-m$
2. 长程衰减：远距离自然衰减
3. 可外推：支持训练外长度
4. 计算高效：与注意力兼容

---

10. 实践建议

10.1 RoPE 配置

对于不同长度需求：

def recommend_rope_config(target_seq_len, model_size):
    """根据目标长度和模型规模推荐 RoPE 配置"""
    
    if target_seq_len <= 8192:
        # 标准 RoPE
        return {
            'base': 10000,
            'extension_method': None,
            'max_seq_len': target_seq_len,
        }
    elif target_seq_len <= 65536:
        # YaRN 扩展
        return {
            'base': 10000,
            'extension_method': 'yarn',
            'original_max_seq_len': 4096,
            'target_max_seq_len': target_seq_len,
        }
    else:  # > 64K
        # 长上下文专用
        return {
            'base': 500000,  # LLaMA 3 风格
            'extension_method': 'yarn',
            'original_max_seq_len': 8192,
            'target_max_seq_len': target_seq_len,
        }

10.2 训练策略

预训练阶段：

1. 使用标准 RoPE（$b=10000$）
2. 训练到稳定收敛

长上下文微调：

1. 应用 YaRN 扩展
2. 使用混合长度批次（短 + 长）
3. 学习率降低 10x

10.3 常见陷阱

错误 1：直接使用 PI 而不调超参

• 现象：长距离性能差
• 解决：使用 YaRN 或类似

错误 2：忘记调整 RoPE 在微调期间

• 现象：上下文长度”缩短”
• 解决：保持 RoPE 缩放一致

错误 3：高频维度被破坏

• 现象：短距离注意力混乱
• 解决：保留高频不变（YaRN 风格）

---

11. 与 Transformer 架构其他组件的交互

11.1 RoPE + GQA

问题：在 GQA（分组查询注意力）中，多个 Q 头共享 K 头，RoPE 如何应用？

解决方案：在 Q 和 K 上都应用 RoPE，但 K 头会被多个 Q 头共享。

class RoPEGQA(nn.Module):
    """RoPE + GQA 实现"""
    
    def __init__(self, d_model, num_q_heads, num_kv_heads, max_seq_len=2048):
        super().__init__()
        self.num_q_heads = num_q_heads
        self.num_kv_heads = num_kv_heads
        self.num_groups = num_q_heads // num_kv_heads
        self.d_k = d_model // num_q_heads
        
        # Q 头独立
        self.W_q = nn.Linear(d_model, num_q_heads * self.d_k)
        # KV 头共享
        self.W_k = nn.Linear(d_model, num_kv_heads * self.d_k)
        self.W_v = nn.Linear(d_model, num_kv_heads * self.d_k)
        self.W_o = nn.Linear(d_model, d_model)
        
        self.rope = RotaryPositionalEmbedding(self.d_k, max_seq_len=max_seq_len)
    
    def forward(self, x, mask=None):
        B, n, _ = x.shape
        
        Q = self.W_q(x).view(B, n, self.num_q_heads, self.d_k).transpose(1, 2)
        K = self.W_k(x).view(B, n, self.num_kv_heads, self.d_k).transpose(1, 2)
        V = self.W_v(x).view(B, n, self.num_kv_heads, self.d_k).transpose(1, 2)
        
        # 应用 RoPE（Q 和 K 都用）
        Q = self.rope(Q)
        K = self.rope(K)
        
        # 重复 K 和 V 以匹配 Q 头数
        K = K.repeat_interleave(self.num_groups, dim=1)
        V = V.repeat_interleave(self.num_groups, dim=1)
        
        # 注意力
        scores = (Q @ K.transpose(-2, -1)) / (self.d_k ** 0.5)
        if mask is not None:
            scores = scores.masked_fill(mask == 0, -1e9)
        
        attn = torch.softmax(scores, dim=-1)
        out = attn @ V
        
        out = out.transpose(1, 2).contiguous().view(B, n, -1)
        return self.W_o(out)

11.2 RoPE + 滑动窗口注意力

问题：滑动窗口只关注局部，如何在长距离中保持相对位置？

方案：

• 应用 RoPE 在所有 token
• 滑动窗口 + 全局注意力（如 GPT-3 LongRoPE）

---

12. 调试 RoPE

12.1 常见问题诊断

def diagnose_rope_issues(model, test_input):
    """诊断 RoPE 相关问题"""
    issues = []
    
    # 1. 检查相对位置编码
    if not hasattr(model, 'rope'):
        issues.append("模型没有 RoPE，可能未使用相对位置编码")
    
    # 2. 检查频率设置
    if hasattr(model, 'rope'):
        rope = model.rope
        if rope.base < 5000:
            issues.append(f"基过小: {rope.base}，可能限制长距离编码")
    
    # 3. 检查应用范围
    for name, module in model.named_modules():
        if 'attn' in name and not hasattr(module, 'rope'):
            issues.append(f"{name} 缺少 RoPE")
    
    # 4. 检查维度对齐
    if hasattr(model, 'rope') and model.rope.d_k % 2 != 0:
        issues.append("RoPE 维度不是偶数，无法分组旋转")
    
    return issues

12.2 验证相对位置编码

def verify_relative_position_encoding(model, x):
    """验证 RoPE 是否正确编码相对位置"""
    # 测试：相对位置相同时注意力分数应相同
    # (即使绝对位置不同)
    
    # 在两个不同位置对 (m1, n1) 和 (m2, n2)
    # 如果 |m1 - n1| == |m2 - n2|，则注意力分数应近似相等
    
    with torch.no_grad():
        # 获取中间层输出
        out = model(x)
        # 检查位置不变性
        # ...

---

13. 数学补充：RoPE 与傅里叶分析

13.1 RoPE 作为 Fourier 基

关键观察：RoPE 的不同频率 $\{thet{a}_i\}$ 对应一组Fourier 基。

形式化：query-key 点积：

$$q^T{R}_{(n-m)}k=\sum _i\left[(q_{2i}{k}_{2i}+q_{2i+1}{k}_{2i+1})\cos ((n-m){\theta }_i)+(q_{2i}{k}_{2i+1}-q_{2i+1}{k}_{2i})\sin ((n-m){\theta }_i)\right]$$

这是 Fourier 级数展开！

13.2 谱视角

每个 query-key 对在位置差 $d=n-m$ 上的”谱”：

$$S(q,k,d)=\sum _i{\alpha }_i(q,k)e^{id{\theta }_i}$$

其中 ${\alpha }_i(q,k)=(q_{2i}+i{q}_{2i+1})\overline{(k_{2i}+i{k}_{2i+1})}$

重要含义：

• RoPE 通过 Fourier 系数编码相对位置
• 频率 ${\theta }_i$ 决定位置编码的”精度”

---

14. 未来方向

14.1 待解决问题

1. 最优频率集合：给定任务和长度，最优 ${\theta }_i$ 是什么？
2. 跨任务迁移：频率选择是否与任务相关？
3. 理论与实践：RoPE 在真实模型中的频率使用模式

14.2 前沿探索

1. RoPE + SSM 混合：状态空间模型中的位置编码
2. 动态 RoPE：频率随上下文调整
3. 多维 RoPE：视频、3D 等

---

15. 关键论文清单

基础

1. Su et al. (2021) — RoFormer: Enhanced Transformer with Rotary Position Embedding
2. Shaw et al. (2018) — Relative Position Encodings

理论分析（2025-2026）

3. Barbero et al. ICLR 2025 — What Makes RoPE Useful?
4. Liu arXiv:2602.10959 (2026) — RoPE as Phase Modulation
5. Oka et al. ICLR 2026 — Probing RoPE through Frequency Entropy
6. Liu et al. arXiv:2504.06308 (2025) — N-dimensional RoPE

长上下文扩展

7. Chen et al. (2023) — Position Interpolation
8. Peng et al. (2023) — YaRN
9. Ding et al. (2024) — LongRoPE

---

16. 总结

RoPE 的本质：

视角	理解
群论	$SO(2)$ 群作用，编码相对位置
频谱	Fourier 基展开，频率 ${\theta }_i$ 控制精度
相位	复数乘法 = 相位调制
信息论	相对距离自然衰减
几何	旋转保持内积结构

现代 RoPE 设计要点：

1. Pre-norm + RoPE 是主流
2. 长上下文需要 YaRN 或类似扩展
3. 频率熵分析揭示模型内部使用模式
4. N 维 RoPE 扩展到图像、视频

---

17. 与相关专题的连接

17.1 Transformer 架构专题

• Transformer数学基础
• 注意力机制现代理论
• 架构收敛模式
• Attention Sink分析

17.2 数学基础

• 注意力机制的线性代数
• 因子图

17.3 应用

• LLM推理优化
• 高效视觉Transformer

---

最后更新：2026-06-21

Footnotes

1. Su et al. (2021). RoFormer: Enhanced Transformer with Rotary Position Embedding. ↩

2. Liu (2026). RoPE as Phase Modulation. arXiv:2602.10959. ↩

3. Oka et al. (2026). Probing RoPE through Frequency Entropy. ICLR 2026. ↩

4. Barbero et al. (2025). What Makes RoPE Useful? ICLR 2025. ↩

5. Liu et al. (2025). Rethinking RoPE: N-dimensional. arXiv:2504.06308. ↩