位置编码的几何理论

位置编码（Positional Encoding, PE）是Transformer架构中编码序列位置信息的关键组件。2025-2026年的研究从几何视角提供了对位置编码的深入理解，揭示了不同编码方案的理论性质和表达能力边界。¹

基础回顾

绝对位置编码

可学习位置嵌入

$${\mathbf{p}}_i={\mathbf{E}}_{pos}[i]$$

其中 ${\mathbf{E}}_{pos}\in {\mathbb{R}}^{L\times d}$ 是可学习参数矩阵。

Sinusoidal位置编码

$${\mathbf{p}}_{i,2j}=\sin \left(\frac{i}{10000^{2j/d}}\right)$$ $${\mathbf{p}}_{i,2j+1}=\cos \left(\frac{i}{10000^{2j/d}}\right)$$

相对位置编码

相对位置编码编码 token 之间的距离 $|i-j|$ 而非绝对位置。

T5 Relative Position Bias

$${\mathbf{b}}_{ij}={\mathbf{r}}_{\text{clamp}(i-j,-R,R)}$$

RoPE（旋转位置编码）

通过旋转矩阵编码相对位置：

$${\mathbf{q}}_i^{\prime }={\mathbf{R}}_i{\mathbf{q}}_i,{\mathbf{k}}_j^{\prime }={\mathbf{R}}_j{\mathbf{k}}_j$$

几何分类框架

对称性视角

不同位置编码方案保持不同的对称性：

编码方案	平移对称性	旋转对称性	时间反转对称性
Sinusoidal	✓	✗	✓
RoPE	✓	✓	✗
ALiBi	✓	✗	✗
可学习PE	✗	✗	✗

定义：平移对称性

一个编码方案具有平移对称性，如果：

$$\exists \varphi :{\mathbb{R}}^d\times \mathbb{R}\to {\mathbb{R}}^d,\varphi (\varphi (\mathbf{x},i),j)=\varphi (\mathbf{x},i+j)$$

几何解释

Sinusoidal编码的几何性质：

• 编码向量在嵌入空间中形成螺旋结构
• 相邻位置的向量点积与距离成负相关
• 保持时间反转对称性

RoPE的几何性质：

• 通过旋转编码位置
• 相对位置的旋转差只依赖于 $|i-j|$
• 破坏时间反转对称性（旋转方向不可逆）

Sinusoidal vs RoPE：几何对比

表达能力对比

Sinusoidal编码

def sinusoidal_encoding(pos, d_model):
    """
    Sinusoidal位置编码
    几何解释：在d维空间中创建螺旋结构
    """
    pe = torch.zeros(pos.shape[0], d_model)
    position = pos.unsqueeze(1)
    div_term = torch.exp(
        torch.arange(0, d_model, 2) * (-math.log(10000) / d_model)
    )
    pe[:, 0::2] = torch.sin(position * div_term)
    pe[:, 1::2] = torch.cos(position * div_term)
    return pe

关键性质：

• $⟨{\mathbf{p}}_i,{\mathbf{p}}_j⟩$ 只依赖于 $|i-j|$
• 内积衰减是振荡的，不是单调的
• 位置编码与内容嵌入是加性的

RoPE编码

def apply_rope(x, pos):
    """
    应用旋转位置编码
    几何解释：在子空间上执行旋转操作
    """
    d_head = x.shape[-1]
    half_d = d_head // 2
    
    # 旋转角
    theta = 10000 ** (-2 * torch.arange(half_d, device=x.device) / d_head)
    angles = pos.unsqueeze(1) * theta
    
    # 旋转矩阵
    cos_a = torch.cos(angles)
    sin_a = torch.sin(angles)
    
    # 应用旋转
    x1, x2 = x[..., :half_d], x[..., half_d:]
    x_rotated = torch.cat([
        x1 * cos_a - x2 * sin_a,
        x1 * sin_a + x2 * cos_a
    ], dim=-1)
    
    return x_rotated

关键性质：

• $⟨{\mathbf{R}}_i\mathbf{q},{\mathbf{R}}_j\mathbf{k}⟩=⟨\mathbf{q},{\mathbf{R}}_{j-i}\mathbf{k}⟩$
• 相对位置编码通过旋转差实现
• 与内容嵌入是乘性的（旋转而非加性）

