文章目录

序列到序列学习（seq2seq）
- 1 - 编码器
- 2 - 解码器
- 3 - 损失函数
- 4 - 训练
- 5 - 预测
- 6 - 预测序列的评估
- 7 - 小结

序列到序列学习（seq2seq）

在本节中，我们将使用两个循环神经网络的编码器和解码器，并将其应用于序列到序列（sequence to sequence,seq2seq）类的学习任务

遵循编码器-解码器的设计原则，循环神经网络编码器使用长度可变的序列作为输入，将其转换为固定形状的隐状态。换言之，输入序列的信息被编码到循环神经网络编码器的隐状态中。为了连续生成输出序列的词元，独立的循环神经网络解码器是基于输入序列的编码信息和输出序列已经看见的或者生成的词元来预测下一个词元。下图演示了如何在机器翻译中使用两个循环神经网络进行序列到序列的学习

在图9.7.1中，特定的“<eos>”表⽰序列结束词元。⼀旦输出序列⽣成此词元，模型就会停⽌预测。在循环神经⽹络解码器的初始化时间步，有两个特定的设计决定：⾸先，特定的“<bos>”表⽰序列开始词元，它是解码器的输⼊序列的第⼀个词元。其次，使⽤循环神经⽹络编码器最终的隐状态来初始化解码器的隐状态。例如，在 [Sutskever et al., 2014]的设计中，正是基于这种设计将输⼊序列的编码信息送⼊到解码器中来⽣成输出序列的。在其他⼀些设计中 [Cho et al., 2014b]，如图9.7.1所⽰，编码器最终的隐状态在每⼀个时间步都作为解码器的输⼊序列的⼀部分。类似于 8.3节中语⾔模型的训练，可以允许标签成为原始的输出序列，从源序列词元“<bos>”、“Ils”、“regardent”、“.”到新序列词元“Ils”、“regardent”、“.”、“<eos>”来移动预测的位置

下面，我们动手构建图9.7.1的设计，并将基于“英-法”数据集来训练这个机器翻译模型

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

1 - 编码器

class Seq2SeqEncoder(d2l.Encoder):"""用于序列到序列学习的循环神经网络编码器"""def __init__(self,vocab_size,embed_size,num_hiddens,num_layers,dropout=0,**kwargs):super(Seq2SeqEncoder,self).__init__(**kwargs)# 嵌入层self.embedding = nn.Embedding(vocab_size,embed_size)self.rnn = nn.GRU(embed_size,num_hiddens,num_layers,dropout=dropout)def forward(self,X,*args):# 输出'X'的形状：（batch_size,num_steps,embed_size）X = self.embedding(X)# 在循环神经网络模型中，第一个轴对应于时间步X = X.permute(1,0,2)# 如果未提交状态，则默认为0output,state = self.rnn(X)# output的形状:(num_steps,batch_size,num_hiddens)# state[0]的形状:(num_layers,batch_size,num_hiddens)return output, state

下面，我们实例化上述编码器的实现：我们使用一个两层门控循环单元编码器，其隐藏单元数为16.给定一个小批量的输入序列X（批量大小为4，时间步为7）。在完成所有时间步后，最后一层的隐状态的输出是一个张量（output由编码器的循环层返回），其形状为（时间步数，批量大小，隐藏单元数）

encoder = Seq2SeqEncoder(vocab_size=10,embed_size=8,num_hiddens=16,num_layers=2)encoder.eval()
X = torch.zeros((4,7),dtype=torch.long)
output,state = encoder(X)
output.shape

torch.Size([7, 4, 16])

由于这里使用的是门控循环单元，所以在最后一个时间步的多层隐状态的形状是（隐藏层的数量，批量大小，隐藏单元的数量），如果使用长短期记忆网络，state中还将包含记忆单元信息

state.shape

torch.Size([2, 4, 16])

2 - 解码器

class Seq2SeqDecoder(d2l.Decoder):"""用于序列到序列学习的循环神经网络解码器"""def __init__(self,vocab_size,embed_size,num_hiddens,num_layers,dropout=0,**kwargs):super(Seq2SeqDecoder,self).__init__(**kwargs)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)def init_state(self,enc_outputs,*args):return enc_outputs[1]def forward(self,X,state):# 输出'X'的形状：(batch_size,num_steps,embed_size)X = self.embedding(X).permute(1,0,2)# 广播context,使其具有与X相同的num_stepscontext = state[-1].repeat(X.shape[0], 1, 1)X_and_context = torch.cat((X, context), 2)output, state = self.rnn(X_and_context, state)output = self.dense(output).permute(1, 0, 2)# output的形状:(batch_size,num_steps,vocab_size)# state[0]的形状:(num_layers,batch_size,num_hiddens)return output, state

