PyTorch教程-9.4. 循环神经网络

在第 9.3 节中，我们描述了马尔可夫模型和 n-grams 用于语言建模，其中 token 的条件概率xt在时间步t只取决于 n−1以前的令牌。如果我们想在时间步长之前合并标记的可能影响t−(n−1)在xt, 我们需要增加n. 然而，模型参数的数量也会随之呈指数增长，因为我们需要存储 |V|n词汇集的数字 V. 因此，而不是建模 P(xt∣xt−1,…,xt−n+1)最好使用潜在变量模型：

(9.4.1)P(xt∣xt−1,…,x1)≈P(xt∣ht−1),

在哪里ht−1是一个隐藏状态，存储序列信息到时间步长t−1. 一般来说，任何时间步的隐藏状态t可以根据当前输入计算xt和之前的隐藏状态ht−1:

(9.4.2)ht=f(xt,ht−1).

为了足够强大的功能f在(9.4.2)中，潜变量模型不是近似值。毕竟， ht可以简单地存储到目前为止观察到的所有数据。但是，它可能会使计算和存储都变得昂贵。

回想一下，我们在第 5 节中讨论了带有隐藏单元的隐藏层 。值得注意的是，隐藏层和隐藏状态指的是两个截然不同的概念。如前所述，隐藏层是在从输入到输出的路径上从视图中隐藏的层。从技术上讲，隐藏状态是我们在给定步骤所做的任何事情的输入，它们只能通过查看先前时间步骤的数据来计算。

递归神经网络(RNN) 是具有隐藏状态的神经网络。在介绍 RNN 模型之前，我们首先重温一下5.1 节介绍的 MLP 模型。

import torch
from d2l import torch as d2l

from mxnet import np, npx
from d2l import mxnet as d2l

npx.set_np()

import jax
from jax import numpy as jnp
from d2l import jax as d2l

No GPU/TPU found, falling back to CPU. (Set TF_CPP_MIN_LOG_LEVEL=0 and rerun for more info.)

import tensorflow as tf
from d2l import tensorflow as d2l

9.4.1. 没有隐藏状态的神经网络

让我们看一下具有单个隐藏层的 MLP。令隐藏层的激活函数为ϕ. 给定一小批示例X∈Rn×d批量大小 n和d输入，隐藏层输出 H∈Rn×h计算为

(9.4.3)H=ϕ(XWxh+bh).

在(9.4.3)中，我们有权重参数 Wxh∈Rd×h, 偏置参数 bh∈R1×h, 以及隐藏单元的数量h, 对于隐藏层。因此， 在求和期间应用广播（参见第 2.1.4 节）。接下来，隐藏层输出H用作输出层的输入。输出层由下式给出

(9.4.4)O=HWhq+bq,

在哪里O∈Rn×q是输出变量，Whq∈Rh×q是权重参数，并且bq∈R1×q 是输出层的偏置参数。如果是分类问题，我们可以使用softmax(O)计算输出类别的概率分布。

这完全类似于我们之前在第 9.1 节中解决的回归问题，因此我们省略了细节。只要说我们可以随机选择特征标签对并通过自动微分和随机梯度下降来学习我们网络的参数就够了。

9.4.2. 具有隐藏状态的循环神经网络

当我们有隐藏状态时，事情就完全不同了。让我们更详细地看一下结构。

假设我们有一小批输入 Xt∈Rn×d在时间步t. 换句话说，对于一个小批量n序列示例，每一行Xt对应于时间步长的一个例子 t从序列。接下来，表示为 Ht∈Rn×h时间步的隐藏层输出t. 与MLP不同，这里我们保存隐藏层输出Ht−1从上一个时间步引入一个新的权重参数 Whh∈Rh×h描述如何在当前时间步中使用上一个时间步的隐藏层输出。具体来说，当前时间步的隐层输出的计算是由当前时间步的输入和上一时间步的隐层输出共同决定的：

(9.4.5)Ht=ϕ(XtWxh+Ht−1Whh+bh).

