从Embedding到RoPE：图解Transformer位置编码的进化之路

从Embedding到RoPE：图解Transformer位置编码的进化之路

如果你曾经尝试过用Transformer模型处理一段文本或一张图片，可能会好奇模型是如何“记住”词语或图像块之间的顺序关系的。毕竟，Transformer的核心注意力机制本身是“排列不变”的——打乱输入序列的顺序，模型计算出的注意力权重可能不会发生本质变化。这就像把一本书的页码全部打乱，你还能理解故事的连贯性吗？位置编码，就是那个为Transformer模型注入“顺序感”的关键角色。

从最初的简单加法，到如今在LLaMA、ChatGLM等大模型中大放异彩的旋转位置编码（RoPE），这条技术演进路径背后，是研究者们对模型如何更优雅、更高效地理解序列中元素相对关系的持续探索。对于跨足NLP和CV领域的学习者来说，理解位置编码的演变，不仅是掌握Transformer架构的必修课，更是洞察模型设计哲学的一扇窗。本文将带你深入这条进化之路，通过可视化的对比和PyTorch底层的实现剖析，揭示不同位置编码方式的数学本质及其对模型能力的深刻影响。

1. 位置编码的基石：为何序列顺序如此重要？

在深入各类编码技术之前，我们首先要建立一个清晰的认知：为什么Transformer需要位置编码？想象一下自注意力机制的计算过程。对于输入序列中的每个元素（在NLP中是词元，在CV中是图像块），模型会计算一个查询向量（Query）、一个键向量（Key）和一个值向量（Value）。注意力权重的核心是查询向量与所有键向量的点积。如果没有任何位置信息，那么“我喜欢猫”和“猫喜欢我”这两个句子，在模型看来，其内部词元之间的关联度可能是一样的，因为“我”和“猫”的词嵌入向量是固定的，它们的点积与顺序无关。

注意：位置编码的核心目标，是打破这种排列不变性，让模型能够感知到“我”在“猫”之前，与“猫”在“我”之前，代表了完全不同的语义。

早期的Transformer论文《Attention Is All You Need》提出了一种正弦/余弦绝对位置编码。它的思想非常直观：为序列中的每个绝对位置（第1个、第2个……第n个）分配一个独一无二的、固定模式的向量，然后把这个向量加到对应的词嵌入向量上。这个编码向量由不同频率的正弦和余弦函数生成：

import torch
import math

def sinusoidal_position_encoding(max_len, d_model):
    """
    生成正弦位置编码矩阵。
    Args:
        max_len: 最大序列长度
        d_model: 模型隐藏层维度
    Returns:
        pe: 位置编码矩阵，形状为 [max_len, d_model]
    """
    pe = torch.zeros(max_len, d_model)
    position = torch.arange(0, max_len).unsqueeze(1)  # [max_len, 1]
    div_term = torch.exp(torch.arange(0, d_model, 2) * -(math.log(10000.0) / d_model))  # [d_model/2]
    pe[:, 0::2] = torch.sin(position * div_term)  # 偶数维度用sin
    pe[:, 1::2] = torch.cos(position * div_term)  # 奇数维度用cos
    return pe  # [max_len, d_model]

这种编码方式有几个有趣的性质：

• 确定性：无需训练，可以预先计算好。
• 周期性：不同频率的波形组合，使得模型能够学习到相对位置关系（理论上，一个位置编码可以被表示为另一个位置编码的线性函数）。
• 外推性有限：模型在训练时如果只见过长度为512的序列，那么对于长度超过512的序列，其位置编码是全新的，模型可能无法很好地泛化。

在视觉Transformer（ViT）中，位置编码的应用需要一些调整。图像被分割成一系列不重叠的块（Patch），每个块被展平并线性投影为一个向量。这些图像块在二维空间中有其固有的（x, y）坐标。一种常见的做法是将二维坐标映射为一维索引（例如，按行优先顺序），然后应用上述一维正弦编码。另一种更贴合图像特性的方法是使用二维正弦编码，分别为行坐标和列坐标生成编码，然后拼接或相加。

