跟着李沐老师学习深度学习（十三）

现代循环神经网络

循环神经网络中梯度异常在实践中的意义引发了一些问题：

早期观测值影响重大：早期观测值对预测所有未来观测值极为重要，如序列中第一个观测值包含校验和，需在序列末尾辨别其是否正确，若无特殊机制存储早期重要信息，就需给该观测值指定很大梯度，因为它影响后续所有观测值。存在无关词元：在对网页内容进行情感分析等任务时，可能存在一些与观测值无关的词元，如辅助 HTML 代码，希望有机制能在隐状态表示中跳过此类词元。序列存在逻辑中断：序列的各个部分之间可能存在逻辑中断，如书的章节之间、证券的熊市和牛市之间的过渡，最好有一种方法来重置内部状态表示。

解决方案

长短期记忆（LSTM）：是学术界提出的用于解决上述问题的最早方法之一。门控循环单元（GRU）：是一个稍微简化的变体，通常能提供与 LSTM 同等的效果，且计算速度明显更快。 门控循环单元（GRU） 关注一个序列： 不是每个观察值都是同等重要只想记住相关的观察需要： 能关注的机制（更新门 update gate）：将重要的数据放入该门能遗忘的机制（重置门 reset gate）：到目前为止，前面东西不重要了。 更新门和重置门

其中：

通过重置门和更新门控制隐状态的更新与重置。重置门决定保留过去状态的程度，更新门控制新状态中旧状态的占比，两者都用 sigmoid 函数将输入转换到 (0, 1) 区间进行凸组合

候选隐状态（备胎）

将重置门 Rt与 常规隐状态更新机制集成，得到在时间步 t 的候选隐状态（candidate hidden state）：

重置门接近 1 时类似普通循环神经网络，接近 0 时候选隐状态取决于当前输入。

隐状态（真正的）

更新门接近 1 时保留旧状态，接近 0 时新隐状态接近候选隐状态，有助于处理梯度消失问题和捕获长序列依赖。

总之，门控循环单元具有以下两个显著特征：

重置门有助于捕获序列中的短期依赖关系；

更新门有助于捕获序列中的长期依赖关系

总结 代码实现 - 从零实现 # 门循环单元GRU # 从零开始实现 import torch from torch import nn from d2l import torch as d2l batch_size, num_steps = 32, 35 train_iter, vocab = d2l.load_data_time_machine(batch_size, num_steps) # 初始化模型参数 def get_params(vocab_size, num_hiddens, device): num_inputs = num_outputs = vocab_size def normal(shape): return torch.randn(size=shape, device=device)*0.01 def three(): return (normal((num_inputs, num_hiddens)), normal((num_hiddens, num_hiddens)), torch.zeros(num_hiddens, device=device)) W_xz, W_hz, b_z = three() # 更新门参数 W_xr, W_hr, b_r = three() # 重置门参数 W_xh, W_hh, b_h = three() # 候选隐状态参数 # 输出层参数 W_hq = normal((num_hiddens, num_outputs)) b_q = torch.zeros(num_outputs, device=device) # 附加梯度 params = [W_xz, W_hz, b_z, W_xr, W_hr, b_r, W_xh, W_hh, b_h, W_hq, b_q] for param in params: param.requires_grad_(True) return params # 定义模型 # 定义隐状态的初始化函数 # 返回一个形状为（批量大小，隐藏单元个数）的张量，张量的值全部为零。 def init_gru_state(batch_size, num_hiddens, device): return (torch.zeros((batch_size, num_hiddens), device=device), ) # 定义门控循环单元模型 def gru(inputs, state, params): W_xz, W_hz, b_z, W_xr, W_hr, b_r, W_xh, W_hh, b_h, W_hq, b_q = params H, = state outputs = [] for X in inputs: Z = torch.sigmoid((X @ W_xz) + (H @ W_hz) + b_z) R = torch.sigmoid((X @ W_xr) + (H @ W_hr) + b_r) H_tilda = torch.tanh((X @ W_xh) + ((R * H) @ W_hh) + b_h) H = Z * H + (1 - Z) * H_tilda Y = H @ W_hq + b_q outputs.append(Y) return torch.cat(outputs, dim=0), (H,) # 训练与预测 vocab_size, num_hiddens, device = len(vocab), 256, d2l.try_gpu() num_epochs, lr = 500, 1 model = d2l.RNNModelScratch(len(vocab), num_hiddens, device, get_params, init_gru_state, gru) d2l.train_ch8(model, train_iter, vocab, lr, num_epochs, device)

