《Pytorch - RNN模型》

前言：
之前的博文部分地讲解了RNN的标准结构，也用pytorch的RNNCell类和RNN类实现了前向传播的计算，这里我们再举一个例子，做一个特别简单特别简单特别简单特别简单的翻译器，目标如下：
将英文hello and thank you翻译成汉语拼音ni hao qie duo xie ni

篇幅有限，我们拿这五个数据练手吧。
如下两个例子也是为了让我们学习一下RNN相关维度的概念。

一：使用RNNCell类实现简单的字符串翻译
这里我们需要用到one-hot vector技术，也就是我们建立一个字符表，包含空格字符和26个小写英文字符，也就是一共有27个字符的字典表，空格符号标号是0，a_z编号是126，我们定义有22个序列的输入（也就是最多一次能接受22个字符的输入），每个输入的x 也是27维度的向量，输出层也是27维度的，也就是多个分类的问题，用RNN实现。代码如下：

import torch
import numpy as np
from torch.autograd import Variable

batch_size = 1      # 批量数据的大小，数据的批次，比如这里有5个需要测试的单词。
seq_len = 22    # 一共是多少个时间序列，是指时间的维度，在这里的意思就是一次性最大能接受20个字符的输入。
input_size = 27     # 某一时刻下，输入的X的维度向量，比如这里的4指的是维度是[4, 1]
hidden_size = 27    # 每一层的激活后 h 的维度，比如这里的2指的是维度是[2, 1]

# num_layers = 1

# a~z标号是1~26, 空格是1，这个字典表，每个字符有个对应的编号，也就是下标就是编号
idx2char = [' ', # 0
            'a', 'b', 'c', 'd', 'e', 'f', 'g', # 1-7
            'h', 'i', 'j', 'k', 'l', 'm', 'n', # 8-14
            'o', 'p', 'q', 'r', 's', 't', # 15-20
            'u', 'v', 'w', 'x', 'y', 'z'] # 21-26
idx2char = np.array(idx2char)
# 每个编号有个对应的向量，也就是下标对应的向量
one_hot_look = np.array(np.eye(idx2char.shape[0])).astype(int)
print('idx2char.shape[0]=', idx2char.shape[0])

x_data = np.zeros((batch_size, seq_len)).astype(int)
y_data = np.zeros((batch_size, seq_len)).astype(int)

# 待翻译的句子
x_data_char = ['hello and thank you']
y_data_char = ['ni hao qie duo xie you']

# 填充每个字符的下标
i=0
for item in x_data_char:
    # fill each data
    j=0
    for letter in item:
        x_data[i][j] = np.where(idx2char == letter)[0][0]
        j = j + 1
    i = i + 1

i=0
for item in y_data_char:
    # fill each data
    j=0
    for letter in item:
        y_data[i][j] = np.where(idx2char == letter)[0][0]
        j = j + 1
    i = i + 1

#print(x_data)
#print(y_data)




# Step 2:============================定义一个RNNCell的模型===================
class RNNCellModel(torch.nn.Module):
    def __init__(self, input_size, hidden_size):
        super(RNNCellModel, self).__init__()
        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

model = RNNCellModel(input_size, hidden_size)



# Step 3:============================定义损失函数和优化器===================
# 定义 loss 函数，这里用的是交叉熵损失函数(Cross Entropy)，这种损失函数之前博文也讲过的。
criterion = torch.nn.CrossEntropyLoss()
# 我们优先使用Adam下降，lr是学习率: 0.1
optimizer = torch.optim.Adam(model.parameters(), 1e-1)





# Step 4:============================开始训练===================
for e in range(200):
    loss = 0
    optimizer.zero_grad()
    hidden = torch.zeros(batch_size, hidden_size)  # 随机初始化的h0，且必须是Tensor类型的
    i = 0
    print('e============================')
    print('predicted str: ', end='')
    for cur_seq in zip(*x_data):   # for each seq
        cur_seq = np.array(cur_seq)
        #input 必须是Tensor类型的
        input = torch.Tensor([one_hot_look[x] for x in cur_seq])
        # print(input.shape)
        # y_label 必须是长整数型，且必须是Tensor类型的
        y_label = torch.LongTensor(np.array(y_data[:, i]))
        #print('real y_label: ', idx2char[y_label.item()], end='')

        # 前向传播
        hidden = model(input, hidden)
        _, idx = hidden.max(dim=1)
        print(idx2char[idx.item()], end='')
        # print(hidden)
        # 累加损失
        loss += criterion(hidden, y_label)

        i = i+1

    loss.backward()
    optimizer.step()
    print(',epoch [%d/200] loss=%.4f' % (e+1, loss.item()), end='')

