刘二大人《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()