RNN学习案例

RNN
目标：将hello，转为ohlol

import torch

# 依据数据大小而设定
batch_size = 1
# 输入的维度
input_size = 4
# 输出的维度，这里为了简单设置为3(因为结果有3类)，如果设置为N，需要最后增加全连接层，self.fc = torch.nn.Linear(N, 3)
hidden_size = 3
# 如果是NLP问题则是分词大小，如果是回归问题则是数据个数
seq_len = 5
# 隐藏层层数，依据数据大小而设定
num_layers = 1

idx2char_1 = ['e', 'h', 'l', 'o']
idx2char_2 = ['h', 'l', 'o']
l1 = [1, 0, 2, 2, 3]
l2 = [2, 0, 1, 2, 1]
matrix = [[1, 0, 0, 0],
          [0, 1, 0, 0],
          [0, 0, 1, 0],
          [0, 0, 0, 1]]
input_list = [matrix[x] for x in l1]
# RNN中输入数据维度为seq_len*batch_size*input_size
inputs = torch.Tensor(input_list).view(seq_len, batch_size, input_size)
# labels（seqLen*batchSize,1）为了之后进行矩阵运算，计算交叉熵
labels = torch.LongTensor(l2)


# RNN中的输入（seq_len*batch_size*input_size）
# RNN中的输出（seq_len*batch_size*hidden_size）
# labels维度 hidden_size*1
class Model(torch.nn.Module):
    def __init__(self, batch_size, input_size, hidden_size, num_layers):
        super(Model, self).__init__()
        self.batch_size = batch_size
        self.input_siz = input_size
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        self.rnn = torch.nn.RNN(input_size=self.input_siz, hidden_size=self.hidden_size, 
        						num_layers=self.num_layers)

    def forward(self, input):
        # 构造h0
        hidden = torch.zeros(self.num_layers, self.batch_size, self.hidden_size)
        # out是所有的h，(seq_len, batch_size, hidden_size)(5,1,3)；_是最后一个h，(num_layers, batch_size, hidden_size)Tensor(1,1,3)
        out, _ = self.rnn(input, hidden)
        # reshape成（SeqLen*batchsize,hiddensize）(5,3)
        return out.view(-1, self.hidden_size)


net = Model(batch_size, input_size, hidden_size, num_layers)
criterion = torch.nn.CrossEntropyLoss()
optim = torch.optim.Adam(net.parameters(), lr=0.05)

for epoch in range(15):
    optim.zero_grad()
    output = net(inputs)  # output为Tensor(5, 3)
    loss = criterion(output, labels)  # label为Tensor(5,)，构造output和label的维度，使符合交叉熵的输入
    loss.backward()
    optim.step()

    # output.max(dim=1)是取出第二维的最大概率值及索引
    probability, idx = output.max(dim=1)
    idx = idx.data.numpy()
    print('Predicted string: ', ''.join([idx2char_2[x] for x in idx]), end='')
    print(", Epoch [%d/15] loss = %.3f" % (epoch + 1, loss.item()))