当前位置：首页 > article >正文

自然语言处理入门4——RNN

article 2025/3/20 8:32:17

一般来说，提到自然语言处理，我们都会涉及到循环神经网络（RNN），这是因为自然语言可以被看作是一个时间序列，这个时间序列中的元素是一个个的token。传统的前馈神经网络结构简单，但是不能很好的处理时间序列数据，RNN便应运而生。

一、RNN概述

语言模型给出了单词序列发生的概率，具体来说就是评估一个单词发生的可能性。我们之前的CBOW模型就是这种（可以参考我的前两篇文章《自然语言处理入门2》《自然语言处理入门3》），但是CBOW模型有个问题，就是长度限制，因为CBOW需要选择一个窗口window来作为上下文，也就是说它只能根据前后一定窗口的大小来预测中间缺失的单词。如果不断加大窗口大小也会造成速度和性能的困扰，并且CBOW这种模型的目的其实主要是为了获取单词的分布式表示方法，基于此所以语言模型一般都使用RNN。

RNN有一个特点，就是不受上下文长度限制（其实也不是不受限制，只是很大程度上可以不受限制，如果长度过长，一样会引起梯度消失等等无法训练的问题，所以才有后面的截断时序训练和门控循环神经网络LSTM等等）。RNN最大的特征就是模型中存在回路，所以才被叫做循环神经网络，结构图如下：

跟一般的前馈神经网络的区别就是，RNN的输出除了流向下一个节点的结果之外，还要把这个结果重新作为输入传到模型中，我们称之为隐藏信息h。把循环网络展开来后，就是上图右边的样子了。每个节点的输入都是原始输入数据本身以及上一个节点传过来的隐藏信息。

举个实际的例子：对于"you say goodbye and i say hello."这句话，传递流程如下图所示：

1. 第一个单词you，先进行向量化也就是embedding操作，序列没有上一个节点传过来的信息，因此输入向量直接经过RNN得到一个输出，转变为概率，可以看到下一个输出概率最高的是say，同时，RNN的输出传递到下一个节点；

2.第二个单词say，先进行embedding得到向量化表示，这次RNN有上一个节点传过来的隐藏信息了，所以要把这个隐藏信息传递到RNN，并且将say的embedding表示数据也一并传入RNN，得到一个输出，转变为概率，得到概率最高的goodbye，同时再把RNN的输出传递到下一个节点；

3.第三个单词goodbye，先进行embedding得到向量化表示，再把上一个的节点的隐藏信息一起传递到RNN中得到输出，转变为概率得到概率最高的输出and，同时再把RNN的输出传递掉下一个节点，这里输出的隐藏信息已经包括了前面的you say goodbye三个单词的信息了，然后以此类推；

... ...

4.最终遍历完时间序列中的所有单词。

不过这里要注意，其实真正的RNN并不存在这样的铺开式结构，这里的示意图只是为了便于理解把RNN在时间方向上展开了而已。

二、RNN的实现

下面我们来实现一下RNN。

有顺序的序列数据训练一般采用“按时间顺序展开的神经网络的误差反向传播法”，简称BPTT。处理长时序数据时，通常的做法是将网络连接截成适当的长度。具体来说，就是将时间轴方向上过长的网络在合适的位置进行截断，从而创建多个小型网络，然后对截出来的小型网络执行误差反向传播法，称为Truncated BPTT。

这是书中提供的方法，因为当序列长度太长的时候，梯度会变得不稳定，容易出现梯度消失问题，并且消耗的计算资源也会很大，所以对网络进行了截断训练，后面的LSTM，GRU等等模型也是为了解决RNN时序过长等引起的问题的方法。

Truncated BPTT的特点就是前馈网络中正常传递，但是反向传播进行截断，以“块”为单位进行误差反向传播，其实也就是等于分块训练，结构如下：

RNN的正向传播用公式表示就是：

ht-1是上一个节点传入的隐藏信息，Wh是隐藏信息的权重矩阵，xt是当前节点输入的数据，Wx是输入数据的权重矩阵，b是偏置。这几个元素进行线性组合后，再应用一次非线性的正切变换，得到的就是输出ht。

反向传播示意图：

反向传播流程：

上一个节点传入的dhnext代表传递过来的梯度信息，要对ht-1（也就是hprev），Wh，xt，Wx和b分别求偏导数，以得到他们各自的梯度（反向传播算法里面有说明，可以参考深度学习教科书）。

假设ht-1Wh + xtWx + b为Z，正向传播公式：

