【无标题】

注意力机制

查询（自主性提示）和键（非自主性提示） 之间的交互形成了注意力汇聚；注意力汇聚有选择性地汇聚了值（感官输入）以生成最终的输出。

根据输入的位置对输出y(i)进行加权 

K是kernel，是衡量x与x(i)之间距离的函数 

   如果一个键值x(i)越接近给定的查询x，那么分配给这个键值的对应值y(i)的注意力权重就会越大，也就是“获得了更多的注意力”

做了一个平滑的回归，导致预测的曲线过于平滑（实际上的曲线没这么平）。

好处：不需要去学，只要足够多的数据，就可以拟合。但是实际上没有这么多数据

学习一个w，来决定某一段是否平滑一点，还是不平滑一点

 拟合的较好，预测曲线和真实曲线比较靠近。坏处：会出现噪音，导致曲线出现抖动

为什么带参数模型更加不平滑？

与不带参数的注意力汇聚模型相比，带参的模型加入可学习的参数后，曲线在某些区域（权重较大的区域）的权重变得更大，权重不大的区域变得更不大。其实就是，可学习参数让注意力更集中于某一些区域

 注意力分数

将Nadaraya-Watson-Gaussian中的高斯核指数部分视为注意力评分函数（attention scoring function）， 简称评分函数（scoring function）， 然后把这个函数的输出结果输入到softmax函数中进行运算。 通过上述步骤，我们将得到与键对应的值的概率分布（即注意力权重），最后注意力汇聚的输出就是基于这些注意力权重的值的加权和。
 

query是一个向量，而不是一个值 

 在某些情况下，并非所有的值都应该被纳入到注意力汇聚中，例如为了在数据集中高效加载处理小批量数据集（每一个样本序列大小形状相同）， 某些文本序列被填充了没有意义的特殊词元。 为了仅将有意义的词元作为值来获取注意力汇聚， 指定一个有效序列长度（即词元的个数）， 以便在计算softmax时过滤掉超出指定范围的位置。

通过这种方式可以在下面的masked_softmax函数中实现这样的掩蔽softmax操作， 其中任何超出有效长度的位置（注意力attention权重分数）都被掩蔽并置为0。

import torch
import d2l.torch
import math
from torch import nn
def masked_softmax(X,valid_lens):
    """通过在最后一个轴上掩蔽元素来执行softmax操作"""
    # X:3D张量，X也即是根据query和keys计算出来的attention分数，valid_lens:1D或2D张量，表示把与填充的keys计算出来的attention分数过滤掉，设置为很小的数-1e6,过滤掉后最后再进行计算softmax,使对填充的keys的attention权重为0
    shape = X.shape
    if valid_lens is None:
        return nn.functional.softmax(X,dim=-1)
    else:
        if valid_lens.dim() == 1:
            #valid_lens如果为1维则valid_lens第一个元素表示对X中第一个样本序列所有样本的valid_lens都是相同的，都是为valid_lens第一个元素长度
            valid_lens = torch.repeat_interleave(valid_lens,shape[1])
        else:
            valid_lens = valid_lens.reshape(-1)
        # 最后一轴上被掩蔽的元素使用一个非常大的负值替换，从而其softmax输出为0
        X = d2l.torch.sequence_mask(X.reshape(-1,shape[-1]),valid_lens,value=-1e6)
        return nn.functional.softmax(X.reshape(shape),dim=-1)

选择不同的注意力评分函数会导致不同的注意力汇聚操作，下面将介绍两个流行的评分函数：加性注意力评分函数和缩放点积注意力评分函数。
 

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

key和query合并起来，两个权重w(k)和w(q)使得k和q的大小一样，并相加

当查询和键是相同长度的矢量时，可以使用点积注意力作为评分函数，计算效率更高

class AdditiveAttention(nn.Module):
    """加性注意力"""
    def __init__(self,key_size,query_size,num_hiddens,dropout):
        super(AdditiveAttention,self).__init__()
        self.W_q = nn.Linear(query_size,num_hiddens,bias=False)
        self.W_k = nn.Linear(key_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 = self.W_q(queries)
        keys = self.W_k(keys)
        # 在维度扩展后，
        # queries的形状：(batch_size，查询的个数，1，num_hidden)
        # key的形状：(batch_size，1，“键－值”对的个数，num_hiddens)
        # 使用广播方式进行求和
        features = queries.unsqueeze(2)+keys.unsqueeze(1)
        #unsqueeze()函数起升维的作用,参数表示在哪个地方加一个维度
        #在第2/1维度，加一个维度进去
        features = torch.tanh(features)
        # self.w_v仅有一个输出，因此从形状中移除最后那个维度。
        # scores的形状：(batch_size，查询的个数，“键-值”对的个数)
        scores = self.W_v(features)
        scores = scores.squeeze(-1)#最后一个维度不要
        self.attention_weights = masked_softmax(scores,valid_lens)
        # values的形状：(batch_size，“键－值”对的个数，值的维度)
        #批量矩阵乘法
        return torch.bmm(self.dropout(self.attention_weights),values)


class DotProductAttention(nn.Module):
    """缩放点积注意力"""
    def __init__(self,dropout):
        super(DotProductAttention,self).__init__()
        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):
        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)

 使用注意力机制的seq2seq

而seq2seq机制的解码器部分拿到的仅仅是编码器最后一层的参数

想要在翻译的时候，让注意力关注在原句子的对应部分

key是编码器对每个词的RNN输出

value是解码器对上一个词的解码输出，

编码器输出一串结果key（是对world这一层的隐藏状态），解码器预测了上一个词“hello”。在注意力机制中，选择key中，和“hello”相近的状态，如“world”。把“world”的这个隐藏状态给解码器解码