深入浅出RNN

RNN是深度学习在自然语言处理领域中的元老级神经网络,它奠定了神经网络技术在NLP领域的发展方向,其名声仅此于CNN,虽然近年来它已经鲜少露面,但江湖地位不减,就连当红明星GRU和LSTM都是它的变种。

RNN(Recurrent Neural Networks)译为递归神经网络最贴切。学过编程的都知道,递归指的是将一个函数循环反复地调用,每次调用,变的只有传进来的参数(input)和生成的结果(output)。下图中,等号右侧部分就是RNN的展开图:input (i1 ~ i4)先后传入同一个隐藏层,隐藏层被调用4次,每次除了生成一个output(o1 ~ o4)之外,还会生成一个hidden state ,它是隐藏层对input的学习成果,hidden state会和下一个input一起作为参数传入隐藏层(红色箭头)。


Figure 1: RNN网络结构

我在深入浅出全连接层中提过,RNN是由全连接层(Linear layer)组成的,准确地说,RNN中的input layer、hidden layer、output layer,就是Figure 1中的那些箭头,它们都是全连接层。

本文将会以重写RNN的方式来由浅入深剖析RNN,点击【这里】可以查看完整源码。

Framework && Dataset

除了使用Fastai Library外,还会用它的轻量级NLP数据集:http://files.fast.ai/data/examples/human_numbers.tgz。数据集是从0到9999的英文数字:“one, two, three, four, five, ……, nine thousand nine hundred ninety eight, nine thousand nine hundred ninety nine”。

我们的任务就是创建一个RNN N-gram语言模型来学习数数,比如说,看到“one, two, three, four, five, ”这10个连续token(”,”也是一个token),就能预测出第11个token是”six”。关于token、N-gram、语言模型、embedding以及nlp mini-batch等内容,可以回看以前的文章自己动手开发AI影评写作机器人,这里不再赘述。

Single output

class Model1(nn.Module):
  def __init__(self):
    super().__init__()
    self.emb = nn.Embedding(nv, wordvec_len)
    self.input = nn.Linear(wordvec_len, nh) # input layer
    self.hid = nn.Linear(nh, nh) # hidden layer
    self.out = nn.Linear(nh, nv) # output layer
    self.bn = nn.BatchNorm1d(nh)
  
  def forward(self, x):
    h = torch.zeros(x.shape[0], nh).to(device=x.device)
    for i in range(x.shape[1]):
      h = h + F.relu(self.input(self.emb(x[:, i])))
      h = self.bn(F.relu(self.hid(h)))
    return self.out(h)

如Figure 1所示,Model1通过一个for循环来(递归)处理每个input(token),并将hidden state传递到下一个循环,等到N个(x.shape[1])token都学习完之后,用第N个hidden state来生成一个output。这就是RNN根据前面N个token来预测第N+1个token的过程。

之所以RNN可以预测第N+1个token,是因为hidden state包含了前面N个token的信息。h = h + F.relu(self.input(self.emb(x[:, i]))),为RNN预测提供了前文的信息。

learn = Learner(data, Model1(), loss_func=loss_f, metrics=acc_f)
learn.fit_one_cycle(10, 1e-4)
epoch   train_loss  valid_loss  acc_f   time
0   3.546392    3.752568    0.024586    00:01
1   2.911883    3.326832    0.227022    00:01
2   2.289827    2.718843    0.447610    00:01
3   1.943045    2.349009    0.465303    00:01
4   1.766844    2.192134    0.466222    00:01
5   1.678379    2.125904    0.466452    00:01
6   1.633395    2.100061    0.464844    00:01
7   1.610903    2.090777    0.464614    00:01
8   1.601126    2.087984    0.459099    00:01
9   1.598013    2.088171    0.459099    00:01

Learner是Fastai提供用于模型训练的library,“acc_f”这栏显示的是模型的预测准确率:45.9%。

Maintain state

class Model3(nn.Module):
  def __init__(self):
    super().__init__()
    self.emb = nn.Embedding(nv, wordvec_len)
    self.input = nn.Linear(wordvec_len, nh)
    self.hid = nn.Linear(nh, nh)
    self.out = nn.Linear(nh, nv)
    self.bn = nn.BatchNorm1d(nh)
    self.h = torch.zeros(bs, nh).cuda()
  
  def forward(self, x):
    h = self.h
    res = []
    for i in range(x.shape[1]):
      h = h + torch.tanh(self.input(self.emb(x[:, i])))
      h = self.bn(torch.tanh(self.hid(h)))
      res.append(h)
    self.h = h.detach()
    res = torch.stack(res, dim=1)
    return self.out(res)

Model1的hidden state只保留了同一个mini-batch内的token信息,一旦开始学习新的mini-batch,hidden state就会清零:h = torch.zeros(x.shape[0], nh).to(device=x.device)

因此,Model3会保留前一个mini-batch训练得到的hidden state,换句话说,此时的hidden state保留了整个dataset的信息。不仅如此,Model3不只是预测第N+1个token,它会预测所有token的下一个token。

epoch   train_loss  valid_loss  acc_f   time
0   3.546392    3.752568    0.024586    00:01
                 ......
