深度学习--------------------------------使用注意力机制的seq2seq

目录

  • 动机
  • 加入注意力
    • Bahdanau注意力的架构
  • 总结
  • Bahdanau注意力代码
    • 带有注意力机制的解码器基本接口
    • 实现带有Bahdanau注意力的循环神经网络解码器
    • 测试Bahdanau注意力解码器
      • 该部分总代码
    • 训练
      • 从零实现总代码
      • 简洁实现代码
    • 将几个英语句子翻译成法语
      • 该部分总代码
    • 将注意力权重序列进行拼接
    • 可视化注意力权重
      • 该部分总代码

动机

动机：在机器翻译中，每个生成的词可能源自与句子中间的不同的词。

在这里插入图片描述

源句子：“hello world .”

其中hello比较重要，所以去翻译这个词的时候应该找到与它相似的（也就是bonjour）应该把关注点放在这个词上面，而不需要去看很多其它的东西。

在这里插入图片描述
例如：假设翻译的是“monde”，那么对应的是“world”这个词



所以说比较长的句子的时候，就是把所有东西压到一起，因为压到一起可能看不出来到底哪一块是前面、哪一块是后面。所以在翻译句子哪个部位的时候去看对应部位的原句子。

但是seq2seq做不了这个事情，因为seq2seq传过去的东西是最后那个词的隐藏状态，seq2seq只用了最后这个词输出的东西，根据这个东西去往下找，

在这里插入图片描述
所以它看不到前面那些词的输入。当然，前面那些词（hello word）已经在这个里面了，假设已经存了很多问题了，那么需要从这里还原出你的未知的信息。

所以这里的动机是说：我想要去翻译对应的词的时候，去让我的注意力关注在原句子中对应的部分。



加入注意力

Bahdanau注意力的架构

在这里插入图片描述

在做解码器的RNN的输入的时候，一块来自Embedding、另外一块来自前面编码器的RNN的最后一个时刻的最后一层的输出作为上下文一块传进去的。
在这里插入图片描述
现在说用最后一个时刻作为上下文，即：作为那个context传进去不好。应该根据当前预测任务去动态的选择，而不是只能是最后时刻的隐藏状态作为输入，可能是前面几个时刻对应的那些隐藏状态作为输入。

例如：
    在翻译第一个的时候（hello），我不应该去把那个RNN最后那个时刻（即：那个句号）对应的state传到解码器的RNN，而是把第一个时刻的隐藏状态传到解码器的RNN。

在这里插入图片描述


①编码器对应每个词的输出作为key和value放进Attention里面。
在这里插入图片描述

②解码器RNN对上一个词的预测输出是query
在这里插入图片描述

③注意力的输出和下一个词的词嵌入合并进入RNN。

在这里插入图片描述


对比seq2seq的改进：

seq2seq永远是上一个RNN里面的最后那一个词的输出，现在是把所有的词拿出来对它做一个weight（做一个加权的平均），然后根据不同的词，比如一开始用前面的那些输出，到后面就用后面那些词的输出。



总结

①Seq2seq中通过隐状态在编码器和解码器中传递信息。

②注意力机制可以根据解码器RNN的输出来匹配到合适的编码器RNN的输出来更有效的传递信息。



Bahdanau注意力代码

import torch
from torch import nn
from d2l import torch as d2l
import os



带有注意力机制的解码器基本接口

# 带有注意力机制的解码器基本接口
class AttentionDecoder(d2l.Decoder):"""带有注意力机制的解码器基本接口"""def __init__(self, **kwargs):super(AttentionDecoder, self).__init__(**kwargs)@propertydef attention_weight(self):raise NotImplementedError


实现带有Bahdanau注意力的循环神经网络解码器

# 实现带有Bahdanau注意力的循环神经网络解码器
class Seq2SeqAttentionDecoder(AttentionDecoder):def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):# 调用父类AttentionDecoder的构造函数进行初始化super(Seq2SeqAttentionDecoder, self).__init__(**kwargs)# 创建一个加性注意力机制的实例，用于计算注意力权重# 这里的key、value、query长度都是num_hiddens，所以可以用点乘的attention（Scaled Dot-Product Attention）# 这里用加性的是因为这里可以学参数，效果会好一点self.attention = d2l.AdditiveAttention(num_hiddens, num_hiddens, num_hiddens, dropout)# 这三行和seq2seq一样的self.embedding = nn.Embedding(vocab_size, embed_size)self.rnn = nn.GRU(embed_size + num_hiddens, num_hiddens, num_layers, dropout=dropout)self.dense = nn.Linear(num_hiddens, vocab_size)# 这里相比之前多了enc_valid_lens，需要告诉哪些是填充的def init_state(self, enc_outputs, enc_valid_lens, *args):outputs, hidden_state = enc_outputs# 对outputs进行维度变换，将batch维和时间步维交换，保持与解码器输入的一致性# 返回初始化的解码器隐藏状态return (outputs.permute(1, 0, 2), hidden_state, enc_valid_lens)def forward(self, X, state):enc_outputs, hidden_state, enc_valid_lens = state# 对输入序列进行嵌入表示，并进行维度变换，将batch维和时间步维交换X = self.embedding(X).permute(1, 0, 2)outputs, self._attention_weights = [], []# 每一步的context会变，所以对于decode的输入的每一个xfor x in X:# hidden_state[-1]是取上一个时间的RNN的输出（最后一层的输出）# 获取当前时间步的查询向量，将隐藏状态的最后一个时间步的特征进行维度扩展# 加一个number of query这个维度进去，虽然这个query只有一个query = torch.unsqueeze(hidden_state[-1], dim=1)# ⭐计算注意力上下文向量，通过注意力机制对编码器的输出进行加权求和# query就是上一个时刻的最后一层的输出# key就是enc_outputs（形状：[批量大小、时间步、num_hiddens]），value就是enc_outputs# enc_valid_lens是一个长为bath_size的一个向量，其中第i个元素表示第i个样本的原始长度是几，因为不算填充context = self.attention(query, enc_outputs, enc_outputs, enc_valid_lens)# 将注意力上下文向量与当前时间步的输入进行拼接，用于输入到循环神经网络# 因为context里面多了一个长为1的维度（就是那个key的维度），所以x也加了一个维度，然后在最后一个维度concat起来x = torch.cat((context, torch.unsqueeze(x, dim=1)), dim=-1)# 执行循环神经网络的前向计算，得到输出和更新后的隐藏状态out, hidden_state = self.rnn(x.permute(1, 0, 2), hidden_state)# 将输出和注意力权重添加到对应的列表中outputs.append(out)self._attention_weights.append(self.attention.attention_weights)# 将输出列表中的结果进行拼接，并通过线性层进行映射outputs = self.dense(torch.cat(outputs, dim=0))# 对输出进行维度变换，将batch维和时间步维交换，并返回更新后的状态信息return outputs.permute(1, 0, 2), [enc_outputs, hidden_state, enc_valid_lens]@propertydef attention_weights(self):# 返回注意力权重return self._attention_weights


