旋转位置RoPE编码详解

LiRuiJie

已于 2025-06-07 17:45:37 修改

阅读量1.1k

点赞数 35

CC 4.0 BY-SA版权

分类专栏：人工智能文章标签：算法机器学习人工智能

于 2025-05-21 12:34:55 首次发布

本文链接：https://blog.csdn.net/lrj41781196/article/details/148109362

人工智能专栏收录该内容

13 篇文章

订阅专栏

一. 旋转位置编码和正余弦位置编码比对

旋转位置编码（RoPE）和正余弦位置编码（Sinusoidal Position Encoding）是两种常用的位置编码方法，它们在处理序列数据时具有不同的数学形式和特性。以下是对两者优劣的详细说明及底层数学推理：

1. 正余弦位置编码（Sinusoidal Position Encoding）

1）数学形式
对于位置 \( \text{pos} \) 和维度 \( i \)，正余弦编码定义为：
\[
\text{PE}(\text{pos}, 2i) = \sin\left(\frac{\text{pos}}{10000^{2i/d}}\right), \quad
\text{PE}(\text{pos}, 2i+1) = \cos\left(\frac{\text{pos}}{10000^{2i/d}}\right)
\]
其中 \( d \) 是模型的嵌入维度，\( i \in [0, d/2) \)。不同维度使用不同频率的正余弦函数，频率随维度增加呈指数下降。

2）优点
1. 显式相对位置编码：
对于固定偏移 \( k \)，存在线性变换 \( T_k \) 使得 \( \text{PE}(\text{pos} + k) = T_k \cdot \text{PE}(\text{pos}) \)。例如，对于频率 \( \omega_i = 1/10000^{2i/d} \)，有：
\[
\begin{aligned}
\sin(\omega_i (\text{pos} + k)) &= \sin(\omega_i \text{pos}) \cos(\omega_i k) + \cos(\omega_i \text{pos}) \sin(\omega_i k), \\
\cos(\omega_i (\text{pos} + k)) &= \cos(\omega_i \text{pos}) \cos(\omega_i k) - \sin(\omega_i \text{pos}) \sin(\omega_i k),
\end{aligned}
\]
这等效于二维旋转矩阵 \( R(\omega_i k) \) 作用在 \( [\sin(\omega_i \text{pos}), \cos(\omega_i \text{pos})]^T \)。因此，相对位置信息可通过线性组合捕捉。

2. 确定性与可扩展性：
编码是确定性的，无需学习参数，且能处理任意长度序列。

3）缺点
1. 内容与位置耦合：
位置编码与词嵌入通过加法结合，导致注意力分数包含四部分：
\[
\mathbf{q}_i^T \mathbf{k}_j = (\mathbf{x}_i + \text{PE}(i)) \mathbf{W}_Q \mathbf{W}_K^T (\mathbf{x}_j + \text{PE}(j))^T,
\]
其中交叉项（如 \( \mathbf{x}_i \mathbf{W}_Q \mathbf{W}_K^T \text{PE}(j)^T \)）需要模型学习复杂的位置-内容交互。

2. 绝对位置偏差：
编码本质上是绝对位置的，长序列泛化可能受限。

---

2. 旋转位置编码（Rotary Position Embedding, RoPE）

1）数学形式
对词嵌入 \( \mathbf{x} \in \mathbb{R}^d \)，将其划分为 \( d/2 \) 个二维子空间，对每个子空间应用旋转矩阵 \( R_m \)：
\[
R_m = \begin{bmatrix}
\cos m\theta_i & -\sin m\theta_i \\
\sin m\theta_i & \cos m\theta_i
\end{bmatrix}, \quad \theta_i = 10000^{-2i/d},
\]
其中 \( m \) 是位置，\( i \) 是子空间索引。查询和键向量通过旋转注入位置信息：
\[
\mathbf{q}_m = R_m \mathbf{x}_m \mathbf{W}_Q, \quad \mathbf{k}_n = R_n \mathbf{x}_n \mathbf{W}_K.
\]

