Pytorch学习笔记13——Basic_RNN
今天讨论一下基本的RNN，RNN叫做循环神经网络，是神经网络的一种。本质是对线性层的复用。
现在考虑一种场景：
已知前四天的温度、气压及是否下雨，我们需要预测第五天的气象情况。显然易见，如果我们只在第五天拿到当天的温度气压值去判断是否下雨，这是没有意义的，因为我们需要提前判断。于是这个问题就变成了：
第一天：温度 气压 是否下雨
第二天：温度 气压 是否下雨
第三天：温度 气压 是否下雨
第四天：温度 气压 是否下雨
一共四个样本，每个样本有三个特征，作为input，去预测第五天的情况。我们可以把x={x1，x2，x3，x4}拼接成一个序列，x2的数值会部分依赖于x1，x3的数值部分依赖于x2，x4的数值部分依赖于x3。
RNN主要用于处理这样具有序列性质的输入数据。
xt表示第t时刻的输入数据，在这里就是第t天的所有数据，特征为三维，因此他是3D的。经过RNN cell后，得到另一个维度的向量，假设变成5D。RNN Cell的本质就是一个线性层，把一个维度映射到另一个维度的空间内。
和我们平常用的线性层不同的是，这里的线性层是共享的。
展开来看，x1为第一天的3D数据，和初始值h0融合之后经过线性层得到h1(hidden)，h1又和x2融合再经过同一个线性层得到h2，h2又和x3融合再经过同一个线性层得到h3…以此类推，这也是RNN叫做循环神经网络的原因。
这里面的初始值h0，如果没有先验，那就可以先设成一个全0向量。
用代码来表示这个过程就是：
h = 0
for x in X:
h = Linear(x, h)
那x(t) 和h(t-1)是怎么融合的呢？具体计算过程如下：
输入x(t)是(1, input_size)大小的，设h(t-1)是(1, hidden_size)大小。
x(t)经过一个self.Linear(input_size, hidden_size)进行线性变换后变成 (1, hidden_size)大小，
h(t-1)经过一个self.Linear(hidden_size, hidden_size)线性变换后变成 (1, hidden_size)大小。
目的就是使两输出矩阵大小相同，从而进行相加融合，最后通过一个tanh激活函数即可。在RNN里更多用tanh而不是sigmoid是因为tanh输出(-1, 1)，往往效果更好。
而RNN Cell实现的就是中间部分的运算。
我们可以把这俩线性运算拼一块，进行向量化操作：
实际上，我们就是做了这样一件拼接的工作，把h和x拼成一个(hidden_size
+input_size)大小的矩阵，Whh和Wih拼成一个hidden_size*(hidden_size + input_size)大小的矩阵。从而变成一个线性层的工作，这就是RNN本质实现方式。
在pytorch中共有两种实现方式：创建RNNCell或直接创建RNN。
1. 创建RNNCell
cell = torch.nn.RNNCell(input_size = input_size, hidden_size = hidden_size)
hidden = cell(input, hidden)
这里把每一时刻的input和前一时刻的hidden送进去，这也注定了用这种创建方法需要我们自己写循环，遍历序列长度。
对于批量训练来说，这里的输入维度是：
input(batch_size, input_size)
hidden(batch_size, hidden_size)
输出维度:
hidden(batch_size, hidden_size)
举个例子，假设现在batch_size就等于1，每次处理1个样本。seqlen = 3，每个样本的序列长为3。输入特征维度为4，即input_size = 4;输出特征维度为2， 即hidden_size = 2
从而，RNNCell的输入矩阵是
input = (batch_size, input_size) = (1, 4)
输出矩阵是
output = (batch_size, hidden_size) = (1, 2)
整个数据集就可以写成:
dataset.shape = (seqlen, batch_size, input_size) = (3, 1, 4)
代表每次处理batch_size个样本的数据，每个样本都是由seqlen长度的序列构成的，在当前时刻有input_size个特征。
import torch
batch_size = 1
seq_len = 3
input_size = 4
hidden_size = 2
cell = torch.nn.RNNCell(input_size = input_size, hidden_size = hidden_size)
dataset = torch.randn(seq_len, batch_size, input_size)
hidden = torch.zeros(batch_size, hidden_size)
for idx, input in enumerate(dataset):
print('='*20, idx, '='*20)#按序列长度seq_len来循环，每次取出input(batch_size, input_size)
print('Input_size = ', input.shape)
hidden = cell(input, hidden)
print('Output_size = ', hidden.shape)
print(hidden) #打印每次输出
==================== 0 ====================
Input_size = torch.Size([1, 4])
Output_size = torch.Size([1, 2])
tensor([[-0.2002, -0.1809]], grad_fn=<TanhBackward0>)
==================== 1 ====================
Input_size = torch.Size([1, 4])
Output_size = torch.Size([1, 2])
tensor([[ 0.6019, -0.6742]], grad_fn=<TanhBackward0>)
==================== 2 ====================
Input_size = torch.Size([1, 4])
Output_size = torch.Size([1, 2])
tensor([[ 0.4382, -0.5559]], grad_fn=<TanhBackward0>)
2. 创建 RNN
cell = torch.nn.RNN(input_size = input_size, hidden_size = hidden_size, num_layers = num_layers)
out, hidden = cell(inputs, hidden)
从左到右：
out表示整个输出{h1, h2 ,…, hN}
hidden表示最终的输出hN
inputs表示整个输入{x1, x2, x3, x4}，
hidden表示初始h0
我们把整个序列送进去，RNN内部自己完成循环，返回每一次的输出以及最终输出。
INPUT:
input.shape = (seqSize, batch_size, input_size)
hidden.shape = (numLayers, batch_size, hidden_size)
OUTPUT:
output.shape = (seqSize,batch_size, hidden_size)
hidden.shape = (numLayers, batch_size, hidden_size)
这里的numlayers指的是层数。
import torch
batch_size = 1
seq_len = 3
input_size = 4
hidden_size = 2
num_layers = 1
cell = torch.nn.RNN(input_size = input_size, hidden_size = hidden_size,
num_layers = num_layers)
inputs = torch.randn(seq_len, batch_size, input_size)
hidden = torch.zeros(num_layers, batch_size, hidden_size)
out, hidden = cell(inputs, hidden)
print('Output size = ', out.shape)
print(out)
print('Hidden size = ', hidden.shape)
print(hidden)
Output size = torch.Size([3, 1, 2])
tensor([[[ 0.7941, 0.2922]],
[[ 0.0260, 0.0201]],
[[ 0.6268, -0.0600]]], grad_fn=<StackBackward0>)
Hidden size = torch.Size([1, 1, 2])
tensor([[[ 0.6268, -0.0600]]], grad_fn=<StackBackward0>)
RNN里面还有一些其他的参数，比如batch_first,如果设置了为True，那么input时需要变成inputs = torch.randn(batch_size, seq_len, input_size).
RNN应用：
进行一个学习任务，将序列"hello"序列学习变换为“ohlol”
①根据字符构造词典，给每个字符分配索引，对词进行one-hot编码
input_size就是所有字符种类，这里等于4。
②送到RNN里，很明显是一个多分类问题，输出得到4向量，接softmax得到P(y = e), P(y = h), P(y = l), P(y = o)。与标签的one-hot编码向量进行损失计算。
import torch
batch_size = 1
input_size = 4
hidden_size = 4
idx2Char = ['e', 'h', 'l', 'o']
x_data = [1, 0, 2, 2, 3]#hello
y_data = [3, 1, 2, 3 ,2]#ohlol
one_hot_lookup = [[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]]
x_one_hot = [one_hot_lookup[x] for x in x_data]
y_one_hot = [one_hot_lookup[y] for y in y_data]
print(x_one_hot)
print(y_one_hot)
[[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 1, 0], [0, 0, 1, 0], [0, 0, 0, 1]]
[[0, 0, 0, 1], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1], [0, 0, 1, 0]]
inputs = torch.Tensor(x_one_hot).view(-1, batch_size, input_size)
labels = torch.Tensor(x_one_hot).view(-1, batch_size, input_size)
print(inputs)
print(labels)
tensor([[[0., 1., 0., 0.]],
[[1., 0., 0., 0.]],
[[0., 0., 1., 0.]],
[[0., 0., 1., 0.]],
[[0., 0., 0., 1.]]])
tensor([[[0., 1., 0., 0.]],
[[1., 0., 0., 0.]],
[[0., 0., 1., 0.]],
[[0., 0., 1., 0.]],
[[0., 0., 0., 1.]]])
class Model(torch.nn.Module):
def __init__(self, input_size, hidden_size, batch_size):
super(Model, self).__init__()
self.batch_size = batch_size
self.input_size = input_size
self.hidden_size = hidden_size
self.rnncell = torch.nn.RNNCell(input_size = self.input_size,
hidden_size = self.hidden_size)
def forward(self, input, hidden):
hidden = self.rnncell(input, hidden)
return hidden
def init_hidden(self):
return torch.zeros(self.batch_size, self.hidden_size)
net = Model(input_size, hidden_size, batch_size)
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(net.parameters(), lr = 0.1)
for epoch in range(25):
loss = 0
optimizer.zero_grad()
hidden = net.init_hidden()
for input, label in zip(inputs, labels):
hidden = net(input, hidden)
loss += criterion(hidden, label)
_, idx = hidden.max(dim=1)
print(idx.item(), end='')
loss.backward()
optimizer.step()
print(", Epoch: [%d/25] loss = %.4f" % (epoch+1, loss.item()))
最终输出：
12131, Epoch: [1/25] loss = 7.0161
12333, Epoch: [2/25] loss = 6.0797
12223, Epoch: [3/25] loss = 5.3174
12223, Epoch: [4/25] loss = 4.7188
10223, Epoch: [5/25] loss = 4.2018
10223, Epoch: [6/25] loss = 3.7728
10223, Epoch: [7/25] loss = 3.4347
10223, Epoch: [8/25] loss = 3.1307
10223, Epoch: [9/25] loss = 2.8780
10223, Epoch: [10/25] loss = 2.6863
10223, Epoch: [11/25] loss = 2.5337
10223, Epoch: [12/25] loss = 2.4025
10223, Epoch: [13/25] loss = 2.2894
10223, Epoch: [14/25] loss = 2.1993
10223, Epoch: [15/25] loss = 2.1284
10223, Epoch: [16/25] loss = 2.0683
10223, Epoch: [17/25] loss = 2.0166
10223, Epoch: [18/25] loss = 1.9729
10223, Epoch: [19/25] loss = 1.9360
10223, Epoch: [20/25] loss = 1.9051
10223, Epoch: [21/25] loss = 1.8795
10223, Epoch: [22/25] loss = 1.8586
10223, Epoch: [23/25] loss = 1.8415
10223, Epoch: [24/25] loss = 1.8273
10223, Epoch: [25/25] loss = 1.8152
10223代表ohlol，可见损失逐步减小，模型学习到了从hello到ohlol的序列变换。
776
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
