【深度学习实验】循环神经网络（五）：基于GRU的语言模型训练（包括自定义门控循环单元GRU）

门控循环单元GRU）"/>

【深度学习实验】循环神经网络（五）：基于GRU的语言模型训练（包括自定义门控循环单元GRU）

文章目录

• 一、实验介绍
• 二、实验环境
• • 1. 配置虚拟环境
  • 2. 库版本介绍
• 三、实验内容
• • （一）自定义门控循环单元（GRU，Gated Recurrent Unit）
  • • 1. get_params
    • 2. init_gru_state
    • 3. gru
  • （二）创建模型
  • • 0. 超参数
    • 1. 使用上述手动实现的GRU函数
    • 2. 调用Pytorch库的GRU类
  • （三）基于GRU的语言模型训练
  • • 1. RNNModel类
    • 2. 训练、测试及其余辅助函数
    • 3. 主函数
    • • a. 训练
      • b. 测试结果
    • 4. 代码整合

​

  经验是智慧之父，记忆是智慧之母。
——谚语

一、实验介绍

• 基于门控的循环神经网络（Gated RNN）
  • 门控循环单元（GRU）
    • 门控循环单元（GRU）具有比传统循环神经网络更少的门控单元，因此参数更少，计算效率更高。GRU通过重置门和更新门来控制信息的流动，从而改善了传统循环神经网络中的长期依赖问题。
  • 长短期记忆网络（LSTM）
    • 长短期记忆网络（LSTM）是另一种常用的门控循环神经网络结构。LSTM引入了记忆单元和输入门、输出门以及遗忘门等门控机制，通过这些门控机制可以选择性地记忆、遗忘和输出信息，有效地处理长期依赖和梯度问题。
• GRU示意图：
  

二、实验环境

  本系列实验使用了PyTorch深度学习框架，相关操作如下：

1. 配置虚拟环境

conda create -n DL python=3.7 

conda activate DL

pip install torch==1.8.1+cu102 torchvision==0.9.1+cu102 torchaudio==0.8.1 -f .html

conda install matplotlib

 conda install scikit-learn

2. 库版本介绍

软件包	本实验版本	目前最新版
matplotlib	3.5.3	3.8.0
numpy	1.21.6	1.26.0
python	3.7.16
scikit-learn	0.22.1	1.3.0
torch	1.8.1+cu102	2.0.1
torchaudio	0.8.1	2.0.2
torchvision	0.9.1+cu102	0.15.2

三、实验内容

（一）自定义门控循环单元（GRU，Gated Recurrent Unit）

1. get_params

def get_params(vocab_size, num_hiddens, device):num_inputs = num_outputs = vocab_sizedef normal(inputs, hiddens):ctx = deviceparam = torch.rand((inputs, hiddens))param.to(ctx)return paramdef 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

  get_params 函数用于初始化模型的参数。它接受三个参数：vocab_size 表示词汇表的大小，num_hiddens 表示隐藏单元的数量，device 表示模型所在的设备（如 CPU 或 GPU）。

• 首先，根据 vocab_size 初始化 num_inputs 和 num_outputs，它们的值都等于 vocab_size。
• 然后，定义了一个内部函数 normal，该函数用于生成一个服从均匀分布的随机参数矩阵。这个函数返回一个形状为 (inputs, hiddens) 的随机参数矩阵，并将其移动到指定的设备上。
• 接下来，定义了另一个内部函数 three，该函数用于生成三个参数组成的元组。这三个参数分别表示更新门参数、重置门参数和候选隐状态参数。
• 使用 three 函数分别初始化了更新门参数 W_xz, W_hz, b_z，重置门参数 W_xr, W_hr, b_r，候选隐状态参数 W_xh, W_hh, b_h。
• 然后，通过调用 normal 函数初始化了输出层参数 W_hq 和 b_q。
• 最后，将所有的参数放入一个列表 params 中，并设置它们的 requires_grad 属性为 True，表示这些参数需要计算梯度。
• 返回参数列表 params。

2. init_gru_state

def init_gru_state(batch_size, num_hiddens, device):return (torch.zeros((batch_size, num_hiddens), device=device), )

  init_gru_state 函数用于初始化隐藏状态，作为时间步 t=0 时的输入。它接受三个参数：batch_size 表示批次大小，num_hiddens 表示隐藏单元的数量，device 表示模型所在的设备。

