• 注意力评分函数 - Attention Scoring Function


    注意力评分函数

    注意力汇聚小结中,我们使用高斯核来对查询和键之间的关系建模。我们可以将其中的

    f ( x ) = ∑ i = 1 n α ( x , x i ) y i = ∑ i = 1 n exp ⁡ ( − 1 2 ( x − x i ) 2 ) ∑ j = 1 n exp ⁡ ( − 1 2 ( x − x j ) 2 ) y i = ∑ i = 1 n s o f t m a x ( − 1 2 ( x − x i ) 2 ) y i .

    f(x)=i=1nα(x,xi)yi=i=1nexp(12(xxi)2)j=1nexp(12(xxj)2)yi=i=1nsoftmax(12(xxi)2)yi." role="presentation" style="position: relative;">f(x)=i=1nα(x,xi)yi=i=1nexp(12(xxi)2)j=1nexp(12(xxj)2)yi=i=1nsoftmax(12(xxi)2)yi.
    f(x)=i=1nα(x,xi)yi=i=1nj=1nexp(21(xxj)2)exp(21(xxi)2)yi=i=1nsoftmax(21(xxi)2)yi.

    高斯核指数部分, α ( x , x i ) \alpha(x, x_i) α(x,xi) 部分即为注意力评分函数(attention scoring function),简称评分函数(scoring function),然后把这个函数的输出结果输入到softmax函数中进行运算。通过上述步骤,我们将得到与键对应的值的概率分布(即注意力权重)。最后,注意力汇聚的输出就是基于这些注意力权重的值的加权和。

    从宏观来看,我们可以使用上述算法来实现注意力机制框架。下图说明了如何将注意力汇聚的输出计算成为值的加权和,其中 a a a 表示注意力评分函数。由于注意力权重是概率分布,因此加权和其本质上是加权平均值。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rdEoM62A-1666829250800)(attachment:QQ%E6%88%AA%E5%9B%BE20221026180658.png)]

    用数学语言描述,假设有一个查询 q ∈ R q \mathbf{q} \in \mathbb{R}^q qRq m m m个“键-值”对 ( k 1 , v 1 ) , … , ( k m , v m ) (\mathbf{k}_1, \mathbf{v}_1), \ldots, (\mathbf{k}_m, \mathbf{v}_m) (k1,v1),,(km,vm),其中 k i ∈ R k \mathbf{k}_i \in \mathbb{R}^k kiRk v i ∈ R v \mathbf{v}_i \in \mathbb{R}^v viRv。注意力汇聚函数 f f f就被表示成值的加权和:

    f ( q , ( k 1 , v 1 ) , … , ( k m , v m ) ) = ∑ i = 1 m α ( q , k i ) v i ∈ R v , f(\mathbf{q}, (\mathbf{k}_1, \mathbf{v}_1), \ldots, (\mathbf{k}_m, \mathbf{v}_m)) = \sum_{i=1}^m \alpha(\mathbf{q}, \mathbf{k}_i) \mathbf{v}_i \in \mathbb{R}^v, f(q,(k1,v1),,(km,vm))=i=1mα(q,ki)viRv,

    其中查询 q \mathbf{q} q和键 k i \mathbf{k}_i ki的注意力权重(标量)是通过注意力评分函数 a a a 将两个向量映射成标量,再经过softmax运算得到的:

    α ( q , k i ) = s o f t m a x ( a ( q , k i ) ) = exp ⁡ ( a ( q , k i ) ) ∑ j = 1 m exp ⁡ ( a ( q , k j ) ) ∈ R . \alpha(\mathbf{q}, \mathbf{k}_i) = \mathrm{softmax}(a(\mathbf{q}, \mathbf{k}_i)) = \frac{\exp(a(\mathbf{q}, \mathbf{k}_i))}{\sum_{j=1}^m \exp(a(\mathbf{q}, \mathbf{k}_j))} \in \mathbb{R}. α(q,ki)=softmax(a(q,ki))=j=1mexp(a(q,kj))exp(a(q,ki))R.

    正如我们所看到的,选择不同的注意力评分函数 a a a 会导致不同的注意力汇聚操作。接下来我们将介绍两个流行的评分函数,稍后将用他们来实现更复杂的注意力机制。

    import math
    import torch
    from torch import nn
    from d2l import torch as d2l
    
    • 1
    • 2
    • 3
    • 4

    掩蔽softmax操作

    正如上面提到的,softmax操作用于输出一个概率分布作为注意力权重。在某些情况下,并非所有的值都应该被纳入到注意力汇聚中。例如,为了高效处理小批量数据集,某些文本序列被填充了没有意义的特殊词元。为了仅将有意义的词元作为值来获取注意力汇聚,我们可以指定一个有效序列长度(即词元的个数),以便在计算softmax时过滤掉超出指定范围的位置。通过这种方式,我们可以在下面的 masked_softmax 函数中,实现这样的掩蔽softmax操作(masked softmax operation),其中任何超出有效长度的位置都被掩蔽并置为0。

    #@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:
                #一维数据,代表对每个列表作切分,即会复制shape[1]个valid_len
                valid_lens = torch.repeat_interleave(valid_lens, shape[1])
            else:
                #二维数据,代表对每个样本作切分,则直接展开valid_len进行切分
                valid_lens = valid_lens.reshape(-1)
            # 最后一轴上被掩蔽的元素使用一个非常大的负值替换,从而其softmax输出为0
            X = d2l.sequence_mask(X.reshape(-1, shape[-1]), valid_lens,
                                  value=-1e6)
            #返回softmax后的X
            return nn.functional.softmax(X.reshape(shape), dim=-1)
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    为了演示此函数是如何工作的,考虑由两个 2 × 4 2 \times 4 2×4 矩阵表示的样本,这两个样本的有效长度分别为 2 2 2 3 3 3。经过掩蔽softmax操作,超出有效长度的值都被掩蔽为0。

    masked_softmax(torch.rand(2, 2, 4), torch.tensor([[2, 3], [2, 3]]))
    
    • 1
    tensor([[[0.4789, 0.5211, 0.0000, 0.0000],
             [0.3361, 0.4192, 0.2447, 0.0000]],
    
            [[0.3115, 0.6885, 0.0000, 0.0000],
             [0.4593, 0.2615, 0.2792, 0.0000]]])
    
    • 1
    • 2
    • 3
    • 4
    • 5

    同样,我们也可以使用二维张量,为矩阵样本中的每一行指定有效长度。

    masked_softmax(torch.rand(2, 2, 4), torch.tensor([[1, 3], [2, 4]]))
    
    • 1
    tensor([[[1.0000, 0.0000, 0.0000, 0.0000],
             [0.3849, 0.2983, 0.3168, 0.0000]],
    
            [[0.4788, 0.5212, 0.0000, 0.0000],
             [0.2977, 0.3028, 0.1474, 0.2521]]])
    
    • 1
    • 2
    • 3
    • 4
    • 5

    加性注意力

    一般来说,当查询和键是不同长度的矢量时,我们可以使用加性注意力作为**评分函数。**给定查询 q ∈ R q \mathbf{q} \in \mathbb{R}^q qRq和键 k ∈ R k \mathbf{k} \in \mathbb{R}^k kRk,加性注意力(additive attention)的评分函数为

    a ( q , k ) = w v ⊤ tanh ( W q q + W k k ) ∈ R , a(\mathbf q, \mathbf k) = \mathbf w_v^\top \text{tanh}(\mathbf W_q\mathbf q + \mathbf W_k \mathbf k) \in \mathbb{R}, a(q,k)=wvtanh(Wqq+Wkk)R,

    其中可学习的参数是 W q ∈ R h × q \mathbf W_q\in\mathbb R^{h\times q} WqRh×q W k ∈ R h × k \mathbf W_k\in\mathbb R^{h\times k} WkRh×k w v ∈ R h \mathbf w_v\in\mathbb R^{h} wvRh。如上式所示,将查询和键连结起来后输入到一个多层感知机(MLP) 中,感知机包含一个隐藏层,其隐藏单元数是一个超参数 h h h。通过使用 tanh ⁡ \tanh tanh 作为激活函数,并且禁用偏置项。

    下面我们来实现加性注意力。

    #具备加性注意力的神经网络
    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)                 #定义键Key的全连接层
            self.W_q = nn.Linear(query_size, num_hiddens, bias=False)               #定义查询Query的全连接层
            self.w_v = nn.Linear(num_hiddens, 1, bias=False)                        #定义值Value的全连接层
            self.dropout = nn.Dropout(dropout)                                      #定义暂退法
        
        #前向传播函数
        def forward(self, queries, keys, values, valid_lens):
            #此时queries的形状(batch_size, 查询的个数,num_hiddens)
            #    keys的形状(batch_size, ”键-值“对的个数,num_hiddens)
            queries, keys = self.W_q(queries), self.W_k(keys)
            
            # 在维度扩展后
            # queries的形状: (batch_size, 查询的个数,1,num_hidden)
            # key的形状: (batch_size,1,”键-值“对的个数,num_hiddens)
            #features的形状: (batch_size, 查询的个数,”键-值“对的个数, num_hiddens)
            features = queries.unsqueeze(2) + keys.unsqueeze(1)
            #使用tanh激活函数
            features = torch.tanh(features)
            # self.w_v 仅有一个输出,因此从形状中移除最后那个维度
            # scores的形状: (batch_size,查询的个数,”键-值“的个数)
            scores = self.w_v(features).squeeze(-1)
            self.attention_weights = masked_softmax(scores, valid_lens)
            # values的形状: (batch_size, ”键-值“的个数,值的维度)
            return torch.bmm(self.dropout(self.attention_weights), values)
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    我们用一个小例子来演示上面的AdditiveAttention类,其中查询、键和值的形状为(批量大小,步数或词元序列长度,特征大小),实际输出为 ( 2 , 1 , 20 ) (2,1,20) (2,1,20) ( 2 , 10 , 2 ) (2,10,2) (2,10,2) ( 2 , 10 , 4 ) (2,10,4) (2,10,4)。注意力汇聚输出的形状为(批量大小,查询的步数,值的维度)。

    """
    此时
    queries形状:(2, 1, 20)
    keys形状:(2, 10, 2)
    values的形状:(2, 10, 4)
    valid_len的长度为 2,即为(2, 6)
    """
    queries, keys = torch.normal(0, 1, (2, 1, 20)), torch.ones((2, 10, 2))
    # values的小批量,两个值矩阵是相同的
    values = torch.arange(40, dtype=torch.float32).reshape(1, 10, 4).repeat(2,1,1)
    # 有效长度分别为 2 和 6
    valid_lens = torch.tensor([2, 6])
    
    # 定义attention对象
    attention = AdditiveAttention(key_size=2, query_size=20, num_hiddens=8,
                                 dropout=0.1)
    
    attention.eval()
    
    #计算其注意力
    attention(queries, keys, values, valid_lens)
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    tensor([[[ 2.0000,  3.0000,  4.0000,  5.0000]],
    
            [[10.0000, 11.0000, 12.0000, 13.0000]]], grad_fn=)
    
    • 1
    • 2
    • 3

    尽管加性注意力包含了可学习的参数,但由于本例子中每个键都是相同的,所以注意力权重是均匀的,由指定的有效长度决定。

    d2l.show_heatmaps(attention.attention_weights.reshape((1, 1, 2, 10)),
                     xlabel='Keys', ylabel='Queries')
    
    • 1
    • 2

    在这里插入图片描述

    缩放点积注意力

    使用点积可以得到计算效率更高的评分函数,但是点积操作要求查询和键具有相同的长度 d d d 。 假设查询和键的所有元素都是独立的随机变量,并且都满足零均值和单位方差,那么两个向量的点积的均值为 0 0 0 ,方差为 d d d为确保无论向量长度如何,点积的方差在不考虑向量长度的情况下仍然是 1 1 1,我们将点积除以 d \sqrt{d} d ,则缩放点积注意力(scaled dot-product attention) 评分函数为:

    a ( q , k ) = q ⊤ k / d . a(\mathbf q, \mathbf k) = \mathbf{q}^\top \mathbf{k} /\sqrt{d}. a(q,k)=qk/d .

    在实践中,我们通常从小批量的角度来考虑提高效率,例如基于 n n n 个查询和 m m m 个键-值对计算注意力,其中查询和键的长度为 d d d ,值的长度为 v v v。查询 Q ∈ R n × d \mathbf Q\in\mathbb R^{n\times d} QRn×d、键 K ∈ R m × d \mathbf K\in\mathbb R^{m\times d} KRm×d和值 V ∈ R m × v \mathbf V\in\mathbb R^{m\times v} VRm×v的缩放点积注意力是:

    s o f t m a x ( Q K ⊤ d ) V ∈ R n × v . \mathrm{softmax}\left(\frac{\mathbf Q \mathbf K^\top }{\sqrt{d}}\right) \mathbf V \in \mathbb{R}^{n\times v}. softmax(d QK)VRn×v.

    在下面的缩放点积注意力的实现中,我们使用了暂退法进行模型正则化

    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):
            # 首先获取quereis和keys的最后一个维度d
            d = queries.shape[-1]
            # 设置transpose_b=True为了交换keys的最后两个维度,即实现 (queries @ keys.T) / sqrt(d)
            # 此时scores的形状为: (batch_size, 查询个数,“键-值”对个数)
            scores = torch.bmm(queries, keys.transpose(1, 2)) / math.sqrt(d)
            # 对注意力评分函数所获结果scores进行softmax操作得到注意力权重矩阵attention_weights
            self.attention_weights = masked_softmax(scores, valid_lens)
            # 最后和values(batch_size,“键-值”对个数,输出维度)相乘,得到最终结果(batch_size, 查询个数,输出维度)
            return torch.bmm(self.dropout(self.attention_weights), values)
        
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    为了演示上述的DotProductAttention类, 我们使用与先前加性注意力例子中相同的键、值和有效长度。 对于点积操作,我们令查询的特征维度与键的特征维度大小相同。

    queries = torch.normal(0, 1, (2, 1, 2))           #queries特征维度同keys一致
    attention = DotProductAttention(dropout=0.5)
    attention.eval()
    attention(queries, keys, values, valid_lens)      #缩放点积注意力神经网络s
    
    • 1
    • 2
    • 3
    • 4
    tensor([[[ 2.0000,  3.0000,  4.0000,  5.0000]],
    
            [[10.0000, 11.0000, 12.0000, 13.0000]]])
    
    • 1
    • 2
    • 3

    尽管加性注意力包含了可学习的参数,但由于本例子中每个键都是相同的,所以注意力权重是均匀的,由指定的有效长度决定。

    d2l.show_heatmaps(attention.attention_weights.reshape((1, 1, 2, 10)),
                      xlabel='Keys', ylabel='Queries')
    
    • 1
    • 2

    在这里插入图片描述

    小结

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

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

  • 相关阅读:
    docker compose和consul(服务注册与发现)
    【阿里云-如何实现实名认证】
    撸视频号收益这个副业靠谱吗?
    前端性能优化方法面试题回答思路总结
    Java面试笔试题大汇总(最全+详细答案)
    宏观经济学复习
    rpm环境安装dpkg包管理工具
    【JAVA知识梳理】异常机制
    阿里巴巴面试题【杭州多测师】【杭州多测师_王sir】
    VALID/READY 握手机制
  • 原文地址:https://blog.csdn.net/weixin_43479947/article/details/127544704