下面，我们用与前面提到的编码器中相同的超参数来实例化解码器。如我们所见，解码器的输出形状变为（批量大小，时间步数，词表大小），其中张量的最后一个维度存储预测的词元分布

decoder = Seq2SeqDecoder(vocab_size=10,embed_size=8,num_hiddens=16,num_layers=2)decoder.eval()
state = decoder.init_state(encoder(X))
output,state = decoder(X,state)
output.shape,state.shape

(torch.Size([4, 7, 10]), torch.Size([2, 4, 16]))

3 - 损失函数

在每个时间步，解码器预测了输出词元的概率分布。类似于语言模型，可以使用softmax来获得分布，并通过计算交叉熵损失函数来进行优化。特定的填充词元被添加到序列的末尾，因此不同长度的序列可以以相同形状的小批量加载。但是，我们应该将填充词元的预测排除在损失函数的计算之外

为此，我们可以使用下面的sequence_mask函数通过零值化屏蔽不相干的项，以便后面任何不相关预测的计算都是于零的乘积，结果都等于零。

例如，若两个序列的有效长度（不包括填充词元）分别为1和2，则第一个序列的第一项和第二个序列的前两项之后的剩余项将被清除为零

def sequence_mask(X,valid_len,value=0):"""在序列中屏蔽不相干的项"""maxlen = X.size(1)mask = torch.arange((maxlen),dtype=torch.float32,device=X.device)[None,:] < valid_len[:,None]X[~mask] = valuereturn X

X = torch.tensor([[1, 2, 3], [4, 5, 6]])
sequence_mask(X, torch.tensor([1, 2]))

tensor([[1, 0, 0],[4, 5, 0]])

我们还可以使用此函数屏蔽最后几个轴上的所有项。若愿意，也可以使用指定的非零值来替换这些项

X = torch.ones(2, 3, 4)
sequence_mask(X, torch.tensor([1, 2]), value=-1)

tensor([[[ 1.,  1.,  1.,  1.],[-1., -1., -1., -1.],[-1., -1., -1., -1.]],[[ 1.,  1.,  1.,  1.],[ 1.,  1.,  1.,  1.],[-1., -1., -1., -1.]]])

现在，我们可以通过扩展softmax交叉熵损失函数来遮蔽不相关的预测。最初，所有预测词元的掩码都设置为1。一旦给定了有效长度，与填充词元对应的掩码将被设置为0，最后，将所有词元的损失乘以掩码，以过滤掉损失中填充词元产生的不相关预测

class MaskedSoftmaxCELoss(nn.CrossEntropyLoss):"""带遮蔽的softmax交叉熵损失函数"""# pred的形状：(batch_size,num_steps,vocab_size)# label的形状：(batch_size,num_steps)# valid_len的形状：(batch_size,)def forward(self,pred,label,valid_len):weights = torch.ones_like(label)weights = sequence_mask(weights,valid_len)self.reduction = 'none'unweighted_loss = super(MaskedSoftmaxCELoss,self).forward(pred.permute(0,2,1),label)weighted_loss = (unweighted_loss * weights).mean(dim=1)return weighted_loss

我们可以创建三个相同的序列来进行代码健全性检查，然后分别指定这些序列的有效长度为4，2和0.结果就是，第一个序列的损失应为第二个序列的两倍，而第三个序列的损失应为零

loss = MaskedSoftmaxCELoss()
loss(torch.ones(3, 4, 10), torch.ones((3, 4), dtype=torch.long),torch.tensor([4, 2, 0]))

tensor([2.3026, 1.1513, 0.0000])

4 - 训练

在下面的循环训练过程中，如图9.7.1所示，特定的序列开始词元<bos>和原始的输出序列（不包括序列结束词元<eos>）拼接在一起作为解码器的输入。这被称为强制教学（teacher forcing），因为原始的输出序列（词元的标签）被被送入解码器。或者，来自上一个时间步的预测得到的词元作为解码器的当前输入