测试Bahdanau注意力解码器

# 创建编码器和解码器的实例
encoder = d2l.Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)
encoder.eval()
decoder = Seq2SeqAttentionDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)
decoder.eval()
# 创建输入序列X
X = torch.zeros((4, 7), dtype=torch.long)
# 初始化解码器的状态
state = decoder.init_state(encoder(X), None)
# 执行解码器的前向计算
output, state = decoder(X, state)
# 输出结果的形状以及状态信息的长度和形状
print(output.shape)
print(len(state))
print(state[0].shape)
print(len(state[1]))
print(state[1][0].shape)



该部分总代码

import torch
from torch import nn
from d2l import torch as d2l
import os# 带有注意力机制的解码器基本接口
class AttentionDecoder(d2l.Decoder):"""带有注意力机制的解码器基本接口"""def __init__(self, **kwargs):super(AttentionDecoder, self).__init__(**kwargs)@propertydef attention_weight(self):raise NotImplementedError# 实现带有Bahdanau注意力的循环神经网络解码器
class Seq2SeqAttentionDecoder(AttentionDecoder):def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):# 调用父类AttentionDecoder的构造函数进行初始化super(Seq2SeqAttentionDecoder, self).__init__(**kwargs)# 创建一个加性注意力机制的实例，用于计算注意力权重# 这里的key、value、query长度都是num_hiddens，所以可以用点乘的attention（Scaled Dot-Product Attention）# 这里用加性的是因为这里可以学参数，效果会好一点self.attention = d2l.AdditiveAttention(num_hiddens, num_hiddens, num_hiddens, dropout)# 这三行和seq2seq一样的self.embedding = nn.Embedding(vocab_size, embed_size)self.rnn = nn.GRU(embed_size + num_hiddens, num_hiddens, num_layers, dropout=dropout)self.dense = nn.Linear(num_hiddens, vocab_size)# 这里相比之前多了enc_valid_lens，需要告诉哪些是填充的def init_state(self, enc_outputs, enc_valid_lens, *args):outputs, hidden_state = enc_outputs# 对outputs进行维度变换，将batch维和时间步维交换，保持与解码器输入的一致性# 返回初始化的解码器隐藏状态return (outputs.permute(1, 0, 2), hidden_state, enc_valid_lens)def forward(self, X, state):enc_outputs, hidden_state, enc_valid_lens = state# 对输入序列进行嵌入表示，并进行维度变换，将batch维和时间步维交换X = self.embedding(X).permute(1, 0, 2)outputs, self._attention_weights = [], []# 每一步的context会变，所以对于decode的输入的每一个xfor x in X:# hidden_state[-1]是取上一个时间的RNN的输出（最后一层的输出）# 获取当前时间步的查询向量，将隐藏状态的最后一个时间步的特征进行维度扩展# 加一个number of query这个维度进去，虽然这个query只有一个# 这里的query形状是[4, 1, 16]query = torch.unsqueeze(hidden_state[-1], dim=1)# ⭐计算注意力上下文向量，通过注意力机制对编码器的输出进行加权求和# query就是上一个时刻的最后一层的输出# key就是enc_outputs（形状：[批量大小、时间步、num_hiddens]），value就是enc_outputs# enc_valid_lens是一个长为bath_size的一个向量，其中第i个元素表示第i个样本的原始长度是几，因为不算填充# 这里的context形状是[4, 1, 16]context = self.attention(query, enc_outputs, enc_outputs, enc_valid_lens)# 将注意力上下文向量与当前时间步的输入进行拼接，用于输入到循环神经网络# 因为context里面多了一个长为1的维度（就是那个key的维度），所以x也加了一个维度，然后在最后一个维度concat起来x = torch.cat((context, torch.unsqueeze(x, dim=1)), dim=-1)# 执行循环神经网络的前向计算，得到输出和更新后的隐藏状态out, hidden_state = self.rnn(x.permute(1, 0, 2), hidden_state)# 将输出和注意力权重添加到对应的列表中outputs.append(out)self._attention_weights.append(self.attention.attention_weights)# 将输出列表中的结果进行拼接，并通过线性层进行映射outputs = self.dense(torch.cat(outputs, dim=0))# 对输出进行维度变换，将batch维和时间步维交换，并返回更新后的状态信息return outputs.permute(1, 0, 2), [enc_outputs, hidden_state, enc_valid_lens]@propertydef attention_weights(self):# 返回注意力权重return self._attention_weights# 创建编码器和解码器的实例
encoder = d2l.Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)
encoder.eval()
decoder = Seq2SeqAttentionDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)
decoder.eval()
# 创建输入序列X
X = torch.zeros((4, 7), dtype=torch.long)
# 初始化解码器的状态
state = decoder.init_state(encoder(X), None)
# 执行解码器的前向计算
output, state = decoder(X, state)
# 输出结果的形状以及状态信息的长度和形状
print(output.shape)
print(len(state))
print(state[0].shape)
print(len(state[1]))
print(state[1][0].shape)

在这里插入图片描述



训练

