自注意力

给定一个由词元组成的输入序列$x_1$,…,$x_n$，∀$x_i$∈$R^d$

自注意力池化层将$x_i$当作key、value、query来对序列抽取特征得到$y_1$,…$y_n$，这里

---

跟CNN、RNN对比

CNN：k：窗口的大小（每次看一个k大小的东西）
     n：序列长度
     d：输入和输出的通道数量

并行度：每一个输出可以自己并行做运算.

最长路径：O(n/k)

RNN：
时间复杂度：序列长度为为n，当更新循环神经网络的隐状态时， d×d的权重矩阵和d维隐状态的乘法计算复杂度为O($d^2$)，所以复杂度为O(n$d^2$)

并行度：每一个$y_i$的输出要等$y_{i-1}$算完

最长路径：$x_1$的信息要一直传递到$x_n$，需要经过一个O(n)的一个序列。

自注意力：在自注意力中，查询、键和值都是n×d矩阵。其中n×d矩阵乘以d×n矩阵，之后输出的n×n矩阵乘以n×d矩阵。因此，自注意力具有O($n^{2}d$)计算复杂度。

并行度：O(n)

最长路径：O(1)，也就是说任何一个地方的信息要到任何一个输出的话，是可以直接过去的。

自注意力适合比较长的文本，因为能看的比较宽。但计算复杂度比较高。

---

位置编码

跟CNN/RNN不同，自注意力并没有记录位置信息。

如果纯用自注意力机制来做序列模型的话，那么没有位置信息，那肯定是有问题的。所以一个加入位置信息的办法是位置编码。
它不是把位置信息加入到模型里面，因为一旦位置信息加入到模型里面总会有各种问题，CNN的会导致每一次得看一个比较长的序列，RNN的话并行度就低了，所以不是改变注意力机制本身，然后就把位置编码信息放到输入里，让输入有位置信息。

    假设长度为n的序列是X∈$R^{n\times d}$，那么使用位置编码矩阵P∈$R^{n\times d}$来输出X+P作为自编码输入。

P的元素计算：

位置编码矩阵

X坐标是它的一个行数，就是说对第i个序列加的那个值是什么？然后四根曲线对应的是第6、7、8、9列

对每一个样本，它的维度每一个加的值是不一样的。样本和样本之间也是不一样的。

---

绝对位置信息

---

相对位置信息

---

总结

①自注意力池化层将$x_i$当做key、value、query来对序列抽取特征。

②完全并行、最长序列为1、但对长序列计算复杂度高。

③位置编码在输入中加入位置信息，使得自注意力能够记忆位置信息。

---

自注意力和位置编码

import math
import torch
from torch import nn
from d2l import torch as d2l

---

自注意力

from d2l import torch as d2lnum_hiddens, num_heads = 100, 5
# 创建多头注意力实例
# 输入参数为隐藏单元数量、查询维度、键维度、值维度、头的数量和dropout率
attention = d2l.MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens,num_hiddens, num_heads, 0.5)
# 将多头注意力设置为评估模式，不进行训练
print(attention.eval())

# 设置批量大小、查询数和有效长度
batch_size, num_queries, valid_lens = 2, 4, torch.tensor([3, 2])
X = torch.ones((batch_size, num_queries, num_hiddens))
# 对输入张量X应用多头注意力机制，并获取输出的形状
print(attention(X, X, X, valid_lens).shape)

该部分总代码

from d2l import torch as d2lnum_hiddens, num_heads = 100, 5
# 创建多头注意力实例
# 输入参数为隐藏单元数量、查询维度、键维度、值维度、头的数量和dropout率
attention = d2l.MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens,num_hiddens, num_heads, 0.5)
attention.eval()
# 设置批量大小、查询数和有效长度
batch_size, num_queries, valid_lens = 2, 4, torch.tensor([3, 2])
X = torch.ones((batch_size, num_queries, num_hiddens))
# 对输入张量X应用多头注意力机制，并获取输出的形状
print(attention(X, X, X, valid_lens).shape)

---

位置编码