结果：

代码实现 - 简洁实现 # 使用高级API,运行速度很快（使用的是编译好的运算符而不是Python来处理之前阐述的许多细节） num_inputs = vocab_size gru_layer = nn.GRU(num_inputs, num_hiddens) model = d2l.RNNModel(gru_layer, len(vocab)) model = model.to(device) d2l.train_ch8(model, train_iter, vocab, lr, num_epochs, device)

结果：

长短期记忆网络（LSTM） 忘记门：将值朝0减少输入门：决定不是忽略掉输入数据输出门：决定是不是使用隐状态

效果上和GRU一样，都是：是不是要忘掉过去的状态，看现在的输入，或者不看现在输入的数据而看前一时刻的状态；

忘记门、输入门、输出门

公式：

候选记忆单元

公式： 候选记忆元如下图所示：

记忆单元

上一个时刻的记忆单元会作为状态加入（与GRU不同之处） 如果遗忘门始终为1且输入门始终为0， 则过去的记忆元Ct-1 将随时间被保存并传递到当前时间步。 引入这种设计是为了缓解梯度消失问题， 并更好地捕获序列中的长距离依赖关系。

这样就得到了计算记忆元的流程图：

隐状态

公式：（将隐藏状态约束到（-1，1）） 只要输出门接近1，就能够有效地将所有记忆信息传递给预测部分， 而对于输出门接近0，只保留记忆元内的所有信息，而不需要更新隐状态。如下提供了数据流的图形化演示。

总结

长短期记忆网络有三种类型的门：输入门、遗忘门和输出门。

长短期记忆网络的隐藏层输出包括“隐状态”和“记忆元”。只有隐状态会传递到输出层，而记忆元完全属于内部信息。

长短期记忆网络可以缓解梯度消失和梯度爆炸。

代码实现 - 从零实现 # 长短期记忆网络（LSTM） import torch from torch import nn from d2l import torch as d2l batch_size, num_steps = 32, 35 train_iter, vocab = d2l.load_data_time_machine(batch_size, num_steps) # [初始化模型参数 # 超参数num_hiddens定义隐藏单元的数量 def get_lstm_params(vocab_size, num_hiddens, device): num_inputs = num_outputs = vocab_size def normal(shape): return torch.randn(size=shape, device=device)*0.01 def three(): return (normal((num_inputs, num_hiddens)), normal((num_hiddens, num_hiddens)), torch.zeros(num_hiddens, device=device)) W_xi, W_hi, b_i = three() # 输入门参数 W_xf, W_hf, b_f = three() # 遗忘门参数 W_xo, W_ho, b_o = three() # 输出门参数 W_xc, W_hc, b_c = three() # 候选记忆元参数 # 输出层参数 W_hq = normal((num_hiddens, num_outputs)) b_q = torch.zeros(num_outputs, device=device) # 附加梯度 params = [W_xi, W_hi, b_i, W_xf, W_hf, b_f, W_xo, W_ho, b_o, W_xc, W_hc, b_c, W_hq, b_q] for param in params: param.requires_grad_(True) return params # 定义模型 # 初始化函数： # 长短期记忆网络的隐状态需要返回一个额外的记忆元， 单元的值为0，形状为（批量大小，隐藏单元数） def init_lstm_state(batch_size, num_hiddens, device): return (torch.zeros((batch_size, num_hiddens), device=device), torch.zeros((batch_size, num_hiddens), device=device)) # 实际模型的定义 def lstm(inputs, state, params): [W_xi, W_hi, b_i, W_xf, W_hf, b_f, W_xo, W_ho, b_o, W_xc, W_hc, b_c, W_hq, b_q] = params (H, C) = state outputs = [] for X in inputs: I = torch.sigmoid((X @ W_xi) + (H @ W_hi) + b_i) F = torch.sigmoid((X @ W_xf) + (H @ W_hf) + b_f) O = torch.sigmoid((X @ W_xo) + (H @ W_ho) + b_o) C_tilda = torch.tanh((X @ W_xc) + (H @ W_hc) + b_c) C = F * C + I * C_tilda H = O * torch.tanh(C) Y = (H @ W_hq) + b_q outputs.append(Y) return torch.cat(outputs, dim=0), (H, C) # 训练和预测 vocab_size, num_hiddens, device = len(vocab), 256, d2l.try_gpu() num_epochs, lr = 500, 1 model = d2l.RNNModelScratch(len(vocab), num_hiddens, device, get_lstm_params, init_lstm_state, lstm) d2l.train_ch8(model, train_iter, vocab, lr, num_epochs, device)

