注意力分数

一、注意力分数（拓展到高纬度）

1、使用高斯核来对查询和键之间的关系建模，其中高斯核指数部分可以视为注意力评分函数（attention scoring function）， 简称评分函数（scoring function）

2、有一个查询 𝑞∈𝑅^𝑞和 𝑚个“键－值”对 (𝑘_1,𝑣_1),…,(𝑘_𝑚,𝑣_𝑚)， 其中𝑘_𝑖∈𝑅^𝑘，𝑣_𝑖∈𝑅^𝑣。 注意力汇聚函数𝑓就被表示成值的加权和

3、评分函数的输出结果输入到softmax函数中进行运算得到与键对应的值的概率分布（即注意力权重）。

4、注意力汇聚的输出就是基于这些注意力权重的值的加权和。

二、掩蔽softmax操作

1、softmax操作用于输出一个概率分布作为注意力权重。 在某些情况下，并非所有的值都应该被纳入到注意力汇聚中。

2、将有意义的词元作为值来获取注意力汇聚， 可以指定一个有效序列长度（即词元的个数）， 以便在计算softmax时过滤掉超出指定范围的位置。

#@save
def masked_softmax(X, valid_lens):
    """通过在最后一个轴上掩蔽元素来执行softmax操作"""
    # X:3D张量，valid_lens:1D或2D张量
    if valid_lens is None:
        return nn.functional.softmax(X, dim=-1)
    else:
        shape = X.shape
        if valid_lens.dim() == 1:
            valid_lens = torch.repeat_interleave(valid_lens, shape[1])
        else:
            valid_lens = valid_lens.reshape(-1)
        # 最后一轴上被掩蔽的元素使用一个非常大的负值替换，从而其softmax输出为0
        X = d2l.sequence_mask(X.reshape(-1, shape[-1]), valid_lens,
                              value=-1e6)
        return nn.functional.softmax(X.reshape(shape), dim=-1)

三、加性注意力

1、当查询和键是不同长度的矢量时，可以使用加性注意力作为评分函数。

2、 给定查询𝑞∈𝑅^𝑞和 键𝑘∈𝑅^𝑘， 加性注意力（additive attention）的评分函数为

（将长为k的key和长为q的query丢到对应的W中，输出长为h，再乘v，输出长就为1了）

3、可学习的参数是𝑊^𝑞∈𝑅^ℎ×𝑞、 𝑊^𝑘∈𝑅^ℎ×𝑘和 𝑤^𝑣∈𝑅^ℎ。

4、 将查询和键连结起来后输入到一个多层感知机（MLP）中， 感知机包含一个隐藏层，其隐藏单元数是一个超参数ℎ。

5、通过使用tanh作为激活函数，并且禁用偏置项

#@save
class AdditiveAttention(nn.Module):
    """加性注意力"""
    def __init__(self, key_size, query_size, num_hiddens, dropout, **kwargs):
        super(AdditiveAttention, self).__init__(**kwargs)
        self.W_k = nn.Linear(key_size, num_hiddens, bias=False)
        self.W_q = nn.Linear(query_size, num_hiddens, bias=False)
        self.w_v = nn.Linear(num_hiddens, 1, bias=False)
        self.dropout = nn.Dropout(dropout)

    def forward(self, queries, keys, values, valid_lens):
        queries, keys = self.W_q(queries), self.W_k(keys)
        # 在维度扩展后，
        # queries的形状：(batch_size，查询的个数，1，num_hidden)
        # key的形状：(batch_size，1，“键－值”对的个数，num_hiddens)
        # 使用广播方式进行求和
        features = queries.unsqueeze(2) + keys.unsqueeze(1)
        features = torch.tanh(features)
        # self.w_v仅有一个输出，因此从形状中移除最后那个维度。
        # scores的形状：(batch_size，查询的个数，“键-值”对的个数)
        scores = self.w_v(features).squeeze(-1)
        #第i行就是第i个query对应的权重，对每一行的权重做softmax
        self.attention_weights = masked_softmax(scores, valid_lens)
        # values的形状：(batch_size，“键－值”对的个数，值的维度)
        return torch.bmm(self.dropout(self.attention_weights), values)

四、缩放点积注意力

1、使用点积可以得到计算效率更高的评分函数， 但是点积操作要求查询和键具有相同的长度𝑑。

2、为确保无论向量长度如何， 点积的方差在不考虑向量长度的情况下仍然是1， 我们再将点积除以𝑑， 则缩放点积注意力（scaled dot-product attention）评分函数为

3、向量化版本

使用暂退法进行模型正则化

#@save
class DotProductAttention(nn.Module):
    """缩放点积注意力"""
    def __init__(self, dropout, **kwargs):
        super(DotProductAttention, self).__init__(**kwargs)
        self.dropout = nn.Dropout(dropout)

    # queries的形状：(batch_size，查询的个数，d)
    # keys的形状：(batch_size，“键－值”对的个数，d)
    # values的形状：(batch_size，“键－值”对的个数，值的维度)
    # valid_lens的形状:(batch_size，)或者(batch_size，查询的个数)
    def forward(self, queries, keys, values, valid_lens=None):
        d = queries.shape[-1]
        # 设置transpose_b=True为了交换keys的最后两个维度
        scores = torch.bmm(queries, keys.transpose(1,2)) / math.sqrt(d)
        self.attention_weights = masked_softmax(scores, valid_lens)
        return torch.bmm(self.dropout(self.attention_weights), values)

五、总结

1、将注意力汇聚的输出计算可以作为值的加权平均，选择不同的注意力评分函数会带来不同的注意力汇聚操作。

2、当查询和键是不同长度的矢量时，可以使用可加性注意力评分函数。当它们的长度相同时，使用缩放的“点－积”注意力评分函数的计算效率更高。