Transformer为什么需要“位置编码”？

标签：编码 Transformer torch self 位置 NTK xq

Transformer为什么需要“位置编码”？

技术微佬丁师兄大模型 2024年11月20日 21:06 湖北

✅ 我是丁师兄，专注于智能驾驶大模型，持续分享LLM面试干货。

offer捷报

坐标苏州的学员，通过训练营的项目和面试辅导，拿下苏州某国企大模型offer，年薪30w+，虽然相比于互联网不高，但是在二线城市国企，也很稳定了，恭喜上岸！

Transformer的位置编码

对于序列处理模型，他的位置信息需要通过显式或者隐式的方式传入给模型。

transformer 系列模型的位置编码常用包括：包括绝对位置编码（包括静态位置编码和可学习位置编码）、相对位置编码、旋转位置编码，下面详细介绍这种位置编码的原理和优缺点。

位置编码

（1）静态位置编码

transformer 原始位置编码方式，通过正弦/余弦函数得到位置编码，为什么要使用正余弦交替出现的方式来得到位置编码呐？

公式1

主要的考虑的点如下：

每个 token 的向量是唯一值；
利用三角函数做位置编码可以保证编码的值在 [-1,1] 之间，是有界函数；
不同的位置向量是可以通过线性变化得到的，这样 token 的位置信息不仅包含了绝对位置还包含了相对位置信息；

三角函数静态编码的重要性质如下图：

class SinPositionEncoding(nn.Module):    def __init__(self, max_sequence_length, d_model, base=10000):        super().__init__()        self.max_sequence_length = max_sequence_length        self.d_model = d_model        self.base = base

    def forward(self):        pe = torch.zeros(self.max_sequence_length, self.d_model, dtype=torch.float)  # size(max_sequence_length, d_model)        exp_1 = torch.arange(self.d_model // 2, dtype=torch.float)  # 初始化一半维度，sin位置编码的维度被分为了两部分        exp_value = exp_1 / (self.d_model / 2)

        alpha = 1 / (self.base ** exp_value)  # size(dmodel/2)        out = torch.arange(self.max_sequence_length, dtype=torch.float)[:, None] @ alpha[None, :]  # size(max_sequence_length, d_model/2)        embedding_sin = torch.sin(out)        embedding_cos = torch.cos(out)

        pe[:, 0::2] = embedding_sin  # 奇数位置设置为sin        pe[:, 1::2] = embedding_cos  # 偶数位置设置为cos        return pe

SinPositionEncoding(d_model=4, max_sequence_length=10, base=10000).forward()

（2）可学习的位置编码

主要存在于 BERT、VIT 等变种系列模型，直接将位置作为可学习的参数，让模型自己学习。

class TrainablePositionEncoding(nn.Module):    def __init__(self, max_sequence_length, d_model):        super().__init__()        self.max_sequence_length = max_sequence_length        self.d_model = d_model

    def forward(self):        pe = nn.Embedding(self.max_sequence_length, self.d_model)        nn.init.constant(pe.weight, 0.)        return pe

（3）相对位置编码

相对位置编码的实现可以参考之前的文章：鹅厂面试官：Transformer为何需要位置编码？

（4）旋转位置编码

旋转位置编码（Rotary Position Embedding，RoPE）是论文 Roformer: Enhanced Transformer With Rotray Position Embedding 提出的一种能够将相对位置信息依赖集成到 self-attention 中并提升 transformer 架构性能的位置编码方式。

而目前很火的 LLaMA、GLM 模型也是采用该位置编码方式。

和相对位置编码相比，RoPE 具有更好的外推性（在训练时和预测时的输入长度不一致，导致模型的泛化能力下降的问题），目前是大模型相对位置编码中应用最广的方式之一。

对于 self- attention 中的 KQV 通过如下方式得到：

其中 qm 表示第 m 个 token 对应的词向量 xm 集成位置信息 m 之后的 query 向量。

而 kn 和 vn 则表示第 n 个 token 对应的词向量 xn 集成位置信息 n 之后的 key 和 value 向量。

对于 transformer 的位置信息是三角函数，所以函数 f 为 x_m+p_i，其中 p_i 是根据公式 1 计算得到的；

对于 BERT 等可学习位置编码，它的f函数是 x_m+p_i，其中 p_i 是模型学习得到的；

对于图例如下：

# 旋转位置编码计算def apply_rotary_emb(    xq: torch.Tensor,    xk: torch.Tensor,    freqs_cis: torch.Tensor,) -> Tuple[torch.Tensor, torch.Tensor]:    # xq.shape = [batch_size, seq_len, dim]    # xq_.shape = [batch_size, seq_len, dim // 2, 2]    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_)        # 应用旋转操作，然后将结果转回实数域    # xq_out.shape = [batch_size, seq_len, dim]    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)

class Attention(nn.Module):    def __init__(self, args: ModelArgs):        super().__init__()

        self.wq = Linear(...)        self.wk = Linear(...)        self.wv = Linear(...)                self.freqs_cis = precompute_freqs_cis(dim, max_seq_len * 2)

    def forward(self, x: torch.Tensor):        bsz, seqlen, _ = x.shape        xq, xk, xv = self.wq(x), self.wk(x), self.wv(x)

        xq = xq.view(batch_size, seq_len, dim)        xk = xk.view(batch_size, seq_len, dim)        xv = xv.view(batch_size, seq_len, dim)

        # attention 操作之前，应用旋转位置编码        xq, xk = apply_rotary_emb(xq, xk, freqs_cis=freqs_cis)                # scores.shape = (bs, seqlen, seqlen)        scores = torch.matmul(xq, xk.transpose(1, 2)) / math.sqrt(dim)        scores = F.softmax(scores.float(), dim=-1)        output = torch.matmul(scores, xv)  # (batch_size, seq_len, dim)  # ......