我们生活的世界充满了形形色色的序列数据，只要是有顺序的数据统统都可以看作是序列数据，比如文字是字符的序列，音乐是音符组成的序列，股价数据也是序列，连DNA序列也属于序列数据。循环神经网络RNN天生就具有处理序列数据的能力。我们在上一篇文章中介绍了循环神经网络，这次我们来看一个具体的序列生成问题：

假设一个简单的序列生成问题，01序列生成。一个序列数据由0和1组成，并且每个0之间是连续的，每个1之间也是连续的，并且0和1的个数相等，比如：

000111

00001111,...,等等

这种序列被称为“上下文无关文法”。如果现在的数据是0000，那下一位其实不好判断，可能是0，也可能是1；如果现在的数据是00001，那下一位一定是1；如果现在数据是00001111，那由于0和1相等，接下来应该结束这个序列。

我们首先尝试生成这种数据：

class MyDataset(Dataset):def __init__(self, samples = 2000, max_size=10, transform=None):max_size=10self.data = []for m in range(samples):probability = 1.0*np.array([10,6,4,3,1,1,1,1,1,1])probability = probability[:max_size]# 生成概率值probability = probability/np.sum(probability)# 生成训练样本# 对于每一个生成的字符串，随机选择一个n，n被选择的权重记录在probability中n = np.random.choice(range(1, max_size+1), p=probability)inputs = [0]*n+[1]*n # 生成仅包含0和1的序列inputs.insert(0,3) # 序列开始处插入3，作为标志位inputs.append(2) # 序列结束处插入2，作为标志位self.data.append(inputs)def __len__(self):return len(self.data)def __getitem__(self, idx):return self.data[idx]

这里，我们首先默认生成2000个样本，每个样本的最大长度为10个数字，probability代表的是生成10个概率值，我们可以把这10个概率值输出来看看：

array([0.34482759, 0.20689655, 0.13793103, 0.10344828, 0.03448276,0.03448276, 0.03448276, 0.03448276, 0.03448276, 0.03448276])

可以看到第一个概率最大，接近0.35，之后依次减少，最后六个概率都仅仅是第一个概率的十分之一，0.035左右。np.random.choice(array, prob)，是指根据prob指明的概率值输出array中的值，我们可以把生成的n打印出来：

for i in range(10):n = np.random.choice(range(1, max_size+1), p=probability)print(n, end=' ') # 以空格分隔
# 这其实就是说，从[1,2,3,4,5,6,7,8,9,10]中，按概率probability随机抽取数字
# 输出：
# 5 3 1 1 1 1 1 1 6 7  

可以多尝试几次，总之，1出现的概率最大，1和2出现的次数都很多，符合我们的直观印象。目的就是为了生成长度为n的随机的01字符串（n个0加上0个1）。同时在字符串的前端加上3，表示字符串起始位置，在字符串的末尾加上2，表示字符串的结束位置，如3000011112，30001112，30000001111112。

我们把生成的样本库用pytorch的dataset和dataloader包装一下，并取出来观察一下：

if __name__ == '__main__':# 定义训练数据集trainDataset = MyDataset()trainDataloader = DataLoader(dataset=trainDataset, batch_size=1, shuffle=True)# 查看数据集内容for i,seq in enumerate(trainDataloader):print(seq)
# 输出
[tensor([3]), tensor([0]), tensor([1]), tensor([2])]
[tensor([3]), tensor([0]), tensor([0]), tensor([0]), tensor([0]), tensor([1]), tensor([1]), tensor([1]), tensor([1]), tensor([2])]
[tensor([3]), tensor([0]), tensor([0]), tensor([1]), tensor([1]), tensor([2])]
[tensor([3]), tensor([0]), tensor([0]), tensor([0]), tensor([1]), tensor([1]), tensor([1]), tensor([2])]
[tensor([3]), tensor([0]), tensor([1]), tensor([2])]
[tensor([3]), tensor([0]), tensor([1]), tensor([2])]

可以看到，生成了3开头，2结尾的01序列，只不过都转成了Tensor类型。