那么他们各自的梯度如下（由于tanh(z)对z的导数是1-(tanh(z))^2）：

基于以上的推断，我们可以写出RNN的实现程序：

import numpy as np

class RNN:
    def __init__(self, Wx, Wh, b):
        self.params = [Wx, Wh, b]
        self.grads = [np.zeros_like(Wx), np.zeros_like(Wh), np.zeros_like(b)]
        self.cache = None
        
    def forward(self, x, h_prev):
        Wx, Wh, b = self.params
        t = np.dot(h_prev, Wh) + np.dot(x, Wx) + b
        h_next = np.tanh(t)
        # 暂存
        self.cache = (x, h_prev, h_next) 
        return h_next # 返回正向隐藏信息
    
    def backward(self, dh_next):
        Wx, Wh, b = self.params
        x, h_prev, h_next = self.cache
        dt = dh_next*(1-h_next**2)
        db = np.sum(dt, axis=0)
        dWh = np.dot(h_prev.T, dt)
        dh_prev = np.dot(dt, Wh.T)
        dWx = np.dot(x.T, dt)
        dx = np.dot(dt, Wx.T)
        self.grads[0][...] = dWx
        self.grads[1][...] = dWh
        self.grads[2][...] = db
        return dx, dh_prev # 返回上一个隐藏信息的梯度和输入的梯度

根据之前说的截断网络训练方法，我们在RNN的基础上构建TimeRNN。Time RNN是T个RNN层连起来的网络。其中有一个成员变量layers，保存T个RNN层，另一个成员变量h保存调用forward方法时的最后一个RNN层隐藏状态。stateful=True表示继承Time RNN层的状态，stateful=False表示不继承Time RNN层的状态。

class TimeRNN:
    def __init__(self, Wx, Wh, b, stateful=False):
        self.params = [Wx, Wh, b]
        self.grads = [np.zeros_like(Wx), np.zeros_like(Wh), np.zeros_like(b)]
        self.layers = None
        self.h, self.dh = None, None
        self.stateful = stateful
        
    def set_state(self, h):
        self.h = h
        
    def reset_state(self):
        self.h = None
    
    def forward(self, xs):
        Wx, Wh, b = self.params # 传入权重矩阵和偏置
        # N表示batch_size，T是xs包括的时序数据个数，D是输入向量的维度
        N, T, D = xs.shape 
        # H表示隐藏状态的向量维数
        D, H = Wx.shape
        self.layers = []
        # 定义输出隐藏信息
        hs = np.empty((N,T,H), dtype='f')
        # 如果是第一个节点或者不继承隐藏状态
        if not self.stateful or self.h is None:
            # 则输入的隐藏信息设置为0
            self.h = np.zeros((N,H), dtype='f')
        for t in range(T):
            # 循环遍历T个节点，记录隐藏信息
            layer = RNN(*self.params)
            self.h = layer.forward(xs[:,t,:],self.h)
            hs[:,t,:] = self.h
            self.layers.append(layer)
        return hs
    
    def backward(self, dhs):
        Wx, Wh, b = self.params
        N, T, D = dhs.shape
        D, H = Wx.shape
        dxs = np.empty((N,T,D), dtype='f')
        dh = 0
        grads = [0,0,0]
        # 这里是反序遍历T个节点
        for t in reversed(range(T)):
            layer = self.layers[t]
            # 每个节点内部做反向传播
            dx,dh = layer.backward(dhs[:,t,:]+dh) # 求和后的梯度
            dxs[:,t,:] = dx
            # 获取Wx,Wh和b的梯度，并进行累加
            for i, grad in enumerate(layer.grads):
                grads[i] += grad
            
        for i,grad in enumerate(grads):
            self.grads[i][...] = grad
        
        self.dh = dh
        
        return dxs

在TimeRNN的基础上构建了RNNLM，RNNLM是指基于RNN的语言模型（language model）。这个模型就是把我们之前的信息都合并在一起，输入的一串时序数据，每串时序数据都要先进行Embedding操作（每串时序数据包含T个单独的时序数据，或者叫token），然后传入TimeRNN层，最后把输出的隐藏信息传入到Affine层，Affine就是一个简单的神经网络，进行计算得到输出结果。（《深度学习入门：基于Python的理论与实现》有详细论述），把这三个操作串联起来形成一个layer。输出的分类结果进行softmax操作，并计算出损失值，传递到Affine层，得到输入的梯度dx，再输入到TimeRNN，这里进行分块，块内反向传播，得到的梯度相加，得到总的梯度，再传递到Emebedding，进行反向传播，最后用优化器optimizer进行梯度更新，完成训练。