class PositionalEncoding(nn.Module):# 初始化函数，接收隐藏单元数量、dropout率和最大序列长度作为输入def __init__(self, num_hiddens, dropout, max_len=1000):super(PositionalEncoding, self).__init__()self.dropout = nn.Dropout(dropout)# 创建一个形状为(batch_size, max_len, num_hiddens)的位置编码张量P，初始化为全0self.P = torch.zeros((1, max_len, num_hiddens))# 生成位置编码矩阵X，其中每一行表示一个位置的编码，编码方式采用sin和cos函数# 编码公式：X[i, j] = sin(i / 10000^(2j / num_hiddens)) 或 cos(i / 10000^(2j / num_hiddens))X = torch.arange(max_len, dtype=torch.float32).reshape(-1, 1) / torch.pow(10000, torch.arange(0, num_hiddens, 2,dtype=torch.float32) / num_hiddens)# 第一维度、第二维的所有元素，第三维将位置编码矩阵中的偶数维度的元素替换为sin函数的结果self.P[:, :, 0::2] = torch.sin(X)# 将位置编码矩阵中的奇数维度的元素替换为cos函数的结果self.P[:, :, 1::2] = torch.cos(X)def forward(self, X):# 将位置编码张量P与输入张量X相加，并将结果移动到与X相同的设备上# self.P[:, :X.shape[1], :]第二维从索引0到 X 的第二维大小的所有元素➡确保P的第二维和X的第二维一致，因为可能是不同的序列长度，为了动态的适应不同长度的输入X = X + self.P[:, :X.shape[1], :].to(X.device)# 对相加后的结果应用dropout，并返回结果return self.dropout(X)

该部分总代码

import torch
from torch import nn
from d2l import torch as d2l# 位置编码
class PositionalEncoding(nn.Module):# 初始化函数，接收隐藏单元数量、dropout率和最大序列长度作为输入def __init__(self, num_hiddens, dropout, max_len=1000):super(PositionalEncoding, self).__init__()self.dropout = nn.Dropout(dropout)# 创建一个形状为(batch_size, max_len, num_hiddens)的位置编码张量P，初始化为全0self.P = torch.zeros((1, max_len, num_hiddens))# 生成位置编码矩阵X，其中每一行表示一个位置的编码，编码方式采用sin和cos函数# 编码公式：X[i, j] = sin(i / 10000^(2j / num_hiddens)) 或 cos(i / 10000^(2j / num_hiddens))X = torch.arange(max_len, dtype=torch.float32).reshape(-1, 1) / torch.pow(10000, torch.arange(0, num_hiddens, 2,dtype=torch.float32) / num_hiddens)# 第一维度、第二维的所有元素，第三维将位置编码矩阵中的偶数维度的元素替换为sin函数的结果self.P[:, :, 0::2] = torch.sin(X)# 将位置编码矩阵中的奇数维度的元素替换为cos函数的结果self.P[:, :, 1::2] = torch.cos(X)def forward(self, X):# 将位置编码张量P与输入张量X相加，并将结果移动到与X相同的设备上# self.P[:, :X.shape[1], :]第二维从索引0到 X 的第二维大小的所有元素➡确保P的第二维和X的第二维一致，因为可能是不同的序列长度，为了动态的适应不同长度的输入X = X + self.P[:, :X.shape[1], :].to(X.device)# 对相加后的结果应用dropout，并返回结果return self.dropout(X)num_hiddens, num_heads = 100, 5
# 创建多头注意力实例
# 输入参数为隐藏单元数量、查询维度、键维度、值维度、头的数量和dropout率
attention = d2l.MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens,num_hiddens, num_heads, 0.5)
# 将多头注意力设置为评估模式，不进行训练
attention.eval()# 设置批量大小、查询数和有效长度
batch_size, num_queries, valid_lens = 2, 4, torch.tensor([3, 2])
X = torch.ones((batch_size, num_queries, num_hiddens))
# 对输入张量X应用多头注意力机制，并获取输出的形状
print(attention(X, X, X, valid_lens).shape)

---

行代表标记在序列中的位置，列代表位置编码的不同维度。

