L11注意力机制和Seq2seq模型

注意力机制

在“编码器—解码器（seq2seq）”⼀节⾥，解码器在各个时间步依赖相同的背景变量（context vector）来获取输⼊序列信息。当编码器为循环神经⽹络时，背景变量来⾃它最终时间步的隐藏状态。将源序列输入信息以循环单位状态编码，然后将其传递给解码器以生成目标序列。然而这种结构存在着问题，尤其是RNN机制实际中存在长程梯度消失的问题，对于较长的句子，我们很难寄希望于将输入的序列转化为定长的向量而保存所有的有效信息，所以随着所需翻译句子的长度的增加，这种结构的效果会显著下降。

与此同时，解码的目标词语可能只与原输入的部分词语有关，而并不是与所有的输入有关。例如，当把“Hello world”翻译成“Bonjour le monde”时，“Hello”映射成“Bonjour”，“world”映射成“monde”。在seq2seq模型中，解码器只能隐式地从编码器的最终状态中选择相应的信息。然而，注意力机制可以将这种选择过程显式地建模。

注意力机制框架

Attention 是一种通用的带权池化方法，输入由两部分构成：询问（query）和键值对（key-value pairs）。

ki∈Rdk,vi∈Rdvk_i \in R^ {d_k},v_i \in R ^{d_v}ki​∈Rdk​,vi​∈Rdv​

Query q∈Rdqq \in R ^{d_q}q∈Rdq​

attention layer得到输出与value的维度一致

o∈Rdvo \in R ^{d_v}o∈Rdv​

对于一个query来说，attention layer 会与每一个key计算注意力分数并进行权重的归一化，输出的向量ooo则是value的加权求和，而每个key计算的权重与value一一对应。

为了计算输出，我们首先假设有一个函数α\alphaα 用于计算query和key的相似性，然后可以计算所有的 attention scores a1,…,ana_1, \ldots, a_na1​,…,an​ by

ai=α(q,ki).
a_i = \alpha(\mathbf q, \mathbf k_i).
ai​=α(q,ki​).

我们使用 softmax函数 获得注意力权重：

b1,…,bn=softmax(a1,…,an).
b_1, \ldots, b_n = \textrm{softmax}(a_1, \ldots, a_n).
b1​,…,bn​=softmax(a1​,…,an​).

最终的输出就是value的加权求和：

o=∑i=1nbivi.
\mathbf o = \sum_{i=1}^n b_i \mathbf v_i.
o=i=1∑n​bi​vi​.

不同的attetion layer的区别在于score函数的选择，在本节的其余部分，我们将讨论两个常用的注意层 Dot-product Attention 和 Multilayer Perceptron Attention；随后我们将实现一个引入attention的seq2seq模型并在英法翻译语料上进行训练与测试。

import math
import torch
import torch.nn as nn

import os
def file_name_walk(file_dir):
    for root, dirs, files in os.walk(file_dir):
#         print("root", root)  # 当前目录路径
         print("dirs", dirs)  # 当前路径下所有子目录
         print("files", files)  # 当前路径下所有非目录子文件

file_name_walk("/home/kesci/input/fraeng6506")

dirs []
files ['_about.txt', 'fra.txt']

Softmax屏蔽

在深入研究实现之前，我们首先介绍softmax操作符的一个屏蔽操作。

def SequenceMask(X, X_len,value=-1e6):
    maxlen = X.size(1)
    #print(X.size(),torch.arange((maxlen),dtype=torch.float)[None, :],'\n',X_len[:, None] )
    mask = torch.arange((maxlen),dtype=torch.float)[None, :] >= X_len[:, None]
    #print(mask)
    X[mask]=value
    return X

def masked_softmax(X, valid_length):
    # X: 3-D tensor, valid_length: 1-D or 2-D tensor
    softmax = nn.Softmax(dim=-1)
    if valid_length is None:
        return softmax(X)
    else:
        shape = X.shape
        if valid_length.dim() == 1:
            try:
                valid_length = torch.FloatTensor(valid_length.numpy().repeat(shape[1], axis=0))#[2,2,3,3]
            except:
                valid_length = torch.FloatTensor(valid_length.cpu().numpy().repeat(shape[1], axis=0))#[2,2,3,3]
        else:
            valid_length = valid_length.reshape((-1,))
        # fill masked elements with a large negative, whose exp is 0
        X = SequenceMask(X.reshape((-1, shape[-1])), valid_length)

        return softmax(X).reshape(shape)

masked_softmax(torch.rand((2,2,4),dtype=torch.float), torch.FloatTensor([2,3]))

tensor([[[0.5423, 0.4577, 0.0000, 0.0000],
         [0.5290, 0.4710, 0.0000, 0.0000]],

        [[0.2969, 0.2966, 0.4065, 0.0000],
         [0.3607, 0.2203, 0.4190, 0.0000]]])

超出2维矩阵的乘法

XXX 和 YYY 是维度分别为(b,n,m)(b,n,m)(b,n,m) 和(b,m,k)(b, m, k)(b,m,k)的张量，进行 bbb 次二维矩阵乘法后得到 ZZZ, 维度为 (b,n,k)(b, n, k)(b,n,k)。

Z[i,:,:]=dot(X[i,:,:],Y[i,:,:])for i=1,…,n .
Z[i,:,:] = dot(X[i,:,:], Y[i,:,:])\qquad for\ i= 1,…,n\ .
Z[i,:,:]=dot(X[i,:,:],Y[i,:,:])for i=1,…,n .

torch.bmm(torch.ones((2,1,3), dtype = torch.float), torch.ones((2,3,2), dtype = torch.float))

tensor([[[3., 3.]],

        [[3., 3.]]])

点积注意力

The dot product 假设query和keys有相同的维度, 即 $\forall i, q,k_