注意力机制（一）：注意力提示、注意力汇聚、Nadaraya-Watson 核回归

专栏：神经网络复现目录

注意力机制

注意力机制（Attention Mechanism）是一种人工智能技术，它可以让神经网络在处理序列数据时，专注于关键信息的部分，同时忽略不重要的部分。在自然语言处理、计算机视觉、语音识别等领域，注意力机制已经得到了广泛的应用。

注意力机制的主要思想是，在对序列数据进行处理时，通过给不同位置的输入信号分配不同的权重，使得模型更加关注重要的输入。例如，在处理一句话时，注意力机制可以根据每个单词的重要性来调整模型对每个单词的注意力。这种技术可以提高模型的性能，尤其是在处理长序列数据时。

在深度学习模型中，注意力机制通常是通过添加额外的网络层实现的，这些层可以学习到如何计算权重，并将这些权重应用于输入信号。常见的注意力机制包括自注意力机制（self-attention）、多头注意力机制（multi-head attention）等。

总之，注意力机制是一种非常有用的技术，它可以帮助神经网络更好地处理序列数据，提高模型的性能。

---

---

注意力提示

查询、键和值

自主性的与非自主性的注意力提示解释了人类的注意力的方式， 下面来看看如何通过这两种注意力提示， 用神经网络来设计注意力机制的框架，

首先，考虑一个相对简单的状况， 即只使用非自主性提示。 要想将选择偏向于感官输入， 则可以简单地使用参数化的全连接层， 甚至是非参数化的最大汇聚层或平均汇聚层。

因此，“是否包含自主性提示”将注意力机制与全连接层或汇聚层区别开来。 在注意力机制的背景下，自主性提示被称为查询（query）。 给定任何查询，注意力机制通过注意力汇聚（attention pooling） 将选择引导至感官输入（sensory inputs，例如中间特征表示）。 在注意力机制中，这些感官输入被称为值（value）。 更通俗的解释，每个值都与一个键（key）配对， 这可以想象为感官输入的非自主提示。 如图所示，可以通过设计注意力汇聚的方式， 便于给定的查询（自主性提示）与键（非自主性提示）进行匹配， 这将引导得出最匹配的值（感官输入）。

通俗的说：查询即为已知正确标签的X-y，键值对即为训练集，未知正确标签的键值对X-y，通过在训练中加入已知正确标签的数据，使训练效果提升

注意力的可视化

#@save
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);

这个函数的输入参数包括：矩阵数据（matrices）、x轴和y轴标签（xlabel和ylabel）、可选的每个热图的标题（titles）、图形大小（figsize）和颜色映射（cmap）。

具体而言，这个函数通过调用"d2l.use_svg_display()"来设置图形输出格式为SVG，接着计算输入矩阵数据的行数和列数，创建一个大小为num_rows*num_cols的子图，每个子图包含一个热图，并使用给定的标签、标题和颜色映射来展示矩阵数据。

最后，这个函数还为每个子图添加一个共享的颜色条，以显示颜色映射与实际数据值之间的对应关系。

下面使用一个简单的例子进行演示。 在本例子中，仅当查询和键相同时，注意力权重为1，否则为0。

attention_weights = torch.eye(10).reshape((1, 1, 10, 10))
show_heatmaps(attention_weights, xlabel='Keys', ylabel='Queries')

注意力汇聚：Nadaraya-Watson 核回归

Nadaraya-Watson核回归（Nadaraya-Watson kernel regression）是一种非参数回归方法，用于估计一个变量 $Y$ 与一个或多个自变量 $X$ 之间的关系。它的基本思想是在每个数据点周围的邻域内对目标变量进行加权平均。在这种方法中，使用一个核函数（通常是高斯核函数）来对每个自变量值进行加权，该权重与该自变量值与每个数据点的距离有关。

Nadaraya-Watson核回归的数学表达式如下：

$$\hat{f}(x)=\sum _{i=1}^n\frac{K_h(x-X_i)Y_i}{{\sum }_{i=1}^n{K}_h(x-X_i)}$$