编码类型	核心思想	优点	缺点	典型应用
正弦绝对位置编码	为每个绝对位置生成固定模式向量，与词嵌入相加。	实现简单，无需训练，能捕捉一定相对关系。	外推性差，无法直接建模精确的相对位置依赖。	原始Transformer, 早期ViT
可学习绝对位置编码	将位置编码作为可训练参数，与模型一同优化。	更灵活，能自适应数据。	需要额外参数，外推性更差（完全没见过的新位置）。	BERT, GPT系列早期版本
相对位置编码	在注意力计算中直接注入成对元素间的相对位置偏置。	直接建模相对关系，理论泛化性更好。	计算和存储开销较大，实现复杂。	Transformer-XL, T5

绝对位置编码就像一个给每个座位贴了固定编号的剧院，模型知道每个词坐在几号位，但需要自己推断两个座位之间的距离。而相对位置编码则直接告诉模型：“这两个词之间相隔了三个座位”。接下来我们要介绍的RoPE，则巧妙地找到了一种用“绝对座位号”来表达“相对距离”的优雅方法。

2. 相对位置编码的困境与RoPE的破局思路

绝对位置编码的加法操作，相当于给每个词元一个固定的“位置身份证”。然而，在自注意力机制中，我们真正关心的是查询（Query）和键（Key）之间的相对位置关系。研究者们开始思考：能否设计一种编码方式，使得在计算Q和K的内积时，自然地涌现出它们的相对位置信息？

这就是相对位置编码的出发点。典型的方法如Transformer-XL中，会在注意力分数上直接加一个可学习的偏置项 B_{i-j}，这个偏置只与两个位置的距离 i-j 有关。然而，这类方法往往需要预设一个最大相对距离，并且增加了模型的参数量和计算图的复杂度。

RoPE（Rotary Position Embedding，旋转位置编码）的提出，提供了一种截然不同且极其优雅的解决方案。它的核心洞见可以概括为一句话：通过旋转矩阵对Query和Key向量进行变换，使得变换后的向量点积结果仅依赖于原始向量和它们的相对位置差。

让我们用一个简化的二维例子来直观理解。假设我们有一个二维的词嵌入向量 q。在RoPE中，我们不是给它加一个位置向量，而是用一个旋转矩阵对它进行变换。对于位置 m，旋转角度是 mθ。这个旋转操作保持了向量的模长（长度）不变，只改变了它的方向。

import torch

def rotate_vector_2d(vec, angle):
    """在二维平面上旋转一个向量。"""
    cos_val = torch.cos(angle)
    sin_val = torch.sin(angle)
    # 二维旋转矩阵
    rot_matrix = torch.tensor([[cos_val, -sin_val],
                               [sin_val, cos_val]], device=vec.device)
    return torch.matmul(rot_matrix, vec)

# 示例：词嵌入向量q在位置m和位置n的旋转
q = torch.tensor([1.0, 0.5])  # 原始查询向量
theta = 0.1  # 旋转基频
m, n = 3, 7  # 两个位置

q_rotated_m = rotate_vector_2d(q, m * theta)  # 位置m的旋转后向量
q_rotated_n = rotate_vector_2d(q, n * theta)  # 位置n的旋转后向量

# 计算点积
dot_product = torch.dot(q_rotated_m, q_rotated_n)
print(f"旋转后向量在位置{m}和{n}的点积: {dot_product:.4f}")

这个二维旋转的妙处在于，两个经过不同角度旋转的向量，其点积结果只取决于它们原始向量的点积以及旋转角度的差值 (m-n)θ。这正是我们想要的相对位置信息！RoPE将这一几何直觉推广到了高维空间。在高维中，旋转操作被分解到多个二维子平面上独立进行，每个子平面有自己的旋转频率 θ_i。

那么，RoPE是如何在注意力机制中具体实现的呢？它并不修改原始的输入嵌入，而是在计算得到Query和Key向量之后，对它们分别应用与各自位置相关的旋转变换，然后再进行点积计算注意力分数。这个过程是乘性的（旋转），而非加性的（添加位置向量）。

3. 深入RoPE的数学原理与高效实现

理解了旋转的直观概念后，我们来看看RoPE的严格数学形式。对于位置 m 的查询向量 q_m 和位置 n 的键向量 k_n，RoPE定义变换函数 f 为：

f(q, m) = R_Θ,m * q f(k, n) = R_Θ,n * k

其中 R_Θ,m 是一个分块对角矩阵，每个2x2子块对应一个二维旋转：

