Attention机制理解

attention背景

在seq2seq结构下，encoder-decoder模型中，模型首先将输入序列encode到固定长度的向量$h$中，然后在decoder中将$h$解码为输出序列。如下图所示：

在这种结构中，输入序列的信息被压缩到了向量$h$中，模型根据$h$和当前时刻的输出确定下一个时刻的输出。

随着序列长度的增加，当序列长度很长时，这种信息压缩方式会造成序列中较早时刻输入的信息损失。因此，为了解决这一问题，attnetion机制被引入到RNN中。

此外，我们在处理自然语言，希望在decoder的不同时刻，能将attention放在encoder的不同时刻的输入上。如翻译"今天天气真好"–“It’s a nice day today”，在输出"It’s a nice day"后，我们希望将attetion放在“今天”这个词汇上，完成翻译，而attention机制很好的实现了这一点。

attention模型

本文重点介绍两种attention机制，即Bahdanau Attention和Luong Attention

Bahdanau Attention

Bahdanau 提出一种基于encoder-decoder架构的attention机制。

论文地址：https://arxiv.org/pdf/1409.0473.pdf

模型架构如下：

原理如下：
首先定义输出条件概率如下：
$$p(y_i|y_1,...,y_{i-1},\mathbf{x})=g(y_{i-1},s_i,c_i)$$
其中，$s_i$为decoder中$i$时刻的隐状态，计算公式如下：
$$s_i=f(s_{i-1},y_{i-1},c_i)$$
$c_i$为$i$时刻的上下文向量，计算公式如下：
1，首先计算decoder当中第$i$个位置与encoder中第$j$个位置的匹配度：
$$e_{ij}=a(s_{i-1},h_j)$$
2，其次将$e_{ij}$进行softmax归一化，映射到概率空间，得到encoder每个位置的权重
$${\alpha }_{ij}=\frac{exp(e_{ij})}{{\sum }_{k=1}^{T_x}exp(e_{ik})}$$
3，然后，对encoder中每个位置的隐向量加权求和，得到$c_i$
$$c_i=\sum _{j=1}^{T_x}{\alpha }_{ij}{h}_j$$

在得到上下文向量$c_i$之后，将其与$i-1$时刻的输出$y_{i-1}$在embedding上（改变embedding维度的大小）拼接后，输入到decoder的RNN单元，得到$i$时刻的隐状态$s_i$，进一步得到输出$o_i$
$$o_i=softmax(W_{vocab}{s}_i)$$

Luong Attention

Bahdanau Attention根据$i-1$时刻的隐向量$s_{i-1}$计算$i$时刻的上下文$c_i$。Luong 提出了一种新的注意力计算方式，根据当前时刻的隐向量$s_i$计算$c_i$

论文地址：https://arxiv.org/pdf/1508.04025.pdf

Luong Attention模型架构如下

Luong Attention没有改变经典encoder-decoder结构计算$s_i$的方式，而是在得到隐状态$s_i$后进一步计算attention，进而得到attention之后的输出。具体计算公式如下：

1，首先得到$i$时刻decode的隐状态：
$$s_i=f(s_{i-1},y_{i-1})$$
2，根据$s_i$计算与encoder中第$j$个位置的匹配度：
$$e_{ij}=a(s_i,h_j)$$
3，将$e_{ij}$进行softmax归一化，映射到概率空间，得到encoder每个位置的权重
$${\alpha }_{ij}=\frac{exp(e_{ij})}{{\sum }_{k=1}^{T_x}exp(e_{ik})}$$
4，对encoder中每个位置的隐向量加权求和，得到$c_i$
$$c_i=\sum _{j=1}^{T_x}{\alpha }_{ij}{h}_j$$
5，由$s_i$和$c_i$得到加入了attention机制的隐状态${\tilde{s}}_i$，拼接（改变hidden维度大小）-变换-激活
$${\tilde{s}}_i=tanh(Wc[s_i,c_i])$$
6，根据${\tilde{s}}_i$计算输出
$$o_i=softmax(W_{vocab}{\tilde{s}}_i)$$

总结以上两种attention机制，主要区别为：Bahdanau Attention根据$i-1$时刻的隐状态计算$i$时刻的注意力；Luong Attention则根据$i$时刻的隐状态计算$i$时刻的注意力

Self Attention