下面，我们来实现一下自定义的RNN模型：

class MyRnn(nn.Module):def __init__(self, input_size, hidden_size, output_size, num_layers = 1):# 定义super(MyRnn, self).__init__()self.hidden_size = hidden_sizeself.num_layers = num_layers# 一个embedding层self.embedding = nn.Embedding(input_size, hidden_size)# PyTorch的RNN层，batch_first标识可以让输入的张量的第一个维度表示batch指标self.rnn = nn.RNN(hidden_size, hidden_size, num_layers, batch_first = True)# 输出的全连接层self.fc = nn.Linear(hidden_size, output_size)# 最后的LogSoftmax层self.softmax = nn.LogSoftmax(dim=1)def forward(self, input):# 运算过程# 先进行embedding层的计算# 它可以把一个数值先转化为one-hot向量，再把这个向量转化为一个hidden_size维的向量# input的尺寸为：batch_size, num_step, data_dimx = self.embedding(input)# 从输入层到隐含层的计算# x的尺寸为：batch_size, num_step, hidden_sizeh0 = torch.zeros(self.num_layers, 1, self.hidden_size)output, hidden = self.rnn(x, h0)# 从输出output中取出最后一个时间步的数值，注意output包含了所有时间步的结果# output尺寸为：batch_size, num_step, hidden_sizeoutput = output[:,-1,:]# output尺寸为：batch_size, hidden_size# 把前面的结果输入给最后一层全连接网络output = self.fc(output)# output尺寸为：batch_size, output_size# softmax函数output = self.softmax(output)return output, hidden

这里，有个地方需要注意，和我上次的循环神经网络简介中介绍的RNN模型不同，多了一个embedding层。这里要特别提一下，embedding层是RNN，特别是自然语言处理（NLP）等工作中特别重要的一个步骤。embedding就是做一个查表，把输入数据映射到一个新的表空间的，本质上其实就是进行了一次降维或升维操作，有点类似卷积神经网络的1x1卷积的作用，下面我们来具体看看embedding操作到底是干了什么。

import torch
import torch.nn as nnembedding = nn.Embedding(10, 3) # an Embedding module containing 10 tensors of size 3
input = torch.LongTensor([[1,2,4,5],[4,3,2,9]]) # a batch of 2 samples of 4 indices each
e = embedding(input)
print(e)
# 输出
tensor([[[-1.1222,  0.5364, -1.5284],[-0.4762,  0.7091, -0.0703],[-1.1492,  0.2443,  0.4336],[ 1.8044,  0.5492,  1.1109]],[[-1.1492,  0.2443,  0.4336],[-0.4599, -0.3097,  0.2294],[-0.4762,  0.7091, -0.0703],[ 0.6926,  1.7407,  1.5432]]], grad_fn=<EmbeddingBackward0>)

是不是很奇怪？我们的输入仅仅是一个2x4的二维张量，怎么变成了2x4x3的三维张量了，并且这些值是哪儿来的呢？别急，我们一步步来看。

print(input.shape)
print(e.shape)
print(embedding.weight)
print(embedding.weight.shape)
# 输出
torch.Size([2, 4])
torch.Size([2, 4, 3])
Parameter containing:
tensor([[ 1.5728,  0.1152,  2.1069],[-1.1222,  0.5364, -1.5284],[-0.4762,  0.7091, -0.0703],[-0.4599, -0.3097,  0.2294],[-1.1492,  0.2443,  0.4336],[ 1.8044,  0.5492,  1.1109],[-1.3228,  0.2966,  0.5020],[-0.4501, -0.1242, -0.2341],[ 0.0743,  0.8168, -1.2459],[ 0.6926,  1.7407,  1.5432]], requires_grad=True)
torch.Size([10, 3])

可以看到，我们输入的大小确实是(2,4)，经过embedding的输出也确实是(2,4,3)了，我们可以看到，embedding的大小是(10,3)，其实简单来说就是，embedding生成了一张10行3列的表，表中的数据是embedding自动计算出来的权重，input里面的值可以看成是索引，[[1,2,4,5],[4,3,2,9]]，我们看到第一个数字1，那我们从embedding表中取到第1行，[-1.1222, 0.5364, -1.5284]，依次类推，得到最后的结果，如下图所示：