train_iter, src_vocab, tgt_vocab = d2l.load_data_nmt(batch_size, num_steps)
encoder = d2l.Seq2SeqEncoder(len(src_vocab), embed_size, num_hiddens, num_layers, dropout)
# 创建目标语言的带有注意力机制的解码器实例
decoder = Seq2SeqAttentionDecoder(len(tgt_vocab), embed_size, num_hiddens, num_layers, dropout)
# 创建编码-解码模型实例
net = d2l.EncoderDecoder(encoder, decoder)
# 训练序列到序列模型
d2l.train_seq2seq(net, train_iter, lr, num_epochs, tgt_vocab, device)
d2l.plt.show()



从零实现总代码

import torch
from torch import nn
from d2l import torch as d2l
import os# 带有注意力机制的解码器基本接口
class AttentionDecoder(d2l.Decoder):"""带有注意力机制的解码器基本接口"""def __init__(self, **kwargs):super(AttentionDecoder, self).__init__(**kwargs)@propertydef attention_weight(self):raise NotImplementedError# 实现带有Bahdanau注意力的循环神经网络解码器
class Seq2SeqAttentionDecoder(AttentionDecoder):def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):# 调用父类AttentionDecoder的构造函数进行初始化super(Seq2SeqAttentionDecoder, self).__init__(**kwargs)# 创建一个加性注意力机制的实例，用于计算注意力权重# 这里的key、value、query长度都是num_hiddens，所以可以用点乘的attention（Scaled Dot-Product Attention）# 这里用加性的是因为这里可以学参数，效果会好一点self.attention = d2l.AdditiveAttention(num_hiddens, num_hiddens, num_hiddens, dropout)# 这三行和seq2seq一样的self.embedding = nn.Embedding(vocab_size, embed_size)self.rnn = nn.GRU(embed_size + num_hiddens, num_hiddens, num_layers, dropout=dropout)self.dense = nn.Linear(num_hiddens, vocab_size)# 这里相比之前多了enc_valid_lens，需要告诉哪些是填充的def init_state(self, enc_outputs, enc_valid_lens, *args):outputs, hidden_state = enc_outputs# 对outputs进行维度变换，将batch维和时间步维交换，保持与解码器输入的一致性# 返回初始化的解码器隐藏状态return (outputs.permute(1, 0, 2), hidden_state, enc_valid_lens)def forward(self, X, state):enc_outputs, hidden_state, enc_valid_lens = state# 对输入序列进行嵌入表示，并进行维度变换，将batch维和时间步维交换X = self.embedding(X).permute(1, 0, 2)outputs, self._attention_weights = [], []# 每一步的context会变，所以对于decode的输入的每一个xfor x in X:# hidden_state[-1]是取上一个时间的RNN的输出（最后一层的输出）# 获取当前时间步的查询向量，将隐藏状态的最后一个时间步的特征进行维度扩展# 加一个number of query这个维度进去，虽然这个query只有一个# 这里的query形状是[4, 1, 16]query = torch.unsqueeze(hidden_state[-1], dim=1)# ⭐计算注意力上下文向量，通过注意力机制对编码器的输出进行加权求和# query就是上一个时刻的最后一层的输出# key就是enc_outputs（形状：[批量大小、时间步、num_hiddens]），value就是enc_outputs# enc_valid_lens是一个长为bath_size的一个向量，其中第i个元素表示第i个样本的原始长度是几，因为不算填充# 这里的context形状是[4, 1, 16]context = self.attention(query, enc_outputs, enc_outputs, enc_valid_lens)# 将注意力上下文向量与当前时间步的输入进行拼接，用于输入到循环神经网络# 因为context里面多了一个长为1的维度（就是那个key的维度），所以x也加了一个维度，然后在最后一个维度concat起来x = torch.cat((context, torch.unsqueeze(x, dim=1)), dim=-1)# 执行循环神经网络的前向计算，得到输出和更新后的隐藏状态out, hidden_state = self.rnn(x.permute(1, 0, 2), hidden_state)# 将输出和注意力权重添加到对应的列表中outputs.append(out)self._attention_weights.append(self.attention.attention_weights)# 将输出列表中的结果进行拼接，并通过线性层进行映射outputs = self.dense(torch.cat(outputs, dim=0))# 对输出进行维度变换，将batch维和时间步维交换，并返回更新后的状态信息return outputs.permute(1, 0, 2), [enc_outputs, hidden_state, enc_valid_lens]@propertydef attention_weights(self):# 返回注意力权重return self._attention_weightsdef read_data_nmt():"""载入 “英语-法语” 数据集 """# 下载并解压数据集data_dir = d2l.download_extract('fra-eng')# 打开数据文件，使用utf-8编码读取文件内容with open(os.path.join(data_dir, 'fra.txt'), 'r', encoding='utf-8') as f:# 返回读取的文件内容return f.read()def preprocess_nmt(text):"""预处理 “英语-法语” 数据集"""def no_space(char, prev_char):# 检查是否需要在字符之前添加空格return char in set(',.!?') and prev_char != ''# 替换特殊字符为空格并转换为小写text = text.replace('\u202f', ' ').replace('\xa0', ' ').lower()# 根据规则在字符之前添加空格out = [' ' + char if i > 0 and no_space(char, text[i - 1]) else charfor i, char in enumerate(text)]# 将处理后的字符列表连接成字符串并返回return ''.join(out)def tokenize_nmt(text, num_examples=None):"""词元化 “英语-法语” 数据数据集 """# 初始化源语言和目标语言的列表source, target = [], []# 对每行文本进行遍历for i, line in enumerate(text.split('\n')):# 如果指定了num_examples，并且超过了指定数量，则退出循环if num_examples and i > num_examples:break# 将每行文本按制表符分割成源语言和目标语言的部分parts = line.split('\t')# 如果分割后有两个部分，说明包含了源语言和目标语言的内容if len(parts) == 2:# 将源语言部分以空格为分隔符进行词元化，存储到源语言列表中source.append(parts[0].split(' '))# 将目标语言部分以空格为分隔符进行词元化，存储到目标语言列表中target.append(parts[1].split(' '))# 返回词元化后的源语言列表和目标语言列表return source, targetdef truncate_pad(line, num_steps, padding_token):"""截断或填充文本序列"""# 如果文本序列的长度超过了指定的步数if len(line) > num_steps:# 截断文本序列，保留前num_steps个元素return line[:num_steps]# 在文本序列末尾填充padding_token，使其长度达到num_stepsreturn line + [padding_token] * (num_steps - len(line))def build_array_nmt(lines, vocab, num_steps):"""将机器翻译的文本序列转换成小批量"""# 将文本序列中的每个词根据词汇表转换为对应的索引lines = [vocab[l] for l in lines]# 在每个文本序列末尾添加<eos>表示句子结束的索引lines = [l + [vocab['<eos>']] for l in lines]# 将每个文本序列截断或填充为固定长度，并转换为tensor形式array = torch.tensor([truncate_pad(l, num_steps, vocab['<pad>']) for l in lines])# 计算有效长度，即非填充部分的长度valid_len = (array != vocab['<pad>']).type(torch.int32).sum(1)# 返回转换后的tensor形式的文本序列和有效长度return array, valid_lendef load_data_nmt(batch_size, num_steps, num_examples=600):"""返回翻译数据集的迭代器和词汇表"""# 载入并预处理文本数据集text = preprocess_nmt(read_data_nmt())# 将文本数据集进行词元化source, target = tokenize_nmt(text, num_examples)# 构建源语言的词汇表对象src_vocab = d2l.Vocab(source, min_freq=2,reserved_tokens=['<pad>', '<bos>', '<eos>'])# 构建目标语言的词汇表对象tgt_vocab = d2l.Vocab(target, min_freq=2,reserved_tokens=['<pad>', '<bos>', '<eos>'])# 将源语言文本序列转换为小批量数据，并获取有效长度src_array, src_valid_len = build_array_nmt(source, src_vocab, num_steps)# 将目标语言文本序列转换为小批量数据，并获取有效长度tgt_array, tgt_valid_len = build_array_nmt(target, tgt_vocab, num_steps)# 构建数据集的数组data_arrays = (src_array, src_valid_len, tgt_array, tgt_valid_len)# 构建数据迭代器data_iter = d2l.load_array(data_arrays, batch_size)# 返回数据迭代器和词汇表对象return data_iter, src_vocab, tgt_vocabembed_size, num_hiddens, num_layers, dropout = 32, 32, 2, 0.1
batch_size, num_steps = 64, 10
lr, num_epochs, device = 0.005, 250, d2l.try_gpu()train_iter, src_vocab, tgt_vocab = load_data_nmt(batch_size, num_steps)
encoder = d2l.Seq2SeqEncoder(len(src_vocab), embed_size, num_hiddens, num_layers, dropout)
# 创建目标语言的带有注意力机制的解码器实例
decoder = Seq2SeqAttentionDecoder(len(tgt_vocab), embed_size, num_hiddens, num_layers, dropout)
# 创建编码-解码模型实例
net = d2l.EncoderDecoder(encoder, decoder)
# 训练序列到序列模型
d2l.train_seq2seq(net, train_iter, lr, num_epochs, tgt_vocab, device)
d2l.plt.show()

