本文介绍了循环神经网络（RNN）的基础知识，包括其结构、参数初始化、预测、训练过程和梯度裁减。RNN在处理序列数据如语言模型时，通过隐藏状态传递历史信息。通过训练一个简单的RNN模型，展示了如何使用PyTorch实现和优化RNN，以降低困惑度并提高预测效果。此外，还对比了随机采样和顺序分区两种训练策略的差异，并讨论了框架内RNN的简洁实现。
4 循环神经网络
潜变量自回归模型中，隐变量
h
t
h_t
ht与
h
t
−
1
h_{t-1}
ht−1和
x
t
−
1
x_{t-1}
xt−1有关,
x
t
x_t
xt与
h
t
h_t
ht和
x
t
−
1
x_{t-1}
xt−1有关。
更新隐藏状态：
h
t
=
ϕ
(
W
h
h
h
t
−
1
+
W
h
x
x
t
−
1
+
b
h
)
h_t=\phi(W_{hh}h_{t-1}+W_{hx}x_{t-1}+b_h)
ht=ϕ(Whhht−1+Whxxt−1+bh)
输出：
o
t
=
ϕ
(
W
h
o
h
t
+
b
o
)
o_{t}=\phi(W_{ho}h_{t}+b_{o})
ot=ϕ(Whoht+bo)
ϕ
\phi
ϕ:激活函数
W
h
x
W_{hx}
Whx: 由
x
t
−
1
x_{t-1}
xt−1影响的隐藏层权重
W
h
h
W_{hh}
Whh: 由
h
t
−
1
h_{t-1}
ht−1影响的隐藏层权重
W
t
o
W_{to}
Wto: 由
h
t
h_{t}
ht影响的隐藏层权重，影响
o
t
o_{t}
ot
如果输入‘你’，更新隐变量预测‘好’字
困惑度
- 衡量一个语言模型的好坏可以用平均交叉熵
π = 1 n ∑ i = 1 n − log p ( x t ∣ x t − 1 , . . . ) \pi = \frac{1}{n} \sum_{i=1}^n - \log p(x_t|x_{t-1},...) π=n1i=1∑n−logp(xt∣xt−1,...)
p是语言模型的预测概率， x t x_t xt是真实词 - NLP使用困惑度
e
x
p
(
π
)
exp(\pi)
exp(π)是平均每次可能选项
- 1表示完美，无穷大最差，困惑度能够很好的体现误差
梯度裁减
- 迭代中计算T个时间步上的梯度，在反向传播过程中产生长度为O(T)的矩阵乘法链，导致数值不稳定
- 梯度裁减能有效预防梯度爆炸
- 如果梯度长度超过
θ
\theta
θ，那么拖回到长度
θ
\theta
θ，使g长度永远不会超过
θ
\theta
θ
g ← m i n ( 1 , θ ∣ ∣ g ∣ ∣ ) g g \leftarrow min(1,\frac{\theta}{||g||})g g←min(1,∣∣g∣∣θ)g
- 如果梯度长度超过
θ
\theta
θ，那么拖回到长度
θ
\theta
θ，使g长度永远不会超过
θ
\theta
θ
RNN的应用
5.循环神经网络的实现
!pip install d2l==0.14
%matplotlib inline
import math
import torch
from torch import nn
from torch.nn import functional as F
from d2l import torch as d2l
# 批量大小，T时间步
batch_size, num_steps = 32, 35
train_iter, vocab = d2l.load_data_time_machine(batch_size, num_steps)
5.1 独热编码
在train_iter中，每个词元都表示为一个数字索引， 将这些索引直接输入神经网络可能会使学习变得困难。 通常将每个词元表示为更具表现力的特征向量。 最简单的表示称为独热编码（one-hot encoding）
F.one_hot(torch.tensor([0, 2]), len(vocab))
将每个索引映射为相互不同的单位向量： 假设词表中不同词元的数目为N（即len(vocab)）， 词元索引的范围为0到N-1。 如果词元的索引是整数i， 那么我们将创建一个长度为N的全0向量， 并将第处的元素设置为1。 此向量是原始词元的一个独热向量。 索引为0和2的独热向量如下所示:
tensor([[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0],
[0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0]])
我们每次采样的小批量数据形状是二维张量： （批量大小，时间步数）。 one_hot函数将这样一个小批量数据转换成三维张量， 张量的最后一个维度等于词表大小（len(vocab)）。我们经常转换输入的维度，以便获得形状为 （时间步数，批量大小，词表大小）的输出。 这将使我们能够更方便地通过最外层的维度， 一步一步地更新小批量数据的隐状态。
5.2 初始化模型参数
def get_params(vocab_size, num_hiddens, device):
'''num_hiddens: 隐藏单元数'''
num_inputs = num_outputs = vocab_size
# 初始化参数，使方差为0.01
def normal(shape):
return torch.randn(size=shape, device=device) * 0.01
# 隐藏层参数
W_xh = normal((num_inputs, num_hiddens))
W_hh = normal((num_hiddens, num_hiddens))
b_h = torch.zeros(num_hiddens, device=device)
# 输出层参数
W_hq = normal((num_hiddens, num_outputs))
b_q = torch.zeros(num_outputs, device=device)
# 附加梯度
params = [W_xh, W_hh, b_h, W_hq, b_q]
for param in params:
param.requires_grad_(True)
return params
5.3 循环神经网络模型
函数在初始化时返回隐状态。返回是一个张量，张量全用0填充， 形状为（批量大小，隐藏单元数）。
def init_rnn_state(batch_size, num_hiddens, device):
return (torch.zeros((batch_size, num_hiddens), device=device), )
# 定义了如何在一个时间步内计算隐状态和输出
def rnn(inputs, state, params):
# inputs的形状：(时间步数量，批量大小，词表大小)
W_xh, W_hh, b_h, W_hq, b_q = params
H, = state
outputs = []
# X的形状：(批量大小，词表大小)
for X in inputs:
# 激活函数tanh
H = torch.tanh(torch.mm(X, W_xh) + torch.mm(H, W_hh) + b_h)
Y = torch.mm(H, W_hq) + b_q
outputs.append(Y)
return torch.cat(outputs, dim=0), (H,)
class RNNModelScratch:
"""从零开始实现的循环神经网络模型"""
def __init__(self, vocab_size, num_hiddens, device,
get_params, init_state, forward_fn):
self.vocab_size, self.num_hiddens = vocab_size, num_hiddens
self.params = get_params(vocab_size, num_hiddens, device)
self.init_state, self.forward_fn = init_state, forward_fn
def __call__(self, X, state):
X = F.one_hot(X.T, self.vocab_size).type(torch.float32)
return self.forward_fn(X, state, self.params)
def begin_state(self, batch_size, device):
return self.init_state(batch_size, self.num_hiddens, device)
检查输出是否具有正确的形状。
num_hiddens = 512
net = RNNModelScratch(len(vocab), num_hiddens, d2l.try_gpu(), get_params,
init_rnn_state, rnn)
state = net.begin_state(X.shape[0], d2l.try_gpu())
Y, new_state = net(X.to(d2l.try_gpu()), state)
Y.shape, len(new_state), new_state[0].shape
(torch.Size([10, 28]), 1, torch.Size([2, 512]))
5.4 预测
首先定义预测函数来生成prefix之后的新字符， 其中的prefix是一个用户提供的包含多个字符的字符串。 在循环遍历prefix中的开始字符时， 我们不断地将隐状态传递到下一个时间步，但是不生成任何输出。 这被称为预热（warm-up）期， 因为在此期间模型会自我更新（例如，更新隐状态）， 但不会进行预测。 预热期结束后，隐状态的值通常比刚开始的初始值更适合预测， 从而预测字符并输出它们。
def predict_ch8(prefix, num_preds, net, vocab, device): #@save
"""在prefix后面生成新字符"""
state = net.begin_state(batch_size=1, device=device)
outputs = [vocab[prefix[0]]]
get_input = lambda: torch.tensor([outputs[-1]], device=device).reshape((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])
predict_ch8('time traveller ', 10, net, vocab, d2l.try_gpu())
5.5 梯度裁减
在RNN中给一个小批量数据进入网络，而不是一个单层隐藏层，而是做T步迭代，T为num_steps，代码设为35，可以看做35个矩阵乘法，因此容易引起梯度爆炸。
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
# 把所有层里面的p里的梯度取平方再求和，然后将计算出来的结果对所有层求和，最后开根号
norm = torch.sqrt(sum(torch.sum((p.grad ** 2)) for p in params))
# 如果norm大于theta，将所有梯度*=theta/norm，使所有梯度concat后计算所得的norm等于theta
# 当梯度特别大时，为了防止梯度在之后的训练中迅速增加，将梯度限制在theta内，保证模型不发散
if norm > theta:
for param in params:
param.grad[:] *= theta / norm
5.6 训练
从零开始编写循环神经网络训练函数
序列数据的不同采样方法（随机采样和顺序分区）将导致隐状态初始化的差异。
当使用顺序分区时， 我们只在每个迭代周期的开始位置初始化隐状态。 由于下一个小批量数据中的第个i子序列样本与当前第i个子序列样本相邻， 因此当前小批量数据最后一个样本的隐状态， 将用于初始化下一个小批量数据第一个样本的隐状态。 这样，存储在隐状态中的序列的历史信息 可以在一个迭代周期内流经相邻的子序列。 然而，在任何一点隐状态的计算， 都依赖于同一迭代周期中前面所有的小批量数据， 这使得梯度计算变得复杂。 为了降低计算量，在处理任何一个小批量数据之前， 我们先分离梯度，使得隐状态的梯度计算总是限制在一个小批量数据的时间步内。
当使用随机抽样时，因为每个样本都是在一个随机位置抽样的， 因此需要为每个迭代周期重新初始化隐状态。
def train_epoch_ch8(net, train_iter, loss, updater, device, use_random_iter):
"""训练网络一个迭代周期（定义见第8章）"""
state, timer = None, d2l.Timer()
metric = d2l.Accumulator(2) # 训练损失之和,词元数量
for X, Y in train_iter:
# 如果随机采样或state为空
if state is None or use_random_iter:
# 在第一次迭代或使用随机抽样时初始化state，隐藏状态初始化
# 如果use_random_iter为True,当前sequence与上一个sequence不是连续的，所以上一个state不应该用在当前时刻，因此每换一个batch都要重置state(即“状态”)
state = net.begin_state(batch_size=X.shape[0], device=device)
else: # 如果顺序分区，只在每个迭代周期的开始位置初始化隐状态
if isinstance(net, nn.Module) and not isinstance(state, tuple):
# state对于nn.GRU是个张量,detach不修改state里的值
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) # 放到GPU
y_hat, state = net(X, state) # 前向传播
# 为什么将所有输出在第一个维度concat，因为从loss角度看，可以看成一个多分类问题
l = loss(y_hat, y.long()).mean()
# 反向传播
# 如果使用pytorch框架中默认的优化器
if isinstance(updater, torch.optim.Optimizer):
updater.zero_grad()
l.backward()
grad_clipping(net, 1) # 梯度剪裁，theta为1
updater.step() # 更新参数权重
# 否则使用d2l.sgd优化器
else:
l.backward()
grad_clipping(net, 1)
# 因为已经调用了mean函数
updater(batch_size=1)
metric.add(l * y.numel(), y.numel())
# 使用困惑度来评价模型
return math.exp(metric[0] / metric[1]), metric[1] / timer.stop()
def train_ch8(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): # 如果使用pytorch框架中的优化器
updater = torch.optim.SGD(net.parameters(), lr)
else: # 用沐神前面写的优化器
updater = lambda batch_size: d2l.sgd(net.params, lr, batch_size)
predict = lambda prefix: predict_ch8(prefix, 50, net, vocab, device)
# 训练和预测
for epoch in range(num_epochs):
ppl, speed = train_epoch_ch8(
net, train_iter, loss, updater, device, use_random_iter)
if (epoch + 1) % 10 == 0: # 每个epoch输出一次预测的结果
print(predict('time traveller'))
animator.add(epoch + 1, [ppl])
print(f'困惑度 {ppl:.1f}, {speed:.1f} 词元/秒 {str(device)}')
print(predict('time traveller'))
print(predict('traveller'))
开始训练
num_epochs, lr = 500, 1
train_ch8(net, train_iter, vocab, lr, num_epochs, d2l.try_gpu())
困惑度 1.0, 76623.6 词元/秒 cuda:0
time travelleryou can show black is white by argument said filby
travelleryou can show black is white by argument said filby
使用随机采样训练
net = RNNModelScratch(len(vocab), num_hiddens, d2l.try_gpu(), get_params,
init_rnn_state, rnn)
train_ch8(net, train_iter, vocab, lr, num_epochs, d2l.try_gpu(),
use_random_iter=True)
困惑度 1.5, 67705.0 词元/秒 cuda:0
time travellerit s against reason said filby of course a solid b
travelleryou can show black is white by argument said filby
5.7 RNN的简洁实现
import torch
from torch import nn
from torch.nn import functional as F
from d2l import torch as d2l
batch_size, num_steps = 32, 35
train_iter, vocab = d2l.load_data_time_machine(batch_size, num_steps)
# 构造一个具有256个隐藏单元的单隐藏层的循环神经网络层
num_hiddens = 256
rnn_layer = nn.RNN(len(vocab), num_hiddens)
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
# 如果RNN是双向的（之后将介绍），num_directions应该是2，否则应该是1
if not self.rnn.bidirectional:
self.num_directions = 1
self.linear = nn.Linear(self.num_hiddens, self.vocab_size)
else:
self.num_directions = 2
self.linear = nn.Linear(self.num_hiddens * 2, 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))
num_epochs, lr = 500, 1
d2l.train_ch8(net, train_iter, vocab, lr, num_epochs, device)
perplexity 1.2, 148888.0 tokens/sec on gpu(0)
time traveller held in his hand was a glitteringmetallic framewo
travelleryou can show black andeed and animated thefire bur
由于深度学习框架的高级API对代码进行了更多的优化， 该模型在较短的时间内达到了较低的困惑度。
扫一扫
2573
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