等于说input里面的值变成了embedding权重表里面的索引值，根据这个索引值去查询embedding表的权重，组成的结果就是把输入进行embedding后的结果。

下面我们再来详细分析一下我们的循环神经网络模型MyRnn里面的运算过程，只要真正理解了这个过程，那就明白了模型里面的运作原理了。

首先，我有一个输入，假设是tensor[1]

input = torch.LongTensor([1]).unsqueeze(0) # 扩展一个维度，作为batch_size
print(input.shape)
print(input)
# 输出
torch.Size([1, 1])
tensor([[1]])

下面，我们进行embedding操作，我们的模型假设input_size=4,hidden_size=2,output_size=3，因为输入有0，1，2，3四种可能，输出有0，1，2三种可能。

# input_size=4,hidden_size=2
embedding = nn.Embedding(4, 2)
print(embedding.weight)
print(embedding.weight.shape)
x = embedding(input) # embedding操作
print(x)
print(x.shape)
# 输出
Parameter containing:
tensor([[ 0.1870,  0.5711],[ 0.2994, -0.4649],[-0.3611, -0.1150],[-1.0868, -0.1419]], requires_grad=True)
torch.Size([4, 2])
tensor([[[ 0.2994, -0.4649]]], grad_fn=<EmbeddingBackward0>)
torch.Size([1, 1, 2])

可以看到，做了embedding操作后，我们的输入从[[1]]变成了[[[ 0.2994, -0.4649]]]，接下来，我们把这个结果和初始化的隐藏层hidden一起送入RNN。

h = torch.zeros(1, x.size(0), 2) # 隐藏层参数layer_size,batch_size,hidden_size
print(h)
print(h.shape)
rnn = nn.RNN(2, 2, batch_first=True) # RNN模型，因为经过了embedding，input的shape变成了和hidden一样的shape

隐藏层的三个参数分别为隐藏层大小layer_size，这里取1，batch_size这里就是x第一个维度，也就是1，hidden_size，设置隐藏层的大小为2。

out, _ = rnn(x, h) # RNN结果
print(out.shape)
print(out)
print(out[:,-1,:]) # 取出结果
# 输出
torch.Size([1, 1, 2])
tensor([[[-0.2823, -0.5443]]], grad_fn=<TransposeBackward1>)
tensor([[-0.2823, -0.5443]], grad_fn=<SliceBackward0>)

可以看到我们现在取出的out结果的shape从[1,1,2]变成了[1,2]，最后我们做一个全连接运算，把分类结果输出：

fc = nn.Linear(2, 3) # 全连接层
out = fc(out[:, -1, :]) # 分类结果
print(out)
# 输出
tensor([[0.7543, 0.5506, 0.8528]], grad_fn=<AddmmBackward0>)

可以看到得到了三个值的分类结果，根据这个值再去获得概率最高的结果，就是最终的输出结果。好了，这就是我们整个模型内部的运行过程。下面给出完整的训练和测试代码：

训练代码：

def train(net, dataloader, epochs=50):criterion = torch.nn.NLLLoss()optimizer = torch.optim.Adam(net.parameters(), lr=0.001)for epoch in range(epochs):train_loss = 0.for i, seq in enumerate(dataloader):loss = 0hidden = net.initHidden()for k in range(len(seq)-1):x = torch.LongTensor([seq[k]]).unsqueeze(0) # 增加一个batch_size的维度y = torch.LongTensor([seq[k+1]])#print(x)#print(y)output, hidden = net(x, hidden)#output, _ = net(x)loss += criterion(output, y)loss = 1.0*loss/len(seq) # 计算每个字符的损失值optimizer.zero_grad()loss.backward()optimizer.step()train_loss += lossif i>0 and i%500==0:print('第{}轮，第{}个，训练Loss：{:.2f}'.format(epoch, i, train_loss.data.numpy()/i))torch.save(net, 'checkpoints/RNN.pt')

