一、说明

三、基本实现

 

        要了解这些独特的位置编码向量如何与嵌入向量一起工作，最好使用嵌入层文章中的示例。

        此实现将直接基于上一篇文章中的实现构建。下面的输出嵌入了三个序列，d_model为 4。

# set the output to 2 decimal places without scientific notation
torch.set_printoptions(precision=2, sci_mode=False)# tokenize the sequences
tokenized_sequences = [tokenize(seq) for seq in sequences]# index the sequences 
indexed_sequences = [[stoi[word] for word in seq] for seq in tokenized_sequences]# convert the sequences to a tensor
tensor_sequences = torch.tensor(indexed_sequences).long()# vocab size
vocab_size = len(stoi)# embedding dimensions
d_model = 4# create the embeddings
lut = nn.Embedding(vocab_size, d_model) # look-up table (lut)# embed the sequence
embeddings = lut(tensor_sequences)embeddings

tensor([[[-0.27, -0.82,  0.33,  1.39],[ 1.72, -0.63, -1.13,  0.10],[-0.23, -0.07, -0.28,  1.17],[ 0.61,  1.46,  1.21,  0.84],[-2.05,  1.77,  1.51, -0.21],[ 0.86, -1.81,  0.55,  0.98]],[[ 0.06, -0.34,  2.08, -1.24],[ 1.44, -0.64,  0.78, -1.10],[ 1.78,  1.22,  1.12, -2.35],[-0.48, -0.40,  1.73,  0.54],[ 1.28, -0.18,  0.52,  2.10],[ 0.34,  0.62, -0.45, -0.64]],[[-0.22, -0.66, -1.00, -0.04],[-0.23, -0.07, -0.28,  1.17],[ 1.44, -0.64,  0.78, -1.10],[ 1.78,  1.22,  1.12, -2.35],[-0.48, -0.40,  1.73,  0.54],[ 0.70, -1.35,  0.15, -1.44]]], grad_fn=<EmbeddingBackward0>)

        下一步是通过位置编码对每个序列中每个单词的位置进行编码。下面的函数遵循上面的定义。唯一值得一提的变化是 L 被标记为max_length。它通常设置为千中的极大值，以确保几乎每个序列都可以正确编码。这确保了相同的位置编码矩阵可以用于不同长度的序列。在添加之前可以将其切成适当的长度。

def gen_pe(max_length, d_model, n):# generate an empty matrix for the positional encodings (pe)pe = np.zeros(max_length*d_model).reshape(max_length, d_model) # for each positionfor k in np.arange(max_length):# for each dimensionfor i in np.arange(d_model//2):# calculate the internal value for sin and costheta = k / (n ** ((2*i)/d_model))       # even dims: sin   pe[k, 2*i] = math.sin(theta) # odd dims: cos               pe[k, 2*i+1] = math.cos(theta)return pe# maximum sequence length
max_length = 10
n = 100
encodings = gen_pe(max_length, d_model, n)

        编码的输出包含 10 个位置编码向量。

array([[ 0.    ,  1.    ,  0.    ,  1.    ],[ 0.8415,  0.5403,  0.0998,  0.995 ],[ 0.9093, -0.4161,  0.1987,  0.9801],[ 0.1411, -0.99  ,  0.2955,  0.9553],[-0.7568, -0.6536,  0.3894,  0.9211],[-0.9589,  0.2837,  0.4794,  0.8776],[-0.2794,  0.9602,  0.5646,  0.8253],[ 0.657 ,  0.7539,  0.6442,  0.7648],[ 0.9894, -0.1455,  0.7174,  0.6967],[ 0.4121, -0.9111,  0.7833,  0.6216]])

        如前所述，max_length设置为 10。虽然这超出了要求，但它确保如果另一个序列的长度为 7、8、9 或 10，则可以使用相同的位置编码矩阵。它只需要被切成适当的长度。下面，嵌入的seq_length为 <>，因此可以相应地对编码进行切片。

# select the first six tokens
seq_length = embeddings.shape[1]
encodings[:seq_length]

