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

现代循环神经网络

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

• 早期观测值影响重大：早期观测值对预测所有未来观测值极为重要，如序列中第一个观测值包含校验和，需在序列末尾辨别其是否正确，若无特殊机制存储早期重要信息，就需给该观测值指定很大梯度，因为它影响后续所有观测值。
• 存在无关词元：在对网页内容进行情感分析等任务时，可能存在一些与观测值无关的词元，如辅助 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 d2lbatch_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_sizedef normal(shape):return torch.randn(size=shape, device=device)*0.01def 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 = paramsH, = stateoutputs = []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_tildaY = H @ W_hq + b_qoutputs.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 d2lbatch_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_sizedef normal(shape):return torch.randn(size=shape, device=device)*0.01def 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) = stateoutputs = []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_tildaH = O * torch.tanh(C)Y = (H @ W_hq) + b_qoutputs.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 d2lbatch_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项目的双语句子对（https://www.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 charfor 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:breakparts = line.split('\t')if len(parts) == 2:source.append(parts[0].split(' '))target.append(parts[1].split(' '))return source, targetsource, 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 nnclass 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_outputsdef init_state(self, enc_outputs, *args):raise NotImplementedErrordef forward(self, X, state):raise NotImplementedError# 合并编码器和解码器
class EncoderDecoder(nn.Module):"""编码器-解码器架构的基类"""def __init__(self, encoder, decoder, **kwargs):super(EncoderDecoder, self).__init__(**kwargs)self.encoder = encoderself.decoder = decoderdef 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 = 0
  • BLEU定义：
    
    前部分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)# 如果未提及状态，则默认为0output, 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_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的形状:(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] = valuereturn XX = 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>']:breakoutput_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])] += 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}')

束搜索

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是贪心）。通过灵活地选择束宽，束搜索可以在正确率和计算代价之间进行权衡。