几何意义

性质	Sinusoidal	RoPE
位置表示	加性	旋转性
位置-内容交互	线性	非线性
位置信息衰减	振荡	线性
计算复杂度	$O(1)$	$O(1)$

RoPE理论分析

长上下文上界

定理（RoPE长上下文上界）：²

对于基参数 $\theta$ 和最大训练长度 $L_{\max }$，有：

$${\theta }_b\le \frac{1}{L_{\max }^2}$$

其中 ${\theta }_b$ 是RoPE的基参数。

最优基参数

命题：RoPE的最优基参数满足：

$$b^{\ast }=\lceil \sqrt{\frac{d_{\text{model}}}{L_{\max }}}\rceil$$

这确保在训练长度内，相位旋转不会发生混淆。

数值稳定性分析

RoPE的数值稳定性由以下条件保证：

$$\Vert {\mathbf{R}}_i\mathbf{q}-{\mathbf{R}}_j\mathbf{q}\Vert \le ϵ$$

对于 $|i-j|\le L_{\max }$，要求：

$$|i-j|\cdot {\theta }_{\max }\ll \pi$$

表达能力分析

位置信息编码容量

信息论视角

位置信息的信息量：

$$I(\text{position})={\log }_2{N}_{\text{distinguishable positions}}$$

对于维度 $d$ 和序列长度 $L$：

$$N_{\text{dist}}\approx \min \left(L,2^d\right)$$

几何容量

定理：$d$ 维位置编码最多可精确区分 $O(d!)$ 个不同位置。

泛化到更长序列

Sinusoidal的泛化

class SinusoidalPE:
    """Sinusoidal位置编码"""
    def __init__(self, d_model, max_len=5000):
        self.d_model = d_model
        self.max_len = max_len
        self._create_encoding(max_len)
    
    def encode(self, pos):
        """编码位置（可泛化到max_len之外）"""
        pe = torch.zeros(1, pos.numel(), self.d_model)
        position = pos.unsqueeze(1)
        pe[:, :, 0::2] = torch.sin(
            position / torch.pow(10000, 2 * torch.arange(0, self.d_model, 2) / self.d_model)
        )
        pe[:, :, 1::2] = torch.cos(
            position / torch.pow(10000, 2 * torch.arange(0, self.d_model, 2) / self.d_model)
        )
        return pe

性质：理论上可泛化到任意长度（数学上连续）。

RoPE的泛化

RoPE的泛化能力受限于：

1. 旋转周期：$2\pi$ 周期可能导致位置混淆
2. 基参数选择：$b$ 越小，周期越长，外推越好
3. 注意力稀释：远距离位置的旋转差异可能被忽略

外推能力对比

方法	训练内插值	短距离外推	长距离外推
可学习PE	优秀	差	无法使用
Sinusoidal	良好	良好	良好（但性能下降）
RoPE (标准)	优秀	良好	需要NTK-Scaling
RoPE + NTK	优秀	优秀	良好
ALiBi	优秀	优秀	良好

位置编码与注意力模式

几何约束

位置编码通过注意力模式施加几何约束：

$${\mathbf{A}}_{ij}=\text{softmax}\left(\frac{{\mathbf{q}}_i^{\prime }{\mathbf{k}}_j^{\prime }}{\sqrt{d}}\right)$$

自然语言的位置偏好

def analyze_position_preference(model, tokens):
    """分析模型的自然语言位置偏好"""
    with torch.no_grad():
        output = model(tokens)
    
    # 提取注意力权重
    attn_weights = model.transformer.h[-1].attn.attn_weights
    
    # 计算位置注意力分布
    seq_len = tokens.shape[1]
    positions = torch.arange(seq_len)
    
    # 对角线注意力（当前位置）
    diag_attn = attn_weights.diagonal(0, 2, 3)
    
    # 邻居注意力
    neighbor_attn = torch.stack([
        attn_weights.diagonal(offset, 2, 3) 
        for offset in [-2, -1, 1, 2]
    ]).mean(0)
    
    return {
        'self_attention': diag_attn.mean().item(),
        'neighbor_attention': neighbor_attn.mean().item(),
        'preference': 'local' if neighbor_attn.mean() > diag_attn.mean() else 'self'
    }