验证代码：

def val(net, dataloader):valid_loss = 0errors = 0show_out = ''net = torch.load('checkpoints/RNN.pt')net.eval()with torch.no_grad():for i, seq in enumerate(dataloader):# 对valid_set中的每一个字符串进行循环loss = 0outstring = ''targets = ''diff = 0hidden = net.initHidden() # 初始化隐含神经元for t in range(len(seq) - 1):# 对每一个字符进行循环x = torch.LongTensor([seq[t]]).unsqueeze(0)# x尺寸：batch_size = 1, time_steps = 1, data_dimension = 1y = torch.LongTensor([seq[t + 1]])# y尺寸：batch_size = 1, data_dimension = 1output, hidden = net(x, hidden)# output尺寸：batch_size, output_size = 3# hidden尺寸：layer_size =1, batch_size=1, hidden_sizemm = torch.max(output, 1)[1][0] # 将概率最大的元素作为输出outstring += str(mm.data.numpy()) # 合成预测的字符串targets += str(y.data.numpy()[0]) # 合成目标字符串#loss += criterion(output, y) # 计算损失函数diff += 1 - mm.eq(y).data.numpy()[0] # 计算模型输出字符串与目标字符串之间存在差异的字符数量#loss = 1.0 * loss / len(seq)#valid_loss += loss # 累积损失函数值errors += diff # 计算累积错误数show_out = outstring + '\n' + targets# 打印结果print(output[0][2].data.numpy())print(show_out)

测试代码：

def test():net = torch.load('checkpoints/RNN.pt')net.eval()for n in range(20):inputs = [0]*n + [1]*ninputs.insert(0,3)inputs.append(2)outstring = ''targets = ''diff = 0hiddens = []hidden = net.initHidden()for t in range(len(inputs)-1):x = Variable(torch.LongTensor([inputs[t]]).unsqueeze(0))y = Variable(torch.LongTensor([inputs[t+1]]))output,hidden = net(x, hidden)hiddens.append(hidden.data.numpy()[0][0])mm = torch.max(output, 1)[1][0]outstring += str(mm.data.numpy())targets += str(y.data.numpy()[0])diff += 1-mm.eq(y).data.numpy()[0]# 打印每一个生成的字符串和目标字符串print("n======",n)print(outstring)print(targets)print('Diff:{}'.format(diff))

最终输出：

第49轮，第500个，训练Loss：0.24
第49轮，第1000个，训练Loss：0.24
第49轮，第1500个，训练Loss：0.24
-0.030197786
0100112
0001112
n====== 0
0
2
Diff:1
n====== 1
012
012
Diff:0
n====== 2
01012
00112
Diff:2
n====== 3
0100112
0001112
Diff:2
n====== 4
010001112
000011112
Diff:2
n====== 5
01000011112
00000111112
Diff:2
n====== 6
0100000111112
0000001111112
Diff:2
n====== 7
010000001111112
000000011111112
Diff:2
n====== 8
01000000011111112
00000000111111112
Diff:2
n====== 9
0100000000111111112
0000000001111111112
Diff:2
n====== 10
010000000001111111112
000000000011111111112
Diff:2
n====== 11
01000000000011111111112
00000000000111111111112
Diff:2
n====== 12
0100000000000111111111112
0000000000001111111111112
Diff:2
n====== 13
010000000000001111111111112
000000000000011111111111112
Diff:2
n====== 14
01000000000000011111111111112
00000000000000111111111111112
Diff:2
n====== 15
0100000000000000111111111111112
0000000000000001111111111111112
Diff:2
n====== 16
010000000000000001111111111111112
000000000000000011111111111111112
Diff:2
n====== 17
01000000000000000011111111111111112
00000000000000000111111111111111112
Diff:2
n====== 18
0100000000000000000111111111111111112
0000000000000000001111111111111111112
Diff:2
n====== 19
010000000000000000001111111111111111112
000000000000000000011111111111111111112
Diff:2

可以看到，模型预测还是比较准确的，就是第二个数字预测错误，以及由0变1的那个位置会预测错误。