15  0.193776    0.834583    0.759517    00:00
16  0.179285    0.845180    0.757031    00:00
17  0.167008    0.859531    0.751491    00:00
18  0.157094    0.860083    0.754972    00:00
19  0.150660    0.854162    0.754474    00:00

Model3是真正意义RNN,它的预测准确率达到72.2%。除此之外,用tanh替代relu,准确率会提升到75.4%,标准RNN的默认激活函数就是tanh。

Pytorch RNN

class Model4(nn.Module):
  def __init__(self):
    super().__init__()
    self.emb = nn.Embedding(nv, wordvec_len)
    self.input = nn.Linear(wordvec_len, nh)
    self.rnn = nn.RNN(nh, nh, 1, batch_first=True)
    self.out = nn.Linear(nh, nv)
    self.bn = BatchNorm1dFlat(nh)
    self.h = torch.zeros(1, bs, nh).cuda()
  
  def forward(self, x):
    res, h = self.rnn(self.input(self.emb(x)), self.h)
    self.h = h.detach()
    return self.out(self.bn(res))
epoch   train_loss  valid_loss  acc_f   time
0   3.546392    3.752568    0.024586    00:01
                 ......
15  0.283078    1.124835    0.662003    00:00
16  0.261476    1.067836    0.680043    00:00
17  0.244309    1.112445    0.670455    00:00
18  0.233984    1.112467    0.668253    00:00
19  0.226839    1.101279    0.671307    00:00

Model4是Model3的对标模型,用Pytorch官方提供的RNN实现,从训练结果来看,它准确率比Model3要低不少,因此,这里温馨提醒,不要把官方code当作圣旨。实践表明,Batchnorm1d()应用在Model3的隐藏层中卓有成效,很可惜,它无法作用于nn.RNN。

class Model4(nn.Module):
  def __init__(self):
    ......
    self.rnn = nn.RNN(nh, nh, 2, batch_first=True, dropout=0.1)
    ......
epoch   train_loss  valid_loss  acc_f   time
0   3.546392    3.752568    0.024586    00:01
                 ......
15  0.123147    0.816822    0.789773    00:00
16  0.111867    0.815223    0.793466    00:00
17  0.102646    0.834602    0.788210    00:00
18  0.096860    0.828752    0.791761    00:00
19  0.092941    0.836145    0.790909    00:00

虽然nn.RNN的表现不如自己手撸的好,但并不是鼓励大家自己造轮子,而且本人也很反对像自己造轮子这种几乎不输出价值的工作方式。事实上,当我们使用2层RNN之后,Model4的表现就优于Model3了。

2层RNN的结构如下图所示,2个隐藏层虽然比1个隐藏层效果更好,但计算量也翻倍了,由于全连接层的参数数量比卷积层的要多得多,深层RNN的训练时间要远远长于相同深度的CNN,因此,RNN层数不宜过多。


Figure 2: 2-layer RNN

GRU

RNN虽然通过hidden state来保留各token的信息,但它并不能有效地处理和使用这些信息,它会将所有训练得来的信息都一股脑地塞进hidden state,并用它来影响后续每个token的学习,而且这种影响不管是好是坏都会随着训练的深入,像滚雪球一样有增无减地将越多越多的信息裹胁进来。

显然RNN缺乏对新老信息(hidden state和token)的调控机制,因此GPU和LSTM就应运而生了。它们为RNN中增加了input gate、output gate、forget gate、update gate等机制,对进出信息进行筛选,丢弃过时的、无用的信息,调控输入信息对模型训练的影响力等。

class Model5(nn.Module):
  def __init__(self):
    super().__init__()
    self.emb = nn.Embedding(nv, wordvec_len)
    self.input = nn.Linear(wordvec_len, nh)
    self.rnn = nn.GRU(nh, nh, 2, batch_first=True, dropout=0.05)
    self.out = nn.Linear(nh, nv)
    self.bn = BatchNorm1dFlat(nh)
    self.h = torch.zeros(2, bs, nh).cuda()
  
  def forward(self, x):
    res, h = self.rnn(self.input(self.emb(x)), self.h)
    self.h = h.detach()
    return self.out(self.bn(res))
epoch   train_loss  valid_loss  acc_f   time
0   3.546392    3.752568    0.024586    00:01
                 ......
5   0.123571    1.116273    0.833310    00:00
6   0.071810    1.277520    0.835156    00:00
7   0.043868    1.258988    0.838068    00:00
8   0.029036    1.265061    0.839134    00:00
9   0.021350    1.290411    0.838778    00:00

Model5用GRU替代了RNN后,在相同情况下,模型准确率又有了提升,达到了83.8%。关于GRU的分析留待下一篇博文,这里不作展开。

END

本文通过重构RNN的方式详解了RNN模型的构成,通过分析它的缺陷,进一步介绍了GRU和LSTM的工作原理。

https://www.jianshu.com/p/b5e8a630a99d

「点点赞赏,手留余香」

    还没有人赞赏,快来当第一个赞赏的人吧!
0 条回复 A 作者 M 管理员
    所有的伟大,都源于一个勇敢的开始!
欢迎您,新朋友,感谢参与互动!欢迎您 {{author}},您在本站有{{commentsCount}}条评论