R_Θ,m = diag(
    [ [cos(mθ_0), -sin(mθ_0)],
      [sin(mθ_0),  cos(mθ_0)] ],
    [ [cos(mθ_1), -sin(mθ_1)],
      [sin(mθ_1),  cos(mθ_1)] ],
    ... )

旋转基频 θ_i 通常设置为 θ_i = 10000^(-2i/d)，其中 d 是向量的维度，i 是维度索引。这个设置继承了正弦位置编码的频率衰减特性，使得不同维度关注不同距离的位置关系。

经过这样的变换后，注意力分数计算变为： <f(q, m), f(k, n)> = q^T * R_Θ,m^T * R_Θ,n * k = q^T * R_Θ,(n-m) * k

关键等式 R_Θ,m^T * R_Θ,n = R_Θ,(n-m) 成立是因为旋转矩阵是正交矩阵，且旋转角度相加。最终，点积结果显式地依赖于相对位置 (n-m)，完美实现了我们的设计目标。

在实际代码实现中，直接构造庞大的旋转矩阵进行乘法效率低下。RoPE可以利用其分块对角和二维旋转的特性，进行高效的向量化计算。主流实现（如LLaMA、ChatGLM）通常采用复数乘法的视角，或者更直接地，对Query和Key向量的元素进行两两分组，执行如下操作：

def apply_rope_naive(q, k, freqs_cis):
    """
    一个简化的RoPE应用示例（非最优实现，用于理解）。
    q, k: [batch, seq_len, num_heads, head_dim]
    freqs_cis: 预计算的复数旋转因子，形状复杂，通常为 [seq_len, head_dim//2]
    """
    batch, seq_len, num_heads, head_dim = q.shape
    # 将q和k的最后一维重塑为 [..., head_dim//2, 2]，视为复数 (实部, 虚部)
    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))
    
    # 应用旋转（复数乘法）
    # freqs_cis 需要广播到合适的形状，例如 [1, seq_len, 1, head_dim//2]
    q_rotated = q_complex * freqs_cis
    k_rotated = k_complex * freqs_cis
    
    # 转回实数表示
    q_out = torch.view_as_real(q_rotated).flatten(-2)
    k_out = torch.view_as_real(k_rotated).flatten(-2)
    
    return q_out.type_as(q), k_out.type_as(k)

更高效且常见的实现方式是利用三角函数公式，避免显式的复数转换：

def apply_rope_efficient(x, freqs_cos, freqs_sin):
    """
    更高效的RoPE实现（常见于开源代码）。
    x: 输入张量，可以是q或k，形状为 [..., dim]
    freqs_cos, freqs_sin: 预计算的cos和sin值，形状与x的对应部分匹配
    """
    # 将x的最后一维拆成两部分 (x1, x2)
    x1, x2 = x[..., 0::2], x[..., 1::2] # 取出所有偶数位和奇数位
    # 旋转操作: [x1 * cos - x2 * sin, x1 * sin + x2 * cos]
    rotated = torch.cat([x1 * freqs_cos - x2 * freqs_sin,
                         x1 * freqs_sin + x2 * freqs_cos], dim=-1)
    return rotated

这里，freqs_cos 和 freqs_sin 是根据位置和频率 θ_i 预先计算好的。torch.nn.functional.embedding 在这个预计算过程中扮演了关键角色。虽然RoPE的核心计算不直接用它，但在一些需要根据位置索引查找预计算编码的实现中，这个高效的查找表函数非常有用。它的作用是从一个大的编码矩阵中，根据位置索引快速取出对应的行向量。

import torch.nn.functional as F

# 假设我们预计算了所有可能位置（例如0-2047）的旋转角度的cos值，形状为 [max_seq_len, dim]
precomputed_cos = torch.randn(2048, 768)
# 对于一个批次的位置索引，例如 [0, 5, 12, 100]
position_ids = torch.tensor([0, 5, 12, 100])
# 高效地取出对应位置的cos向量
cos_embeddings = F.embedding(position_ids, precomputed_cos)  # 形状 [4, 768]

4. 可视化对比：不同编码如何塑造注意力图？

