【深度学习实验】注意力机制（三）：打分函数—

文章目录

一、实验介绍
二、实验环境
- 1. 配置虚拟环境
- 2. 库版本介绍
三、实验内容
- 0. 理论介绍
- - a. 认知神经学中的注意力
  - b. 注意力机制
- 1. 注意力权重矩阵可视化（矩阵热图）
- 2. 掩码Softmax 操作
- 3. 打分函数——加性注意力模型
- - 1. 初始化
  - 2. 前向传播
  - 3. 内部组件
  - 4. 实现细节
  - 5. 模拟实验
  - 6. 代码整合

一、实验介绍

注意力机制作为一种模拟人脑信息处理的关键工具，在深度学习领域中得到了广泛应用。本系列实验旨在通过理论分析和代码演示，深入了解注意力机制的原理、类型及其在模型中的实际应用。

本文将介绍打分函数——加性注意力模型

二、实验环境

本系列实验使用了PyTorch深度学习框架，相关操作如下：

1. 配置虚拟环境

conda create -n DL python=3.7

conda activate DL

pip install torch==1.8.1+cu102 torchvision==0.9.1+cu102 torchaudio==0.8.1 -f https://download.pytorch.org/whl/torch_stable.html

conda install matplotlib

 conda install scikit-learn

2. 库版本介绍

软件包	本实验版本	目前最新版
matplotlib	3.5.3	3.8.0
numpy	1.21.6	1.26.0
python	3.7.16
scikit-learn	0.22.1	1.3.0
torch	1.8.1+cu102	2.0.1
torchaudio	0.8.1	2.0.2
torchvision	0.9.1+cu102	0.15.2

三、实验内容

0. 理论介绍

a. 认知神经学中的注意力

人脑每个时刻接收的外界输入信息非常多，包括来源于视
觉、听觉、触觉的各种各样的信息。单就视觉来说，眼睛每秒钟都会发送千万比特的信息给视觉神经系统。人脑通过注意力来解决信息超载问题，注意力分为两种主要类型：

聚焦式注意力（Focus Attention）：
- 这是一种自上而下的有意识的注意力，通常与任务相关。
- 在这种情况下，个体有目的地选择关注某些信息，而忽略其他信息。
- 在深度学习中，注意力机制可以使模型有选择地聚焦于输入的特定部分，以便更有效地进行任务，例如机器翻译、文本摘要等。
基于显著性的注意力（Saliency-Based Attention）
- 这是一种自下而上的无意识的注意力，通常由外界刺激驱动而不需要主动干预。
- 在这种情况下，注意力被自动吸引到与周围环境不同的刺激信息上。
- 在深度学习中，这种注意力机制可以用于识别图像中的显著物体或文本中的重要关键词。

在深度学习领域，注意力机制已被广泛应用，尤其是在自然语言处理任务中，如机器翻译、文本摘要、问答系统等。通过引入注意力机制，模型可以更灵活地处理不同位置的信息，提高对长序列的处理能力，并在处理输入时动态调整关注的重点。

b. 注意力机制