def train_seq2seq(net,data_iter,lr,num_epochs,tgt_vocab,device):"""训练序列到序列模型"""def xavier_init_weights(m):if type(m) == nn.Linear:nn.init.xavier_uniform_(m.weight)if type(m) == nn.GRU:for param in m._flat_weights_names:if "weight" in param:nn.init.xavier_uniform_(m._parameters[param])net.apply(xavier_init_weights)net.to(device)optimizer = torch.optim.Adam(net.parameters(),lr=lr)loss = MaskedSoftmaxCELoss()net.train()animator = d2l.Animator(xlabel='epoch',ylabel='loss',xlim=[10,num_epochs])for epoch in range(num_epochs):timer = d2l.Timer()metric = d2l.Accumulator(2) # 训练损失总会，词元数量for batch in data_iter:optimizer.zero_grad()X, X_valid_len, Y, Y_valid_len = [x.to(device) for x in batch]bos = torch.tensor([tgt_vocab['<bos>']] * Y.shape[0],device=device).reshape(-1, 1)dec_input = torch.cat([bos, Y[:, :-1]], 1) # 强制教学Y_hat, _ = net(X, dec_input, X_valid_len)l = loss(Y_hat,Y,Y_valid_len)l.sum().backward() # 损失函数的标量进行“反向传播”d2l.grad_clipping(net,1)num_tokens = Y_valid_len.sum()optimizer.step()with torch.no_grad():metric.add(l.sum(),num_tokens)if (epoch + 1) % 10 == 0:animator.add(epoch + 1, (metric[0] / metric[1],))print(f'loss{metric[0] / metric[1]:.3f},{metric[1] / timer.stop():.1f}'f'tokens/sec on{str(device)}')

现在，在机器翻译数据集上，我们可以创建和训练一个循环神经网络“编码器-解码器”模型用于序列到序列的学习

embed_size,num_hiddens,num_layers,dropout = 32,32,2,0.1
batch_size,num_steps = 64,10
lr,num_epochs,device = 0.005,300,d2l.try_gpu()train_iter, src_vocab, tgt_vocab = d2l.load_data_nmt(batch_size, num_steps)
encoder = Seq2SeqEncoder(len(src_vocab), embed_size, num_hiddens, num_layers,dropout)
decoder = Seq2SeqDecoder(len(tgt_vocab), embed_size, num_hiddens, num_layers,dropout)net = d2l.EncoderDecoder(encoder, decoder)
train_seq2seq(net, train_iter, lr, num_epochs, tgt_vocab, device)

loss 0.021, 23807.7 tokens/sec on cuda:0

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mg3wmo2n-1662904032828)(https://yingziimage.oss-cn-beijing.aliyuncs.com/img/202209112131596.svg)]

5 - 预测

def predict_seq2seq(net, src_sentence, src_vocab, tgt_vocab, num_steps,device, save_attention_weights=False):"""序列到序列模型的预测"""# 在预测时将net设置为评估模式net.eval()src_tokens = src_vocab[src_sentence.lower().split(' ')] + [src_vocab['<eos>']]enc_valid_len = torch.tensor([len(src_tokens)], device=device)src_tokens = d2l.truncate_pad(src_tokens, num_steps, src_vocab['<pad>'])# 添加批量轴enc_X = torch.unsqueeze(torch.tensor(src_tokens, dtype=torch.long, device=device), dim=0)enc_outputs = net.encoder(enc_X, enc_valid_len)dec_state = net.decoder.init_state(enc_outputs, enc_valid_len)# 添加批量轴dec_X = torch.unsqueeze(torch.tensor([tgt_vocab['<bos>']], dtype=torch.long, device=device), dim=0)output_seq, attention_weight_seq = [], []for _ in range(num_steps):Y,dec_state = net.decoder(dec_X,dec_state)# 我们使用具有预测最高可能性的词元，作为解码器在下一时间步的输入dec_X = Y.argmax(dim=2)pred = dec_X.squeeze(dim=0).type(torch.int32).item()# 保持注意力权重（稍后讨论）if save_attention_weights:attention_weight_seq.append(net.decoder.attention_weights)# 一旦序列结束词被预测，输出序列的生成就完成了if pred == tgt_vocab['<eos>']:breakoutput_seq.append(pred)return ' '.join(tgt_vocab.to_tokens(output_seq)), attention_weight_seq

6 - 预测序列的评估

def bleu(pred_seq,label_seq,k):"""计算BLEU"""pred_tokens, label_tokens = pred_seq.split(' '), label_seq.split(' ')len_pred, len_label = len(pred_tokens), len(label_tokens)score = math.exp(min(0, 1 - len_label / len_pred))for n in range(1, k + 1):num_matches, label_subs = 0, collections.defaultdict(int)for i in range(len_label - n + 1):label_subs[' '.join(label_tokens[i: i + n])] += 1for i in range(len_pred - n + 1):if label_subs[' '.join(pred_tokens[i: i + n])] > 0:num_matches += 1label_subs[' '.join(pred_tokens[i: i + n])] -= 1score *= math.pow(num_matches / (len_pred - n + 1), math.pow(0.5, n))return score

最后，利用训练好的循环神经网络“编码器-解码器”模型，将几个英法句子翻译成法语，并计算BLEU的最终结果

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):translation, attention_weight_seq = predict_seq2seq(net, eng, src_vocab, tgt_vocab, num_steps, device)print(f'{eng}=>{translation}, bleu{bleu(translation, fra, k=2):.3f}')

