NLP中Mask全解

妖狐艹你老母 2022-11-27 12:15 243阅读 0赞

Mask 在NLP中是一个很常规的操作，也有多种应用的场景和形式，下面尝试从以下几个方面去全（用了夸张的修辞手法）解Mask，并尽可能地辅以图片说明和代码解释：

*  Mask的作用：
 *  处理非定长序列
    
     *  RNN中的Mask
     *  Attention中Mask
 *  防止标签泄露
    
     *  Transformer中的Mask
     *  BERT中的Mask
     *  XLNet中的Mask

#### Mask的作用 ####

对于NLP中mask的作用，先上结论：

> 1、padding mask：处理非定长序列，区分padding和非padding部分，如在RNN等模型和Attention机制中的应用等
> 
> 2、sequence mask：防止标签泄露，如：Transformer decoder中的mask矩阵，BERT中的\[Mask\]位，XLNet中的mask矩阵等

> PS：padding mask 和 sequence mask非官方命名

#### 处理非定长序列 ####

在NLP中，文本一般是不定长的，所以在进行 batch训练之前，要先进行长度的统一，过长的句子可以通过truncating 截断到固定的长度，过短的句子可以通过 padding 增加到固定的长度，但是 padding 对应的字符只是为了统一长度，并没有实际的价值，因此希望在之后的计算中屏蔽它们，这时候就需要 Mask。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nvbmd5dW5saTExMTE_size_16_color_FFFFFF_t_70_pic_center]

[图片参考][Link 1]

上图为中文场景下，一个 batch=5 的，以字为单位的输入矩阵（也可以在分词后以词为单位）和 mask 矩阵，左图已经将文本 padding 到统一长度了，右图中的1表示有效字，0代表无效字。

#### RNN中的Mask ####

对于RNN等模型，本身是可以直接处理不定长数据的，因此它不需要提前告知 sequence length，如下是pytorch下的LSTM定义：

nn.LSTM(input_size, hidden_size, *args, **kwargs)

但是在实践中，为了 batch 训练，一般会把不定长的序列 padding 到相同长度，再用 mask 去区分非 padding 部分和 padding 部分。

区分的目的是使得RNN只作用到它实际长度的句子，而不会处理无用的 padding 部分，这样RNN的输出和隐状态都会是对应句子实际的最后一位。另外，对于token级别的任务，也可以通过mask去忽略 padding 部分对应的loss。

不过，在 pytorch 中，对 mask 的具体实现形式不是mask矩阵，而是通过一个句子长度列表来实现的，但本质一样。实现如下，sentence\_lens 表示的是这个batch中每一个句子的实际长度。[参考][Link 2]

embed_input_x_packed = pack_padded_sequence(embed_input_x, sentence_lens, batch_first=True)
    encoder_outputs_packed, (h_last, c_last) = self.lstm(embed_input_x_packed)
    encoder_outputs, _ = pad_packed_sequence(encoder_outputs_packed, batch_first=True)

btw，在 pytorch 的 Embedding 和 Loss 中也有对 padding 值的设置：

# padding_idx (int, optional): If given, pads the output with the embedding vector at 
    # `padding_idx` (initialized to zeros) whenever it encounters the index.
    embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=0)
    
    # ignore_index (int, optional): Specifies a target value that is ignored
    # and does not contribute to the input gradient.
    criterion = nn.CrossEntropyLoss(ignore_index=0)

#### Attention中Mask ####

在 Attention 机制中，同样需要忽略 padding 部分的影响，这里以transformer encoder中的self-attention为例：

self-attention中，Q和K在点积之后，需要先经过mask再进行softmax，因此，对于要屏蔽的部分，mask之后的输出需要为负无穷，这样softmax之后输出才为0。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nvbmd5dW5saTExMTE_size_16_color_FFFFFF_t_70_pic_center 1]

[图片参考][Link 3]