2）优点
1. 显式相对位置编码：
注意力分数 \( \mathbf{q}_m^T \mathbf{k}_n \) 仅依赖相对位置 \( n - m \)：
\[
\mathbf{q}_m^T \mathbf{k}_n = (\mathbf{x}_m \mathbf{W}_Q)^T R_{m}^T R_n (\mathbf{x}_n \mathbf{W}_K) = (\mathbf{x}_m \mathbf{W}_Q)^T R_{n - m} (\mathbf{x}_n \mathbf{W}_K),
\]
其中 \( R_{n - m} \) 是相对位置的旋转矩阵。内积直接编码相对位置，无需模型学习。

2. 模长不变性：
旋转是正交变换，保持向量模长，增强数值稳定性。

3. 长序列适应性：
相对位置编码天然适应长序列，测试时无需外推。

3）缺点
1. *实现复杂度：
需将向量分块旋转，实现较复杂。

2. 预设频率敏感性：
频率参数 \( \theta_i \) 需预设，可能影响不同任务表现。

3. 数学推导对比

1）正余弦编码的注意力分数
\[
\mathbf{q}_i^T \mathbf{k}_j = \underbrace{\mathbf{x}_i \mathbf{W}_Q \mathbf{W}_K^T \mathbf{x}_j^T}_{\text{内容项}} + \underbrace{\mathbf{x}_i \mathbf{W}_Q \mathbf{W}_K^T \text{PE}(j)^T + \text{PE}(i) \mathbf{W}_Q \mathbf{W}_K^T \mathbf{x}_j^T}_{\text{交叉项}} + \underbrace{\text{PE}(i) \mathbf{W}_Q \mathbf{W}_K^T \text{PE}(j)^T}_{\text{位置项}}.
\]
模型需同时学习内容、位置及其交互，增加了复杂性。

2）RoPE的注意力分数
\[
\mathbf{q}_m^T \mathbf{k}_n = (\mathbf{x}_m \mathbf{W}_Q)^T R_{n - m} (\mathbf{x}_n \mathbf{W}_K) = \sum_{i=0}^{d/2-1} (\mathbf{x}_m^{(i)} \mathbf{W}_Q^{(i)})^T R^{(i)}_{n - m} (\mathbf{x}_n^{(i)} \mathbf{W}_K^{(i)}),
\]
其中 \( R^{(i)}_{n - m} \) 是第 \( i \) 个子空间的旋转矩阵。相对位置 \( n - m \) 直接作用于内积，简化了位置建模。

3）总结

特性	正余弦位置编码	旋转位置编码
位置信息注入方式	加法（词嵌入 + 位置编码）	乘法（旋转矩阵作用于词嵌入）
相对位置编码	需通过线性变换学习	显式编码于内积中
长序列适应性	可处理任意长度，但泛化能力有限	更优（依赖相对位置，无需绝对位置外推）
计算复杂度	低（预计算加法）	中等（分块旋转操作）
数值稳定性	可能受相加干扰	优（旋转保持模长不变）
实现难度	简单	复杂

4）选择建议：
- 正余弦编码适合计算资源有限或需要快速实现的场景。
- 旋转编码适合对位置敏感的任务（如长文本生成、问答），尤其是需要显式相对位置建模的场景。

二. 旋转位置编码计算逻辑示例

以下以输入 **5个token**，每个token的词向量维度为 **512** 为例，详细说明旋转位置编码的计算步骤，包括权重矩阵 \( W^Q \)、\( W^K \) 的维度及旋转矩阵 \( R_m \) 的生成过程。

1. 输入与权重矩阵

(1) 输入矩阵
输入序列为 **5个token**，每个token的词向量维度为 **512**，输入矩阵表示为：
\[
X \in \mathbb{R}^{5 \times 512}
\]

(2) 权重矩阵
- **查询权重矩阵** \( W^Q \in \mathbb{R}^{512 \times 512} \)
- **键权重矩阵** \( W^K \in \mathbb{R}^{512 \times 512} \)
- **值权重矩阵** \( W^V \in \mathbb{R}^{512 \times 512} \)

通过线性变换生成初始的 \( Q \)、\( K \)、\( V \)：
\[
Q = X W^Q, \quad K = X W^K, \quad V = X W^V \quad \Rightarrow \quad Q, K, V \in \mathbb{R}^{5 \times 512}
\]

2. 旋转位置编码的核心思想