前面两种attention机制都是基于encoder-decoder模型，计算不同时刻decoder输出与encoder之间的关系，即target与source之间的关系。

self-attention机制基于transformer模型，计算不同位置词向量之间的关系
。。。。待完善

attention实现

class BahdanauAttention(nn.Module):
    def __init__(self, encode_hidden_size, decode_hidden_size):
        super().__init__()
        self.W = nn.Linear(decode_hidden_size+2*encode_hidden_size, decode_hidden_size)
        self.V = nn.Linear(decode_hidden_size, 1)

    def forward(self, query, values, mask):
        # query:[1, batch, dec]
        # values:[batch, seq_enc, 2*enc]
        query = query.permute(1, 0, 2).expand(-1, values.size(1), -1)
        mask = torch.unsqueeze(mask, -1)
        score = self.V(torch.tanh(self.W(torch.cat((query, values), dim=-1)))) #[batch, seq_enc, 1]
        masked_score = score.data.masked_fill(~mask, -1e6)
        attention_weights = torch.softmax(masked_score, dim=1)
        context_vector = torch.sum(attention_weights*values, dim=1, keepdim=True)

        return context_vector


class Decoder(nn.Module):
    def __init__(self, embedding_dim, decode_hidden_size, vocab_size):
        super().__init__()
        self.attention = BahdanauAttention(decode_hidden_size, decode_hidden_size)
        self.gru = nn.GRU(embedding_dim+2*decode_hidden_size, decode_hidden_size, bidirectional=False, batch_first=True)
        self.out = nn.Linear(decode_hidden_size, vocab_size)
        # self.drop = nn.Dropout()

    def forward(self, inputs, decode_hidden_state, encode_output, mask):
        # inputs:[batch, 1, emb]
        # decode_hidden_state:[1, batch, dec]
        attention_vector = self.attention(decode_hidden_state, encode_output, mask) #[batch, 1, enc]
        inputs = torch.cat((inputs, attention_vector), dim=-1) #[batch, 1, emb+enc]
        decode_output, decode_hidden_state = self.gru(inputs, decode_hidden_state) #[batch, 1, dec] | [1, batch, dec]
        decode_output = self.out(decode_output) #[batch, 1, vocab]

        return decode_output, decode_hidden_state

class LuongAttention(nn.Module):
    def __init__(self, encode_hidden_size, decode_hidden_size):
        super().__init__()
        self.W = nn.Linear(decode_hidden_size+2*encode_hidden_size, decode_hidden_size)
        self.V = nn.Linear(decode_hidden_size, 1)

    def forward(self, query, values, mask):
        # query:[1, batch, dec]
        # values:[batch, seq_enc, 2*enc]
        query = query.permute(1, 0, 2).expand(-1, values.size(1), -1)
        mask = torch.unsqueeze(mask, -1)
        score = self.V(torch.tanh(self.W(torch.cat((query, values), dim=-1)))) #[batch, seq_enc, 1]
        masked_score = score.data.masked_fill(~mask, -1e6)
        attention_weights = torch.softmax(masked_score, dim=1)
        context_vector = torch.sum(attention_weights*values, dim=1, keepdim=True)

        return context_vector


class Decoder(nn.Module):
    def __init__(self, embedding_dim, decode_hidden_size, vocab_size):
        super().__init__()
        self.attention = LuongAttention(decode_hidden_size, decode_hidden_size)
        self.gru = nn.GRU(embedding_dim, decode_hidden_size, bidirectional=False, batch_first=True)
        self.fc = nn.Linear(3*decode_hidden_size, decode_hidden_size)
        self.out = nn.Linear(decode_hidden_size, vocab_size)
        # self.drop = nn.Dropout()

    def forward(self, inputs, decode_hidden_state, encode_output, mask):
        # inputs:[batch, 1, emb]
        # decode_hidden_state:[1, batch, dec]
        decode_output, decode_hidden_state = self.gru(inputs, decode_hidden_state) #[batch, 1, dec] | [1, batch, dec]
        attention_vector = self.attention(decode_hidden_state, encode_output, mask)  # [batch, 1, enc]
        decode_output = torch.tanh(self.fc(torch.cat((decode_output, attention_vector), dim=-1)))
        decode_output = self.out(decode_output) #[batch, 1, vocab]

        return decode_output, decode_hidden_state