class SimpleRnnlm:
    def __init__(self, vocab_size, wordvec_size, hidden_size):
        V,D,H = vocab_size, wordvec_size, hidden_size
        rn = np.random.randn
        # 初始化权重
        embed_W = (rn(V,D)/100).astype('f')
        rnn_Wx = (rn(D,H)/np.sqrt(D)).astype('f')
        rnn_Wh = (rn(H,H)/np.sqrt(H)).astype('f')
        rnn_b = np.zeros(H).astype('f')
        affine_W = (rn(H,V)/np.sqrt(H)).astype('f')
        affine_b = np.zeros(V).astype('f')
        # 生成层
        self.layers = [
            TimeEmbedding(embed_W),
            TimeRNN(rnn_Wx, rnn_Wh, rnn_b, stateful=True),
            TimeAffine(affine_W, affine_b)
        ]
        self.loss_layer = TimeSoftmaxWithLoss()
        self.rnn_layer = self.layers[1]
        # 将所有的权重和梯度整理到列表中
        self.params, self.grads = [],[]
        for layer in self.layers:
            self.params += layer.params
            self.grads += layer.grads
            
    def forward(self, xs, ts):
        for layer in self.layers:
            xs = layer.forward(xs)
        loss = self.loss_layer.forward(xs, ts)
        return loss
    
    def backward(self, dout=1):
        dout = self.loss_layer.backward(dout)
        for layer in reversed(self.layers):
            dout = layer.backward(dout)
        return dout
    
    def reset_state(self):
        self.rnn_layer.reset_state()

我们可以用之前用到的一个英文语料库ptb进行训练。语言模型是基于已经出现的单词预测将要出现的单词的概率分布。困惑度（perplexity）是一个比较常用的指标，它是概率的倒数，如果预测一个单词出现的概率是0.2，则它的困惑度是5，如果预测一个单词出现的概率是0.8，则它的困惑度是1.25，我们的模型训练过程可视化指标选择用困惑度来表示。困惑度自然是越低越好。

import numpy as np

# 设定超参数
batch_size = 10
wordvec_size = 100
hidden_size = 100  # RNN的隐藏状态向量的元素个数
time_size = 5  # RNN的展开大小
lr = 0.1
max_epoch = 100

# 读入训练数据
corpus, word_to_id, id_to_word = load_data('train')
corpus_size = 1000  # 缩小测试用的数据集
corpus = corpus[:corpus_size]
vocab_size = int(max(corpus) + 1)
xs = corpus[:-1]  # 输入
#print(xs.shape)
ts = corpus[1:]  # 输出（监督标签）

# 生成模型
model = SimpleRnnlm(vocab_size, wordvec_size, hidden_size)
optimizer = SGD(lr)
trainer = RnnlmTrainer(model, optimizer)

trainer.fit(xs, ts, max_epoch, batch_size, time_size)
trainer.plot()
# 输出
| epoch 1 |  iter 1 / 19 | time 0[s] | perplexity 417.35
| epoch 2 |  iter 1 / 19 | time 0[s] | perplexity 387.39
| epoch 3 |  iter 1 / 19 | time 0[s] | perplexity 272.27
| epoch 4 |  iter 1 / 19 | time 0[s] | perplexity 224.16
| epoch 5 |  iter 1 / 19 | time 0[s] | perplexity 210.55
| epoch 6 |  iter 1 / 19 | time 0[s] | perplexity 208.73
| epoch 7 |  iter 1 / 19 | time 0[s] | perplexity 200.27
| epoch 8 |  iter 1 / 19 | time 0[s] | perplexity 200.94
| epoch 9 |  iter 1 / 19 | time 0[s] | perplexity 194.13
| epoch 10 |  iter 1 / 19 | time 0[s] | perplexity 189.88
... ...
| epoch 95 |  iter 1 / 19 | time 2[s] | perplexity 6.94
| epoch 96 |  iter 1 / 19 | time 2[s] | perplexity 6.83
| epoch 97 |  iter 1 / 19 | time 2[s] | perplexity 6.54
| epoch 98 |  iter 1 / 19 | time 2[s] | perplexity 6.41
| epoch 99 |  iter 1 / 19 | time 2[s] | perplexity 5.99
| epoch 100 |  iter 1 / 19 | time 2[s] | perplexity 5.89