在这里插入图片描述
在这里插入图片描述



简洁实现代码

import torch
from torch import nn
from d2l import torch as d2l
import os# 带有注意力机制的解码器基本接口
class AttentionDecoder(d2l.Decoder):"""带有注意力机制的解码器基本接口"""def __init__(self, **kwargs):super(AttentionDecoder, self).__init__(**kwargs)@propertydef attention_weight(self):raise NotImplementedError# 实现带有Bahdanau注意力的循环神经网络解码器
class Seq2SeqAttentionDecoder(AttentionDecoder):def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):# 调用父类AttentionDecoder的构造函数进行初始化super(Seq2SeqAttentionDecoder, self).__init__(**kwargs)# 创建一个加性注意力机制的实例，用于计算注意力权重# 这里的key、value、query长度都是num_hiddens，所以可以用点乘的attention（Scaled Dot-Product Attention）# 这里用加性的是因为这里可以学参数，效果会好一点self.attention = d2l.AdditiveAttention(num_hiddens, num_hiddens, num_hiddens, dropout)# 这三行和seq2seq一样的self.embedding = nn.Embedding(vocab_size, embed_size)self.rnn = nn.GRU(embed_size + num_hiddens, num_hiddens, num_layers, dropout=dropout)self.dense = nn.Linear(num_hiddens, vocab_size)# 这里相比之前多了enc_valid_lens，需要告诉哪些是填充的def init_state(self, enc_outputs, enc_valid_lens, *args):outputs, hidden_state = enc_outputs# 对outputs进行维度变换，将batch维和时间步维交换，保持与解码器输入的一致性# 返回初始化的解码器隐藏状态return (outputs.permute(1, 0, 2), hidden_state, enc_valid_lens)def forward(self, X, state):enc_outputs, hidden_state, enc_valid_lens = state# 对输入序列进行嵌入表示，并进行维度变换，将batch维和时间步维交换X = self.embedding(X).permute(1, 0, 2)outputs, self._attention_weights = [], []# 每一步的context会变，所以对于decode的输入的每一个xfor x in X:# hidden_state[-1]是取上一个时间的RNN的输出（最后一层的输出）# 获取当前时间步的查询向量，将隐藏状态的最后一个时间步的特征进行维度扩展# 加一个number of query这个维度进去，虽然这个query只有一个# 这里的query形状是[4, 1, 16]query = torch.unsqueeze(hidden_state[-1], dim=1)# ⭐计算注意力上下文向量，通过注意力机制对编码器的输出进行加权求和# query就是上一个时刻的最后一层的输出# key就是enc_outputs（形状：[批量大小、时间步、num_hiddens]），value就是enc_outputs# enc_valid_lens是一个长为bath_size的一个向量，其中第i个元素表示第i个样本的原始长度是几，因为不算填充# 这里的context形状是[4, 1, 16]context = self.attention(query, enc_outputs, enc_outputs, enc_valid_lens)# 将注意力上下文向量与当前时间步的输入进行拼接，用于输入到循环神经网络# 因为context里面多了一个长为1的维度（就是那个key的维度），所以x也加了一个维度，然后在最后一个维度concat起来x = torch.cat((context, torch.unsqueeze(x, dim=1)), dim=-1)# 执行循环神经网络的前向计算，得到输出和更新后的隐藏状态out, hidden_state = self.rnn(x.permute(1, 0, 2), hidden_state)# 将输出和注意力权重添加到对应的列表中outputs.append(out)self._attention_weights.append(self.attention.attention_weights)# 将输出列表中的结果进行拼接，并通过线性层进行映射outputs = self.dense(torch.cat(outputs, dim=0))# 对输出进行维度变换，将batch维和时间步维交换，并返回更新后的状态信息return outputs.permute(1, 0, 2), [enc_outputs, hidden_state, enc_valid_lens]@propertydef attention_weights(self):# 返回注意力权重return self._attention_weightsembed_size, num_hiddens, num_layers, dropout = 32, 32, 2, 0.1
batch_size, num_steps = 64, 10
lr, num_epochs, device = 0.005, 250, d2l.try_gpu()train_iter, src_vocab, tgt_vocab = d2l.load_data_nmt(batch_size, num_steps)
encoder = d2l.Seq2SeqEncoder(len(src_vocab), embed_size, num_hiddens, num_layers, dropout)
# 创建目标语言的带有注意力机制的解码器实例
decoder = Seq2SeqAttentionDecoder(len(tgt_vocab), embed_size, num_hiddens, num_layers, dropout)
# 创建编码-解码模型实例
net = d2l.EncoderDecoder(encoder, decoder)
# 训练序列到序列模型
d2l.train_seq2seq(net, train_iter, lr, num_epochs, tgt_vocab, device)
d2l.plt.show()