• 使用 torch.zeros 函数创建并返回一个形状为 (batch_size, num_hiddens) 的全零张量，表示初始的隐藏状态。

3. gru

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,)

   gru 函数是实现门控循环单元的关键部分，接受三个参数：inputs 表示输入序列，state 表示隐藏状态，params 表示模型的参数。

• 首先，从 params 中解包出更新门参数、重置门参数、候选隐状态参数以及输出层参数。
• 然后，通过一个循环遍历输入序列 inputs。
• 在每个时间步，根据输入 X 和当前的隐藏状态 H，计算更新门 Z、重置门 R 和候选隐状态 H_tilda。
• 然后，根据门控机制和候选隐状态，计算新的隐藏状态 H。
• 接着，使用隐藏状态 H 计算输出 Y。
• 将输出 Y 添加到输出列表 outputs 中。
• 循环结束后，使用 torch.cat 函数将输出列表中的所有输出连接起来，得到一个形状为 (seq_length * batch_size, num_outputs) 的张量，表示模型在整个序列上的输出。
• 最后，返回连接后的输出张量和最终的隐藏状态 (H,)。

（二）创建模型

0. 超参数

batch_size, num_steps = 32, 35
train_iter, vocab = d2l.load_data_time_machine(batch_size, num_steps)
vocab_size, num_hiddens, num_epochs, lr= 28, 256, 200, 1
device = try_gpu()

• 调用d2l.load_data_time_machine函数加载了训练数据，并设置了一些训练超参数。

1. 使用上述手动实现的GRU函数

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)

• 使用先前定义的参数初始化函数、隐藏状态初始化函数和GRU函数创建自定义的RNN模型model；
• 调用d2l.train_ch8函数对该模型进行训练。

2. 调用Pytorch库的GRU类

gru_layer = nn.GRU(vocab_size, num_hiddens)
model_gru = RNNModel(gru_layer, vocab_size)
train(model_gru, train_iter, vocab, lr, num_epochs, device)

• 创建了一个使用PyTorch库中的GRU类的model_gru，并对其进行训练。
• 关于训练过程，请继续阅读

（三）基于GRU的语言模型训练

注：本实验使用Pytorch库的GRU类，不使用自定义的GRU函数

1. RNNModel类

• 参考前文: 【深度学习实验】循环神经网络（三）：门控制——自定义循环神经网络LSTM（长短期记忆网络）模型

2. 训练、测试及其余辅助函数

• 参考前文: 【深度学习实验】循环神经网络（四）：基于 LSTM 的语言模型训练

3. 主函数

a. 训练

batch_size, num_steps = 32, 35
train_iter, vocab = d2l.load_data_time_machine(batch_size, num_steps)
vocab_size, num_hiddens, num_epochs, lr= 28, 256, 200, 1
device = try_gpu()
gru_layer = nn.GRU(vocab_size, num_hiddens)
model_gru = RNNModel(gru_layer, vocab_size)
train(model_gru, train_iter, vocab, lr, num_epochs, device)print(predict('time ', 10, model_gru, vocab, device))

• 训练中每个小批次（batch）的大小和每个序列的时间步数（time step）的值分别为32，25
• 加载的训练数据迭代器和词汇表
• vocab_size 是词汇表的大小，num_hiddens 是GRU 隐藏层中的隐藏单元数量，num_epochs 是训练的迭代次数，lr 是学习率
• 选择可用的 GPU 设备进行训练，如果没有可用的 GPU，则会使用 CPU
• 训练模型
• 模型测试

b. 测试结果

4. 代码整合