理论阐述和代码实现或许还有些抽象，让我们通过可视化的注意力热力图，来直观感受不同位置编码方式对模型“关注模式”的影响。我们构建一个简单的实验：使用一个单头注意力层，输入一个固定的、无意义的特征序列，然后观察在不同位置编码下，模型计算出的注意力权重矩阵。

我们对比三种情况：

1. 无位置编码：注意力权重完全对称，模型无法区分顺序。
2. 正弦绝对位置编码（加法）：注意力图会呈现出一定的带状或对角线模式，但对角线附近的权重衰减模式可能不够灵活。
3. RoPE（旋转位置编码）：注意力图能清晰地展现出对相对位置的敏感性，通常在对角线附近有最强的响应，并随着相对距离的增大呈现平滑的衰减，这种衰减模式由旋转频率 θ_i 控制。

提示：在实际的Transformer模型中，由于还有可学习的权重矩阵，注意力图会更加复杂。但位置编码决定了这种位置相关性的“底色”。

下面的伪代码展示了如何生成这样的对比图：

import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np

def visualize_attention_with_encoding(encoding_type='rope'):
    """
    模拟并可视化不同位置编码下的注意力热力图。
    """
    seq_len = 20
    d_model = 64
    num_heads = 1
    head_dim = d_model // num_heads
    
    # 生成随机查询和键向量（模拟经过线性投影后）
    q = torch.randn(1, seq_len, num_heads, head_dim)  # [batch, seq, heads, dim]
    k = torch.randn(1, seq_len, num_heads, head_dim)
    
    if encoding_type == 'none':
        q_encoded, k_encoded = q, k
        title = "No Positional Encoding"
    elif encoding_type == 'sinusoidal':
        # 生成正弦编码并加到q, k上（简化，实际应加在输入嵌入后）
        pe = sinusoidal_position_encoding(seq_len, head_dim).unsqueeze(0).unsqueeze(2) # [1, seq, 1, dim]
        q_encoded = q + pe
        k_encoded = k + pe
        title = "Sinusoidal (Absolute) Encoding"
    elif encoding_type == 'rope':
        # 应用RoPE
        freqs_cis = precompute_freqs_cis(head_dim, seq_len)  # 预计算旋转因子
        # 这里需要将freqs_cis广播到q,k的形状，并应用apply_rope_efficient
        q_encoded = apply_rope_efficient(q, freqs_cos, freqs_sin)
        k_encoded = apply_rope_efficient(k, freqs_cos, freqs_sin)
        title = "RoPE (Rotary Position Encoding)"
    
    # 计算注意力分数 (缩放点积)
    scores = torch.matmul(q_encoded, k_encoded.transpose(-2, -1)) / (head_dim ** 0.5) # [1, seq, seq]
    attn_weights = torch.softmax(scores, dim=-1).squeeze().detach().numpy()
    
    # 绘图
    plt.figure(figsize=(8, 6))
    sns.heatmap(attn_weights, cmap='viridis', square=True, cbar_kws={'label': 'Attention Weight'})
    plt.xlabel('Key Position')
    plt.ylabel('Query Position')
    plt.title(f'Attention Heatmap - {title}')
    plt.tight_layout()
    plt.show()

# 分别生成三种情况的可视化
# visualize_attention_with_encoding('none')
# visualize_attention_with_encoding('sinusoidal')
# visualize_attention_with_encoding('rope')

通过对比热力图，你可以清晰地看到RoPE如何引导模型形成一种更符合直觉的注意力模式：对于某个查询位置，它更关注邻近的键位置，并且这种关注度随着距离平滑下降。而正弦编码也可能产生类似模式，但RoPE因其乘性交互和明确的相对位置建模，往往能产生更清晰、更稳定的远程衰减特性。

5. RoPE在视觉Transformer（ViT）中的二维扩展

在自然语言处理中，序列是一维的。但在计算机视觉中，当我们将图像分割成块并展平为序列时，我们丢失了关键的二维空间结构信息。原始的ViT使用一维位置编码，只是简单地为每个图像块分配一个顺序编号（例如，从左到右、从上到下）。这虽然有效，但未能充分利用二维邻域关系。

RoPE可以自然地扩展到二维情况，为视觉Transformer提供更精确的空间位置感知。核心思想很简单：分别对行坐标和列坐标应用旋转编码。假设一个图像块在二维网格中的坐标为 (y, x)，其对应的查询或键向量 z（维度为 d）可以被分成两部分：z = [z_y, z_x]，其中 z_y 和 z_x 各占 d/2 维。然后，我们使用 y 坐标对 z_y 部分应用RoPE，使用 x 坐标对 z_x 部分应用RoPE。

