深度学习（PyTorch）——循环神经网络（RNN）基础篇四

B站up主“刘二大人”视频 笔记

本文章是该视频的一部分，该部分的案例代码使用RNN做一个简单的实验，其余部分见作者的其他文章。

一、什么是循环神经网络

循环神经网络或RNN是一类用于处理序列数据的神经网络。就像卷积网络是专门用于处理网格化数据的神经网络。

RNN的思想是利用序列化的信息。在传统的神经网络中，我们假设所有输入和输出彼此独立。但对于许多任务而言，这个假设有问题。例如你想预测句子中的下一个单词，就需要知道它前面有哪些单词。

RNN被称为循环，因为它对序列列的每个元素执行相同的任务，并且基于先前的计算进行输出。RNN的另一个优点是它具有“记忆”，它可以收集到目前为止已经计算的信息。理论上，RNN可以在任意长的序列中使用信息，但实际使用中仅仅往回记录几步。

二、神经网络中的参数共享

参数共享可以使得模型能够拓展到不同形式的样本(序列数据中指不同长度的样本)并进行泛化。
在处理网格化数据时(例如图像问题)，卷积神经网络就是采用了参数共享的思想(卷积核)，不但大大减少了参数量，而且提升了网络性能。在处理序列数据时，例如时延神经网络中，它在一维时间序列上使用卷积，每个时间步使用相同的卷积核。
循环神经网络以不同方式共享参数，输出的每一项是前一项的函数，输出的每一项对先前的输出应用相同的更新规则而产生。

二、循环神经网络能干什么

RNN在许多NLP任务中取得了巨大成功。 在这个领域最常用的RNN类型是LSTM，它在捕获长期依赖方面要比普通的RNN好得多。但不要担心，LSTM和RNN基本相同，它们只是采用不同的方式来计算隐藏状态。

三、RNN使用案例，代码如下：

import torch
input_size = 4
hidden_size = 4
num_layers = 1
batch_size = 1
seq_len = 5
 
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]
 
inputs = torch.Tensor(x_one_hot).view(seq_len, batch_size, input_size)
labels = torch.LongTensor(y_data)
 
 
class Model(torch.nn.Module):
    def __init__(self, input_size, hidden_size, batch_size, num_layers=1):
        super(Model, self).__init__()
        self.num_layers = num_layers
        self.batch_size = batch_size
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.rnn = torch.nn.RNN(input_size=self.input_size,
                                    hidden_size=self.hidden_size,
                                    num_layers=num_layers)
 
    def forward(self, input):
        hidden = torch.zeros(self.num_layers,  # 构造h0
                             self.batch_size,
                             self.hidden_size)
        out, _ = self.rnn(input, hidden)
        return out.view(-1, self.hidden_size)
 
 
net = Model(input_size, hidden_size, batch_size, num_layers)
 
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(net.parameters(), lr=0.05)
 
for epoch in range(15):
    optimizer.zero_grad()  # 优化器归零
    outputs = net(inputs)
    loss = criterion(outputs, labels)
    loss.backward()  # 反向传播
    optimizer.step()  # 优化器更新
    _, idx = outputs.max(dim=1)
    idx = idx.data.numpy()
    print('Predicted: ',  ''.join([idx2char[x] for x in idx]), end='')
    print(', Epoch [%d/15] loss=%.3f ' % (epoch + 1, loss.item()))
 
 

运行结果如下：

 视频截图如下：

 

 ​​​​​