注意力机制（Attention Mechanism）：
- 作为资源分配方案，注意力机制允许有限的计算资源集中处理更重要的信息，以应对信息超载的问题。
- 在神经网络中，它可以被看作一种机制，通过选择性地聚焦于输入中的某些部分，提高了神经网络的效率。
基于显著性的注意力机制的近似： 在神经网络模型中，最大汇聚（Max Pooling）和门控（Gating）机制可以被近似地看作是自下而上的基于显著性的注意力机制，这些机制允许网络自动关注输入中与周围环境不同的信息。
聚焦式注意力的应用： 自上而下的聚焦式注意力是一种有效的信息选择方式。在任务中，只选择与任务相关的信息，而忽略不相关的部分。例如，在阅读理解任务中，只有与问题相关的文章片段被选择用于后续的处理，减轻了神经网络的计算负担。
注意力的计算过程：注意力机制的计算分为两步。首先，在所有输入信息上计算注意力分布，然后根据这个分布计算输入信息的加权平均。这个计算依赖于一个查询向量（Query Vector），通过一个打分函数来计算每个输入向量和查询向量之间的相关性。
- 注意力分布（Attention Distribution）：注意力分布表示在给定查询向量和输入信息的情况下，选择每个输入向量的概率分布。Softmax 函数被用于将分数转化为概率分布，其中每个分数由一个打分函数计算得到。
- 打分函数（Scoring Function）：打分函数衡量查询向量与输入向量之间的相关性。文中介绍了几种常用的打分函数，包括加性模型、点积模型、缩放点积模型和双线性模型。这些模型通过可学习的参数来调整注意力的计算。
  - 加性模型： $\mathbf{s}(\mathbf{x}, \mathbf{q}) = \mathbf{v}^T \tanh(\mathbf{W}\mathbf{x} + \mathbf{U}\mathbf{q})$
  - 点积模型： $\mathbf{s}(\mathbf{x}, \mathbf{q}) = \mathbf{x}^T \mathbf{q}$
  - 缩放点积模型： $\mathbf{s}(\mathbf{x}, \mathbf{q}) = \frac{\mathbf{x}^T \mathbf{q}}{\sqrt{D}}$ （缩小方差，增大softmax梯度）
  - 双线性模型： $\mathbf{s}(\mathbf{x}, \mathbf{q}) = \mathbf{x}^T \mathbf{W} \mathbf{q}$ （非对称性）
软性注意力机制：
- 定义：软性注意力机制通过一个“软性”的信息选择机制对输入信息进行汇总，允许模型以概率形式对输入的不同部分进行关注，而不是强制性地选择一个部分。
- 加权平均：软性注意力机制中的加权平均表示在给定任务相关的查询向量时，每个输入向量受关注的程度，通过注意力分布实现。
- Softmax 操作：注意力分布通常通过 Softmax 操作计算，确保它们成为一个概率分布。

1. 注意力权重矩阵可视化（矩阵热图）

【深度学习实验】注意力机制（一）：注意力权重矩阵可视化（矩阵热图heatmap）

在这里插入图片描述

2. 掩码Softmax 操作

【深度学习实验】注意力机制（二）：掩码Softmax 操作
在这里插入图片描述
PS：记录~一天两上热搜榜

3. 打分函数——加性注意力模型

$\mathbf{s}(\mathbf{x}, \mathbf{q}) = \mathbf{v}^T \tanh(\mathbf{W}\mathbf{x} + \mathbf{U}\mathbf{q})$

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)
        self.attention_weights = masked_softmax(scores, valid_lens)
        # values的形状：(batch_size，“键－值”对的个数，值的维度)
        return torch.bmm(self.dropout(self.attention_weights), values)

AdditiveAttention 类实现了加性注意力机制。下面对该类的主要组件和功能进行详细介绍：

1. 初始化

参数:
- key_size: 键的维度。
- query_size: 查询的维度。
- num_hiddens: 隐藏层的维度。
- dropout: Dropout 正则化的概率。
说明: 定义了模型的各个组件，包括线性变换层和 Dropout 层。

2. 前向传播

参数:
- queries: 查询张量，形状为 (batch_size, num_queries, query_size).
- keys: 键张量，形状为 (batch_size, num_kv_pairs, key_size).
- values: 值张量，形状为 (batch_size, num_kv_pairs, value_size).
- valid_lens: 有效长度张量，形状为 (batch_size,).
返回值: 加权平均后的值张量，形状为 (batch_size, num_queries, value_size)。

3. 内部组件

W_q: 将查询进行线性变换的层。
W_k: 将键进行线性变换的层。
w_v: 将特征进行线性变换的层，该层输出的形状为 (batch_size, num_queries, num_kv_pairs, 1)，并通过 squeeze(-1) 操作得到注意力分数。
dropout: Dropout 正则化层。

4. 实现细节