在这里插入图片描述

在这里插入图片描述



将几个英语句子翻译成法语

# 将几个英语句子翻译成汉语
# 英语句子列表
engs = ['go', "i lost .", 'he\'s calm .', 'i\'m home .']
# 对应的汉语句子列表
fras = ['va !', 'j\' ai perdu .', 'il est calme .', 'je suis chez moi .']
# 遍历英语句子和汉语句子的对应关系
for eng, fra in zip(engs, fras):# 使用训练好的模型net对英语句子进行翻译，并获取注意力权重序列translation, dec_attention_weight_seq = d2l.predict_seq2seq(net, eng, src_vocab, tgt_vocab, num_steps, device, True)# 打印英语句子、翻译结果和BLEU分数print(f' {eng} => {translation}, ',f'bleu {d2l.bleu(translation, fra, k=2):.3f}')

在这里插入图片描述


该部分总代码

import torch
from torch import nn
from d2l import torch as d2l
import os# 带有注意力机制的解码器基本接口
class AttentionDecoder(d2l.Decoder):"""带有注意力机制的解码器基本接口"""def __init__(self, **kwargs):super(AttentionDecoder, self).__init__(**kwargs)@propertydef attention_weight(self):raise NotImplementedError# 实现带有Bahdanau注意力的循环神经网络解码器
class Seq2SeqAttentionDecoder(AttentionDecoder):def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):# 调用父类AttentionDecoder的构造函数进行初始化super(Seq2SeqAttentionDecoder, self).__init__(**kwargs)# 创建一个加性注意力机制的实例，用于计算注意力权重# 这里的key、value、query长度都是num_hiddens，所以可以用点乘的attention（Scaled Dot-Product Attention）# 这里用加性的是因为这里可以学参数，效果会好一点self.attention = d2l.AdditiveAttention(num_hiddens, num_hiddens, num_hiddens, dropout)# 这三行和seq2seq一样的self.embedding = nn.Embedding(vocab_size, embed_size)self.rnn = nn.GRU(embed_size + num_hiddens, num_hiddens, num_layers, dropout=dropout)self.dense = nn.Linear(num_hiddens, vocab_size)# 这里相比之前多了enc_valid_lens，需要告诉哪些是填充的def init_state(self, enc_outputs, enc_valid_lens, *args):outputs, hidden_state = enc_outputs# 对outputs进行维度变换，将batch维和时间步维交换，保持与解码器输入的一致性# 返回初始化的解码器隐藏状态return (outputs.permute(1, 0, 2), hidden_state, enc_valid_lens)def forward(self, X, state):enc_outputs, hidden_state, enc_valid_lens = state# 对输入序列进行嵌入表示，并进行维度变换，将batch维和时间步维交换X = self.embedding(X).permute(1, 0, 2)outputs, self._attention_weights = [], []# 每一步的context会变，所以对于decode的输入的每一个xfor x in X:# hidden_state[-1]是取上一个时间的RNN的输出（最后一层的输出）# 获取当前时间步的查询向量，将隐藏状态的最后一个时间步的特征进行维度扩展# 加一个number of query这个维度进去，虽然这个query只有一个# 这里的query形状是[4, 1, 16]query = torch.unsqueeze(hidden_state[-1], dim=1)# ⭐计算注意力上下文向量，通过注意力机制对编码器的输出进行加权求和# query就是上一个时刻的最后一层的输出# key就是enc_outputs（形状：[批量大小、时间步、num_hiddens]），value就是enc_outputs# enc_valid_lens是一个长为bath_size的一个向量，其中第i个元素表示第i个样本的原始长度是几，因为不算填充# 这里的context形状是[4, 1, 16]context = self.attention(query, enc_outputs, enc_outputs, enc_valid_lens)# 将注意力上下文向量与当前时间步的输入进行拼接，用于输入到循环神经网络# 因为context里面多了一个长为1的维度（就是那个key的维度），所以x也加了一个维度，然后在最后一个维度concat起来x = torch.cat((context, torch.unsqueeze(x, dim=1)), dim=-1)# 执行循环神经网络的前向计算，得到输出和更新后的隐藏状态out, hidden_state = self.rnn(x.permute(1, 0, 2), hidden_state)# 将输出和注意力权重添加到对应的列表中outputs.append(out)self._attention_weights.append(self.attention.attention_weights)# 将输出列表中的结果进行拼接，并通过线性层进行映射outputs = self.dense(torch.cat(outputs, dim=0))# 对输出进行维度变换，将batch维和时间步维交换，并返回更新后的状态信息return outputs.permute(1, 0, 2), [enc_outputs, hidden_state, enc_valid_lens]@propertydef attention_weights(self):# 返回注意力权重return self._attention_weightsembed_size, num_hiddens, num_layers, dropout = 32, 32, 2, 0.1
batch_size, num_steps = 64, 10
lr, num_epochs, device = 0.005, 250, d2l.try_gpu()train_iter, src_vocab, tgt_vocab = d2l.load_data_nmt(batch_size, num_steps)
encoder = d2l.Seq2SeqEncoder(len(src_vocab), embed_size, num_hiddens, num_layers, dropout)
# 创建目标语言的带有注意力机制的解码器实例
decoder = Seq2SeqAttentionDecoder(len(tgt_vocab), embed_size, num_hiddens, num_layers, dropout)
# 创建编码-解码模型实例
net = d2l.EncoderDecoder(encoder, decoder)
# 训练序列到序列模型
d2l.train_seq2seq(net, train_iter, lr, num_epochs, tgt_vocab, device)
# 将几个英语句子翻译成汉语
# 英语句子列表
engs = ['go', "i lost .", 'he\'s calm .', 'i\'m home .']
# 对应的汉语句子列表
fras = ['va !', 'j\' ai perdu .', 'il est calme .', 'je suis chez moi .']
# 遍历英语句子和汉语句子的对应关系
for eng, fra in zip(engs, fras):# 使用训练好的模型net对英语句子进行翻译，并获取注意力权重序列translation, dec_attention_weight_seq = d2l.predict_seq2seq(net, eng, src_vocab, tgt_vocab, num_steps, device, True)# 打印英语句子、翻译结果和BLEU分数print(f' {eng} => {translation}, ',f'bleu {d2l.bleu(translation, fra, k=2):.3f}')