tensor([[ 0.00,  1.00,  0.00,  1.00],[ 0.84,  0.54,  0.10,  1.00],[ 0.91, -0.42,  0.20,  0.98],[ 0.14, -0.99,  0.30,  0.96],[-0.76, -0.65,  0.39,  0.92],[-0.96,  0.28,  0.48,  0.88]])

        由于所有三个序列的序列长度相同，因此只需要一个位置编码矩阵，并且可以使用 PyTorch 在所有三个序列上广播。此示例中的嵌入批处理的形状为 （3， 6， 4），位置编码在切片为 （10， 4） 之前形状为 （6， 4）。然后广播该矩阵以创建图像中看到的（3，6，4）编码矩阵。有关广播的更多信息，请阅读广播简单简介。

        这允许添加两个矩阵而不会出现任何问题。

embedded_sequence + encodings[:seq_length] # encodings[:6]

将位置编码添加到嵌入时，输出与部分开头的图像相同。

tensor([[[-0.27,  0.18,  0.33,  2.39],[ 2.57, -0.09, -1.03,  1.09],[ 0.68, -0.49, -0.08,  2.15],[ 0.75,  0.47,  1.50,  1.80],[-2.80,  1.12,  1.90,  0.71],[-0.10, -1.53,  1.03,  1.86]],[[ 0.06,  0.66,  2.08, -0.24],[ 2.28, -0.10,  0.88, -0.10],[ 2.69,  0.80,  1.32, -1.37],[-0.34, -1.39,  2.03,  1.50],[ 0.52, -0.83,  0.91,  3.02],[-0.62,  0.90,  0.03,  0.23]],[[-0.22,  0.34, -1.00,  0.96],[ 0.61,  0.47, -0.18,  2.16],[ 2.35, -1.06,  0.98, -0.12],[ 1.92,  0.23,  1.41, -1.40],[-1.24, -1.06,  2.12,  1.46],[-0.26, -1.06,  0.63, -0.56]]], grad_fn=<AddBackward0>)

        此输出将传递到模型的下一层，即下一篇文章将介绍的多头注意力。

        但是，由于此基本实现使用嵌套循环，因此效率不高，尤其是在使用较大的 d_model 和 max_length 值时。相反，可以使用更以 PyTorch 为中心的方法。

四、修改 PyTorch 的位置编码公式

        图片来源：Chili Math

        为了利用 PyTorch 的功能，需要使用对数规则修改原始方程，特别是除数。

        除数为：

        为了修改除数，通过取其指数将 n 带入分子中。然后，使用规则 7 将整个方程提高为 e 的指数。然后，使用规则 3 将指数拉出日志。然后简化以获得结果。

        这很重要，因为它可用于一次生成位置编码的所有除数。下面很明显，4 维嵌入只需要两个除数，因为除数每 2i 才会变化一次，其中 i 是维度。这在每个位置重复：

        由于只有 i 可以设置为的最大数字d_model除以 2，因此可以计算一次项：

d_model = 4
n = 100div_term = torch.exp(torch.arange(0, d_model, 2) * -(math.log(n) / d_model))

        这个简短的代码片段可用于生成所需的所有除数。对于此示例，d_model设置为 4，n 设置为 100。输出是两个除数：

tensor([1.0000, 0.1000])

        从这里，可以利用 PyTorch 的索引功能，用几行代码创建整个位置编码矩阵。下一步是生成从 k 到 L-1 的每个位置。

max_length = 10# generate the positions into a column matrix
k = torch.arange(0, max_length).unsqueeze(1)      

tensor([[0],[1],[2],[3],[4],[5],[6],[7],[8],[9]])

        使用位置和除数，可以轻松计算正弦和余弦函数的内部。

        通过将 k 和 div_term相乘，可以计算每个位置的输入。PyTorch 将自动广播矩阵以允许乘法。请注意，这是 Hadamard 乘积而不是矩阵乘法，因为相应的元素将相互乘法：

 

k*div_term

        此计算的输出可以在上图中看到。剩下要做的就是将输入插入 cos 和 sin 函数，并将它们适当地保存在矩阵中。

        这可以通过创建适当大小的空矩阵来开始：

# generate an empty tensor
pe = torch.zeros(max_length, d_model)

tensor([[0., 0., 0., 0.],[0., 0., 0., 0.],[0., 0., 0., 0.],[0., 0., 0., 0.],[0., 0., 0., 0.],[0., 0., 0., 0.],[0., 0., 0., 0.],[0., 0., 0., 0.],[0., 0., 0., 0.],[0., 0., 0., 0.]])

        现在，偶数列是罪恶的，可以用 pe[：， 0：：2] 选择。这告诉 PyTorch 选择每一行和每一列偶数列。对于奇数列也可以这样做，它们是 cos： pe[：， 1：：2]。再一次，这告诉 PyTorch 选择每一行和每一奇数列。由于 k*div_term 的结果中存储了所有必要的输入，因此可用于计算每个奇数和偶数列。