import torch
from torch import nn
from d2l import torch as d2l# 位置编码
class PositionalEncoding(nn.Module):# 初始化函数，接收隐藏单元数量、dropout率和最大序列长度作为输入def __init__(self, num_hiddens, dropout, max_len=1000):super(PositionalEncoding, self).__init__()self.dropout = nn.Dropout(dropout)# 创建一个形状为(batch_size, max_len, num_hiddens)的位置编码张量P，初始化为全0self.P = torch.zeros((1, max_len, num_hiddens))# 生成位置编码矩阵X，其中每一行表示一个位置的编码，编码方式采用sin和cos函数# 编码公式：X[i, j] = sin(i / 10000^(2j / num_hiddens)) 或 cos(i / 10000^(2j / num_hiddens))X = torch.arange(max_len, dtype=torch.float32).reshape(-1, 1) / torch.pow(10000, torch.arange(0, num_hiddens, 2,dtype=torch.float32) / num_hiddens)# 第一维度、第二维的所有元素，第三维将位置编码矩阵中的偶数维度的元素替换为sin函数的结果self.P[:, :, 0::2] = torch.sin(X)# 将位置编码矩阵中的奇数维度的元素替换为cos函数的结果self.P[:, :, 1::2] = torch.cos(X)def forward(self, X):# 将位置编码张量P与输入张量X相加，并将结果移动到与X相同的设备上# self.P[:, :X.shape[1], :]第二维从索引0到 X 的第二维大小的所有元素➡确保P的第二维和X的第二维一致，因为可能是不同的序列长度，为了动态的适应不同长度的输入X = X + self.P[:, :X.shape[1], :].to(X.device)# 对相加后的结果应用dropout，并返回结果return self.dropout(X)# 设置位置编码的维度和序列的长度
encoding_dim, num_steps = 32, 60
pos_encoding = PositionalEncoding(encoding_dim, 0)
pos_encoding.eval()
# 应用位置编码器到全0张量上，得到位置编码后的张量X
X = pos_encoding(torch.zeros((1, num_steps, encoding_dim)))
# 获取位置编码器中的位置编码张量P，截取与X相同长度的部分
P = pos_encoding.P[:, :X.shape[1], :]
# 绘制位置编码张量P中特定维度的子集
d2l.plot(torch.arange(num_steps), P[0, :, 6:10].T, xlabel='Row (position)',figsize=(6, 2.5), legend=["Col %d" % d for d in torch.arange(6, 10)])
d2l.plt.show()

---

二进制表示

for i in range(8):# 打印当前数字的二进制表示，使用字符串格式化进行对齐和补零print(f'{i} in binary is {i:>03b}')

在编码维度上降低频率

# 在编码维度上降低频率
# 从位置编码张量P中获取第一个样本的编码部分，并添加两个维度
P = P[0, :, :].unsqueeze(0).unsqueeze(0)
# 显示热力图，以编码维度为x轴，位置为y轴
d2l.show_heatmaps(P, xlabel='Column (encoding dimension)',ylabel='Row (position)', figsize=(3.5, 4), cmap='Blues')

该部分总代码

import torch
from torch import nn
from d2l import torch as d2l# 位置编码
class PositionalEncoding(nn.Module):# 初始化函数，接收隐藏单元数量、dropout率和最大序列长度作为输入def __init__(self, num_hiddens, dropout, max_len=1000):super(PositionalEncoding, self).__init__()self.dropout = nn.Dropout(dropout)# 创建一个形状为(batch_size, max_len, num_hiddens)的位置编码张量P，初始化为全0self.P = torch.zeros((1, max_len, num_hiddens))# 生成位置编码矩阵X，其中每一行表示一个位置的编码，编码方式采用sin和cos函数# 编码公式：X[i, j] = sin(i / 10000^(2j / num_hiddens)) 或 cos(i / 10000^(2j / num_hiddens))X = torch.arange(max_len, dtype=torch.float32).reshape(-1, 1) / torch.pow(10000, torch.arange(0, num_hiddens, 2,dtype=torch.float32) / num_hiddens)# 第一维度、第二维的所有元素，第三维将位置编码矩阵中的偶数维度的元素替换为sin函数的结果self.P[:, :, 0::2] = torch.sin(X)# 将位置编码矩阵中的奇数维度的元素替换为cos函数的结果self.P[:, :, 1::2] = torch.cos(X)def forward(self, X):# 将位置编码张量P与输入张量X相加，并将结果移动到与X相同的设备上# self.P[:, :X.shape[1], :]第二维从索引0到 X 的第二维大小的所有元素➡确保P的第二维和X的第二维一致，因为可能是不同的序列长度，为了动态的适应不同长度的输入X = X + self.P[:, :X.shape[1], :].to(X.device)# 对相加后的结果应用dropout，并返回结果return self.dropout(X)# 设置位置编码的维度和序列的长度
encoding_dim, num_steps = 32, 60
pos_encoding = PositionalEncoding(encoding_dim, 0)
pos_encoding.eval()
# 应用位置编码器到全0张量上，得到位置编码后的张量X
X = pos_encoding(torch.zeros((1, num_steps, encoding_dim)))
# 获取位置编码器中的位置编码张量P，截取与X相同长度的部分
P = pos_encoding.P[:, :X.shape[1], :]
# 在编码维度上降低频率
# 从位置编码张量P中获取第一个样本的编码部分，并添加两个维度
P = P[0, :, :].unsqueeze(0).unsqueeze(0)
# 显示热力图，以编码维度为x轴，位置为y轴
d2l.show_heatmaps(P, xlabel='Column (encoding dimension)',ylabel='Row (position)', figsize=(3.5, 4), cmap='Blues')
d2l.plt.show()