# 导入必要的库
import torch
from torch import nn
import torch.nn.functional as F
from d2l import torch as d2l
import mathclass RNNModel(nn.Module):def __init__(self, rnn_layer, vocab_size, **kwargs):super(RNNModel, self).__init__(**kwargs)self.rnn = rnn_layerself.vocab_size = vocab_sizeself.num_hiddens = self.rnn.hidden_sizeself.num_directions = 1self.linear = nn.Linear(self.num_hiddens, self.vocab_size)def forward(self, inputs, state):X = F.one_hot(inputs.T.long(), self.vocab_size)X = X.to(torch.float32)Y, state = self.rnn(X, state)# 全连接层首先将Y的形状改为(时间步数*批量大小,隐藏单元数)# 它的输出形状是(时间步数*批量大小,词表大小)。output = self.linear(Y.reshape((-1, Y.shape[-1])))return output, state# 在第一个时间步，需要初始化一个隐藏状态，由此函数实现def begin_state(self, device, batch_size=1):if not isinstance(self.rnn, nn.LSTM):# nn.GRU以张量作为隐状态return torch.zeros((self.num_directions * self.rnn.num_layers,batch_size, self.num_hiddens),device=device)else:# nn.LSTM以元组作为隐状态return (torch.zeros((self.num_directions * self.rnn.num_layers,batch_size, self.num_hiddens), device=device),torch.zeros((self.num_directions * self.rnn.num_layers,batch_size, self.num_hiddens), device=device))def train(net, train_iter, vocab, lr, num_epochs, device, use_random_iter=False):loss = nn.CrossEntropyLoss()animator = d2l.Animator(xlabel='epoch', ylabel='perplexity',legend=['train'], xlim=[10, num_epochs])if isinstance(net, nn.Module):updater = torch.optim.SGD(net.parameters(), lr)else:updater = lambda batch_size: d2l.sgd(net.params, lr, batch_size)for epoch in range(num_epochs):ppl, speed = train_epoch(net, train_iter, loss, updater, device, use_random_iter)if (epoch + 1) % 10 == 0:animator.add(epoch + 1, [ppl])print('Train Done!')torch.save(net.state_dict(), 'chapter6.pth')print(f'困惑度 {ppl:.1f}, {speed:.1f} 词元/秒 {str(device)}')def train_epoch(net, train_iter, loss, updater, device, use_random_iter):state, timer = None, d2l.Timer()metric = d2l.Accumulator(2)  # 训练损失之和,词元数量for X, Y in train_iter:if state is None or use_random_iter:# 在第一次迭代或使用随机抽样时初始化statestate = net.begin_state(batch_size=X.shape[0], device=device)if isinstance(net, nn.Module) and not isinstance(state, tuple):# state对于nn.GRU是个张量state.detach_()else:# state对于nn.LSTM或对于我们从零开始实现的模型是个张量for s in state:s.detach_()y = Y.T.reshape(-1)X, y = X.to(device), y.to(device)y_hat, state = net(X, state)l = loss(y_hat, y.long()).mean()if isinstance(updater, torch.optim.Optimizer):updater.zero_grad()l.backward()grad_clipping(net, 1)updater.step()else:l.backward()grad_clipping(net, 1)# 因为已经调用了mean函数updater(batch_size=1)metric.add(l * d2l.size(y), d2l.size(y))return math.exp(metric[0] / metric[1]), metric[1] / timer.stop()def predict(prefix, num_preds, net, vocab, device):state = net.begin_state(batch_size=1, device=device)outputs = [vocab[prefix[0]]]get_input = lambda: torch.reshape(torch.tensor([outputs[-1]], device=device), (1, 1))for y in prefix[1:]:  # 预热期_, state = net(get_input(), state)outputs.append(vocab[y])for _ in range(num_preds):  # 预测num_preds步y, state = net(get_input(), state)outputs.append(int(y.argmax(dim=1).reshape(1)))return ''.join([vocab.idx_to_token[i] for i in outputs])def grad_clipping(net, theta):if isinstance(net, nn.Module):params = [p for p in net.parameters() if p.requires_grad]else:params = net.paramsnorm = torch.sqrt(sum(torch.sum((p.grad ** 2)) for p in params))if norm > theta:for param in params:param.grad[:] *= theta / normdef try_gpu(i=0):# """如果存在，则返回gpu(i)，否则返回cpu()"""# # if torch.cuda.device_count() >= i + 1:# #     return torch.device(f'cuda:{i}')return torch.device('cpu')batch_size, num_steps = 32, 35
train_iter, vocab = d2l.load_data_time_machine(batch_size, num_steps)
vocab_size, num_hiddens, num_epochs, lr = 28, 256, 200, 1
device = try_gpu()gru_layer = nn.GRU(vocab_size, num_hiddens)
model_gru = RNNModel(gru_layer, vocab_size)
train(model_gru, train_iter, vocab, lr, num_epochs, device)print(predict('time ', 10, model_gru, vocab, device))