与(9.4.3)相比， (9.4.5)多了一项 Ht−1Whh从而实例化 (9.4.2)。从隐藏层输出之间的关系 Ht和Ht−1相邻时间步长，我们知道这些变量捕获并保留了序列的历史信息直到它们当前时间步长，就像神经网络当前时间步长的状态或记忆一样。因此，这样的隐藏层输出称为隐藏状态。由于隐藏状态在当前时间步中使用前一个时间步的相同定义，因此(9.4.5)的计算是 循环的。因此，正如我们所说，基于循环计算的具有隐藏状态的神经网络被称为循环神经网络。在 RNN 中执行(9.4.5)计算的层称为循环层。

构建 RNN 有许多不同的方法。具有由(9.4.5)定义的隐藏状态的 RNN非常常见。对于时间步t，输出层的输出类似于MLP中的计算：

(9.4.6)Ot=HtWhq+bq.

RNN 的参数包括权重 Wxh∈Rd×h,Whh∈Rh×h, 和偏差bh∈R1×h隐藏层的，连同权重 Whq∈Rh×q和偏见 bq∈R1×q的输出层。值得一提的是，即使在不同的时间步长，RNN 也始终使用这些模型参数。因此，RNN 的参数化成本不会随着时间步数的增加而增加。

图 9.4.1说明了 RNN 在三个相邻时间步的计算逻辑。随时步t，隐藏状态的计算可以被视为：（i）连接输入 Xt在当前时间步t和隐藏状态Ht−1在之前的时间步t−1; (ii) 将连接结果馈送到具有激活函数的全连接层ϕ. 这样一个全连接层的输出就是隐藏状态Ht当前时间步的t. 在这种情况下，模型参数是Wxh和Whh, 和一个偏差bh, 全部来自 (9.4.5)。当前时间步的隐藏状态 t,Ht, 将参与计算隐藏状态Ht+1下一个时间步t+1. 更，Ht也将被送入全连接输出层计算输出Ot当前时间步的t.

图 9.4.1具有隐藏状态的 RNN。

我们刚刚提到计算 XtWxh+Ht−1Whh 对于隐藏状态相当于矩阵乘法的串联Xt和Ht−1和串联Wxh和Whh. 虽然这可以在数学上得到证明，但在下文中我们仅使用一个简单的代码片段来说明这一点。首先，我们定义矩阵 X、W_xh、H和W_hh，其形状分别为 (3, 1)、(1, 4)、(3, 4) 和 (4, 4)。分别乘以X和，然后将这两个乘法相加，我们得到形状为 (3, 4) 的W_xh矩阵 H。W_hh

X, W_xh = torch.randn(3, 1), torch.randn(1, 4)
H, W_hh = torch.randn(3, 4), torch.randn(4, 4)
torch.matmul(X, W_xh) + torch.matmul(H, W_hh)

tensor([[-1.6464, -8.4141, 1.5096, 3.9953],
    [-1.2590, -0.2353, 2.5025, 0.2107],
    [-2.5954, 0.8102, -1.3280, -1.1265]])

X, W_xh = np.random.randn(3, 1), np.random.randn(1, 4)
H, W_hh = np.random.randn(3, 4), np.random.randn(4, 4)
np.dot(X, W_xh) + np.dot(H, W_hh)

array([[-0.21952915, 4.256434 , 4.5812645 , -5.344988 ],
    [ 3.447858 , -3.0177274 , -1.6777471 , 7.535347 ],
    [ 2.2390068 , 1.4199957 , 4.744728 , -8.421293 ]])

X, W_xh = jax.random.normal(d2l.get_key(), (3, 1)), jax.random.normal(
                            d2l.get_key(), (1, 4))
H, W_hh = jax.random.normal(d2l.get_key(), (3, 4)), jax.random.normal(
                            d2l.get_key(), (4, 4))
jnp.matmul(X, W_xh) + jnp.matmul(H, W_hh)

Array([[-4.9585376 , -2.7011836 , 2.6214707 , 0.4295503 ],
    [ 0.85284555, 1.0258489 , -0.01304248, -0.08559555],
    [ 4.970079 , 1.1702325 , -3.1437514 , -2.7272367 ]],   dtype=float32)