将注意力权重序列进行拼接


# 将注意力权重序列进行拼接，并调整形状
attention_weights = torch.cat([step[0][0][0] for step in dec_attention_weight_seq], 0).reshape((1, 1, -1, num_steps))


可视化注意力权重

# 可视化注意力权重
# 显示注意力权重的热图，仅显示与输入英语句子对应的位置
d2l.show_heatmaps(attention_weights[:,:,:,:len(engs[-1].split()) + 1].cpu(),xlabel = 'key positions', ylabel = 'Query posistions')

在这里插入图片描述


该部分总代码

import torch
from torch import nn
from d2l import torch as d2l
import os# 带有注意力机制的解码器基本接口
class AttentionDecoder(d2l.Decoder):"""带有注意力机制的解码器基本接口"""def __init__(self, **kwargs):super(AttentionDecoder, self).__init__(**kwargs)@propertydef attention_weight(self):raise NotImplementedError# 实现带有Bahdanau注意力的循环神经网络解码器
class Seq2SeqAttentionDecoder(AttentionDecoder):def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):# 调用父类AttentionDecoder的构造函数进行初始化super(Seq2SeqAttentionDecoder, self).__init__(**kwargs)# 创建一个加性注意力机制的实例，用于计算注意力权重# 这里的key、value、query长度都是num_hiddens，所以可以用点乘的attention（Scaled Dot-Product Attention）# 这里用加性的是因为这里可以学参数，效果会好一点self.attention = d2l.AdditiveAttention(num_hiddens, num_hiddens, num_hiddens, dropout)# 这三行和seq2seq一样的self.embedding = nn.Embedding(vocab_size, embed_size)self.rnn = nn.GRU(embed_size + num_hiddens, num_hiddens, num_layers, dropout=dropout)self.dense = nn.Linear(num_hiddens, vocab_size)# 这里相比之前多了enc_valid_lens，需要告诉哪些是填充的def init_state(self, enc_outputs, enc_valid_lens, *args):outputs, hidden_state = enc_outputs# 对outputs进行维度变换，将batch维和时间步维交换，保持与解码器输入的一致性# 返回初始化的解码器隐藏状态return (outputs.permute(1, 0, 2), hidden_state, enc_valid_lens)def forward(self, X, state):enc_outputs, hidden_state, enc_valid_lens = state# 对输入序列进行嵌入表示，并进行维度变换，将batch维和时间步维交换X = self.embedding(X).permute(1, 0, 2)outputs, self._attention_weights = [], []# 每一步的context会变，所以对于decode的输入的每一个xfor x in X:# hidden_state[-1]是取上一个时间的RNN的输出（最后一层的输出）# 获取当前时间步的查询向量，将隐藏状态的最后一个时间步的特征进行维度扩展# 加一个number of query这个维度进去，虽然这个query只有一个# 这里的query形状是[4, 1, 16]query = torch.unsqueeze(hidden_state[-1], dim=1)# ⭐计算注意力上下文向量，通过注意力机制对编码器的输出进行加权求和# query就是上一个时刻的最后一层的输出# key就是enc_outputs（形状：[批量大小、时间步、num_hiddens]），value就是enc_outputs# enc_valid_lens是一个长为bath_size的一个向量，其中第i个元素表示第i个样本的原始长度是几，因为不算填充# 这里的context形状是[4, 1, 16]context = self.attention(query, enc_outputs, enc_outputs, enc_valid_lens)# 将注意力上下文向量与当前时间步的输入进行拼接，用于输入到循环神经网络# 因为context里面多了一个长为1的维度（就是那个key的维度），所以x也加了一个维度，然后在最后一个维度concat起来x = torch.cat((context, torch.unsqueeze(x, dim=1)), dim=-1)# 执行循环神经网络的前向计算，得到输出和更新后的隐藏状态out, hidden_state = self.rnn(x.permute(1, 0, 2), hidden_state)# 将输出和注意力权重添加到对应的列表中outputs.append(out)self._attention_weights.append(self.attention.attention_weights)# 将输出列表中的结果进行拼接，并通过线性层进行映射outputs = self.dense(torch.cat(outputs, dim=0))# 对输出进行维度变换，将batch维和时间步维交换，并返回更新后的状态信息return outputs.permute(1, 0, 2), [enc_outputs, hidden_state, enc_valid_lens]@propertydef attention_weights(self):# 返回注意力权重return self._attention_weightsembed_size, num_hiddens, num_layers, dropout = 32, 32, 2, 0.1
batch_size, num_steps = 64, 10
lr, num_epochs, device = 0.005, 250, d2l.try_gpu()train_iter, src_vocab, tgt_vocab = d2l.load_data_nmt(batch_size, num_steps)
encoder = d2l.Seq2SeqEncoder(len(src_vocab), embed_size, num_hiddens, num_layers, dropout)
# 创建目标语言的带有注意力机制的解码器实例
decoder = Seq2SeqAttentionDecoder(len(tgt_vocab), embed_size, num_hiddens, num_layers, dropout)
# 创建编码-解码模型实例
net = d2l.EncoderDecoder(encoder, decoder)
# 训练序列到序列模型
d2l.train_seq2seq(net, train_iter, lr, num_epochs, tgt_vocab, device)
# 将几个英语句子翻译成汉语
# 英语句子列表
engs = ['go', "i lost .", 'he\'s calm .', 'i\'m home .']
# 对应的汉语句子列表
fras = ['va !', 'j\' ai perdu .', 'il est calme .', 'je suis chez moi .']
# 遍历英语句子和汉语句子的对应关系
for eng, fra in zip(engs, fras):# 使用训练好的模型net对英语句子进行翻译，并获取注意力权重序列translation, dec_attention_weight_seq = d2l.predict_seq2seq(net, eng, src_vocab, tgt_vocab, num_steps, device, True)# 打印英语句子、翻译结果和BLEU分数print(f' {eng} => {translation}, ',f'bleu {d2l.bleu(translation, fra, k=2):.3f}')# 将注意力权重序列进行拼接，并调整形状
attention_weights = torch.cat([step[0][0][0] for step in dec_attention_weight_seq], 0).reshape((1, 1, -1, num_steps))
# 可视化注意力权重
# 显示注意力权重的热图，仅显示与输入英语句子对应的位置
d2l.show_heatmaps(attention_weights[:, :, :, :len(engs[-1].split()) + 1].cpu(),xlabel='key positions', ylabel='Query posistions')
d2l.plt.show()

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.xdnf.cn/news/1557063.html

