刘二大人《Pytorch深度学习与实践》12循环神经网络基础篇

104 阅读 0 评论 69 点赞

我是靠谱客的博主自觉歌曲，最近开发中收集的这篇文章主要介绍刘二大人《Pytorch深度学习与实践》12循环神经网络基础篇，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

RNN的模型中包括两种模块一种是RNNCell模块，另一种是RNN模块，我把这两个模块放在一个代码段里，其中RNNCell模块用''''''掩藏了，只要删除掉这个符号就行

代码如下

import torch
batch_size = 1
# 一次输入多少个input_size
seq_len = 3
# 一个句子被分为几份进行输入
input_size = 4
# 一次选择多少个句子进行输入
hidden_size = 2
num_layers = 1
# ==========RNNCell模块===========
"""
cell = torch.nn.RNNCell(input_size=input_size, hidden_size=hidden_size)
datasets = torch.randn(seq_len, batch_size, input_size)
hidden = torch.zeros(batch_size, hidden_size)
for idx, input in enumerate(datasets):
print('=' * 20, idx, '=' * 20)
print('Input size:', input.shape)
# input的形状应该满足（batch_size,input_size)这样一个大小
hidden = cell(input, hidden)
print('output size:', hidden.shape)
# output的形状应该满足（batch_size,hidden_size)这样一个大小
print(hidden)
"""
# ==========RNN模块===============
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)
# out代表是H1、H2、一直到Hn，hidden代表的是最后一个输出Hn
print(inputs.shape)
# 刚输入的维度是（seq_lens,batch_size,input_size)
print('output size:', out.shape)
# 输出的维度为（seq_lens,batch_size,hidden_size),因为Hn是输出项，所以要和隐藏层维度一致
print('output:', out)
print('Hidden size:', hidden.shape)
# 隐藏层维度为（num_layers,batch_size,hidden_size)
print('Hidden:', hidden)

此外由于传统的RNN网络采用one-hot独热编码，下列方法采用了embedding方法，两种方法的区别可以去看这篇文章

(31条消息) word embedding以及one-hot编码的区别及应用_秀秀的奇妙旅行-CSDN博客_embedding和one hot

具体实现代码如下

import torch
# embedding 包括输入和嵌入两个步骤，一个嵌入和一个输入
def embedding():
num_class = 4
# 类别数量，即hello有四种字母
input_size = 4
# 输入的特征数，即hello有四种特征字母
hidden_size = 8
# 隐藏层维度，自己设置，即隐藏层的隐藏节点数
embedding_size = 10
# 将输入嵌入到10维的空间
num_layers = 2
# RNN层数
batch_size = 1
seq_len = 5
# 输入设置为5个内容
index_chart = ['e', 'h', 'l', 'o']
# 预测的结果是设置的索引，这样方便对结果更快地进行取值
x_data = [[1, 0, 2, 2, 3]]
# 输入维度为（batch_size,seq_size)
y_data = [3, 1, 2, 3, 2]
# 测试输出为一个一维向量，即（1*5）的向量
# 将x_data和y_data通过LongTensor分别转换成32位浮点数和64位浮点数
inputs = torch.LongTensor(x_data)
labels = torch.LongTensor(y_data)
class Model(torch.nn.Module):
def __init__(self):
super(Model, self).__init__()
# 给出input大小和embedding大小，构成input_size*embedding_size的矩阵
# 进行embedding处理，把输入的长整型张量转变成嵌入层的稠密型张量，这里输入就要改成二维张量x_data = [[1, 0, 2, 2, 3]]
self.emb = torch.nn.Embedding(input_size, embedding_size)
# 将input的维度映射为embedding_size这样一个维度
self.rnn = torch.nn.RNN(input_size=embedding_size, hidden_size=hidden_size, batch_first=True,
num_layers=num_layers)
# 将隐藏层的输出转化成num_class尺寸大小的输出
self.fc = torch.nn.Linear(hidden_size, num_class)
def forward(self, x):
hidden = torch.zeros(num_layers, x.size(0), hidden_size)
x = self.emb(
x)
# input维度为(batch_size,seq_size)即（1,5）,output维度为（batch_size，seq_size,embedding_size)即（1,5,10）
x, _ = self.rnn(x, hidden)
x = self.fc(x)
return x.view(-1, num_class)
# 为了使用交叉熵函数，将x转换成一个矩阵(batch_size*seq_len,num_class)
net = Model()
# 计算损失和更新
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(net.parameters(), lr=0.03)
# 训练
for epoch in range(15):
optimizer.zero_grad()
outputs = net(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
_, index = outputs.max(dim=1)
# max函数得到预测的概率最大的值和最大值的索引，取dim=1说明得到的是索引值，dim=0是最大值
index = index.data.numpy()
print('Predicted: ', ''.join([index_chart[x] for x in index]), end='')
print(', Epoch [%d/15] loss = %.3f' % (epoch + 1, loss.item()))
embedding()