X, W_xh = tf.random.normal((3, 1)), tf.random.normal((1, 4))
H, W_hh = tf.random.normal((3, 4)), tf.random.normal((4, 4))
tf.matmul(X, W_xh) + tf.matmul(H, W_hh)

现在我们连接矩阵X和H列（轴 1），以及矩阵W_xh和W_hh行（轴 0）。这两个串联分别产生形状为 (3, 5) 和形状 (5, 4) 的矩阵。将这两个级联矩阵相乘，我们得到与上面相同的形状 (3, 4) 的输出矩阵。

torch.matmul(torch.cat((X, H), 1), torch.cat((W_xh, W_hh), 0))

tensor([[-1.6464, -8.4141, 1.5096, 3.9953],
    [-1.2590, -0.2353, 2.5025, 0.2107],
    [-2.5954, 0.8102, -1.3280, -1.1265]])

np.dot(np.concatenate((X, H), 1), np.concatenate((W_xh, W_hh), 0))

array([[-0.21952918, 4.256434 , 4.5812645 , -5.344988 ],
    [ 3.4478583 , -3.0177271 , -1.677747 , 7.535347 ],
    [ 2.2390068 , 1.4199957 , 4.744728 , -8.421294 ]])

jnp.matmul(jnp.concatenate((X, H), 1), jnp.concatenate((W_xh, W_hh), 0))

Array([[-4.9585376 , -2.7011836 , 2.6214707 , 0.4295503 ],
    [ 0.85284555, 1.0258489 , -0.01304245, -0.08559557],
    [ 4.9700794 , 1.1702325 , -3.1437514 , -2.7272365 ]],   dtype=float32)

tf.matmul(tf.concat((X, H), 1), tf.concat((W_xh, W_hh), 0))

9.4.3. 基于 RNN 的字符级语言模型

回想一下9.3 节中的语言建模，我们的目标是根据当前和过去的标记预测下一个标记，因此我们将原始序列移动一个标记作为目标（标签）。 本吉奥等。( 2003 )首次提出使用神经网络进行语言建模。在下文中，我们将说明如何使用 RNN 来构建语言模型。设小批量大小为 1，文本序列为“机器”。为了简化后续部分的训练，我们将文本标记为字符而不是单词，并考虑字符级语言模型。 图 9.4.2演示了如何通过用于字符级语言建模的 RNN 基于当前字符和先前字符预测下一个字符。

图 9.4.2基于 RNN 的字符级语言模型。输入和目标序列分别是“机器”和“机器”。

在训练过程中，我们对每个时间步的输出层的输出进行 softmax 操作，然后使用交叉熵损失来计算模型输出与目标之间的误差。由于隐藏层中隐藏状态的循环计算，图 9.4.2中时间步长 3 的输出， O3, 由文本序列“m”、“a”和“c”确定。由于训练数据中序列的下一个字符是“h”，时间步长3的损失将取决于基于特征序列“m”、“a”、“c”和“c”生成的下一个字符的概率分布这个时间步长的目标“h”。

实际上，每个标记都由一个d维向量，我们使用批量大小n>1. 因此，输入 Xt在时间步t将是一个n×d 矩阵，这与我们在 第 9.4.2 节中讨论的相同。

在接下来的部分中，我们将为字符级语言模型实现 RNN。

9.4.4. 概括

对隐藏状态使用循环计算的神经网络称为循环神经网络 (RNN)。RNN 的隐藏状态可以捕获序列到当前时间步的历史信息。通过循环计算，RNN 模型参数的数量不会随着时间步数的增加而增加。至于应用程序，RNN 可用于创建字符级语言模型。

9.4.5. 练习

如果我们使用循环神经网络来预测文本序列中的下一个字符，那么任何输出所需的维度是多少？

为什么 RNN 可以基于文本序列中所有先前的标记来表达某个标记在某个时间步的条件概率？

如果反向传播一个长序列，梯度会发生什么变化？

与本节中描述的语言模型相关的一些问题是什么？