# set the odd values (columns 1 and 3)
pe[:, 0::2] = torch.sin(k * div_term)# set the even values (columns 2 and 4)
pe[:, 1::2] = torch.cos(k * div_term)# add a dimension for broadcasting across sequences: optional       
pe = pe.unsqueeze(0)  

tensor([[[ 0.00,  1.00,  0.00,  1.00],[ 0.84,  0.54,  0.10,  1.00],[ 0.91, -0.42,  0.20,  0.98],[ 0.14, -0.99,  0.30,  0.96],[-0.76, -0.65,  0.39,  0.92],[-0.96,  0.28,  0.48,  0.88],[-0.28,  0.96,  0.56,  0.83],[ 0.66,  0.75,  0.64,  0.76],[ 0.99, -0.15,  0.72,  0.70],[ 0.41, -0.91,  0.78,  0.62]]])

        这些值与使用嵌套的 for 循环获取的值相同。回顾一下，以下是所有代码：

max_length = 10
d_model = 4
n = 100def gen_pe(max_length, d_model, n):# calculate the div_termdiv_term = torch.exp(torch.arange(0, d_model, 2) * -(math.log(n) / d_model))# generate the positions into a column matrixk = torch.arange(0, max_length).unsqueeze(1)# generate an empty tensorpe = torch.zeros(max_length, d_model)# set the even valuespe[:, 0::2] = torch.sin(k * div_term)# set the odd valuespe[:, 1::2] = torch.cos(k * div_term)# add a dimension       pe = pe.unsqueeze(0)        # the output has a shape of (1, max_length, d_model)return pe                           gen_pe(max_length, d_model, n)  

虽然它更复杂，但这是 PyTorch 使用的实现，因为它增强了机器学习的性能。

五、变压器中的位置编码

        现在所有的艰苦工作都已经完成，实施很简单。它源自注释转换器和PyTorch。请注意，n 的默认值为 10，000，默认max_length为 5，000。

        此实现还包含 dropout，它以给定的概率 p 随机清零其输入的某些元素。这有助于正则化并防止神经元共同适应（过度依赖彼此）。输出也按¹⁄₍₁_p₎的系数进行缩放。而不是在本文中深入讨论它。有关详细信息，请参阅有关辍学层的文章。在转向变压器模型的其余部分之前，最好现在就熟悉它，因为它几乎位于其他每一层中。

class PositionalEncoding(nn.Module):def __init__(self, d_model: int, dropout: float = 0.1, max_length: int = 5000):"""Args:d_model:      dimension of embeddingsdropout:      randomly zeroes-out some of the inputmax_length:   max sequence length"""# inherit from Modulesuper().__init__()     # initialize dropout                  self.dropout = nn.Dropout(p=dropout)      # create tensor of 0spe = torch.zeros(max_length, d_model)    # create position column   k = torch.arange(0, max_length).unsqueeze(1)  # calc divisor for positional encoding div_term = torch.exp(                                 torch.arange(0, d_model, 2) * -(math.log(10000.0) / d_model))# calc sine on even indicespe[:, 0::2] = torch.sin(k * div_term)    # calc cosine on odd indices   pe[:, 1::2] = torch.cos(k * div_term)  # add dimension     pe = pe.unsqueeze(0)          # buffers are saved in state_dict but not trained by the optimizer                        self.register_buffer("pe", pe)                        def forward(self, x: Tensor):"""Args:x:        embeddings (batch_size, seq_length, d_model)Returns:embeddings + positional encodings (batch_size, seq_length, d_model)"""# add positional encoding to the embeddingsx = x + self.pe[:, : x.size(1)].requires_grad_(False) # perform dropoutreturn self.dropout(x)

        前向传递

        要执行正向传递，可以使用与之前相同的嵌入式序列。

embeddings