class RoPE2D(nn.Module):
    """二维旋转位置编码"""
    def __init__(self, dim, freq=10000.0):
        super().__init__()
        assert dim % 2 == 0, "维度必须是偶数以便分割为行和列部分"
        self.half_dim = dim // 2
        # 为行和列部分分别创建旋转编码器（共享或独立的频率均可）
        # 这里简化为共享频率基，实际也可为行、列设置不同的base
        self.rope_y = RotaryEmbedding1D(self.half_dim, freq)
        self.rope_x = RotaryEmbedding1D(self.half_dim, freq)
    
    def forward(self, tokens, positions):
        """
        tokens: [batch, num_patches, num_heads, dim] 或 [batch, num_heads, num_patches, dim]
        positions: [batch, num_patches, 2]  (y, x) 坐标
        """
        batch, num_patches, num_heads, dim = tokens.shape
        # 分割特征为行部分和列部分
        tokens_y, tokens_x = torch.chunk(tokens, 2, dim=-1)  # 各 [..., half_dim]
        
        # 获取坐标
        pos_y = positions[..., 0].long()  # 行索引 [batch, num_patches]
        pos_x = positions[..., 1].long()  # 列索引
        
        # 应用一维RoPE
        tokens_y_encoded = self.rope_y(tokens_y, pos_y)
        tokens_x_encoded = self.rope_x(tokens_x, pos_x)
        
        # 合并
        encoded_tokens = torch.cat([tokens_y_encoded, tokens_x_encoded], dim=-1)
        return encoded_tokens

这种二维RoPE（RoPE-2D）让模型能够明确感知到图像块在垂直和水平方向上的相对距离。例如，一个位于 (2,3) 的块与 (2,5) 的块在列方向上距离为2，与 (4,3) 的块在行方向上距离为2。这对于需要理解空间布局的任务（如目标检测、分割）尤为重要。

在实际的ViT模型中集成RoPE-2D，通常意味着修改注意力模块。在计算Query和Key之后，不是直接使用，而是先通过一个像上面 RoPE2D 这样的层进行位置编码，然后再计算点积。

class AttentionWithRoPE2D(nn.Module):
    def __init__(self, dim, num_heads, rope_freq=10000.0):
        super().__init__()
        self.num_heads = num_heads
        self.head_dim = dim // num_heads
        self.scale = self.head_dim ** -0.5
        
        self.qkv = nn.Linear(dim, dim * 3)  # 生成q, k, v
        self.proj = nn.Linear(dim, dim)
        
        # 初始化二维RoPE
        self.rope = RoPE2D(self.head_dim, freq=rope_freq)
        
    def forward(self, x, positions_2d):
        B, N, C = x.shape  # N是图像块数量
        qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, self.head_dim).permute(2, 0, 3, 1, 4)
        q, k, v = qkv[0], qkv[1], qkv[2]  # [B, num_heads, N, head_dim]
        
        # 应用二维RoPE到q和k
        q = self.rope(q, positions_2d)
        k = self.rope(k, positions_2d)
        
        # 计算注意力
        attn = (q @ k.transpose(-2, -1)) * self.scale
        attn = attn.softmax(dim=-1)
        
        out = (attn @ v).transpose(1, 2).reshape(B, N, C)
        out = self.proj(out)
        return out

我在一些涉及图像生成的实验项目中尝试过RoPE-2D。与标准的一维位置编码相比，一个明显的感受是模型在生成具有规则几何结构（如建筑、对称物体）的图像时，轮廓和线条的连贯性更好。这很可能是因为二维旋转编码更精准地建模了图像块之间的空间邻接关系，让自注意力机制能更好地在二维平面上“巡游”。

6. RoPE的优势、局限与实战选择

经过前面的剖析，RoPE的优势已经非常清晰：

