注意力汇聚：NadarayaWatson核回归

• Nadaraya-Watson核回归是具有注意力机制的机器学习范例。

• Nadaraya-Watson核回归的注意力汇聚是对训练数据中输出的加权平均。从注意力的角度来看&＃xff0c;分配给每个值的注意力权重取决于将值所对应的键和查询作为输入的函数。

• 注意力汇聚可以分为非参数型和带参数型。

• 参考10.2. 注意力汇聚&＃xff1a;Nadaraya-Watson 核回归 — 动手学深度学习 2.0.0 documentation

框架下的注意力机制的主要成分 &＃xff1a; 查询&＃xff08;自主提示&＃xff09;和键&＃xff08;非自主提示&＃xff09;之间的交互形成了注意力汇聚&＃xff1b; 注意力汇聚有选择地聚合了值&＃xff08;感官输入&＃xff09;以生成最终的输出。

本节将介绍注意力汇聚的更多细节&＃xff0c; 以便从宏观上了解注意力机制在实践中的运作方式。 具体来说&＃xff0c;1964年提出的Nadaraya-Watson核回归模型 是一个简单但完整的例子&＃xff0c;可以用于演示具有注意力机制的机器学习。

pip install mxnet&＃61;&＃61;1.7.0.post1

pip install d2l&＃61;&＃61;0.15.0

from mxnet import autograd, gluon, np, npx
from mxnet.gluon import nn
from d2l import mxnet as d2l
npx.set_np()
1.生成数据集 

简单起见&＃xff0c;考虑下面这个回归问题&＃xff1a; 给定的成对的“输入&＃xff0d;输出”数据集 {(x1,y1),…,(xn,yn)}&＃xff0c; 如何学习f来预测任意新输入x的输出y^&＃61;f(x)&＃xff1f;

根据下面的非线性函数生成一个人工数据集&＃xff0c; 其中加入的噪声项为ϵ&＃xff1a;

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

n_train &＃61; 50 # 训练样本数
x_train &＃61; np.sort(np.random.rand(n_train) * 5) # 排序后的训练样本
def f(x):
return 2 * np.sin(x) &＃43; x**0.8
y_train &＃61; f(x_train) &＃43; np.random.normal(0.0, 0.5, (n_train,)) # 训练样本的输出
x_test &＃61; np.arange(0, 5, 0.1) # 测试样本
y_truth &＃61; f(x_test) # 测试样本的真实输出
n_test &＃61; len(x_test) # 测试样本数
n_test

50

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

def plot_kernel_reg(y_hat):
d2l.plot(x_test, [y_truth, y_hat], &＃39;x&＃39;, &＃39;y&＃39;, legend&＃61;[&＃39;Truth&＃39;, &＃39;Pred&＃39;],
xlim&＃61;[0, 5], ylim&＃61;[-1, 5])
d2l.plt.plot(x_train, y_train, &＃39;o&＃39;, alpha&＃61;0.5);
 2.平均汇聚

 先使用最简单的估计器来解决回归问题。 基于平均汇聚来计算所有训练样本输出值的平均值&＃xff1a;

如下图所示&＃xff0c;这个估计器确实不够聪明。 真实函数f&＃xff08;“Truth”&＃xff09;和预测函数&＃xff08;“Pred”&＃xff09;相差很大。

y_hat &＃61; y_train.mean().repeat(n_test)
plot_kernel_reg(y_hat)
 3. 非参数注意力汇聚

显然&＃xff0c;平均汇聚忽略了输入xi。 于是Nadaraya (Nadaraya, 1964)和 Watson (Watson, 1964)提出了一个更好的想法&＃xff0c; 根据输入的位置对输出yi进行加权&＃xff1a;