结果：

代码实现 - 简洁实现 # 简洁实现 num_inputs = vocab_size lstm_layer = nn.LSTM(num_inputs, num_hiddens) model = d2l.RNNModel(lstm_layer, len(vocab)) model = model.to(device) d2l.train_ch8(model, train_iter, vocab, lr, num_epochs, device) 深度循环神经网络

回顾RNN，主要就是如何得到更多的非线性 —— 多加几个隐藏层。

更深的：

总结 在深度循环神经网络中，隐状态的信息被传递到当前层的下一时间步和下一层的当前时间步。 有许多不同风格的深度循环神经网络， 如长短期记忆网络、门控循环单元、或经典循环神经网络。 这些模型在深度学习框架的高级API中都有涵盖。 总体而言，深度循环神经网络需要大量的调参（如学习率和修剪） 来确保合适的收敛，模型的初始化也需要谨慎。 代码实现 # 深度循环神经网络 import torch from torch import nn from d2l import torch as d2l batch_size, num_steps = 32, 35 train_iter, vocab = d2l.load_data_time_machine(batch_size, num_steps) # 通过num_layers的值来设定隐藏层数 vocab_size, num_hiddens, num_layers = len(vocab), 256, 2 num_inputs = vocab_size device = d2l.try_gpu() lstm_layer = nn.LSTM(num_inputs, num_hiddens, num_layers) model = d2l.RNNModel(lstm_layer, len(vocab)) model = model.to(device) # 训练和预测 num_epochs, lr = 500, 2 d2l.train_ch8(model, train_iter, vocab, lr*1.0, num_epochs, device)

结果：

双向循环神经网络

对于某些序列，可以从前往后看，也可以从后往前看。 首先，给一个例子，我们考虑以下三个在文本序列中填空的任务。 根据可获得的信息量，我们可以用不同的词填空， 如“很高兴”（“happy”）、“不”（“not”）和“非常”（“very”）。 很明显，每个短语的“下文”传达了重要信息（如果有的话）， 而这些信息关乎到选择哪个词来填空， 所以无法利用这一点的序列模型将在相关任务上表现不佳。 例如，如果要做好命名实体识别 （例如，识别“Green”指的是“格林先生”还是绿色）， 不同长度的上下文范围重要性是相同的。

取决于过去和未来的上下文，可以填很不一样的词到目前为止RNN只看过去在填空的时候，也可以看未来 双向RNN 一个前向RNN隐层一个方向RNN隐层合并两个隐状态得到输出 公式： 总结 特性：使用来自**序列两端（过去和未来）**的观测信息预测当前观测。问题：在预测下一个词元时，因测试期间只有过去数据，精度较差；计算速度慢，前向传播需在双向层进行前向和后向递归，反向传播依赖前向传播结果，导致梯度求解链长。应用场景：实际应用较少，用于填充缺失单词、词元注释（如命名实体识别）以及作为序列处理流水线步骤对序列编码（如机器翻译），不能预测未来。 代码实现

首先，双向RNN不能训练语言模型，所以下面这个是一个错误的应用，只是为了演示该模型。与之前不同的是：改为bidirectional=True

import torch from torch import nn from d2l import torch as d2l # 加载数据 batch_size, num_steps, device = 32, 35, d2l.try_gpu() train_iter, vocab = d2l.load_data_time_machine(batch_size, num_steps) # 通过设置“bidirective=True”来定义双向LSTM模型 vocab_size, num_hiddens, num_layers = len(vocab), 256, 2 num_inputs = vocab_size # 改为 bidirectional=True就是双向rnn lstm_layer = nn.LSTM(num_inputs, num_hiddens, num_layers, bidirectional=True) model = d2l.RNNModel(lstm_layer, len(vocab)) model = model.to(device) # 训练模型 num_epochs, lr = 500, 1 d2l.train_ch8(model, train_iter, vocab, lr, num_epochs, device)