go . => va !, bleu 1.000
i lost . => j'ai perdu ., bleu 1.000
he's calm . => il est malade ., bleu 0.658
i'm home . => je vous suis <unk> ., bleu 0.000

7 - 小结

根据“编码器-解码器”架构的设计，我们可以使⽤两个循环神经⽹络来设计⼀个序列到序列学习的模型
在实现编码器和解码器时，我们可以使⽤多层循环神经⽹络
我们可以使⽤遮蔽来过滤不相关的计算，例如在计算损失时
在“编码器－解码器”训练中，强制教学⽅法将原始输出序列（⽽⾮预测结果）输⼊解码器
BLEU是⼀种常⽤的评估⽅法，它通过测量预测序列和标签序列之间的n元语法的匹配度来评估预测

现代循环神经网络 - 序列到序列学习相关推荐

【李宏毅机器学习】Recurrent Neural Network Part1 循环神经网络（p20）学习笔记
李宏毅机器学习学习笔记汇总课程链接文章目录 Example Application Slot Filling 把词用向量来表示的方法 1-of-N encoding / one-hot Beyon ...
【李宏毅机器学习】Recurrent Neural Network Part2 循环神经网络（p21）学习笔记
李宏毅机器学习学习笔记汇总课程链接文章目录 Learning Target Learning Unfortunately 基于RNN的的网络不总是容易去学习 The error surface i ...
如何解决LSTM循环神经网络中的超长序列问题
时间 2017-06-27 15:57:39 机器之心原文 https://www.jiqizhixin.com/articles/e8d4e413-a718-49ac-ae79-c197ba8 ...
神经网络学习小记录2——利用tensorflow构建循环神经网络（RNN）
神经网络学习小记录2--利用tensorflow构建循环神经网络(RNN) 学习前言 RNN简介 tensorflow中RNN的相关函数 tf.nn.rnn_cell.BasicLSTMCell tf ...
图深度学习——卷积神经网络循环神经网络自编码器
卷积神经网络常用做图像分类任务.举例:识别图中的兔子前馈神经网络做兔子图像识别图像可以通过矩阵表示,然后将矩阵转换成向量,就可以作为前馈神经网络的输入,但是 1.参数量就非常大,需要大量数据进行 ...
09.7. 序列到序列学习（seq2seq）
文章目录 9.7. 序列到序列学习(seq2seq) 9.7.1. 编码器 9.7.2. 解码器 9.7.3. 损失函数 9.7.4. 训练 9.7.5. 预测 9.7.6. 预测序列的评估 9.7. ...
MLK | 一文理清深度学习循环神经网络
MLK,即Machine Learning Knowledge,本专栏在于对机器学习的重点知识做一次梳理,便于日后温习,内容主要来自于<百面机器学习>一书,结合自己的经验与思考做的一些总结 ...
PyTorch 学习笔记（十一）：循环神经网络（RNN）
对于人类而言,以前见过的事物会在脑海中留下记忆,虽然随后记忆会慢慢消失,但是每当经过提醒,人们往往可以重拾记忆.在神经网络中也是一样,之前介绍的CNN模型都是与时间序列无关的模型,它有明显的局限性,就 ...
时序预测的三种方式：统计学模型、机器学习、循环神经网络
作者 | luanhz 来源 | 小数志导读时序预测是一类经典的问题,在学术界和工业界都有着广泛的研究和应用.甚至说,世间万物加上时间维度后都可抽象为时间序列问题,例如股票价格.天气变化等等.关于 ...
rnn神经网络模型_ICLR 2019 | 与胶囊网络异曲同工：Bengio等提出四元数循环神经网络...
选自 openreview 作者:Titouan Parcollet 机器之心编译近日,Yoshua Bengio 等人提出了一种新型的循环神经网络,其以四元数来编码序列输入,称为四元循环神经网络. ...

现代循环神经网络 - 序列到序列学习