其中，$\hat{f}(x)$ 表示在给定 $X=x$ 的情况下，目标变量 $Y$ 的估计值；$K_h$ 是核函数，通常是高斯核函数；$X_i$ 是第 $i$ 个数据点的自变量值，$Y_i$ 是对应的目标变量值；$n$ 是数据集中的样本数量；$h$ 是带宽参数，它控制着核函数的大小。

Nadaraya-Watson核回归是一种灵活的方法，可以适用于各种类型的数据集，但它也有一些限制，例如，当数据点非常稀疏或带宽参数过大或过小时，它的表现可能会受到影响。

下面通过一个简单的例子解释

生成数据集

我们生成一个人工数据集，依据下面的公式：
$$y_i=2sin(x_i)+x_i^{0.8}+ϵ$$

其中$ϵ$服从均值为0和标准差为0.5的正态分布。 在这里生成了50个训练样本和50个测试样本。 为了更好地可视化之后的注意力模式，需要将训练样本进行排序。

n_train = 50  # 训练样本数
x_train, _ = torch.sort(torch.rand(n_train) * 5)   # 排序后的训练样本

def f(x):
    return 2 * torch.sin(x) + x**0.8

y_train = f(x_train) + torch.normal(0.0, 0.5, (n_train,))  # 训练样本的输出
x_test = torch.arange(0, 5, 0.1)  # 测试样本
y_truth = f(x_test)  # 测试样本的真实输出
n_test = len(x_test)  # 测试样本数
n_test

下面的函数将绘制所有的训练样本（样本由圆圈表示）， 不带噪声项的真实数据生成函数
（标记为“Truth”）， 以及学习得到的预测函数（标记为“Pred”）。

def plot_kernel_reg(y_hat):
    d2l.plot(x_test, [y_truth, y_hat], 'x', 'y', legend=['Truth', 'Pred'],
             xlim=[0, 5], ylim=[-1, 5])
    d2l.plt.plot(x_train, y_train, 'o', alpha=0.5);

非参数注意力汇聚

正如刚才所描述的Nadaraya-Watson 核回归公式：
$$\hat{f}(x)=\sum _{i=1}^n\frac{K_h(x-X_i)Y_i}{{\sum }_{i=1}^n{K}_h(x-X_i)}$$
我们一般将其重写为更通用的注意力汇聚公式：
$$f(x)=\sum _{i=1}^n\alpha (x,x_i)y_i$$
其中$x$是查询,$(x_i,y_i)$是键值对。

具体的，我们使用高斯核，其定义为：
$$K(u)=\frac{1}{\sqrt{2}}exp(-\frac{u^2}{2})$$

代入得到最终的注意力模型：

$$\begin{gathered} f(x)=\sum _{i=1}^n\alpha (x,x_i)y_i \\ =\sum _{i=1}^n\frac{exp(-\frac{1}{2}(x-x_i){)}^2}{{\sum }_{j=1}^{n}exp(-\frac{1}{2}(x-x_i))}{y}_i \\ =\sum _{i=1}^{n}softmax(-\frac{1}{2}(x-x_i{)}^2)y_i \end{gathered}$$

在中， 如果一个键越是接近给定的查询， 那么分配给这个键对应值的注意力权重就会越大， 也就“获得了更多的注意力”。值得注意的是，Nadaraya-Watson核回归是一个非参数模型。 因此， 是 非参数的注意力汇聚（nonparametric attention pooling）模型。 接下来，我们将基于这个非参数的注意力汇聚模型来绘制预测结果。 从绘制的结果会发现新的模型预测线是平滑的，并且比平均汇聚的预测更接近真实。

# X_repeat的形状:(n_test,n_train),
# 每一行都包含着相同的测试输入（例如：同样的查询）
X_repeat = x_test.repeat_interleave(n_train).reshape((-1, n_train))
# x_train包含着键。attention_weights的形状：(n_test,n_train),
# 每一行都包含着要在给定的每个查询的值（y_train）之间分配的注意力权重
attention_weights = nn.functional.softmax(-(X_repeat - x_train)**2 / 2, dim=1)
# y_hat的每个元素都是值的加权平均值，其中的权重是注意力权重
y_hat = torch.matmul(attention_weights, y_train)
plot_kernel_reg(y_hat)

