循环神经网络RNN
RNN原理
Recurrent Neural Network
当前时刻的输入和结合过去时刻的输入来做出一个输出，此输出表示的含义是预测出来的下一个时刻的序列值。在RNN中，过去看到的信息存在隐/潜变量之中。
这种情况就是当前时刻的标准结果值yt是下一个时刻的输入/观察值xt+1，所以是当前时刻模型的输出ot和下一时刻的观察值xt+1进行比较来计算损失。
tips: 上图可以脑海中想象把观察的蓝色行整体向右平移一个单位，这样时刻就对齐了。
损失计算方式
预测下一个词可以看作是一种分类问题，假设总共Vocab里面有m个词，经过softmax之后对每一个词都会有一个概率，取对应的真实词的概率值，用于上述公式中进行计算，因为预测是一个序列，序列长度为n，所以需要对这n个求平均，之后加加入指数的计算，求得困惑度值。
梯度裁剪
g向量指的是模型所有层的梯度全都放到这个g向量之中，其长度指的是g向量的L2范数，如果其长度没有超过一个给定的值，那么不做处理；如果超过了，需要将其根据公式缩放回给定值。那么里面的每个梯度的绝对值都不超过此给定值。
RNN从零开始实现
import math
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=batch_size, num_steps=num_steps)
# 独热编码
# shape 变成了 2*28
print(F.one_hot(torch.tensor([0, 2]), len(vocab)))
X = torch.arange(10).reshape((2, 5))
# 把X转置一下，把batch_size*num_steps 转置成num_steps*batch_size
print(F.one_hot(X.T, len(vocab)).shape)
# torch.Size([5, 2, 28])
# 这样访问第一维的数据的时候全都是同一个时间步的
def get_params(vocab_size, num_hiddens, device):
num_inputs = num_outputs = vocab_size
def normal(shape):
# 均值为 0，标准差为 1 乘以 0.01 后，标准差变成 0.01，均值仍然是 0
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
def init_rnn_state(batch_size, num_hiddens, device):
# 做成一个长度为1的tuple 方便后面模型的统一
return (torch.zeros((batch_size, num_hiddens), device=device), )
# 跑一个epoch中的一个batch
def rnn(inputs, state, params):
W_xh, W_hh, b_h, W_hq, b_q = params
H, = state
outputs = []
# inputs 是 num_steps*batch_size*vocab_size
# 通过inputs的最外层循环 每个X的形状：(批量大小，词表大小) 表示是同一个时间步的
for X in inputs:
H = torch.tanh(torch.mm(X, W_xh) + torch.mm(H, W_hh) + b_h)
Y = torch.mm(H, W_hq) + b_q
# 把每个时间步的输出结果都追加到outputs这个list之中
outputs.append(Y)
# 把outputs按照第0维拼接起来，就是竖直方向拼接
# 变成二维的 (num_steps*batch_size, vocab_size) 同一个时间步在竖直方向上是连续存放的
# 再把最后当前最新的隐藏层状态H 封成一个长度为1的元组return出去
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
# 这里传入的参数X 表示的是shape是batch_size*num_steps 里面是一个个数字
# 在将其独热编码处理一下
def __call__(self, X, state):
X = F.one_hot(X.T, self.vocab_size).type(torch.float32)
# 处理完成之后的X 其shape为num_steps*batch_size*vocab_size 同上面定义的rnn函数传参中的inputs一致
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, forward_fn=rnn)
state = net.begin_state(X.shape[0], d2l.try_gpu())
Y, new_state = net(X.to(d2l.try_gpu()), state=state)
print(Y.shape, len(new_state), new_state[0].shape)
# torch.Size([10, 28]) 1 torch.Size([2, 512])
def predict_ch8(prefix, num_preds, net, vocab, device):
# prefix是给定的字符序列，要在读过这些字符之后，在其后面 利用网络 连续生成num_preds个新的字符
# 给一个字符预测下一个字符
state = net.begin_state(batch_size=1, device=device)
# outputs是一个list 里面的每个元素存放的都是某个字符在vocab字典中对应的索引 是一个整数
outputs = [vocab[prefix[0]]]
# 定义了一个 lambda 函数（匿名函数），它的作用是从 outputs 列表中获取最后一个元素...
# outputs[-1] 含义是最新看到的/最新预测出来的字符，将其作为输入去预测下一个字符
get_input = lambda: torch.tensor([outputs[-1]], device=device).reshape((1, 1))
for y in prefix[1:]:
# 这部分意思是说要将prefix都看完，将序列信息都更新存储在state中
# 但是此时的outputs里面不用存网络的预测值 直接存真实值即可
_, state = net(get_input(), state)
outputs.append(vocab[y])
for _ in range(num_preds):
y, state = net(get_input(), state)
# 按照第1维也就是有28个数字的维度 找出值最大的索引值
outputs.append(int(y.argmax(dim=1).reshape(1)))
# 注意这里 ''就是一对儿单引号 不是空格 join() 方法用于 将列表中的字符串拼接成一个整体
return ''.join([vocab.idx_to_token[i] for i in outputs])
res = predict_ch8('time traveller ', 10, net, vocab, d2l.try_gpu())
print(res)
# 梯度裁剪
def grad_clipping(net, theta):
# 把网络每一层的可以训练学习的参数做成一个list列表存放在params中
if isinstance(net, nn.Module):
params = [p for p in net.parameters() if p.requires_grad]
else:
params = net.params
# 这里p就是每一层的参数 也是多维的比如是个矩阵 将其梯度也就是里面的
# 每个值都平方 在求和 然后再对所有层的求个和 再开根号
L2norm = torch.sqrt(sum(torch.sum((p.grad**2)) for p in params))
if L2norm > theta:
for param in params:
param.grad[:] *= theta / L2norm
# 训练一个epoch
def train_epoch_ch8(net, train_iter, loss, updater, device, use_random_iter):
state, timer = None, d2l.Timer()
# 有2个 分别是 训练损失之和,词元数量
metric = d2l.Accumulator(2)
# 这里的X Y 其shape都是batch_size*num_steps
for X, Y in train_iter:
if state is None or use_random_iter:
# 第一个批次的state自然需要初始化 此外 如果采用随机的iter，那么每一个批次的数据
# 跟上一个批次的数据不是连续的 没有序列信息 因此 隐藏层的状态state需要重新初始化
state = net.begin_state(batch_size=X.shape[0], device=device)
else:
# 否则state的数据可以继续用于下一个批次 但是要detach 使得梯度计算从当前批次开始
if isinstance(net, nn.Module) and not isinstance(state, tuple):
# state 通常是一个张量（如果是简单 RNN）
state.detach_()
else:
# 如果 state 是一个元组（比如 LSTM 的 h, c），就对 每个张量 进行 detach_() 操作
for s in state:
s.detach_()
# Y.T 为num_steps*batch_size 再将其拉成一个向量 那么同一个时间步的批次内数据是连续存放的
y = Y.T.reshape(-1)
X, y = X.to(device), y.to(device)
y_hat, state = net(X, state)
# y.long() 将 y 转换为 long 类型（通常是标签 y 必须是 int64 类型，适用于分类任务）
l = loss(y_hat, y.long()).mean()
if isinstance(updater, torch.optim.Optimizer):
updater.zero_grad()
l.backward()
grad_clipping(net, theta=1)
updater.step()
else:
l.backward()
grad_clipping(net, theta=1)
# 这里这个updater是自定义的 在后面 是一个lambda匿名函数 需要传入参数batch_size
updater(batch_size=1)
# 每个iter y的元素个数都是num_steps*batch_size个 再把这个epoch的每次iter的数据都累加
metric.add(l * y.numel(), y.numel())
# 返回的第一个是困惑度 第二个是单位时间内运行的样本数
return math.exp(metric[0] / metric[1]), metric[1] / timer.stop()
# 训练函数 训练多个epoch
def train_ch8(net, train_iter, vocab, lr, num_epochs, device,
use_random_iter=False):
loss = nn.CrossEntropyLoss()
if isinstance(net, nn.Module):
updater = torch.optim.SGD(net.parameters(), lr=lr)
else:
# updater 是一个 匿名函数（Lambda 函数）
# 作用是：根据 batch_size 调用 d2l.sgd() 更新 net.params
updater = lambda batch_size: d2l.sgd(params=net.params, lr=lr, batch_size=batch_size)
predict = lambda prefix: predict_ch8(prefix, num_preds=50, net=net, vocab=vocab, device=device)
for epoch in range(num_epochs):
perplexity, speed = train_epoch_ch8(
net, train_iter, loss, updater, device, use_random_iter)
if (epoch + 1) % 10 == 0:
print(f'第 {epoch + 1} 轮: {predict("time traveller")}')
print(f'困惑度 {perplexity:.1f}, {speed:.1f} 词元/秒 {str(device)}')
print(predict('time traveller'))
print(predict('traveller'))
num_epochs, lr = 500, 1
print('use_random_iter=False : ')
train_ch8(net, train_iter, vocab, lr, num_epochs, d2l.try_gpu())
# 第 500 轮: time traveller for so it will be convenient to speak of himwas e
# 困惑度 1.0, 119486.3 词元/秒 cuda:0
# time traveller for so it will be convenient to speak of himwas e
# travelleryou can show black is white by argument said filby
print('use_random_iter=True : ')
train_ch8(net, train_iter, vocab, lr, num_epochs, d2l.try_gpu(),
use_random_iter=True)
# 第 500 轮: time travellerit s against reason said filbywhat dees afo rod th
# 困惑度 1.3, 121242.6 词元/秒 cuda:0
# time travellerit s against reason said filbywhat dees afo rod th
# travelleryou can show black is white by argument said filby
使用PyTorch框架的RNN实现
这里需要注意的就是PyTorch框架中的nn.RNN只包含到了隐藏层结束，没有包含最后的输出层，这个层需要自己加上。
import math
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)
num_hiddens = 256
rnn_layer = nn.RNN(len(vocab), num_hiddens)
# 形状是（隐藏层数，批量大小，隐藏单元数）
state = torch.zeros((1, batch_size, num_hiddens))
print(state.shape)
# torch.Size([1, 32, 256])
X = torch.rand(size=(num_steps, batch_size, len(vocab)))
# rnn_layer的“输出”（Y）不涉及输出层的计算： 它是指每个时间步的隐状态，这些隐状态可以用作后续输出层的输入
Y, state_new = rnn_layer(X, state)
print(Y.shape, state_new.shape)
# 所以这里Y的shape中最后一个是256也就是num_hiddens 而不是vocab_size
# 因为rnn_layer没有包含输出层 到隐藏层就结束了 跟从零开始实现的有所区别
# torch.Size([35, 32, 256]) torch.Size([1, 32, 256])
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
if not self.rnn.bidirectional:
self.num_directions = 1
self.linear = nn.Linear(self.num_hiddens, self.vocab_size)
else:
# 如果RNN是双向的（之后将介绍），num_directions应该是2，否则应该是1
self.num_directions = 2
self.linear = nn.Linear(self.num_hiddens * 2, self.vocab_size)
def forward(self, inputs, state):
# 这里inputs的shape应该是 (batch_size, num_steps)
# 应该独热编码 X 变成了 (num_steps, batch_size, vocab_size)
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):
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))
device = d2l.try_gpu()
net = RNNModel(rnn_layer=rnn_layer, vocab_size=len(vocab))
net = net.to(device=device)
res = d2l.predict_ch8('time traveller', 10, net, vocab, device)
print(res)
num_epochs, lr = 500, 1
# 梯度裁剪
def grad_clipping(net, theta):
# 把网络每一层的可以训练学习的参数做成一个list列表存放在params中
if isinstance(net, nn.Module):
params = [p for p in net.parameters() if p.requires_grad]
else:
params = net.params
# 这里p就是每一层的参数 也是多维的比如是个矩阵 将其梯度也就是里面的
# 每个值都平方 在求和 然后再对所有层的求个和 再开根号
L2norm = torch.sqrt(sum(torch.sum((p.grad**2)) for p in params))
if L2norm > theta:
for param in params:
param.grad[:] *= theta / L2norm
# 训练一个epoch
def train_epoch_ch8(net, train_iter, loss, updater, device, use_random_iter):
state, timer = None, d2l.Timer()
# 有2个 分别是 训练损失之和,词元数量
metric = d2l.Accumulator(2)
# 这里的X Y 其shape都是batch_size*num_steps
for X, Y in train_iter:
if state is None or use_random_iter:
# 第一个批次的state自然需要初始化 此外 如果采用随机的iter，那么每一个批次的数据
# 跟上一个批次的数据不是连续的 没有序列信息 因此 隐藏层的状态state需要重新初始化
state = net.begin_state(batch_size=X.shape[0], device=device)
else:
# 否则state的数据可以继续用于下一个批次 但是要detach 使得梯度计算从当前批次开始
if isinstance(net, nn.Module) and not isinstance(state, tuple):
# state 通常是一个张量（如果是简单 RNN）
state.detach_()
else:
# 如果 state 是一个元组（比如 LSTM 的 h, c），就对 每个张量 进行 detach_() 操作
for s in state:
s.detach_()
# Y.T 为num_steps*batch_size 再将其拉成一个向量 那么同一个时间步的批次内数据是连续存放的
y = Y.T.reshape(-1)
X, y = X.to(device), y.to(device)
y_hat, state = net(X, state)
# y.long() 将 y 转换为 long 类型（通常是标签 y 必须是 int64 类型，适用于分类任务）
l = loss(y_hat, y.long()).mean()
if isinstance(updater, torch.optim.Optimizer):
updater.zero_grad()
l.backward()
grad_clipping(net, theta=1)
updater.step()
else:
l.backward()
grad_clipping(net, theta=1)
# 这里这个updater是自定义的 在后面 是一个lambda匿名函数 需要传入参数batch_size
updater(batch_size=1)
# 每个iter y的元素个数都是num_steps*batch_size个 再把这个epoch的每次iter的数据都累加
metric.add(l * y.numel(), y.numel())
# 返回的第一个是困惑度 第二个是单位时间内运行的样本数
return math.exp(metric[0] / metric[1]), metric[1] / timer.stop()
# 训练函数 训练多个epoch
def train_ch8(net, train_iter, vocab, lr, num_epochs, device,
use_random_iter=False):
loss = nn.CrossEntropyLoss()
if isinstance(net, nn.Module):
updater = torch.optim.SGD(net.parameters(), lr=lr)
else:
# updater 是一个 匿名函数（Lambda 函数）
# 作用是：根据 batch_size 调用 d2l.sgd() 更新 net.params
updater = lambda batch_size: d2l.sgd(params=net.params, lr=lr, batch_size=batch_size)
predict = lambda prefix: d2l.predict_ch8(prefix, num_preds=50, net=net, vocab=vocab, device=device)
for epoch in range(num_epochs):
perplexity, speed = train_epoch_ch8(
net, train_iter, loss, updater, device, use_random_iter)
if (epoch + 1) % 10 == 0:
print(f'第 {epoch + 1} 轮: {predict("time traveller")}')
print(f'困惑度 {perplexity:.1f}, {speed:.1f} 词元/秒 {str(device)}')
print(predict('time traveller'))
print(predict('traveller'))
train_ch8(net, train_iter, vocab, lr, num_epochs, device)
# 第 500 轮: time traveller after the paccerese eathery handinge cithee caine
# 困惑度 1.3, 411553.0 词元/秒 cuda:0 可以看出使用框架的speed快了很多
# time traveller after the paccerese eathery handinge cithee caine
# travelleritif fid filby an a ceattinbee mat s ventee marous
扫一扫
1549
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