- 目标：将位置信息注入 \( Q \) 和 \( K \) 中，使得它们的点积能隐式编码相对位置。
- 方法：将每个词向量的维度划分为 **256个二维子空间**，对每个子空间应用旋转矩阵 \( R_m^{(i)} \)，旋转角度由位置 \( m \) 和频率 \( \theta_i \) 决定。

3. 旋转矩阵的生成

(1) 频率参数
对第 \( i \) 个二维子空间，频率参数定义为：
\[
\theta_i = 10000^{-2i/512}, \quad i \in [0, 255]
\]
例如：
- \( i = 0 \): \( \theta_0 = 10000^{0} = 1 \)
- \( i = 1 \): \( \theta_1 = 10000^{-2/512} \approx 0.9647 \)
- \( i = 255 \): \( \theta_{255} = 10000^{-510/512} \approx 1.58 \times 10^{-5} \)

(2) 旋转角度
对位置 \( m \)，第 \( i \) 个子空间的旋转角度为：
\[
\text{angle}_i = m \cdot \theta_i
\]

(3) 旋转矩阵
生成二维旋转矩阵：
\[
R_m^{(i)} = \begin{bmatrix}
\cos(\text{angle}_i) & -\sin(\text{angle}_i) \\
\sin(\text{angle}_i) & \cos(\text{angle}_i)
\end{bmatrix}
\]

4. 计算旋转后的 Q 和 K

(1) 划分二维子空间
将每个token的 **512维向量** 划分为 **256个二维子空间**：
\[
\mathbf{q}_m = [\mathbf{q}_m^{(0)}, \mathbf{q}_m^{(1)}, \ldots, \mathbf{q}_m^{(255)}], \quad \mathbf{q}_m^{(i)} \in \mathbb{R}^2
\]
例如：
- \( \mathbf{q}_m^{(0)} = [q_{m,0}, q_{m,1}] \)
- \( \mathbf{q}_m^{(1)} = [q_{m,2}, q_{m,3}] \)
- ...
- \( \mathbf{q}_m^{(255)} = [q_{m,510}, q_{m,511}] \)
(2) 应用旋转矩阵
对每个子空间 \( i \) 和位置 \( m \)，计算旋转后的向量：
\[
\begin{aligned}
q_{m,2i}^{\text{rot}} &= q_{m,2i} \cos(m\theta_i) - q_{m,2i+1} \sin(m\theta_i) \\
q_{m,2i+1}^{\text{rot}} &= q_{m,2i} \sin(m\theta_i) + q_{m,2i+1} \cos(m\theta_i)
\end{aligned}
\]

(3) 重构旋转后的 Q 和 K
将所有子空间旋转后的结果拼接回 **512维向量**，得到旋转后的 \( Q_{\text{rot}} \) 和 \( K_{\text{rot}} \)。

5. 注意力分数的计算

计算旋转后的注意力分数矩阵：
\[
\text{Attention Scores} = \frac{Q_{\text{rot}} \cdot K_{\text{rot}}^T}{\sqrt{512}}
\]
由于旋转矩阵的正交性，内积仅依赖相对位置 \( n - m \)：
\[
\mathbf{q}_m^{\text{rot}} \cdot \mathbf{k}_n^{\text{rot}} = \sum_{i=0}^{255} \mathbf{q}_m^{(i)} \cdot R_{n-m}^{(i)} \cdot \mathbf{k}_n^{(i)}
\]

6. 具体数值示例

假设 **位置 \( m = 1 \)**，**子空间 \( i = 0 \)**：
- 频率：\( \theta_0 = 1 \)
- 旋转角度：\( \text{angle}_0 = 1 \times 1 = 1 \) 弧度
- 旋转矩阵：
\[
R_1^{(0)} = \begin{bmatrix}
\cos(1) & -\sin(1) \\
\sin(1) & \cos(1)
\end{bmatrix} \approx \begin{bmatrix}
0.5403 & -0.8415 \\
0.8415 & 0.5403
\end{bmatrix}
\]
- 原始子空间向量：\( \mathbf{q}_1^{(0)} = [2.0, 3.0] \)
- 旋转后向量：
\[
\begin{aligned}
q_{1,0}^{\text{rot}} &= 2.0 \times 0.5403 - 3.0 \times 0.8415 \approx -1.6245 \\
q_{1,1}^{\text{rot}} &= 2.0 \times 0.8415 + 3.0 \times 0.5403 \approx 3.0252
\end{aligned}
\]

