目录
自注意力
给定一个由词元组成的输入序列 x 1 x_1 x1,..., x n x_n xn，∀ x i x_i xi∈ R d R^d Rd
自注意力池化层将 x i x_i xi当作key、value、query来对序列抽取特征得到 y 1 y_1 y1,... y n y_n yn，这里
跟CNN、RNN对比
CNN：k：窗口的大小（每次看一个k大小的东西）
n：序列长度
d：输入和输出的通道数量
并行度：每一个输出可以自己并行做运算.
最长路径：O(n/k)
RNN：
时间复杂度 ：序列长度为为n，当更新循环神经网络的隐状态时， d×d的权重矩阵和d维隐状态的乘法计算复杂度为O( d 2 d^2 d2)，所以复杂度为O(n d 2 d^2 d2)
并行度 ：每一个 y i y_i yi的输出要等 y i − 1 y_{i-1} yi−1算完
最长路径 ： x 1 x_1 x1的信息要一直传递到 x n x_n xn，需要经过一个O(n)的一个序列。
自注意力：在自注意力中，查询、键和值都是n×d矩阵。其中n×d矩阵乘以d×n矩阵，之后输出的n×n矩阵乘以n×d矩阵。因此，自注意力具有O( n 2 d n^2d n2d)计算复杂度。
并行度：O(n)
最长路径：O(1)，也就是说任何一个地方的信息要到任何一个输出的话，是可以直接过去的。
自注意力适合比较长的文本，因为能看的比较宽。但计算复杂度比较高。
位置编码
跟CNN/RNN不同，自注意力并没有记录位置信息。
如果纯用自注意力机制来做序列模型的话，那么没有位置信息，那肯定是有问题的。所以一个加入位置信息的办法是位置编码。
它不是把位置信息加入到模型里面 ，因为一旦位置信息加入到模型里面总会有各种问题，CNN的会导致每一次得看一个比较长的序列，RNN的话并行度就低了，所以不是改变注意力机制本身 ，然后就把位置编码信息放到输入里，让输入有位置信息。
假设长度为n的序列是X∈ R n × d R^{n×d} Rn×d，那么使用位置编码矩阵P∈ R n × d R^{n×d} Rn×d来输出X+P作为自编码输入。
P的元素计算：
位置编码矩阵
X坐标是它的一个行数，就是说对第i个序列加的那个值是什么？然后四根曲线对应的是第6、7、8、9列
对每一个样本，它的维度每一个加的值是不一样的。样本和样本之间也是不一样的。
绝对位置信息
相对位置信息
总结
①自注意力池化层将 x i x_i xi当做key、value、query来对序列抽取特征。
②完全并行、最长序列为1、但对长序列计算复杂度高。
③位置编码在输入中加入位置信息，使得自注意力能够记忆位置信息。
自注意力和位置编码
python
import math
import torch
from torch import nn
from d2l import torch as d2l自注意力
python
from d2l import torch as d2l
num_hiddens, num_heads = 100, 5
# 创建多头注意力实例
# 输入参数为隐藏单元数量、查询维度、键维度、值维度、头的数量和dropout率
attention = d2l.MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens,
num_hiddens, num_heads, 0.5)
# 将多头注意力设置为评估模式，不进行训练
print(attention.eval())
python
# 设置批量大小、查询数和有效长度
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)
该部分总代码
python
from d2l import torch as d2l
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)位置编码
python
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，初始化为全0
self.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)该部分总代码
python
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，初始化为全0
self.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)行代表标记在序列中的位置，列代表位置编码的不同维度。
python
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，初始化为全0
self.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()
二进制表示
python
for i in range(8):
# 打印当前数字的二进制表示，使用字符串格式化进行对齐和补零
print(f'{i} in binary is {i:>03b}')
在编码维度上降低频率
python
# 在编码维度上降低频率
# 从位置编码张量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')
该部分总代码
python
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，初始化为全0
self.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()