位置编码对Attention的影响

编码类型	Attention模式	空间结构
无PE	全局均匀	置换不变
Sinusoidal	局部增强+振荡	螺旋结构
RoPE	局部增强	旋转不变
ALiBi	线性衰减	层次结构

设计与选择指南

任务适配

短序列任务

推荐：可学习PE或Sinusoidal

# 短序列（< 1K tokens）
if seq_len < 1024:
    pe = nn.Embedding(seq_len, d_model)  # 可学习
    # 或
    pe = SinusoidalPE(d_model, seq_len)   # Sinusoidal

长序列任务

推荐：RoPE + NTK-Scaling或ALiBi

# 长序列（> 4K tokens）
if seq_len > 4096:
    # RoPE with NTK-Scaling
    rope_base = 10000 * (ntk_scale ** (d_model / (d_model - 2)))
    # 或
    pe = ALiBiAttention(num_heads)  # ALiBi

长度外推任务

推荐：ALiBi或NTK-Scaled RoPE

# 需要长度外推
def choose_pe_for_extrapolation(train_len, test_len):
    if test_len > train_len * 2:
        return 'alibi'  # 更好的外推能力
    elif test_len > train_len:
        return 'rope_ntk'  # 可接受的外推
    else:
        return 'rope_standard'  # 训练长度内

超参数调优

RoPE基参数

def tune_rope_base(d_model, train_len, target_extrap_ratio=2.0):
    """
    调优RoPE基参数
    
    理论指导：
    - 基参数越小，外推能力越强
    - 但太小的基参数影响训练效率
    """
    # 经验公式
    base = max(10000, train_len * target_extrap_ratio ** 0.5)
    
    # 理论下界
    base_lower = 1 / (train_len ** 2)
    
    return max(base_lower, base)

位置编码维度

def pe_dimension_needed(train_len, tolerance=0.01):
    """
    计算所需的位置编码维度
    
    基于Nyquist采样定理
    """
    # 最高频率
    f_max = 1 / tolerance
    
    # 所需维度
    d_needed = math.ceil(math.log2(f_max * train_len) / math.log2(10000) * 2)
    
    return max(d_needed, 32)

混合位置编码

ALiBi + RoPE

两者可以组合使用：

class HybridPositionEncoding(nn.Module):
    """
    ALiBi + RoPE混合位置编码
    
    结合两者优势：
    - RoPE：精细的相对位置编码
    - ALiBi：线性衰减的外推能力
    """
    def __init__(self, d_model, num_heads):
        super().__init__()
        self.d_model = d_model
        self.num_heads = num_heads
        self.rope = RotaryPositionEmbedding(d_model)
        self.alibi_slopes = self._get_alibi_slopes(num_heads)
    
    def _get_alibi_slopes(self, num_heads):
        slopes = torch.pow(2, -8.0 / torch.arange(1, num_heads + 1).float())
        slopes = torch.where(
            torch.arange(1, num_heads + 1).float() > 8,
            torch.ones(num_heads),
            slopes
        )
        return slopes
    
    def forward(self, x, position_ids=None):
        # RoPE部分
        x_rope = self.rope.rotate_queries(x)
        x_rope = self.rope.rotate_keys(x_rope)
        
        # ALiBi偏置
        seq_len = x.shape[1]
        positions = torch.arange(seq_len, device=x.device)
        distance = positions.unsqueeze(0) - positions.unsqueeze(1)
        alibi_bias = -distance.abs() * self.alibi_slopes.view(-1, 1, 1)
        
        return x_rope, alibi_bias[:, :, :seq_len, :seq_len]

CoPE（条件位置编码）

CoPE根据内容动态决定位置：

class ConditionalPositionEncoding(nn.Module):
    """
    条件位置编码
    
    位置不是预先定义的，而是根据内容动态计算
    """
    def __init__(self, d_model):
        super().__init__()
        self.proj = nn.Linear(d_model, 1)
    
    def forward(self, x):
        # 计算门控值
        gates = torch.sigmoid(self.proj(x))
        
        # 累积得到位置
        positions = torch.cumsum(gates, dim=1)
        
        # 归一化
        positions = positions / (positions[:, -1:] + 1e-6)
        
        return positions