其中K是核&＃xff08;kernel&＃xff09;。 公式 (10.2.3)所描述的估计器被称为 Nadaraya-Watson核回归&＃xff08;Nadaraya-Watson kernel regression&＃xff09;。 这里不会深入讨论核函数的细节&＃xff0c; 但受此启发&＃xff0c; 我们可以从 图10.1.3中的注意力机制框架的角度 重写 (10.2.3)&＃xff0c; 成为一个更加通用的注意力汇聚&＃xff08;attention pooling&＃xff09;公式&＃xff1a;

 其中x是查询&＃xff0c;(xi,yi)是键值对。 比较 (10.2.4)和 (10.2.2)&＃xff0c; 注意力汇聚是yi的加权平均。 将查询x和键xi之间的关系建模为 注意力权重&＃xff08;attention weight&＃xff09;α(x,xi)&＃xff0c; 如 (10.2.4)所示&＃xff0c; 这个权重将被分配给每一个对应值yi。 对于任何查询&＃xff0c;模型在所有键值对注意力权重都是一个有效的概率分布&＃xff1a; 它们是非负的&＃xff0c;并且总和为1。

为了更好地理解注意力汇聚&＃xff0c; 下面考虑一个高斯核&＃xff08;Gaussian kernel&＃xff09;&＃xff0c;其定义为&＃xff1a;

将高斯核代入 (10.2.4)和 (10.2.3)可以得到&＃xff1a;

 在 (10.2.6)中&＃xff0c; 如果一个键xi越是接近给定的查询x&＃xff0c; 那么分配给这个键对应值yi的注意力权重就会越大&＃xff0c; 也就“获得了更多的注意力”。 

值得注意的是&＃xff0c;Nadaraya-Watson核回归是一个非参数模型。 因此&＃xff0c; (10.2.6)是 非参数的注意力汇聚&＃xff08;nonparametric attention pooling&＃xff09;模型。 接下来&＃xff0c;我们将基于这个非参数的注意力汇聚模型来绘制预测结果。 从绘制的结果会发现新的模型预测线是平滑的&＃xff0c;并且比平均汇聚的预测更接近真实。

# X_repeat的形状:(n_test,n_train),
# 每一行都包含着相同的测试输入&＃xff08;例如&＃xff1a;同样的查询&＃xff09;
X_repeat &＃61; x_test.repeat(n_train).reshape((-1, n_train))
# x_train包含着键。attention_weights的形状&＃xff1a;(n_test,n_train),
# 每一行都包含着要在给定的每个查询的值&＃xff08;y_train&＃xff09;之间分配的注意力权重
attention_weights &＃61; npx.softmax(-(X_repeat - x_train)**2 / 2)
# y_hat的每个元素都是值的加权平均值&＃xff0c;其中的权重是注意力权重
y_hat &＃61; np.dot(attention_weights, y_train)
plot_kernel_reg(y_hat)

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

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

show_heatmaps(np.expand_dims(np.expand_dims(attention_weights, 0), 0),
xlabel&＃61;&＃39;Sorted training inputs&＃39;,
ylabel&＃61;&＃39;Sorted testing inputs&＃39;)

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

例如&＃xff0c;与 (10.2.6)略有不同&＃xff0c; 在下面的查询x和键xi之间的距离乘以可学习参数w&＃xff1a;

本节的余下部分将通过训练这个模型 (10.2.7)来学习注意力汇聚的参数。

4.1.批量矩阵乘法 

为了更有效地计算小批量数据的注意力&＃xff0c; 我们可以利用深度学习开发框架中提供的批量矩阵乘法。

假设第一个小批量数据包含n个矩阵X1,…,Xn&＃xff0c; 形状为a×b&＃xff0c; 第二个小批量包含n个矩阵Y1,…,Yn&＃xff0c; 形状为b×c。 它们的批量矩阵乘法得到n个矩阵 X1Y1,…,XnYn&＃xff0c; 形状为a×c。 因此&＃xff0c;假定两个张量的形状分别是(n,a,b)和(n,b,c)&＃xff0c; 它们的批量矩阵乘法输出的形状为(n,a,c)。

X &＃61; np.ones((2, 1, 4))
Y &＃61; np.ones((2, 4, 6))
npx.batch_dot(X, Y).shape

(2, 1, 6)

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

weights &＃61; np.ones((2, 10)) * 0.1
values &＃61; np.arange(20).reshape((2, 10))
npx.batch_dot(np.expand_dims(weights, 1), np.expand_dims(values, -1))