如若内容造成侵权/违法违规/事实不符，请联系一条长河网进行投诉反馈，一经查实，立即删除！

相关文章

CVSS 4.0 学习笔记

CVSS 4.0 学习笔记

通用漏洞评分系统（CVSS）捕获了主要技术软件、硬件和固件漏洞的特征。其输出包括数字分数，表明与其他漏洞。 以下因素可能包括但不限于：监管要求、客户数量受影响、因违约造成的金钱损失、生命或财产受到威胁，或潜在漏洞的声誉影响。这些因素在CVSS评估范围之外。 CVSS的好…
阅读更多...
基于PHP猫咖私人影院系统【附源码】

基于PHP猫咖私人影院系统【附源码】

效果如下&#xff1a; 系统首页界面 用户注册界面 包厢信息界面 零食信息界面 管理员登录界面 包厢预订界面 猫咪信息界面 研究背景 近年来&#xff0c;随着生活品质的提升和个性化消费需求的增长&#xff0c;猫咖和私人影院等新兴休闲娱乐方式逐渐受到年轻人的青睐。猫咖结合…
阅读更多...
招联金融校招内推2025

招联金融校招内推2025

【投递方式】 直接扫下方二维码&#xff0c;或点击内推官网https://wecruit.hotjob.cn/SU61025e262f9d247b98e0a2c2/mc/position/campus&#xff0c;使用内推码 igcefb 投递&#xff09; 【招聘岗位】 后台开发 前端开发 数据开发 数据运营 算法开发 技术运维 软件测试 产品策…
阅读更多...
复现文章：R语言复现文章画图

复现文章：R语言复现文章画图

文章目录 介绍数据和代码图1图2图6附图2附图3附图4附图5附图6 介绍 文章提供画图代码和数据&#xff0c;本文记录 数据和代码 数据可从以下链接下载&#xff08;画图所需要的所有数据&#xff09;&#xff1a; 百度云盘链接: https://pan.baidu.com/s/1peU1f8_TG2kUKXftkpYq…
阅读更多...
人机协作：科技与人类智慧的融合

人机协作：科技与人类智慧的融合

随着科技的飞速发展&#xff0c;越来越多的领域开始借助人工智能&#xff08;AI&#xff09;和自动化技术来提升工作效率。人机协作&#xff08;Human-Machine Collaboration&#xff09;这一概念逐渐成为现代技术进步的核心。它不仅改变了我们的工作方式&#xff0c;也在重新定…
阅读更多...
基于SpringBoot“花开富贵”花园管理系统【附源码】

基于SpringBoot“花开富贵”花园管理系统【附源码】

效果如下&#xff1a; 系统注册页面 系统首页界面 植物信息详细页面 后台登录界面 管理员主界面 植物分类管理界面 植物信息管理界面 园艺记录管理界面 研究背景 随着城市化进程的加快和人们生活质量的提升&#xff0c;越来越多的人开始追求与自然和谐共生的生活方式&#xf…
阅读更多...
基于YOLOv8-deepsort算法的智能车辆目标检测车辆跟踪和车辆计数

基于YOLOv8-deepsort算法的智能车辆目标检测车辆跟踪和车辆计数

关于深度实战社区 我们是一个深度学习领域的独立工作室。团队成员有&#xff1a;中科大硕士、纽约大学硕士、浙江大学硕士、华东理工博士等&#xff0c;曾在腾讯、百度、德勤等担任算法工程师/产品经理。全网20多万粉丝&#xff0c;拥有2篇国家级人工智能发明专利。 社区特色…
阅读更多...
中国当代哲学家思想家教育家颜廷利：真正问题意识体现在哪些方面

中国当代哲学家思想家教育家颜廷利：真正问题意识体现在哪些方面