位置编码理论前沿

2026年最新进展

1. 位置编码的表达能力边界

定理：对于任意位置编码方案 $\varphi$，存在函数类 $\mathcal{F}$ 使得：

$$\forall f\in \mathcal{F},\text{TransformerPE}⊉f$$

这给出了位置编码表达能力的理论上界。

2. 最优位置编码设计原则

原则1：保持必要的对称性（平移对称性）
原则2：允许内容依赖的位置调整
原则3：平衡局部和全局信息编码

3. 位置编码与模型压缩

class CompressedPositionEncoding(nn.Module):
    """
    压缩位置编码
    
    使用低秩近似减少位置编码参数量
    """
    def __init__(self, d_model, rank=16):
        super().__init__()
        self.U = nn.Parameter(torch.randn(d_model, rank))
        self.V = nn.Parameter(torch.randn(rank, d_model))
    
    def forward(self, positions):
        # 低秩位置编码
        pe = positions @ (self.U @ self.V)
        return pe

实践代码

完整RoPE实现

import torch
import torch.nn as nn
import math
 
class RotaryPositionEmbedding(nn.Module):
    def __init__(self, dim, base=10000):
        super().__init__()
        self.dim = dim
        self.base = base
        inv_freq = 1.0 / (base ** (torch.arange(0, dim, 2).float() / dim))
        self.register_buffer('inv_freq', inv_freq)
    
    def forward(self, max_seq_len):
        seq = torch.arange(max_seq_len, device=self.inv_freq.device)
        freqs = seq.unsqueeze(1) @ self.inv_freq.unsqueeze(0)
        emb = torch.cat([freqs, freqs], dim=-1)
        return emb.cos(), emb.sin()
    
    @staticmethod
    def rotate_half(x):
        x1 = x[..., :x.shape[-1] // 2]
        x2 = x[..., x.shape[-1] // 2:]
        return torch.cat([-x2, x1], dim=-1)
    
    def apply_rotary(self, q, k, cos, sin):
        q_embed = (q * cos) + (self.rotate_half(q) * sin)
        k_embed = (k * cos) + (self.rotate_half(k) * sin)
        return q_embed, k_embed
 
 
class RoPEMultiHeadAttention(nn.Module):
    def __init__(self, d_model, num_heads):
        super().__init__()
        self.d_model = d_model
        self.num_heads = num_heads
        self.d_k = d_model // num_heads
        
        self.w_q = nn.Linear(d_model, d_model)
        self.w_k = nn.Linear(d_model, d_model)
        self.w_v = nn.Linear(d_model, d_model)
        self.w_o = nn.Linear(d_model, d_model)
        
        self.rope = RotaryPositionEmbedding(self.d_k)
    
    def forward(self, x, mask=None):
        batch_size, seq_len, _ = x.shape
        
        # QKV投影
        q = self.w_q(x).view(batch_size, seq_len, self.num_heads, self.d_k).transpose(1, 2)
        k = self.w_k(x).view(batch_size, seq_len, self.num_heads, self.d_k).transpose(1, 2)
        v = self.w_v(x).view(batch_size, seq_len, self.num_heads, self.d_k).transpose(1, 2)
        
        # 应用RoPE
        cos, sin = self.rope(seq_len)
        q, k = self.rope.apply_rotary(q, k, cos, sin)
        
        # 注意力计算
        scores = torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(self.d_k)
        
        if mask is not None:
            scores = scores.masked_fill(mask == 0, -1e9)
        
        attn_weights = torch.softmax(scores, dim=-1)
        output = torch.matmul(attn_weights, v)
        
        output = output.transpose(1, 2).contiguous().view(batch_size, seq_len, self.d_model)
        return self.w_o(output)

参考文献

---

相关词条：ALiBi位置编码，Transformer与注意力机制，稀疏注意力与长度外推，Transformer表达能力：热带几何视角

Footnotes

1. Anonymous, “On the Geometry of Positional Encodings”, arXiv:2604.05217, 2026 ↩

2. Anonymous, “Rotary Positional Embeddings as Phase Modulation”, arXiv:2602.10959, 2026 ↩