array([[[ 4.5]],
[[14.5]]])

 

4.2.定义模型

基于 (10.2.7)中的 带参数的注意力汇聚&＃xff0c;使用小批量矩阵乘法&＃xff0c; 定义Nadaraya-Watson核回归的带参数版本为&＃xff1a;

class NWKernelRegression(nn.Block):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.w &＃61; self.params.get(&＃39;w&＃39;, shape&＃61;(1,))
def forward(self, queries, keys, values):
# queries和attention_weights的形状为(查询数&＃xff0c;“键&＃xff0d;值”对数)
queries &＃61; queries.repeat(keys.shape[1]).reshape((-1, keys.shape[1]))
self.attention_weights &＃61; npx.softmax(
-((queries - keys) * self.w.data())**2 / 2)
# values的形状为(查询数&＃xff0c;“键&＃xff0d;值”对数)
return npx.batch_dot(np.expand_dims(self.attention_weights, 1),
np.expand_dims(values, -1)).reshape(-1)

4.3.训练

接下来&＃xff0c;将训练数据集变换为键和值用于训练注意力模型。 在带参数的注意力汇聚模型中&＃xff0c; 任何一个训练样本的输入都会和除自己以外的所有训练样本的“键&＃xff0d;值”对进行计算&＃xff0c; 从而得到其对应的预测输出。

# X_tile的形状:(n_train&＃xff0c;n_train)&＃xff0c;每一行都包含着相同的训练输入
X_tile &＃61; np.tile(x_train, (n_train, 1))
# Y_tile的形状:(n_train&＃xff0c;n_train)&＃xff0c;每一行都包含着相同的训练输出
Y_tile &＃61; np.tile(y_train, (n_train, 1))
# keys的形状:(&＃39;n_train&＃39;&＃xff0c;&＃39;n_train&＃39;-1)
keys &＃61; X_tile[(1 - np.eye(n_train)).astype(&＃39;bool&＃39;)].reshape((n_train, -1))
# values的形状:(&＃39;n_train&＃39;&＃xff0c;&＃39;n_train&＃39;-1)
values &＃61; Y_tile[(1 - np.eye(n_train)).astype(&＃39;bool&＃39;)].reshape((n_train, -1))

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

net &＃61; NWKernelRegression()
net.initialize()
loss &＃61; gluon.loss.L2Loss()
trainer &＃61; gluon.Trainer(net.collect_params(), &＃39;sgd&＃39;, {&＃39;learning_rate&＃39;: 0.5})
animator &＃61; d2l.Animator(xlabel&＃61;&＃39;epoch&＃39;, ylabel&＃61;&＃39;loss&＃39;, xlim&＃61;[1, 5])
for epoch in range(5):
with autograd.record():
l &＃61; loss(net(x_train, keys, values), y_train)
l.backward()
trainer.step(1)
print(f&＃39;epoch {epoch &＃43; 1}, loss {float(l.sum()):.6f}&＃39;)
animator.add(epoch &＃43; 1, float(l.sum()))

书上结果是这样的&＃xff0c;代码复制过去运行的&＃xff0c;我不理解

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

# keys的形状:(n_test&＃xff0c;n_train)&＃xff0c;每一行包含着相同的训练输入&＃xff08;例如&＃xff0c;相同的键&＃xff09;
keys &＃61; np.tile(x_train, (n_test, 1))
# value的形状:(n_test&＃xff0c;n_train)
values &＃61; np.tile(y_train, (n_test, 1))
y_hat &＃61; net(x_test, keys, values)
plot_kernel_reg(y_hat)

噢&＃xff0c;啥玩意&＃xff0c;预测啥也不是啊&＃xff0c;书上是这样的

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

d2l.show_heatmaps(np.expand_dims(
np.expand_dims(net.attention_weights, 0), 0),
xlabel&＃61;&＃39;Sorted training inputs&＃39;,
ylabel&＃61;&＃39;Sorted testing inputs&＃39;)

 书上这样的&＃xff0c;哎&＃xff0c;回头再看看&＃xff0c;看不出哪里的问题