7. 总结

步骤	操作
输入维度	5个token，每个512维
权重矩阵	WQ,WK∈R512×512WQ,WK∈R512×512
子空间划分	将512维划分为256个二维子空间
旋转矩阵生成	基于位置 mm 和频率 θi=10000−2i/512θi=10000−2i/512
旋转后Q/K	每个二维子空间独立旋转，拼接后保持512维
注意力分数	内积隐式编码相对位置 n−mn−m

通过旋转位置编码，模型无需显式学习位置偏差，直接通过几何变换捕捉相对位置关系，提升长序列建模能力。

三. 基于pytorch的完整代码实现

基于PyTorch的正余弦位置编码与旋转位置编码（RoPE）实现详解

1. 正余弦位置编码（Sinusoidal Position Encoding）

1）数学公式：
对于位置 \( \text{pos} \) 和维度 \( i \)，编码定义为：
\[
\text{PE}(\text{pos}, 2i) = \sin\left(\frac{\text{pos}}{10000^{2i/d}}\right), \quad
\text{PE}(\text{pos}, 2i+1) = \cos\left(\frac{\text{pos}}{10000^{2i/d}}\right)
\]
其中 \( d \) 为嵌入维度。

2）PyTorch实现步骤：

1. 生成位置索引与维度索引：

import torch