使用线性变换将查询和键映射到相同的隐藏维度。
通过广播方式计算注意力得分。
使用 tanh 激活函数将得分映射到 (-1, 1) 范围。
计算注意力分数，并通过 masked_softmax 函数计算注意力权重。
对注意力权重进行 Dropout 正则化。
将注意力权重应用到值上，得到最终的加权平均结果。

此加性注意力实现的目标是通过学习注意力权重，根据输入的查询和键对值进行加权平均，用于处理序列数据中的关联信息。

5. 模拟实验

模拟输入数据并使用上述AdditiveAttention模型进行前向传播。

# 创建模拟的输入数据
queries, keys = torch.normal(0, 1, (2, 1, 20)), torch.ones((2, 10, 2))

queries: 一个形状为 (2, 1, 20) 的张量，表示两个查询。这个张量的第一个维度是批量大小，第二个维度是查询的个数，第三个维度是查询的特征维度。
keys: 一个形状为 (2, 10, 2) 的张量，表示两个样本，每个样本包含10个键值对。每个键值对的维度为2。

# 创建模拟的values数据
values = torch.arange(40, dtype=torch.float32).reshape(1, 10, 4).repeat(2, 1, 1)

values: 一个形状为 (2, 10, 4) 的张量，表示两个样本，每个样本包含10个值。每个值的维度为4。

# 创建模拟的有效长度数据
valid_lens = torch.tensor([2, 6])

valid_lens: 一个形状为 (2,) 的张量，表示两个样本的有效长度。在注意力机制中，这用于指定每个查询关注的键值对数量。

# 创建 AdditiveAttention 模型
attention = AdditiveAttention(key_size=2, query_size=20, num_hiddens=8, dropout=0.1)
attention.eval()

创建了一个 AdditiveAttention 的实例，指定了键的维度 key_size、查询的维度 query_size、隐藏层的维度 num_hiddens 和 Dropout 的概率 dropout。

# 使用模型进行前向传播
attention(queries, keys, values, valid_lens)

调用 attention 模型的前向传播方法，传入查询 queries、键 keys、值 values 和有效长度 valid_lens。
模型返回加权平均后的值，形状为 (2, 1, 4)，表示两个查询的输出。

在这里插入图片描述

绘制矩阵热图：

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

在这里插入图片描述

6. 代码整合

# 导入必要的库
import torch
from torch import nn
from d2l import torch as d2l


def show_heatmaps(matrices, xlabel, ylabel, titles=None, figsize=(2.5, 2.5), cmap='Reds'):
    """显示矩阵热图"""
    d2l.use_svg_display()
    num_rows, num_cols = matrices.shape[0], matrices.shape[1]
    fig, axes = d2l.plt.subplots(num_rows, num_cols, figsize=figsize,
                                 sharex=True, sharey=True, squeeze=False)
    for i, (row_axes, row_matrices) in enumerate(zip(axes, matrices)):
        for j, (ax, matrix) in enumerate(zip(row_axes, row_matrices)):
            pcm = ax.imshow(matrix.detach().numpy(), cmap=cmap)
            if i == num_rows - 1:
                ax.set_xlabel(xlabel)
            if j == 0:
                ax.set_ylabel(ylabel)
            if titles:
                ax.set_title(titles[j])
    fig.colorbar(pcm, ax=axes, shrink=0.6)


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)


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)
        self.attention_weights = masked_softmax(scores, valid_lens)
        # values的形状：(batch_size，“键－值”对的个数，值的维度)
        return torch.bmm(self.dropout(self.attention_weights), values)


queries, keys = torch.normal(0, 1, (2, 1, 20)), torch.ones((2, 10, 2))

values = torch.arange(40, dtype=torch.float32).reshape(1, 10, 4).repeat(2, 1, 1)
valid_lens = torch.tensor([2, 6])

attention = AdditiveAttention(key_size=2, query_size=20, num_hiddens=8, dropout=0.1)
attention.eval()
attention(queries, keys, values, valid_lens)
weights = attention.attention_weights
show_heatmaps(attention.attention_weights.reshape((1, 1, 2, 10)),
              xlabel='Keys', ylabel='Queries')