tensor([[[-0.27, -0.82,  0.33,  1.39],[ 1.72, -0.63, -1.13,  0.10],[-0.23, -0.07, -0.28,  1.17],[ 0.61,  1.46,  1.21,  0.84],[-2.05,  1.77,  1.51, -0.21],[ 0.86, -1.81,  0.55,  0.98]],[[ 0.06, -0.34,  2.08, -1.24],[ 1.44, -0.64,  0.78, -1.10],[ 1.78,  1.22,  1.12, -2.35],[-0.48, -0.40,  1.73,  0.54],[ 1.28, -0.18,  0.52,  2.10],[ 0.34,  0.62, -0.45, -0.64]],[[-0.22, -0.66, -1.00, -0.04],[-0.23, -0.07, -0.28,  1.17],[ 1.44, -0.64,  0.78, -1.10],[ 1.78,  1.22,  1.12, -2.35],[-0.48, -0.40,  1.73,  0.54],[ 0.70, -1.35,  0.15, -1.44]]], grad_fn=<EmbeddingBackward0>)

        嵌入序列后，可以创建位置编码矩阵。dropout 设置为 0.0 以便轻松查看嵌入和位置编码之间的相加。这些值与从头开始实现不同，因为 n 的默认值为 10，000 而不是 100。

d_model = 4
max_length = 10
dropout = 0.0# create the positional encoding matrix
pe = PositionalEncoding(d_model, dropout, max_length)# preview the values
pe.state_dict()

OrderedDict([('pe',tensor([[[ 0.00,  1.00,  0.00,  1.00],[ 0.84,  0.54,  0.01,  1.00],[ 0.91, -0.42,  0.02,  1.00],[ 0.14, -0.99,  0.03,  1.00],[-0.76, -0.65,  0.04,  1.00],[-0.96,  0.28,  0.05,  1.00],[-0.28,  0.96,  0.06,  1.00],[ 0.66,  0.75,  0.07,  1.00],[ 0.99, -0.15,  0.08,  1.00],[ 0.41, -0.91,  0.09,  1.00]]]))])

        在添加它们之前，序列的形状为 （batch_size、seq_length、d_model），即 （3， 6， 4）。位置编码在切片和广播后具有相同的大小，因此前向传递的输出大小为 （batch_size、seq_length、d_model），仍然是 （3， 6， 4）。这表示嵌入在 3 维空间中的 6 个序列，每个序列 4 个令牌，带有位置编码以指示它们在序列中的位置。

pe(embeddings)

 tensor([[[-0.27,  0.18,  0.33,  2.39],[ 2.57, -0.09, -1.12,  1.10],[ 0.68, -0.49, -0.26,  2.17],[ 0.75,  0.47,  1.24,  1.84],[-2.80,  1.12,  1.55,  0.79],[-0.10, -1.53,  0.60,  1.98]],[[ 0.06,  0.66,  2.08, -0.24],[ 2.28, -0.10,  0.79, -0.10],[ 2.69,  0.80,  1.14, -1.35],[-0.34, -1.39,  1.76,  1.54],[ 0.52, -0.83,  0.56,  3.10],[-0.62,  0.90, -0.40,  0.35]],[[-0.22,  0.34, -1.00,  0.96],[ 0.61,  0.47, -0.27,  2.17],[ 2.35, -1.06,  0.80, -0.10],[ 1.92,  0.23,  1.15, -1.35],[-1.24, -1.06,  1.77,  1.54],[-0.26, -1.06,  0.20, -0.44]]], grad_fn=<AddBackward0>)

本系列的下一篇文章是多头注意力层。

请不要忘记点赞和关注更多！:)

引用

1. 辍学层
2. 位置编码概述
3. PyTorch 的位置编码实现
4. 带注释的变压器
5. 变压器的位置编码

附录

可视化位置编码的唯一性

在得出结论之前，验证位置编码的唯一性并了解它们如何与更大的序列一起工作将是有益的。

使用 matplotlib，可以轻松地将向量相互比较。

def visualize_pe(max_length, d_model, n):plt.imshow(gen_pe(max_length, d_model, n), aspect="auto")plt.title("Positional Encoding")plt.xlabel("Encoding Dimension")plt.ylabel("Position Index")# set the tick marks for the axesif d_model < 10:plt.xticks(torch.arange(0, d_model))if max_length < 20:plt.yticks(torch.arange(max_length-1, -1, -1))plt.colorbar()plt.show()# plot the encodings
max_length = 10
d_model = 4
n = 100visualize_pe(max_length, d_model, n)

 

        每行表示一个位置编码向量，每列表示与嵌入组合时将添加到的相应维度。

        这也可以在较大的值 n、d_model 和 max_length 中看到：

# plot the encodings
max_length = 1000
d_model = 512
n = 10000visualize_pe(max_length, d_model, n)

参考资源：Positional Encoding. This article is the second in The… | by Hunter Phillips | Medium