结果：很差，因为没有未来信息，精度很低，预测信息很不靠谱。

编码器-解码器架构 机器翻译和数据集 机器翻译指的是将文本序列从一种语言自动翻译成另一种语言。使用单词级词元化时的词表大小，将明显大于使用字符级词元化时的词表大小。为了缓解这一问题，我们可以将低频词元视为相同的未知词元。通过截断和填充文本序列，可以保证所有的文本序列都具有相同的长度，以便以小批量的方式加载。 代码实现 # 机器翻译与数据集 # 语言模型是自然语言处理的关键， 而机器翻译是语言模型最成功的基准测试 # 机器翻译（machine translation）指的是 将序列从一种语言自动翻译成另一种语言。 import os import torch from d2l import torch as d2l # 下载和预处理数据集 # 下载一个由Tatoeba项目的双语句子对（ .manythings.org/anki/） 组成的“英－法”数据集 # # 英语是源语言（source language）， 法语是目标语言（target language） d2l.DATA_HUB['fra-eng'] = (d2l.DATA_URL + 'fra-eng.zip', '94646ad1522d915e7b0f9296181140edcf86a4f5') def read_data_nmt(): """载入“英语－法语”数据集""" data_dir = d2l.download_extract('fra-eng') with open(os.path.join(data_dir, 'fra.txt'), 'r', encoding='utf-8') as f: return f.read() raw_text = read_data_nmt() print(raw_text[:75]) # 预处理 # 用空格代替不间断空格（non-breaking space） # 使用小写字母替换大写字母 # 在单词和标点符号之间插入空格。 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 char for i, char in enumerate(text)] return ''.join(out) text = preprocess_nmt(raw_text) print(text[:80]) # 词元化 # tokenize_nmt函数对前num_examples个文本序列对进行词元， 其中每个词元要么是一个词，要么是一个标点符号。 # 此函数返回两个词元列表：source和target： # source[i]是源语言（这里是英语）第 𝑖 个文本序列的词元列表 # target[i]是目标语言（这里是法语）第 𝑖 个文本序列的词元列表。 def tokenize_nmt(text, num_examples=None): """词元化“英语－法语”数据数据集""" source, target = [], [] for i, line in enumerate(text.split('\n')): 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, target source, target = tokenize_nmt(text) source[:6], target[:6] # 绘制每个文本序列所包含的词元数量的直方图 #@save def show_list_len_pair_hist(legend, xlabel, ylabel, xlist, ylist): """绘制列表长度对的直方图""" d2l.set_figsize() _, _, patches = d2l.plt.hist( [[len(l) for l in xlist], [len(l) for l in ylist]]) d2l.plt.xlabel(xlabel) d2l.plt.ylabel(ylabel) for patch in patches[1].patches: patch.set_hatch('/') d2l.plt.legend(legend) show_list_len_pair_hist(['source', 'target'], '# tokens per sequence', 'count', source, target); # 构建两个词表 # 将出现次数少于2次的低频率词元 视为相同的未知（“<unk>”）词元 # 在小批量时用于将序列填充到相同长度的填充词元（“<pad>”）， 以及序列的开始词元（“<bos>”）和结束词元（“<eos>”） src_vocab = d2l.Vocab(source, min_freq=2, reserved_tokens=['<pad>', '<bos>', '<eos>']) len(src_vocab) # 加载数据集 def truncate_pad(line, num_steps, padding_token): """截断或填充文本序列""" if len(line) > num_steps: return line[:num_steps] # 截断 return line + [padding_token] * (num_steps - len(line)) # 填充 truncate_pad(src_vocab[source[0]], 10, src_vocab['<pad>']) # 定义一个函数： 将文本序列 [转换成小批量数据集用于训练 def build_array_nmt(lines, vocab, num_steps): """将机器翻译的文本序列转换成小批量""" lines = [vocab[l] for l in lines] lines = [l + [vocab['<eos>']] for l in lines] array = torch.tensor([truncate_pad( l, num_steps, vocab['<pad>']) for l in lines]) valid_len = (array != vocab['<pad>']).type(torch.int32).sum(1) return array, valid_len # 训练模型 def 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_vocab # 读出“英语－法语”数据集中的第一个小批量数据 train_iter, src_vocab, tgt_vocab = load_data_nmt(batch_size=2, num_steps=8) for X, X_valid_len, Y, Y_valid_len in train_iter: print('X:', X.type(torch.int32)) print('X的有效长度:', X_valid_len) print('Y:', Y.type(torch.int32)) print('Y的有效长度:', Y_valid_len) break 编码器和解码器

