Transformer 源码复现杂记

让我们逐个解释这些语句的作用以及常见用法，并给出展示案例：

1. K.transpose(-1, -2)：

   • 作用：这个语句使用 PyTorch 中的 transpose() 方法对张量 K 进行转置操作。在本例中，transpose(-1, -2) 表示将张量的最后两个维度进行转置。
   • 常见用法：通常用于交换张量的维度顺序，以适应特定的计算需求。
   • 示例：

     import torch
     
     # 创建一个大小为 (2, 3, 4) 的张量
     K = torch.tensor([[[1, 2, 3, 4],
                        [5, 6, 7, 8],
                        [9, 10, 11, 12]],
                       [[13, 14, 15, 16],
                        [17, 18, 19, 20],
                        [21, 22, 23, 24]]])
     
     # 对张量进行转置操作
     K_transposed = K.transpose(-1, -2)
     
     print(K_transposed)
     1
     2
     3
     4
     5
     6
     7
     8
     9
     10
     11
     12
     13
     14

     输出结果：

     tensor([[[ 1,  5,  9],
              [ 2,  6, 10],
              [ 3,  7, 11],
              [ 4,  8, 12]],
     
             [[13, 17, 21],
              [14, 18, 22],
              [15, 19, 23],
              [16, 20, 24]]])
     1
     2
     3
     4
     5
     6
     7
     8
     9

2. masked_fill_(attn_mask, -1e9)：

   • 作用：这个语句使用 PyTorch 中的 masked_fill_() 方法，根据给定的掩码张量 attn_mask，将张量 scores 中对应位置为 True 的元素填充为指定的值（在这里是 -1e9）。
   • 常见用法：通常用于在计算过程中将指定位置的元素置为特定值，例如在注意力计算中屏蔽填充位置的影响。
   • 示例：

     import torch
     
     # 创建一个大小为 (2, 3, 3) 的 scores 张量和一个大小相同的 attn_mask 张量
     scores = torch.tensor([[[0.1, 0.2, 0.3],
                             [0.4, 0.5, 0.6],
                             [0.7, 0.8, 0.9]],
                            [[1.0, 1.1, 1.2],
                             [1.3, 1.4, 1.5],
                             [1.6, 1.7, 1.8]]])
     attn_mask = torch.tensor([[[False, False, True],
                                 [True, True, True],
                                 [False, False, False]],
                                [[False, True, False],
                                 [False, False, False],
                                 [True, True, True]]])
     
     # 对 scores 张量进行填充操作
     scores.masked_fill_(attn_mask, -1e9)
     
     print(scores)
     1
     2
     3
     4
     5
     6
     7
     8
     9
     10
     11
     12
     13
     14
     15
     16
     17
     18
     19
     20

     输出结果：

     tensor([[[ 1.0000e-01,  2.0000e-01, -1.0000e+09],
              [-1.0000e+09, -1.0000e+09, -1.0000e+09],
              [ 7.0000e-01,  8.0000e-01,  9.0000e-01]],
     
             [[ 1.0000e+00, -1.0000e+09,  1.2000e+00],
              [ 1.3000e+00,  1.4000e+00,  1.5000e+00],
              [-1.0000e+09, -1.0000e+09, -1.0000e+09]]])
     1
     2
     3
     4
     5
     6
     7

3. nn.Softmax(dim=-1)(scores)：

   • 作用：这个语句使用 PyTorch 中的 Softmax 层，对张量 scores 进行 Softmax 操作，其中 dim=-1 表示沿着张量的最后一个维度进行 Softmax 操作。
   • 常见用法：常用于将一个张量的元素转换为概率分布，Softmax 操作可以将每个元素映射到 (0, 1) 区间，并且使得所有元素的和为 1。
   • 示例：

     import torch
     import torch.nn as nn
     
     # 创建一个大小为 (2, 3) 的 scores 张量
     scores = torch.tensor([[1.0, 2.0, 3.0],
                            [4.0, 5.0, 6.0]])
     
     # 使用 nn.Softmax 对 scores 张量进行 Softmax 操作
     softmax_layer = nn.Softmax(dim=-1)
     softmax_scores = softmax_layer(scores)
     
     print(softmax_scores)
     1
     2
     3
     4
     5
     6
     7
     8
     9
     10
     11
     12

     输出结果：

     tensor([[0.0900, 0.2447, 0.6652],
             [0.0900, 0.2447, 0.6652]])
     1
     2

np.triu() 是 NumPy 中的一个函数，用于生成一个上三角矩阵或者将矩阵中除了主对角线及其以上的元素设为零。

具体来说，np.triu() 函数的作用是返回输入矩阵的上三角部分（包括主对角线），而将主对角线以下的元素设为零。

下面是 np.triu() 函数的语法：

numpy.triu(m, k=0)
1

参数说明：

• m：输入的矩阵。
• k：指定对角线的偏移量。默认值为 0，表示主对角线。正值表示主对角线以上的对角线，负值表示主对角线以下的对角线。

示例：

import numpy as np

# 创建一个 3x3 的矩阵
matrix = np.array([[1, 2, 3],
                   [4, 5, 6],
                   [7, 8, 9]])

# 生成 matrix 的上三角部分
upper_triangle = np.triu(matrix)

print(upper_triangle)
1
2
3
4
5
6
7
8
9
10
11

输出：

[[1 2 3]
 [0 5 6]
 [0 0 9]]
1
2
3

在这个示例中，np.triu(matrix) 生成了矩阵 matrix 的上三角部分，即保留了主对角线及其以上的元素，而将主对角线以下的元素设为零。