Deep learning 如果掩码接收到一批不同的句子作为输入，那么它在转换器中是如何工作的？

我目前正在研究Transformer模型的PyTorch实现，有一个问题

现在，我已经对我的模型进行了编码，以便它批量接收源和目标句子对。这些句子是使用预先制作的词汇表中各自的索引编码的。例如：

[[3,  2,  1, 23, 13, 50, 541, 0],
 [3, 24, 13,  0,  0,  0,   0, 0],
 [3, 98,  2,  4,  1,  23, 25, 4]]

其中

0

是填充索引

我的问题是，如果这些句子被分批输入，我们应该如何使用掩蔽机制。我想我之所以困惑是因为我知道面具看起来像：

[[1, 0, 0, 0],
 [1, 1, 0, 0],
 [1, 1, 1, 0],
 [1, 1, 1, 1]]

这样我们就可以强制解码器只处理下一个序列。我们是否在运行模型时将此掩码迭代应用于同一个句子？例如，如果我们使用我上面给出的第一句话：

# Iteration 1
[3, 0, 0, 0, 0, 0, 0, 0]

# Iteration 2
[3, 2, 0, 0, 0, 0, 0, 0]

.
.
.

---

因此，我们将在每个位置，每个批次中的每个句子获得一个预测？

您的解码器批次掩码是一个下三角掩码（您有），按元素排列，并使用一个pad掩码，在您的标题不是pad值的情况下，pad掩码是正确的。下面是一些用于生成此类面具的玩具代码（主要取自），并附有一个示例：

import numpy as np
import torch

def lower_triangular_mask(size):
    """
    Create a lower triangular mask
    """

    lt_mask = np.triu(np.ones((1, size, size)), k=1)
    lt_mask = torch.from_numpy(lt_mask) == 0

    return lt_mask

def create_mask(caption, pad_value):
    """
    Creates the transformer decode mask
    """

    # create pad mask
    pad_mask = (caption != pad_value).unsqueeze(-2)

    # create lower triangular mask
    size = caption.size(1)
    lt_mask = lower_triangular_mask(size)

    # return the bitwise AND of the two masks
    return pad_mask & lt_mask

if __name__ == '__main__':
    torch.manual_seed(0)

    # Here, we generate some random sequences, with an assigned pad value of 1
    pad_value = 1
    caption = torch.randint(2, 10, size=(2, 5))
    caption[0, 3] = pad_value
    caption[0, 4] = pad_value

    print(caption)

    mask = create_mask(caption, pad_value)
    print(mask.size())
    print(mask)

上面的代码返回

tensor([[6, 9, 7, 1, 1],
        [5, 5, 9, 3, 5]])
torch.Size([2, 5, 5])
tensor([[[ True, False, False, False, False],
         [ True,  True, False, False, False],
         [ True,  True,  True, False, False],
         [ True,  True,  True, False, False],
         [ True,  True,  True, False, False]],

        [[ True, False, False, False, False],
         [ True,  True, False, False, False],
         [ True,  True,  True, False, False],
         [ True,  True,  True,  True, False],
         [ True,  True,  True,  True,  True]]])

---

第一个标题比第二个标题短，导致了一个掩码，该掩码不会让转换器超过其序列的末尾。

解码器批处理掩码是一个较低的三角形掩码（您有），按元素排列，并使用一个pad掩码，如果您的标题不是pad值，则该掩码为真。下面是一些用于生成此类面具的玩具代码（主要取自），并附有一个示例：

import numpy as np
import torch

def lower_triangular_mask(size):
    """
    Create a lower triangular mask
    """

    lt_mask = np.triu(np.ones((1, size, size)), k=1)
    lt_mask = torch.from_numpy(lt_mask) == 0

    return lt_mask

def create_mask(caption, pad_value):
    """
    Creates the transformer decode mask
    """

    # create pad mask
    pad_mask = (caption != pad_value).unsqueeze(-2)

    # create lower triangular mask
    size = caption.size(1)
    lt_mask = lower_triangular_mask(size)

    # return the bitwise AND of the two masks
    return pad_mask & lt_mask

if __name__ == '__main__':
    torch.manual_seed(0)

    # Here, we generate some random sequences, with an assigned pad value of 1
    pad_value = 1
    caption = torch.randint(2, 10, size=(2, 5))
    caption[0, 3] = pad_value
    caption[0, 4] = pad_value

    print(caption)

    mask = create_mask(caption, pad_value)
    print(mask.size())
    print(mask)

上面的代码返回

tensor([[6, 9, 7, 1, 1],
        [5, 5, 9, 3, 5]])
torch.Size([2, 5, 5])
tensor([[[ True, False, False, False, False],
         [ True,  True, False, False, False],
         [ True,  True,  True, False, False],
         [ True,  True,  True, False, False],
         [ True,  True,  True, False, False]],

        [[ True, False, False, False, False],
         [ True,  True, False, False, False],
         [ True,  True,  True, False, False],
         [ True,  True,  True,  True, False],
         [ True,  True,  True,  True,  True]]])

第一个标题比第二个标题短，导致了一个掩码，该掩码不允许转换器在其序列结束后出现