回顾：

在CNN中，将“特征提取”看作编码器，softmax回归看作解码器；—> 编码器：将输入编程成中间表达形式（特征）；解码器：将中间表示解码成输出。在RNN中，编码器：将文本表示成向量；解码器：向量表示成输出。

引出：

机器翻译是序列转换模型的一个核心问题， 其输入和输出都是长度可变的序列。 为了处理这种类型的输入和输出， 我们可以设计一个包含两个主要组件的架构： 第一个组件是一个编码器（encoder）： 它接受一个长度可变的序列作为输入， 并将其转换为具有固定形状的编码状态。第二个组件是解码器（decoder）： 它将固定形状的编码状态映射到长度可变的序列。

这被称为编码器-解码器（encoder-decoder）架构。 一个模块被分为两部分：编码器处理输入；解码器负责输出

代码实现 # 编码器-解码器架构 # 机器翻译是序列转换模型的一个核心问题， 其输入和输出都是长度可变的序列。 # 为了处理这种类型的输入和输出， 我们可以设计一个包含两个主要组件的架构： # 第一个组件是一个编码器（encoder）： 它接受一个长度可变的序列作为输入， 并将其转换为具有固定形状的编码状态。 # 第二个组件是解码器（decoder）： 它将固定形状的编码状态映射到长度可变的序列。 # 这被称为编码器-解码器（encoder-decoder）架构 # 编码器 from torch import nn class Encoder(nn.Module): """编码器-解码器架构的基本编码器接口""" def __init__(self, **kwarge): super(Encoder, self).__init__(**kwarge) def forward(self, X, *args): raise NotImplementedError # 解码器 # 用于将编码器的输出（enc_outputs）转换为编码后的状态 class Decoder(nn.Module): def __init__(self, **kwargs): super(Decoder, self).__init__(**kwargs) # 中间状态：编码的输出enc_outputs def init_state(self, enc_outputs, *args): raise NotImplementedError def forward(self, X, state): raise NotImplementedError # 合并编码器和解码器 class EncoderDecoder(nn.Module): """编码器-解码器架构的基类""" def __init__(self, encoder, decoder, **kwargs): super(EncoderDecoder, self).__init__(**kwargs) self.encoder = encoder self.decoder = decoder def forward(self, enc_X, dec_X, *args): enc_outputs = self.encoder(enc_X, *args) dec_state = self.decoder.init_state(enc_outputs, *args) return self.decoder(dec_X, dec_state) 序列到序列学习（seq2seq）

在生物中，将DNA序列转为RNA。

机器翻译 机器翻译是最常见的应用给定一个源语言的句子，自动翻译成目标语言这两个句子都可以有不同的长度 Seq2Seq

编码器是一个RNN，读取输入的句子

可以是双向的（经常用在Encoder中）

解码器使用另一个RNN来输入

编码器解码器细节

编码器是没有输出的RNN编码器最后时间步的隐状态用作解码器的初始隐状态

训练：