现在来观察注意力的权重。 这里测试数据的输入相当于查询，而训练数据的输入相当于键。 因为两个输入都是经过排序的，因此由观察可知“查询-键”对越接近， 注意力汇聚的注意力权重就越高。

d2l.show_heatmaps(attention_weights.unsqueeze(0).unsqueeze(0),
                  xlabel='Sorted training inputs',
                  ylabel='Sorted testing inputs')

unsqueeze()是PyTorch中的一个函数，用于在指定维度上插入一个维度，从而扩展张量的维度。
该函数接受一个张量和一个整数作为输入参数。整数参数表示要插入新维度的位置。如果该参数为负数，则表示从末尾开始倒数的位置。
下面是一个例子

import torch
x = torch.randn(3, 4)
# 在第一维上插入一个维度
y = x.unsqueeze(0)
print(y.shape)  # 输出: torch.Size([1, 3, 4])
# 在倒数第一维上插入一个维度
z = x.unsqueeze(-1)
print(z.shape)  # 输出: torch.Size([3, 4, 1])

其中，d1, d2, …, dn 是张量 attention_weights 原本的维度，也就是说，这段代码将 attention_weights 的维度在最前面添加了两个大小为 1 的维度。

具体来说，unsqueeze(0) 的作用是在第 0 维添加一个大小为 1 的维度，而 unsqueeze(0) 的作用是在第 1 维再添加一个大小为 1 的维度。

例如，如果 attention_weights 的维度为 (d1, d2)，那么这段代码的作用就是将其扩展为 (1, 1, d1, d2)。

这种维度扩展在深度学习中经常被用来进行广播操作，以便在不同形状的张量之间执行数学运算。

带参数注意力汇聚

非参数的Nadaraya-Watson核回归具有一致性（consistency）的优点： 如果有足够的数据，此模型会收敛到最优结果。 尽管如此，我们还是可以轻松地将可学习的参数集成到注意力汇聚中。

下面考虑带参数的注意力汇聚
$$\begin{gathered} f(x)=\sum _{i=1}^n\alpha (x,x_i)y_i \\ =\sum _{i=1}^n\frac{exp(-\frac{1}{2}(x-x_i)w{)}^2}{{\sum }_{j=1}^{n}exp(-\frac{1}{2}(x-x_i)w{)}^2}{y}_i \\ =\sum _{i=1}^{n}softmax(-\frac{1}{2}((x-x_i)w{)}^2)y_i \end{gathered}$$

批量矩阵乘法

在PyTorch中，可以使用torch.bmm()函数来实现批量矩阵乘法。这个函数接受两个输入张量，第一个张量的形状为(batch_size, n, m)，第二个张量的形状为(batch_size, m, p)，其中batch_size表示批量大小，n和p表示矩阵的行数和列数，m表示两个矩阵的公共维度。函数返回一个张量，其形状为(batch_size, n, p)，表示批量中每个样本的矩阵乘积结果。

X = torch.ones((2, 1, 4))
Y = torch.ones((2, 4, 6))
torch.bmm(X, Y).shape

在注意力机制的背景中，我们可以使用小批量矩阵乘法来计算小批量数据中的加权平均值。

weights = torch.ones((2, 10)) * 0.1
values = torch.arange(20.0).reshape((2, 10))
torch.bmm(weights.unsqueeze(1), values.unsqueeze(-1))

定义模型

class NWKernelRegression(nn.Module):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.w = nn.Parameter(torch.rand((1,), requires_grad=True))

    def forward(self, queries, keys, values):
        # queries和attention_weights的形状为(查询个数，“键－值”对个数)
        queries = queries.repeat_interleave(keys.shape[1]).reshape((-1, keys.shape[1]))
        self.attention_weights = nn.functional.softmax(
            -((queries - keys) * self.w)**2 / 2, dim=1)
        # values的形状为(查询个数，“键－值”对个数)
        return torch.bmm(self.attention_weights.unsqueeze(1),
                         values.unsqueeze(-1)).reshape(-1)

这段代码实现了一个基于Nadaraya-Watson核回归的注意力机制模型。