def attention(query, key, value, mask=None, dropout=None):
        "Compute 'Scaled Dot Product Attention'"
        d_k = query.size(-1)
        scores = torch.matmul(query, key.transpose(-2, -1)) \
                 / math.sqrt(d_k)
        if mask is not None:
            scores = scores.masked_fill(mask == 0, -1e9)	# mask步骤，用 -1e9 代表负无穷
        p_attn = F.softmax(scores, dim = -1)
        if dropout is not None:
            p_attn = dropout(p_attn)
        return torch.matmul(p_attn, value), p_attn

[代码参考][Link 4]

PS：上述两个参考都是非常好的 transformer 介绍文章，参考1，图片与文字相得益彰，参考2，代码与讲解相辅相成。

#### 防止标签泄露 ####

在语言模型中，常常需要从上一个词预测下一个词，但如果要在LM中应用 self attention 或者是同时使用上下文的信息，要想不泄露要预测的标签信息，就需要 mask 来“遮盖”它。不同的mask方式，也对应了一篇篇的paper，这里选取典型的几个。

#### Transformer中的Mask ####

Transformer 是包括 Encoder和 Decoder的，Encoder中 self-attention 的 padding mask 如上，而 Decoder 还需要防止标签泄露，即在 t 时刻不能看到 t 时刻之后的信息，因此在上述 padding mask的基础上，还要加上 sequence mask。

sequence mask 一般是通过生成一个上三角矩阵来实现的，上三角区域对应要mask的部分。

在Transformer 的 Decoder中，先不考虑 padding mask，一个包括四个词的句子\[A,B,C,D\]在计算了相似度scores之后，得到下面第一幅图，将scores的上三角区域mask掉，即替换为负无穷，再做softmax得到第三幅图。这样，比如输入 B 在self-attention之后，也只和A，B有关，而与后序信息无关。

因为在softmax之后的加权平均中: B‘ = 0.48\*A+0.52\*B，而 C，D 对 B’不做贡献。

![在这里插入图片描述][2020081515190284.PNG_pic_center]

[图片参考][Link 5]

实际应用中，Decoder 需要结合 padding mask 和 sequence mask，下面在pytorch框架下以一个很简化的例子展示 Transformer 中 的两种 Mask。

import torch
    
    def padding_mask(seq, pad_idx):
        return (seq != pad_idx).unsqueeze(-2)   # [B, 1, L]
    
    def sequence_mask(seq):
        batch_size, seq_len = seq.size()
        mask = 1- torch.triu(torch.ones((seq_len, seq_len), dtype=torch.uint8),diagonal=1)
        mask = mask.unsqueeze(0).expand(batch_size, -1, -1)  # [B, L, L]
        return mask
    
    def test():
        # 以最简化的形式测试Transformer的两种mask
        seq = torch.LongTensor([[1,2,0]])	# batch_size=1, seq_len=3，padding_idx=0
        embedding = torch.nn.Embedding(num_embeddings=3, embedding_dim=10, padding_idx=0)
        query, key = embedding(seq), embedding(seq)
        scores = torch.matmul(query, key.transpose(-2, -1))
    
        mask_p = padding_mask(seq, 0)
        mask_s = sequence_mask(seq)
        mask_decoder = mask_p & mask_s	# 结合 padding mask 和 sequence mask
    
        scores_encoder = scores.masked_fill(mask_p==0, -1e9) # 对于scores，在mask==0的位置填充
        scores_decoder = scores.masked_fill(mask_decoder==0, -1e9)
    
    test()

对应的各mask值为：

# mask_p
    [[[1 1 0]]]
    # mask_s
    [[[1 0 0]
      [1 1 0]
      [1 1 1]]]
    # mask_decoder
    [[[1 0 0]
      [1 1 0]
      [1 1 0]]]

可以看到 mask\_decoder 的第三列为0 ，对应padding mask，上三角为0，对应sequence mask。

#### BERT中的Mask ####

BERT实际上是Transformer的Encoder，为了在语言模型的训练中，使用上下文信息又不泄露标签信息，采用了Masked LM，简单来说就是随机的选择序列的部分token用 \[Mask\] 标记代替。