• 显式相对位置建模：其设计保证了注意力分数只依赖于相对位置，这是其理论上的优雅之处。
• 良好的外推性：由于旋转操作的周期性，模型在一定程度上能够处理比训练序列更长的输入。虽然绝对旋转角度会一直增加，但点积的周期性使得模型对稍长的序列仍有泛化能力。当然，极长的外推仍需专门技术（如NTK-aware缩放、YaRN等）来优化。
• 线性注意力兼容性：RoPE是乘性的，可以与线性注意力（Linear Attention）等高效变体结合，只需对旋转后的Q和K应用线性化核函数即可。
• 无需额外参数：旋转矩阵由确定的公式生成，不增加模型可训练参数量（尽管有些实现允许频率参数可学习）。

然而，RoPE也并非银弹，有其适用的场景和局限：

• 计算开销：虽然实现高效，但相比无位置编码或简单的加法编码，RoPE仍会带来额外的计算量，尤其是在序列很长或头数很多时。
• 对预训练长度的依赖：虽然外推性较好，但最优性能通常还是在接近训练长度的范围内。对于远超训练长度的输入，注意力分数可能会因为旋转角过大而出现退化。
• 在Decoder-only模型中的单向性：在GPT这类仅使用解码器的自回归模型中，需要结合因果掩码（Causal Mask）使用RoPE，确保当前位置不能“看到”未来的位置。

那么，在实际项目中该如何选择位置编码呢？这里有一些经验性的建议：

• 从头开始训练大型语言模型：RoPE是目前的主流和推荐选择。其在长上下文建模、外推性和性能上的综合表现最佳，被LLaMA、GLM、PaLM等众多顶尖模型采用。
• 训练视觉Transformer（ViT）：对于图像分类等任务，标准的可学习一维位置编码或二维正弦编码通常已足够。如果任务对空间关系极度敏感（如密集预测、图像生成），可以尝试RoPE-2D，但要注意其实现复杂性和计算成本。
• 微调现有模型：遵循基础模型的选择。如果基座模型用了RoPE（如LLaMA），微调时自然沿用。
• 资源受限或序列极短：简单的绝对位置编码（正弦或可学习）可能更轻量、更易实现。
• 需要极长上下文（>100K tokens）：可能需要结合RoPE与专门的外推技术（如NTK-aware、YaRN、PI等）来动态调整旋转频率。

在PyTorch中集成RoPE时，一个常见的“坑”是数据类型和广播问题。确保预计算的旋转因子 freqs_cis 与输入张量 q、k 在设备（CPU/GPU）和数据类型（float16/bfloat16/float32）上保持一致。混合精度训练时，通常将 freqs_cis 计算为float32，然后在应用时转换为与激活值相同的精度。

# 预计算时使用float32保证精度
freqs = 1.0 / (base ** (torch.arange(0, dim, 2, dtype=torch.float32) / dim))
t = torch.arange(max_seq_len, dtype=torch.float32)
freqs = torch.outer(t, freqs)  # [max_seq_len, dim//2]
freqs_cis = torch.polar(torch.ones_like(freqs), freqs)  # 复数形式

# 在前向传播时，根据输入x的数据类型进行转换
def apply_rotary_emb(xq, xk, freqs_cis):
    xq_ = xq.float().reshape(*xq.shape[:-1], -1, 2)
    xk_ = xk.float().reshape(*xk.shape[:-1], -1, 2)
    xq_ = torch.view_as_complex(xq_)
    xk_ = torch.view_as_complex(xk_)
    
    # 将freqs_cis调整为与xq_相同的设备和数据类型（仅取所需长度）
    freqs_cis = freqs_cis[: xq_.size(-3), :].to(xq_)  # 调整形状并转换设备/类型
    
    xq_out = torch.view_as_real(xq_ * freqs_cis).flatten(-2)
    xk_out = torch.view_as_real(xk_ * freqs_cis).flatten(-2)
    return xq_out.type_as(xq), xk_out.type_as(xk)

位置编码从最初的简单相加，发展到如今RoPE的巧妙旋转，体现了深度学习领域对模型归纳偏置（Inductive Bias）的深入思考和精妙设计。理解RoPE，不仅仅是学会使用一个工具，更是学习一种如何将几何直觉、数学性质和计算效率融合到神经网络设计中的思维方式。下次当你看到LLaMA或ChatGLM的代码时，不妨多花点时间琢磨一下其中那段关于旋转位置编码的实现，它可能是整个模型能够流畅理解长文本对话的一个关键齿轮。