文章目录
- 一、实验介绍
- 二、实验环境
-
- [1. 配置虚拟环境](#1. 配置虚拟环境)
- [2. 库版本介绍](#2. 库版本介绍)
- 三、实验内容
-
- [(一)自定义门控循环单元(GRU,Gated Recurrent Unit)](#(一)自定义门控循环单元(GRU,Gated Recurrent Unit))
-
- [1. get_params](#1. get_params)
- [2. init_gru_state](#2. init_gru_state)
- [3. gru](#3. gru)
- (二)创建模型
-
- [0. 超参数](#0. 超参数)
- [1. 使用上述手动实现的GRU函数](#1. 使用上述手动实现的GRU函数)
- [2. 调用Pytorch库的GRU类](#2. 调用Pytorch库的GRU类)
- (三)基于GRU的语言模型训练
-
- [1. RNNModel类](#1. RNNModel类)
- [2. 训练、测试及其余辅助函数](#2. 训练、测试及其余辅助函数)
- [3. 主函数](#3. 主函数)
-
- [a. 训练](#a. 训练)
- [b. 测试结果](#b. 测试结果)
- [4. 代码整合](#4. 代码整合)
经验是智慧之父,记忆是智慧之母。
------谚语
一、实验介绍
- 基于门控的循环神经网络(Gated RNN)
- 门控循环单元(GRU)
- 门控循环单元(GRU)具有比传统循环神经网络更少的门控单元,因此参数更少,计算效率更高。GRU通过重置门 和更新门来控制信息的流动,从而改善了传统循环神经网络中的长期依赖问题。
- 长短期记忆网络(LSTM)
- 长短期记忆网络(LSTM)是另一种常用的门控循环神经网络结构。LSTM引入了记忆单元 和输入门 、输出门 以及遗忘门等门控机制,通过这些门控机制可以选择性地记忆、遗忘和输出信息,有效地处理长期依赖和梯度问题。
- 门控循环单元(GRU)
- GRU示意图:
二、实验环境
本系列实验使用了PyTorch深度学习框架,相关操作如下:
1. 配置虚拟环境
bash
conda create -n DL python=3.7
bash
conda activate DL
bash
pip install torch==1.8.1+cu102 torchvision==0.9.1+cu102 torchaudio==0.8.1 -f https://download.pytorch.org/whl/torch_stable.html
bash
conda install matplotlib
bash
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
python
def get_params(vocab_size, num_hiddens, device):
num_inputs = num_outputs = vocab_size
def normal(inputs, hiddens):
ctx = device
param = torch.rand((inputs, hiddens))
param.to(ctx)
return param
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
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
python
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
python
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,)
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. 超参数
python
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函数
python
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类
python
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类
2. 训练、测试及其余辅助函数
3. 主函数
a. 训练
python
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. 代码整合
python
# 导入必要的库
import torch
from torch import nn
import torch.nn.functional as F
from d2l import torch as d2l
import math
class RNNModel(nn.Module):
def __init__(self, rnn_layer, vocab_size, **kwargs):
super(RNNModel, self).__init__(**kwargs)
self.rnn = rnn_layer
self.vocab_size = vocab_size
self.num_hiddens = self.rnn.hidden_size
self.num_directions = 1
self.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:
# 在第一次迭代或使用随机抽样时初始化state
state = 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.params
norm = torch.sqrt(sum(torch.sum((p.grad ** 2)) for p in params))
if norm > theta:
for param in params:
param.grad[:] *= theta / norm
def 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))