该模型的输入包括3个张量：queries、keys和values。其中，queries是查询，形状为(batch_size, query_length, embedding_size)，keys和values都是形状为(batch_size, key_length, embedding_size)的张量

模型的主要过程是根据queries和keys计算注意力权重，然后将values和注意力权重进行加权平均，得到最终的输出张量。具体地，模型首先将queries重复key_length次，并将结果reshape为(batch_size * key_length, embedding_size)，然后计算queries和keys之间的距离，通过Nadaraya-Watson核函数将距离转化为注意力权重，最后将values和注意力权重进行加权平均。

该模型的输出是一个形状为(batch_size * query_length,)的一维张量，表示每个输入向量对应的输出结果。该模型可以用于对序列数据进行建模，如文本分类、语言翻译等任务。

repeat_interleave()是PyTorch中的一个函数，用于沿着指定维度重复张量的元素，并将它们展开成一维。这个函数接受一个张量和一个整数参数，整数参数表示要重复元素的次数。

示例：

import torch

x = torch.tensor([1, 2, 3])
y = x.repeat_interleave(2)

print(y)  # 输出: tensor([1, 1, 2, 2, 3, 3])

训练

# X_tile的形状:(n_train，n_train)，每一行都包含着相同的训练输入
X_tile = x_train.repeat((n_train, 1))
# Y_tile的形状:(n_train，n_train)，每一行都包含着相同的训练输出
Y_tile = y_train.repeat((n_train, 1))
# keys的形状:('n_train'，'n_train'-1)
keys = X_tile[(1 - torch.eye(n_train)).type(torch.bool)].reshape((n_train, -1))
# values的形状:('n_train'，'n_train'-1)
values = Y_tile[(1 - torch.eye(n_train)).type(torch.bool)].reshape((n_train, -1))

训练带参数的注意力汇聚模型时，使用平方损失函数和随机梯度下降。

net = NWKernelRegression()
loss = nn.MSELoss(reduction='none')
trainer = torch.optim.SGD(net.parameters(), lr=0.5)
animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[1, 5])

for epoch in range(5):
    trainer.zero_grad()
    l = loss(net(x_train, keys, values), y_train)
    l.sum().backward()
    trainer.step()
    print(f'epoch {epoch + 1}, loss {float(l.sum()):.6f}')
    animator.add(epoch + 1, float(l.sum()))

如下所示，训练完带参数的注意力汇聚模型后可以发现： 在尝试拟合带噪声的训练数据时， 预测结果绘制的线不如之前非参数模型的平滑。

可视化

# keys的形状:(n_test，n_train)，每一行包含着相同的训练输入（例如，相同的键）
keys = x_train.repeat((n_test, 1))
# value的形状:(n_test，n_train)
values = y_train.repeat((n_test, 1))
y_hat = net(x_test, keys, values).unsqueeze(1).detach()
plot_kernel_reg(y_hat)

为什么新的模型更不平滑了呢？ 下面看一下输出结果的绘制图： 与非参数的注意力汇聚模型相比， 带参数的模型加入可学习的参数后， 曲线在注意力权重较大的区域变得更不平滑。

那么，学习得到的参数w​​的价值是什么？

我们将参数w输出来看一下：

tensor([23.3051], requires_grad=True)

值大约为23，且参数w​只是一个标量参数，不是向量，那就说明w都是相同的参数23，我们试着将非参数注意力汇聚添加一个23的权重：

attention_weights = nn.functional.softmax(-((x_repeat - x_train) * 23)**2 / 2, dim=1)
可以得到类似参数注意力汇聚一样的效果。

可以发现这样的话拟合效果就更好了，但是也变成了和参数注意力汇聚一样尖锐的加权区域。那么为什么在可视化注意力权重时，它会使加权区域更加尖锐？

我们观察上述公式发现，w​加在(x-x_i)​外，平方之内，乘以一个-1/2​​​之后就相当于绝对值扩大了230倍左右，我们知道softmax函数在x趋向负无穷的时候值无限趋近于0，所以这样一来就保留了键和查询之间的差距足够小的pair，过滤掉了键和值差距较大的pair，从而达到注意力效果，使得预测结果更加准确。