def sinusoidal_position_encoding(max_len, d_model):
    position = torch.arange(max_len).unsqueeze(1)  # (max_len, 1)
    div_term = torch.exp(torch.arange(0, d_model, 2) * -(math.log(10000.0) / d_model)
    pe = torch.zeros(max_len, d_model)
    pe[:, 0::2] = torch.sin(position * div_term)  # 偶数维度
    pe[:, 1::2] = torch.cos(position * div_term)  # 奇数维度
    return pe  # (max_len, d_model)

2. 与输入嵌入结合：

class TransformerEmbedding(nn.Module):
    def __init__(self, vocab_size, d_model, max_len):
        super().__init__()
        self.token_embed = nn.Embedding(vocab_size, d_model)
        self.pe = nn.Parameter(sinusoidal_position_encoding(max_len, d_model), requires_grad=False)
    
    def forward(self, x):
        # x: (batch_size, seq_len)
        embeddings = self.token_embed(x)  # (batch_size, seq_len, d_model)
        seq_len = x.size(1)
        embeddings += self.pe[:seq_len, :]  # 添加位置编码
        return embeddings

3. 关键细节：
- 预计算与缓存：位置编码矩阵预先计算并注册为不训练的模型参数（`requires_grad=False`）。
- 动态长度处理：通过切片 `pe[:seq_len]` 适应不同序列长度。
- 广播机制：PyTorch自动将 `pe` 广播到批次维度。

2. 旋转位置编码（RoPE）

1）数学公式：
对词向量 \( \mathbf{x} \in \mathbb{R}^d \)，划分为 \( d/2 \) 个二维子空间，每个子空间应用旋转矩阵：
\[
R_m^{(i)} = \begin{bmatrix}
\cos(m\theta_i) & -\sin(m\theta_i) \\
\sin(m\theta_i) & \cos(m\theta_i)
\end{bmatrix}, \quad \theta_i = 10000^{-2i/d}
\]

2）PyTorch实现步骤：

1. 生成频率张量：

def get_freqs(d_model: int):
    theta = 1.0 / (10000 ** (torch.arange(0, d_model, 2) / d_model))
    return theta  # (d_model // 2,)

2. 生成旋转矩阵：

def rotate_half(x):
    # 将输入分为前后两半并旋转
    x1, x2 = x.chunk(2, dim=-1)
    return torch.cat((-x2, x1), dim=-1)

def apply_rotary_pos_emb(q, k, freqs):
    # q, k: (batch_size, seq_len, n_heads, head_dim)
    # freqs: (1, seq_len, 1, head_dim // 2)
    theta = freqs.unsqueeze(0).unsqueeze(2)  # (1, seq_len, 1, head_dim//2)
    theta = theta.to(q.device)
    
    # 构造复数形式
    q_complex = torch.view_as_complex(q.float().reshape(*q.shape[:-1], -1, 2))
    k_complex = torch.view_as_complex(k.float().reshape(*k.shape[:-1], -1, 2))
    
    # 应用旋转
    rotated_q = q_complex * torch.polar(torch.ones_like(theta), theta)
    rotated_k = k_complex * torch.polar(torch.ones_like(theta), theta)
    
    # 转换回实数形式
    rotated_q = torch.view_as_real(rotated_q).flatten(-2)
    rotated_k = torch.view_as_real(rotated_k).flatten(-2)
    return rotated_q.type_as(q), rotated_k.type_as(k)

3. 整合到注意力层：

class RotaryAttention(nn.Module):
    def __init__(self, d_model, n_heads):
        super().__init__()
        self.d_model = d_model
        self.n_heads = n_heads
        self.head_dim = d_model // n_heads
        self.freqs = get_freqs(self.head_dim)
        
        self.wq = nn.Linear(d_model, d_model)
        self.wk = nn.Linear(d_model, d_model)
        self.wv = nn.Linear(d_model, d_model)
    
    def forward(self, x, freqs):
        # x: (batch_size, seq_len, d_model)
        B, L, _ = x.shape
        q = self.wq(x).view(B, L, self.n_heads, self.head_dim)
        k = self.wk(x).view(B, L, self.n_heads, self.head_dim)
        v = self.wv(x).view(B, L, self.n_heads, self.head_dim)
        
        # 应用RoPE
        q_rot, k_rot = apply_rotary_pos_emb(q, k, freqs)
        
        # 计算注意力分数
        scores = torch.einsum('bqhd,bkhd->bhqk', q_rot, k_rot) / (self.head_dim ** 0.5)
        attn = torch.softmax(scores, dim=-1)
        out = torch.einsum('bhqk,bkhd->bqhd', attn, v).reshape(B, L, -1)
        return out

4. 关键细节：
- 复数操作优化：使用 `torch.view_as_complex` 和 `torch.polar` 简化旋转操作。
- 维度处理：将多头注意力头维度（`head_dim`）分为二维子空间，适应旋转操作。
- 频率张量缓存：预先计算频率张量 `freqs`，避免重复计算。

3. 完整模型集成

1）RoPE集成到Transformer：

class RotaryTransformer(nn.Module):
    def __init__(self, vocab_size, d_model, n_heads, max_len):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, d_model)
        self.freqs = get_freqs(d_model // n_heads)
        self.attention = RotaryAttention(d_model, n_heads)
        # 其他层（FFN、LayerNorm等）省略
    
    def forward(self, x):
        x = self.embedding(x)
        freqs = self.freqs[:x.size(1)]  # 动态截取频率
        x = self.attention(x, freqs)
        return x

2）动态位置适应：

# 在训练时根据实际序列长度调整
def get_freqs_for_seq(seq_len, freqs_base):
    return freqs_base[:seq_len]

4. 验证与测试

1）正余弦编码验证：

max_len = 50
d_model = 512
pe = sinusoidal_position_encoding(max_len, d_model)
assert pe.shape == (max_len, d_model)

2）RoPE旋转验证：

# 检查旋转后的内积是否仅依赖相对位置
q = torch.randn(1, 2, 1, 64)  # 位置1和2的查询
k = torch.randn(1, 2, 1, 64)  # 位置1和2的键
freqs = get_freqs(64 // 2)
q_rot, k_rot = apply_rotary_pos_emb(q, k, freqs)
score_same = (q_rot[0,1] @ k_rot[0,1].T).item()  # 位置1与1
score_diff = (q_rot[0,1] @ k_rot[0,0].T).item()  # 位置1与0
assert score_same != score_diff  # 确保位置敏感

5. 总结

编码类型	实现关键点
正余弦编码	预计算位置编码矩阵，动态切片适配序列长度，通过广播机制高效相加。
旋转编码（RoPE）	利用复数操作实现向量旋转，分块处理二维子空间，确保注意力分数反映相对位置。

性能优化建议：
- 缓存频率张量：避免每次前向传播重复计算。
- 混合精度训练：使用 `torch.cuda.amp` 加速RoPE中的复数运算。
- 自定义内核：对旋转操作编写CUDA内核以进一步提升效率。