这波Mask操作，思想很直接，实现很简单，效果很惊人。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nvbmd5dW5saTExMTE_size_16_color_FFFFFF_t_70_pic_center 2]

BERT之后，也有不少在Mask的范围和形式上做文章的，比如：ERNIE，但大同小异，不多赘述。

而XLNet的Mask操作非常的巧(nan)妙(dong)，如下。

#### XLNet中的Mask ####

XLNet通过**Permutation Language Modeling**实现了不在输入中加\[Mask\]，同样可以利用上下文信息，关键的操作就是下面所示的 Attention Mask 机制。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nvbmd5dW5saTExMTE_size_16_color_FFFFFF_t_70_pic_center 3]

但并不是那么好理解，要理解XLNet中的Mask，一定要先看张俊林老师的：[XLNet:运行机制及和Bert的异同比较][XLNet_Bert]，再来看下面的内容。上图也是引自该文，这里再引用一句我认为非常关键的一段话：

> 在Transformer内部，通过Attention掩码，从X的输入单词里面，也就是Ti的上文和下文单词中，随机选择i-1个，放到Ti的上文位置中，把其它单词的输入通过Attention掩码隐藏掉，于是就能够达成我们期望的目标（当然这个所谓放到Ti的上文位置，只是一种形象的说法，其实在内部，就是通过Attention Mask，把其它没有被选到的单词Mask掉，不让它们在预测单词Ti的时候发生作用，如此而已。看着就类似于把这些被选中的单词放到了上文Context\_before的位置了）

对于排列序列：3->2->4->1，通过 Attention Mask，在 self-attention 的加权平均计算中，以上图中的 E 2 ′ E\_\{2^\{'\}\} E2′ 为例：

self-attention 计算之后Content stream中的 $ E\_\{2^\{’\}\}= a\_\{2\} E\_2 + a\_\{3\} E\_3 ， 其 中 ，其中 ，其中E\_2$ 表示第2个词对应的向量，其他同理。这样在$ E\_\{2^\{’\}\} 中 就 看 到 了 它 的 下 文 中就看到了它的下文 中就看到了它的下文E\_3 ， 就 好 像 是 把 ，就好像是把 ，就好像是把E\_3$放到了它的上文位置一样，但实际顺序并没有改变。

对序列进行排列的目的是为了生成这个 Attention Mask，再加上双流注意力去解决预测歧义的问题，可以说就是Permutation Language Modeling 的全部了。

到这里，就是本文全部的Mask，但这肯定不是NLP中Mask的全部，但希望能帮助你去更好地理解Mask。

听说，喜欢这篇文章的人一般还喜欢：

[超细节的BERT/Transformer知识点][BERT_Transformer]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nvbmd5dW5saTExMTE_size_16_color_FFFFFF_t_70_pic_center]: /images/20221124/29faf4484d0a4505b53d5220b466421a.png
[Link 1]: https://www.cnblogs.com/neopenx/p/4806006.html
[Link 2]: https://zhuanlan.zhihu.com/p/34418001
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nvbmd5dW5saTExMTE_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221124/589e759569e542398592c6521cbd39fd.png
[Link 3]: https://jalammar.github.io/illustrated-transformer/
[Link 4]: http://nlp.seas.harvard.edu/2018/04/03/attention.html#attention
[2020081515190284.PNG_pic_center]: /images/20221124/cfaffd79cce4408093cad11670eebe8e.png
[Link 5]: https://baijiahao.baidu.com/s?id=1652093322137148754&wfr=spider&for=pc
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nvbmd5dW5saTExMTE_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221124/6bfd1b21b1604481b234ce85fcdcfb2d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nvbmd5dW5saTExMTE_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221124/b6fe1c93d6174f29badd0c7a1f381c70.png
[XLNet_Bert]: https://zhuanlan.zhihu.com/p/70257427
[BERT_Transformer]: https://zhuanlan.zhihu.com/p/132554155