训练时解码器使用目标句子作为输入推理的时候就是根据当前的输入和状态来生成输出。 衡量生成序列的好坏的BLEU pn是预测中所有n-gram的精度 表示 n 元语法的精确度，它是两个数量的比值： 第一个是预测序列与标签序列中匹配的n元语法的数量， 第二个是预测序列中 n 元语法的数量的比率；标签序列A B C D E F 和预测序列A B B C D，有p1 = 4/5，p2 = 3/4，p2 = 1/3，p4 = 0BLEU定义： 前部分min()代表 惩罚过段的预测；后部分有高权重。 总结 seq2seq从一个句子生成另一个句子根据“编码器-解码器”架构的设计， 我们可以使用两个循环神经网络来设计一个序列到序列学习的模型。在实现编码器和解码器时，我们可以使用多层循环神经网络。将编码器最后时间隐状态来初始解码器隐状态来完成信息传递在“编码器－解码器”训练中，强制教学方法将原始输出序列（而非预测结果）输入解码器。BLEU是一种常用的评估方法，它通过测量预测序列和标签序列之间的 𝑛 元语法的匹配度来评估预测。 代码实现 # 序列到序列学习 import collections import math import torch from torch import nn from d2l import torch as d2l # 实现循环神经网络编码器 class Seq2SeqEncoder(d2l.Encoder): """用于序列到序列学习的循环神经网络编码器""" def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs): super(Seq2SeqEncoder, self).__init__(**kwargs) # 使用嵌入层（embedding layer） 获得输入序列中每个词元的特征向量。 # 嵌入层的权重是一个矩阵 # 其行数等于输入词表的大小（vocab_size）， 其列数等于特征向量的维度（embed_size） 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) # 如果未提及状态，则默认为0 output, state = self.rnn(X) # 得到输出和状态 # output的形状:(num_steps,batch_size,num_hiddens) # state的形状:(num_layers,batch_size,num_hiddens) return output, state # 实例化 上述编码器的实现：使用一个两层门控循环单元编码器，其隐藏单元数为 16 # 定一小批量的输入序列X（批量大小为 4 ，时间步为 7 ）。 # 完成所有时间步之后，最后一层的隐状态的输出是一个张量，形状：（时间步数，批量大小，隐藏单元数） encoder = Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2) encoder.eval() # dropout就不会生效了 X = torch.zeros((4, 7), dtype=torch.long) output, state = encoder(X) # output形状：（时间步数，批量大小，隐藏单元数） # state形状：（隐藏层的数量，批量大小，隐藏单元的数量） output.shape,state.shape # 解码器 # 直接使用编码器最后一个时间步的隐状态来初始化解码器的隐状态 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_steps context = 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的形状:(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 # 损失函数 # sequence_mask函数 [通过零值化屏蔽不相关的项] # 以便后面任何不相关预测的计算都是与零的乘积，结果都等于零。 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] = value return X X = torch.tensor([[1, 2, 3], [4, 5, 6]]) sequence_mask(X, torch.tensor([1, 2])) # 还可以使用此函数屏蔽最后几个轴上的所有项 X = torch.ones(2, 3, 4) sequence_mask(X, torch.tensor([1, 2]), value=-1) # 通过扩展softmax交叉熵损失函数来遮蔽不相关的预测 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 # 创建三个相同序列进行代码健全性检查 loss = MaskedSoftmaxCELoss() loss(torch.ones(3, 4, 10), torch.ones((3, 4), dtype=torch.long), torch.tensor([4, 2, 0])) # 训练 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) # 预测 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>']: break output_seq.append(pred) return ' '.join(tgt_vocab.to_tokens(output_seq)), attention_weight_seq # 预测序列的评估 def bleu(pred_seq, label_seq, k): #@save """计算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])] += 1 for i in range(len_pred - n + 1): if label_subs[' '.join(pred_tokens[i: i + n])] > 0: num_matches += 1 label_subs[' '.join(pred_tokens[i: i + n])] -= 1 score *= 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}') 束搜索

beam search

贪心搜索（greedy search） 在seq2seq中我们使用贪心搜索来预测序列 将当前时刻预测概率最大的值输出 但贪心很可能不是最优的： 效率高但可能不是最优的 穷举搜索

如果目标是获得最优序列， 我们可以考虑使用穷举搜索（exhaustive search）： 穷举地列举所有可能的输出序列及其条件概率， 然后计算输出条件概率最高的一个。

最优算法：对所有可能的序列，计算它的概率，然后选取最好的那个。如果输出字典大小为n，序列最长为T，那么需要考虑 n^T个序列 n = 10000, T = 10: n^T = 10^40优点肯定能找到最优，但是计算不可行 束搜索（折中）

保持最好的k个候选（束宽：k）

在每个时刻，对每个候选新加一项（n种可能），在 kn 个选项中选出最好的k个。 候选输出序列是A、C、AB、CE、ABD和CED

时间复杂度O(knT)

每个候选的最终分数是：

L是最终候选序列的长度，通常α = 0.75 总结

束搜索的结果介于贪心搜索和穷举搜索之间（k=1是贪心）。通过灵活地选择束宽，束搜索可以在正确率和计算代价之间进行权衡。