输出结果如下：训练的字符串是hello and thank you

这个模型基本就差不多了训练出来是 ni hao qie duo xie ni

二：使用RNN类实现简单的字符串翻译
或者还可以用RNN模型来做，这样省去了自己写循环迭代序列的过程
，这里需要注意模型的建立需要传入层数，以及需要传递batch_size，因为hidden节点需要这个参数。

import torch
import numpy as np
from torch.autograd import Variable

batch_size = 1      # 批量数据的大小，数据的批次，比如这里有5个需要测试的单词。
seq_len = 22    # 一共是多少个时间序列，是指时间的维度，在这里的意思就是一次性最大能接受22个字符的输入。
input_size = 27     # 某一时刻下，输入的X的维度向量，比如这里的4指的是维度是[4, 1]
hidden_size = 27    # 每一层的激活后 h 的维度，比如这里的2指的是维度是[2, 1]
num_layers = 3      # 共有三层RNN

# a~z标号是1~26, 空格是1，这个字典表，每个字符有个对应的编号，也就是下标就是编号
idx2char = [' ', # 0
            'a', 'b', 'c', 'd', 'e', 'f', 'g', # 1-7
            'h', 'i', 'j', 'k', 'l', 'm', 'n', # 8-14
            'o', 'p', 'q', 'r', 's', 't', # 15-20
            'u', 'v', 'w', 'x', 'y', 'z'] # 21-26
idx2char = np.array(idx2char)
# 每个编号有个对应的向量，也就是下标对应的向量
one_hot_look = np.array(np.eye(idx2char.shape[0])).astype(int)
print('idx2char.shape[0]=', idx2char.shape[0])

x_data = np.zeros((batch_size, seq_len)).astype(int)
y_data = np.zeros((batch_size, seq_len)).astype(int)

# 待翻译的句子
x_data_char = ['hello and thank you']
y_data_char = ['ni hao qie duo xie you']

# 填充每个字符的下标
i=0
for item in x_data_char:
    # fill each data
    j=0
    for letter in item:
        x_data[i][j] = np.where(idx2char == letter)[0][0]
        j = j + 1
    i = i + 1

i=0
for item in y_data_char:
    # fill each data
    j=0
    for letter in item:
        y_data[i][j] = np.where(idx2char == letter)[0][0]
        j = j + 1
    i = i + 1

#print(x_data)
#print(y_data)
x_one_hot = [one_hot_look[x] for x in x_data]
inputs = torch.Tensor(x_one_hot).view(seq_len, batch_size, input_size)
lables = torch.LongTensor(y_data).view(-1)



# Step 2:============================定义一个RNNCell的模型===================
class RNNModel(torch.nn.Module):
    def __init__(self, input_size, hidden_size, batch_size, num_layers):
        super(RNNModel, self).__init__()
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.batch_size = batch_size
        self.num_layers = num_layers
        self.rnn = torch.nn.RNN(input_size=self.input_size, hidden_size=self.hidden_size,
                                num_layers=num_layers)

    def forward(self, input):
        # 由于不需要自己写序列的迭代，因此直接将随机初始化h0写道这里
        hidden = torch.zeros(num_layers, batch_size, hidden_size)  # 随机初始化的h0，且必须是Tensor类型的

        # 我们只关心output: [seq_len, batch_size, hidden_size]
        # input是: [seq_len, batch_size, input_size]
        output, _ = self.rnn(input, hidden)

        # 将out reshape到[seq_len * batch_size, hidden_size]
        return output.view(-1, self.hidden_size)

model = RNNModel(input_size, hidden_size, batch_size, num_layers)



# Step 3:============================定义损失函数和优化器===================
# 定义 loss 函数，这里用的是交叉熵损失函数(Cross Entropy)，这种损失函数之前博文也讲过的。
criterion = torch.nn.CrossEntropyLoss()
# 我们优先使用Adam下降，lr是学习率: 0.1
optimizer = torch.optim.Adam(model.parameters(), lr=0.05)





# Step 4:============================开始训练===================
for e in range(200):
    loss = 0
    optimizer.zero_grad()

    # 前向传播
    hidden = model(inputs)
    # 计算损失
    loss = criterion(hidden, lables)
    # 反向传播，更新参数
    loss.backward()
    optimizer.step()

    _, idx = hidden.max(dim=1)
    idx = idx.data.numpy()
    print('e============================')
    print('predicted str: ', end='')
    print(''.join([idx2char[x] for x in idx]), end='')
    print(',epoch [%d/200] loss=%.4f' % (e+1, loss.item()), end='')

效果如下：很明显，损失好像更低了些。