在《升命学说》这部划时代的著作中&#xff0c;二十一世纪的杰出哲学家颜廷利教授提出了一个引人深思的观点。他巧妙地将阿拉伯数字“5”与汉字“吾”联系起来&#xff0c;指出两者发音相似&#xff0c;而“吾”字代表着自我。在儿童识字教学中&#xff0c;教师们常以创意的方式…
阅读更多...
Linux操作系统——概念扫盲I

Linux操作系统——概念扫盲I

目录 虚拟机概念刨析 在那之前&#xff0c;询问什么是虚拟化&#xff1f; 现在来看看什么是虚拟机 虚拟机有啥好的 小差&#xff1a;那JVM也叫Java Virtual Machine&#xff0c;有啥区别呢&#xff1f; Reference 虚拟机概念刨析 我们下面来简单聊聊虚拟机这个概念。对于…
阅读更多...
物联网开发者必读：从HTTP到MQTT，八大协议全解码！

物联网开发者必读：从HTTP到MQTT，八大协议全解码！

我是小米，一个喜欢分享技术的29岁程序员。如果你喜欢我的文章，欢迎关注我的微信公众号“软件求生”，获取更多技术干货！ Hello 大家好，我是小米，一个喜欢研究和分享技术的IT宅。今天咱们聊点不一样的——物联网（IoT）中的各种协议！最近在研究IoT的过程中，我发现物联网领…
阅读更多...
基于ssm vue uniapp实现的爱心小屋公益机构智慧管理系统

基于ssm vue uniapp实现的爱心小屋公益机构智慧管理系统

博主介绍&#xff1a;专注于Java&#xff08;springboot ssm 等开发框架&#xff09; vue .net php phython node.js uniapp 微信小程序 等诸多技术领域和毕业项目实战、企业信息化系统建设&#xff0c;从业十五余年开发设计教学工作☆☆☆ 精彩专栏推荐订阅☆☆☆☆☆不然…
阅读更多...
基于PHP的校园二手书交易管理系统

基于PHP的校园二手书交易管理系统

有需要请加文章底部Q哦 可远程调试 基于PHP的校园二手书交易管理系统 一 介绍 此二手书交易管理系统基于原生PHP开发&#xff0c;数据库mysql&#xff0c;前端bootstrap。系统角色分为用户和管理员。 技术栈&#xff1a;phpmysqlbootstrapphpstudyvscode 二 功能 用户 1 注…
阅读更多...
窗口系统与图形绘制接口

窗口系统与图形绘制接口

个人博客:Sekyoro的博客小屋 个人网站:Proanimer的个人网站 当我们想要进行底层图形应用(GUI)开发时,往往需要用到窗口系统和图形库,这里简单介绍一下 视窗系统(window system)与通信协议 下面内容主要针对Unix-like操作系统 视窗系统是以使用视窗作为主要特征之一的图形用…
阅读更多...
设计模式01-类图及设计原理(Java)

设计模式01-类图及设计原理(Java)

一、设计模式综述 1.设计模式基本概念 设计模式&#xff08;Design Pattern&#xff09;是前辈们对代码开发经验的总结&#xff0c;是解决特定问题的一系列套路。它不是语法规定&#xff0c;而是一套用来提高代码可复用性、可维护性、可读性、稳健性以及安全性的解决方案。 …
阅读更多...
Linux 系统成为隐秘“Perfctl”加密挖矿恶意软件的目标

Linux 系统成为隐秘“Perfctl”加密挖矿恶意软件的目标

Aqua Security 的研究人员上周透露&#xff0c;数以千计的 Linux 系统可能感染了极难追踪且持久的“perfctl”&#xff08;或“ perfcc ”&#xff09;加密挖掘恶意软件&#xff0c;许多其他系统仍然面临被入侵的风险。 在观察到的所有攻击中&#xff0c;恶意软件都被用来运行…
阅读更多...
C++ 非STL数据结构学习——1.4 图

C++ 非STL数据结构学习——1.4 图

一般而言&#xff0c;图的实现有邻接矩阵和邻接表两种。 1. 邻接矩阵 #include <iostream> #include <vector>class Graph { private:int V; // 顶点数量std::vector<std::vector<int>> adjMatrix; // 邻接矩阵std::vector<bool> visited; // 记…
阅读更多...
逐次逼近型ADC转换器（SAR ADC）的原理与应用

逐次逼近型ADC转换器（SAR ADC）的原理与应用

逐次逼近型ADC&#xff08;SAR ADC&#xff0c;Successive Approximation Register Analog-to-Digital Converter&#xff09;是一种广泛应用于模拟信号数字化的模数转换器。它以其高速度、低功耗以及适中的分辨率而著称&#xff0c;特别适合于各种嵌入式系统、传感器接口以及物…
阅读更多...
下标记数（一）

下标记数（一）

第1题 0~5出现次数&#xff08;程序填空&#xff09; 统计出一串0~5数字构成的数列中&#xff0c;6种数字各自出现的次数。 输入格式 第一行1个正整数&#xff1a;N&#xff0c;范围在[1,100]。第二行N个由0~5组成的数列。 输出格式 一行6个整数&#xff0c;分别是0~5出现的…
阅读更多...
数据结构--线性表双向链表的实现

数据结构--线性表双向链表的实现

目录 思路设计 总体思维导图 插入部分 头插法尾插法 任意位置插入 删除部分 头结点 尾节点 中间节点 只有头结点且删除的就是头结点 ​编辑 清空链表部分 遍历清空链表的所有节点 不遍历清空 各部分代码 Main部分 MyListedList部分 IndexOutOfException部分 …
阅读更多...
深入了解卡尔曼滤波：最优状态估计的数学神器

深入了解卡尔曼滤波：最优状态估计的数学神器

深入了解卡尔曼滤波&#xff1a;最优状态估计的数学神器 卡尔曼滤波是一种递归的状态估计方法&#xff0c;它通过系统模型和测量值来更新状态的最优估计。我们先来了解一下卡尔曼滤波的基本原理。 1. 假设条件 卡尔曼滤波的基本假设如下&#xff1a; 线性动态模型&#xff…
阅读更多...
最新文章

Copyright @ 2022~2023