近期参加了伯禹教育、Datawhale、和鲸科技组织的“《动手学深度学习》代码讲解PyTorch版”课程学习，本文为第一次学习记录。涉及知识点：过拟合、欠拟合的解决方案；梯度消失与梯度爆炸；循环神经网络。

• 过拟合、欠拟合的解决方案之权重衰减
  • 方法
  • 高维线性回归实验
  • 从零开始实现
    • 初始化模型参数
    • 定义(L_2)范数惩罚项
    • 定义训练和测试
    • 观察过拟合
    • 使用权重衰减
  • 简洁实现
  • 小结
  • 练习
• 过拟合、欠拟合的解决方案之丢弃法
  • 方法
  • 从零开始实现
    • 定义模型参数
    • 定义模型
    • 训练和测试模型
  • 简洁实现
  • 小结
  • 练习
  • 参考文献
• 数值稳定性和模型初始化
  • 衰减和爆炸
  • 随机初始化模型参数
    • MXNet的默认随机初始化
    • Xavier随机初始化
  • 小结
  • 练习
  • 参考文献
• 循环神经网络
  • 不含隐藏状态的神经网络
  • 含隐藏状态的循环神经网络
  • 应用：基于字符级循环神经网络的语言模型
  • 小结
  • 练习
• 循环神经网络的从零开始实现
  • one-hot向量
  • 初始化模型参数
  • 定义模型
  • 定义预测函数
  • 裁剪梯度
  • 困惑度
  • 定义模型训练函数
  • 训练模型并创作歌词
  • 小结
  • 练习

过拟合、欠拟合的解决方案之权重衰减

上一节中我们观察了过拟合现象，即模型的训练误差远小于它在测试集上的误差。虽然增大训练数据集可能会减轻过拟合，但是获取额外的训练数据往往代价高昂。本节介绍应对过拟合问题的常用方法：权重衰减（weight decay）。

方法

权重衰减等价于\(L_2\)范数正则化（regularization）。正则化通过为模型损失函数添加惩罚项使学出的模型参数值较小，是应对过拟合的常用手段。我们先描述\(L_2\)范数正则化，再解释它为何又称权重衰减。

\(L_2\)范数正则化在模型原损失函数基础上添加\(L_2\)范数惩罚项，从而得到训练所需要最小化的函数。\(L_2\)范数惩罚项指的是模型权重参数每个元素的平方和与一个正的常数的乘积。以“线性回归”一节中的线性回归损失函数

\[\ell(w_1, w_2, b) = \frac{1}{n} \sum_{i=1}^n \frac{1}{2}\left(x_1^{(i)} w_1 + x_2^{(i)} w_2 + b - y^{(i)}\right)^2 \]

为例，其中\(w_1, w_2\)是权重参数，\(b\)是偏差参数，样本\(i\)的输入为\(x_1^{(i)}, x_2^{(i)}\)，标签为\(y^{(i)}\)，样本数为\(n\)。将权重参数用向量\(\boldsymbol{w} = [w_1, w_2]\)表示，带有\(L_2\)范数惩罚项的新损失函数为

\[\ell(w_1, w_2, b) + \frac{\lambda}{2n} \|\boldsymbol{w}\|^2, \]

其中超参数\(\lambda > 0\)。当权重参数均为0时，惩罚项最小。当\(\lambda\)较大时，惩罚项在损失函数中的比重较大，这通常会使学到的权重参数的元素较接近0。当\(\lambda\)设为0时，惩罚项完全不起作用。上式中\(L_2\)范数平方$|\boldsymbol{w}|^2$展开后得到\(w_1^2 + w_2^2\)。有了\(L_2\)范数惩罚项后，在小批量随机梯度下降中，我们将“线性回归”一节中权重\(w_1\)和\(w_2\)的迭代方式更改为

\[\begin{aligned} w_1 &\leftarrow \left(1- \frac{\eta\lambda}{|\mathcal{B}|} \right)w_1 - \frac{\eta}{|\mathcal{B}|} \sum_{i \in \mathcal{B}}x_1^{(i)} \left(x_1^{(i)} w_1 + x_2^{(i)} w_2 + b - y^{(i)}\right),\\ w_2 &\leftarrow \left(1- \frac{\eta\lambda}{|\mathcal{B}|} \right)w_2 - \frac{\eta}{|\mathcal{B}|} \sum_{i \in \mathcal{B}}x_2^{(i)} \left(x_1^{(i)} w_1 + x_2^{(i)} w_2 + b - y^{(i)}\right). \end{aligned} \]

可见，\(L_2\)范数正则化令权重\(w_1\)和\(w_2\)先自乘小于1的数，再减去不含惩罚项的梯度。因此，\(L_2\)范数正则化又叫权重衰减。权重衰减通过惩罚绝对值较大的模型参数为需要学习的模型增加了限制，这可能对过拟合有效。实际场景中，我们有时也在惩罚项中添加偏差元素的平方和。

高维线性回归实验

下面，我们以高维线性回归为例来引入一个过拟合问题，并使用权重衰减来应对过拟合。设数据样本特征的维度为\(p\)。对于训练数据集和测试数据集中特征为\(x_1, x_2, \ldots, x_p\)的任一样本，我们使用如下的线性函数来生成该样本的标签：

\[y = 0.05 + \sum_{i = 1}^p 0.01x_i + \epsilon, \]

其中噪声项\(\epsilon\)服从均值为0、标准差为0.01的正态分布。为了较容易地观察过拟合，我们考虑高维线性回归问题，如设维度\(p=200\)；同时，我们特意把训练数据集的样本数设低，如20。

%matplotlib inline
import d2lzh as d2l
from mxnet import autograd, gluon, init, nd
from mxnet.gluon import data as gdata, loss as gloss, nn

n_train, n_test, num_inputs = 20, 100, 200
true_w, true_b = nd.ones((num_inputs, 1)) * 0.01, 0.05

features = nd.random.normal(shape=(n_train + n_test, num_inputs))
labels = nd.dot(features, true_w) + true_b
labels += nd.random.normal(scale=0.01, shape=labels.shape)
train_features, test_features = features[:n_train, :], features[n_train:, :]
train_labels, test_labels = labels[:n_train], labels[n_train:]

从零开始实现

下面先介绍从零开始实现权重衰减的方法。我们通过在目标函数后添加\(L_2\)范数惩罚项来实现权重衰减。

初始化模型参数

首先，定义随机初始化模型参数的函数。该函数为每个参数都附上梯度。

def init_params():
    w = nd.random.normal(scale=1, shape=(num_inputs, 1))
    b = nd.zeros(shape=(1,))
    w.attach_grad()
    b.attach_grad()
    return [w, b]

定义\(L_2\)范数惩罚项

下面定义\(L_2\)范数惩罚项。这里只惩罚模型的权重参数。

def l2_penalty(w):
    return (w**2).sum() / 2

定义训练和测试

下面定义如何在训练数据集和测试数据集上分别训练和测试模型。与前面几节中不同的是，这里在计算最终的损失函数时添加了\(L_2\)范数惩罚项。

batch_size, num_epochs, lr = 1, 100, 0.003
net, loss = d2l.linreg, d2l.squared_loss
train_iter = gdata.DataLoader(gdata.ArrayDataset(
    train_features, train_labels), batch_size, shuffle=True)

def fit_and_plot(lambd):
    w, b = init_params()
    train_ls, test_ls = [], []
    for _ in range(num_epochs):
        for X, y in train_iter:
            with autograd.record():
                # 添加了L2范数惩罚项
                l = loss(net(X, w, b), y) + lambd * l2_penalty(w)
            l.backward()
            d2l.sgd([w, b], lr, batch_size)
        train_ls.append(loss(net(train_features, w, b),
                             train_labels).mean().asscalar())
        test_ls.append(loss(net(test_features, w, b),
                            test_labels).mean().asscalar())
    d2l.semilogy(range(1, num_epochs + 1), train_ls, 'epochs', 'loss',
                 range(1, num_epochs + 1), test_ls, ['train', 'test'])
    print('L2 norm of w:', w.norm().asscalar())

观察过拟合

接下来，让我们训练并测试高维线性回归模型。当lambd设为0时，我们没有使用权重衰减。结果训练误差远小于测试集上的误差。这是典型的过拟合现象。

fit_and_plot(lambd=0)

L2 norm of w: 11.611941

使用权重衰减

下面我们使用权重衰减。可以看出，训练误差虽然有所提高，但测试集上的误差有所下降。过拟合现象得到一定程度的缓解。另外，权重参数的\(L_2\)范数比不使用权重衰减时的更小，此时的权重参数更接近0。

fit_and_plot(lambd=3)

L2 norm of w: 0.040959217

简洁实现

这里我们直接在构造Trainer实例时通过wd参数来指定权重衰减超参数。默认下，Gluon会对权重和偏差同时衰减。我们可以分别对权重和偏差构造Trainer实例，从而只对权重衰减。

def fit_and_plot_gluon(wd):
    net = nn.Sequential()
    net.add(nn.Dense(1))
    net.initialize(init.Normal(sigma=1))
    # 对权重参数衰减。权重名称一般是以weight结尾
    trainer_w = gluon.Trainer(net.collect_params('.*weight'), 'sgd',
                              {'learning_rate': lr, 'wd': wd})
    # 不对偏差参数衰减。偏差名称一般是以bias结尾
    trainer_b = gluon.Trainer(net.collect_params('.*bias'), 'sgd',
                              {'learning_rate': lr})
    train_ls, test_ls = [], []
    for _ in range(num_epochs):
        for X, y in train_iter:
            with autograd.record():
                l = loss(net(X), y)
            l.backward()
            # 对两个Trainer实例分别调用step函数，从而分别更新权重和偏差
            trainer_w.step(batch_size)
            trainer_b.step(batch_size)
        train_ls.append(loss(net(train_features),
                             train_labels).mean().asscalar())
        test_ls.append(loss(net(test_features),
                            test_labels).mean().asscalar())
    d2l.semilogy(range(1, num_epochs + 1), train_ls, 'epochs', 'loss',
                 range(1, num_epochs + 1), test_ls, ['train', 'test'])
    print('L2 norm of w:', net[0].weight.data().norm().asscalar())

与从零开始实现权重衰减的实验现象类似，使用权重衰减可以在一定程度上缓解过拟合问题。

fit_and_plot_gluon(0)

L2 norm of w: 13.311795

fit_and_plot_gluon(3)

L2 norm of w: 0.032668564

小结

• 正则化通过为模型损失函数添加惩罚项使学出的模型参数值较小，是应对过拟合的常用手段。
• 权重衰减等价于\(L_2\)范数正则化，通常会使学到的权重参数的元素较接近0。
• 权重衰减可以通过Gluon的wd超参数来指定。
• 可以定义多个Trainer实例对不同的模型参数使用不同的迭代方法。

练习

• 回顾一下训练误差和泛化误差的关系。除了权重衰减、增大训练量以及使用复杂度合适的模型，你还能想到哪些办法来应对过拟合？
• 如果你了解贝叶斯统计，你觉得权重衰减对应贝叶斯统计里的哪个重要概念？
• 调节实验中的权重衰减超参数，观察并分析实验结果。

过拟合、欠拟合的解决方案之丢弃法

除了前一节介绍的权重衰减以外，深度学习模型常常使用丢弃法（dropout）[1] 来应对过拟合问题。丢弃法有一些不同的变体。本节中提到的丢弃法特指倒置丢弃法（inverted dropout）。

方法

回忆一下，“多层感知机”一节的图3.3描述了一个单隐藏层的多层感知机。其中输入个数为4，隐藏单元个数为5，且隐藏单元\(h_i\)（\(i=1, \ldots, 5\)）的计算表达式为

\[h_i = \phi\left(x_1 w_{1i} + x_2 w_{2i} + x_3 w_{3i} + x_4 w_{4i} + b_i\right), \]

这里\(\phi\)是激活函数，\(x_1, \ldots, x_4\)是输入，隐藏单元\(i\)的权重参数为\(w_{1i}, \ldots, w_{4i}\)，偏差参数为\(b_i\)。当对该隐藏层使用丢弃法时，该层的隐藏单元将有一定概率被丢弃掉。设丢弃概率为\(p\)，
那么有\(p\)的概率\(h_i\)会被清零，有\(1-p\)的概率\(h_i\)会除以\(1-p\)做拉伸。丢弃概率是丢弃法的超参数。具体来说，设随机变量\(\xi_i\)为0和1的概率分别为\(p\)和\(1-p\)。使用丢弃法时我们计算新的隐藏单元\(h_i'\)

\[h_i' = \frac{\xi_i}{1-p} h_i. \]

由于\(E(\xi_i) = 1-p\)，因此

\[E(h_i') = \frac{E(\xi_i)}{1-p}h_i = h_i. \]

即丢弃法不改变其输入的期望值。让我们对图3.3中的隐藏层使用丢弃法，一种可能的结果如图3.5所示，其中\(h_2\)和\(h_5\)被清零。这时输出值的计算不再依赖\(h_2\)和\(h_5\)，在反向传播时，与这两个隐藏单元相关的权重的梯度均为0。由于在训练中隐藏层神经元的丢弃是随机的，即\(h_1, \ldots, h_5\)都有可能被清零，输出层的计算无法过度依赖\(h_1, \ldots, h_5\)中的任一个，从而在训练模型时起到正则化的作用，并可以用来应对过拟合。在测试模型时，我们为了拿到更加确定性的结果，一般不使用丢弃法。

从零开始实现

根据丢弃法的定义，我们可以很容易地实现它。下面的dropout函数将以drop_prob的概率丢弃NDArray输入X中的元素。

import d2lzh as d2l
from mxnet import autograd, gluon, init, nd
from mxnet.gluon import loss as gloss, nn

def dropout(X, drop_prob):
    assert 0 <= drop_prob <= 1
    keep_prob = 1 - drop_prob
    # 这种情况下把全部元素都丢弃
    if keep_prob == 0:
        return X.zeros_like()
    mask = nd.random.uniform(0, 1, X.shape) < keep_prob
    return mask * X / keep_prob

我们运行几个例子来测试一下dropout函数。其中丢弃概率分别为0、0.5和1。

X = nd.arange(16).reshape((2, 8))
dropout(X, 0)

[[ 0.  1.  2.  3.  4.  5.  6.  7.]
 [ 8.  9. 10. 11. 12. 13. 14. 15.]]
<NDArray 2x8 @cpu(0)>

dropout(X, 0.5)

[[ 0.  2.  4.  6.  0.  0.  0. 14.]
 [ 0. 18.  0.  0. 24. 26. 28.  0.]]
<NDArray 2x8 @cpu(0)>

dropout(X, 1)

[[0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0.]]
<NDArray 2x8 @cpu(0)>

定义模型参数

实验中，我们依然使用“softmax回归的从零开始实现”一节中介绍的Fashion-MNIST数据集。我们将定义一个包含两个隐藏层的多层感知机，其中两个隐藏层的输出个数都是256。

num_inputs, num_outputs, num_hiddens1, num_hiddens2 = 784, 10, 256, 256

W1 = nd.random.normal(scale=0.01, shape=(num_inputs, num_hiddens1))
b1 = nd.zeros(num_hiddens1)
W2 = nd.random.normal(scale=0.01, shape=(num_hiddens1, num_hiddens2))
b2 = nd.zeros(num_hiddens2)
W3 = nd.random.normal(scale=0.01, shape=(num_hiddens2, num_outputs))
b3 = nd.zeros(num_outputs)

params = [W1, b1, W2, b2, W3, b3]
for param in params:
    param.attach_grad()

定义模型

下面定义的模型将全连接层和激活函数ReLU串起来，并对每个激活函数的输出使用丢弃法。我们可以分别设置各个层的丢弃概率。通常的建议是把靠近输入层的丢弃概率设得小一点。在这个实验中，我们把第一个隐藏层的丢弃概率设为0.2，把第二个隐藏层的丢弃概率设为0.5。我们可以通过“自动求梯度”一节中介绍的is_training函数来判断运行模式为训练还是测试，并只需在训练模式下使用丢弃法。

drop_prob1, drop_prob2 = 0.2, 0.5

def net(X):
    X = X.reshape((-1, num_inputs))
    H1 = (nd.dot(X, W1) + b1).relu()
    if autograd.is_training():  # 只在训练模型时使用丢弃法
        H1 = dropout(H1, drop_prob1)  # 在第一层全连接后添加丢弃层
    H2 = (nd.dot(H1, W2) + b2).relu()
    if autograd.is_training():
        H2 = dropout(H2, drop_prob2)  # 在第二层全连接后添加丢弃层
    return nd.dot(H2, W3) + b3

训练和测试模型

这部分与之前多层感知机的训练和测试类似。

num_epochs, lr, batch_size = 5, 0.5, 256
loss = gloss.SoftmaxCrossEntropyLoss()
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)
d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, batch_size,
              params, lr)

epoch 1, loss 1.1250, train acc 0.564, test acc 0.773
epoch 2, loss 0.5834, train acc 0.784, test acc 0.784
epoch 3, loss 0.4944, train acc 0.820, test acc 0.847
epoch 4, loss 0.4462, train acc 0.837, test acc 0.858
epoch 5, loss 0.4169, train acc 0.848, test acc 0.867

简洁实现

在Gluon中，我们只需要在全连接层后添加Dropout层并指定丢弃概率。在训练模型时，Dropout层将以指定的丢弃概率随机丢弃上一层的输出元素；在测试模型时，Dropout层并不发挥作用。

net = nn.Sequential()
net.add(nn.Dense(256, activation="relu"),
        nn.Dropout(drop_prob1),  # 在第一个全连接层后添加丢弃层
        nn.Dense(256, activation="relu"),
        nn.Dropout(drop_prob2),  # 在第二个全连接层后添加丢弃层
        nn.Dense(10))
net.initialize(init.Normal(sigma=0.01))

下面训练并测试模型。

trainer = gluon.Trainer(net.collect_params(), 'sgd', {'learning_rate': lr})
d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, batch_size, None,
              None, trainer)

epoch 1, loss 1.1132, train acc 0.565, test acc 0.782
epoch 2, loss 0.5729, train acc 0.788, test acc 0.840
epoch 3, loss 0.4903, train acc 0.821, test acc 0.847
epoch 4, loss 0.4407, train acc 0.838, test acc 0.860
epoch 5, loss 0.4163, train acc 0.847, test acc 0.839

小结

• 我们可以通过使用丢弃法应对过拟合。
• 丢弃法只在训练模型时使用。

练习

• 如果把本节中的两个丢弃概率超参数对调，会有什么结果？
• 增大迭代周期数，比较使用丢弃法与不使用丢弃法的结果。
• 如果将模型改得更加复杂，如增加隐藏层单元，使用丢弃法应对过拟合的效果是否更加明显？
• 以本节中的模型为例，比较使用丢弃法与权重衰减的效果。如果同时使用丢弃法和权重衰减，效果会如何？

参考文献

[1] Srivastava, N., Hinton, G., Krizhevsky, A., Sutskever, I., & Salakhutdinov, R. (2014). Dropout: a simple way to prevent neural networks from overfitting. JMLR

数值稳定性和模型初始化

理解了正向传播与反向传播以后，我们来讨论一下深度学习模型的数值稳定性问题以及模型参数的初始化方法。深度模型有关数值稳定性的典型问题是衰减（vanishing）和爆炸（explosion）。

衰减和爆炸

当神经网络的层数较多时，模型的数值稳定性容易变差。假设一个层数为\(L\)的多层感知机的第\(l\)层\(\boldsymbol{H}^{(l)}\)的权重参数为\(\boldsymbol{W}^{(l)}\)，输出层\(\boldsymbol{H}^{(L)}\)的权重参数为\(\boldsymbol{W}^{(L)}\)。为了便于讨论，不考虑偏差参数，且设所有隐藏层的激活函数为恒等映射（identity mapping）\(\phi(x) = x\)。给定输入\(\boldsymbol{X}\)，多层感知机的第\(l\)层的输出\(\boldsymbol{H}^{(l)} = \boldsymbol{X} \boldsymbol{W}^{(1)} \boldsymbol{W}^{(2)} \ldots \boldsymbol{W}^{(l)}\)。此时，如果层数\(l\)较大，\(\boldsymbol{H}^{(l)}\)的计算可能会出现衰减或爆炸。举个例子，假设输入和所有层的权重参数都是标量，如权重参数为0.2和5，多层感知机的第30层输出为输入\(\boldsymbol{X}\)分别与\(0.2^{30} \approx 1 \times 10^{-21}\)（衰减）和\(5^{30} \approx 9 \times 10^{20}\)（爆炸）的乘积。类似地，当层数较多时，梯度的计算也更容易出现衰减或爆炸。

随着内容的不断深入，我们会在后面的章节进一步介绍深度学习的数值稳定性问题以及解决方法。

随机初始化模型参数

在神经网络中，通常需要随机初始化模型参数。下面我们来解释这样做的原因。

回顾“多层感知机”一节图3.3描述的多层感知机。为了方便解释，假设输出层只保留一个输出单元\(o_1\)（删去\(o_2\)和\(o_3\)以及指向它们的箭头），且隐藏层使用相同的激活函数。如果将每个隐藏单元的参数都初始化为相等的值，那么在正向传播时每个隐藏单元将根据相同的输入计算出相同的值，并传递至输出层。在反向传播中，每个隐藏单元的参数梯度值相等。因此，这些参数在使用基于梯度的优化算法迭代后值依然相等。之后的迭代也是如此。在这种情况下，无论隐藏单元有多少，隐藏层本质上只有1个隐藏单元在发挥作用。因此，正如在前面的实验中所做的那样，我们通常将神经网络的模型参数，特别是权重参数，进行随机初始化。

MXNet的默认随机初始化

随机初始化模型参数的方法有很多。在“线性回归的简洁实现”一节中，我们使用net.initialize(init.Normal(sigma=0.01))使模型net的权重参数采用正态分布的随机初始化方式。如果不指定初始化方法，如net.initialize()，MXNet将使用默认的随机初始化方法：权重参数每个元素随机采样于-0.07到0.07之间的均匀分布，偏差参数全部清零。

Xavier随机初始化

还有一种比较常用的随机初始化方法叫作Xavier随机初始化 [1]。
假设某全连接层的输入个数为\(a\)，输出个数为\(b\)，Xavier随机初始化将使该层中权重参数的每个元素都随机采样于均匀分布

\[U\left(-\sqrt{\frac{6}{a+b}}, \sqrt{\frac{6}{a+b}}\right). \]

它的设计主要考虑到，模型参数初始化后，每层输出的方差不该受该层输入个数影响，且每层梯度的方差也不该受该层输出个数影响。

小结

• 深度模型有关数值稳定性的典型问题是衰减和爆炸。当神经网络的层数较多时，模型的数值稳定性容易变差。
• 我们通常需要随机初始化神经网络的模型参数，如权重参数。

练习

• 有人说随机初始化模型参数是为了“打破对称性”。这里的“对称”应如何理解？
• 是否可以将线性回归或softmax回归中所有的权重参数都初始化为相同值？

参考文献

[1] Glorot, X., & Bengio, Y. (2010, March). Understanding the difficulty of training deep feedforward neural networks. In Proceedings of the thirteenth international conference on artificial intelligence and statistics (pp. 249-256).

循环神经网络

上一节介绍的\(n\)元语法中，时间步\(t\)的词\(w_t\)基于前面所有词的条件概率只考虑了最近时间步的\(n-1\)个词。如果要考虑比\(t-(n-1)\)更早时间步的词对\(w_t\)的可能影响，我们需要增大\(n\)。但这样模型参数的数量将随之呈指数级增长（可参考上一节的练习）。

本节将介绍循环神经网络。它并非刚性地记忆所有固定长度的序列，而是通过隐藏状态来存储之前时间步的信息。首先我们回忆一下前面介绍过的多层感知机，然后描述如何添加隐藏状态来将它变成循环神经网络。

不含隐藏状态的神经网络

让我们考虑一个含单隐藏层的多层感知机。给定样本数为\(n\)、输入个数（特征数或特征向量维度）为\(d\)的小批量数据样本\(\boldsymbol{X} \in \mathbb{R}^{n \times d}\)。设隐藏层的激活函数为\(\phi\)，那么隐藏层的输出\(\boldsymbol{H} \in \mathbb{R}^{n \times h}\)计算为

\[\boldsymbol{H} = \phi(\boldsymbol{X} \boldsymbol{W}_{xh} + \boldsymbol{b}_h), \]

其中隐藏层权重参数\(\boldsymbol{W}_{xh} \in \mathbb{R}^{d \times h}\)，隐藏层偏差参数 \(\boldsymbol{b}_h \in \mathbb{R}^{1 \times h}\)，\(h\)为隐藏单元个数。上式相加的两项形状不同，因此将按照广播机制相加（参见“数据操作”一节）。把隐藏变量\(\boldsymbol{H}\)作为输出层的输入，且设输出个数为\(q\)（如分类问题中的类别数），输出层的输出为

\[\boldsymbol{O} = \boldsymbol{H} \boldsymbol{W}_{hq} + \boldsymbol{b}_q, \]

其中输出变量\(\boldsymbol{O} \in \mathbb{R}^{n \times q}\), 输出层权重参数\(\boldsymbol{W}_{hq} \in \mathbb{R}^{h \times q}\), 输出层偏差参数\(\boldsymbol{b}_q \in \mathbb{R}^{1 \times q}\)。如果是分类问题，我们可以使用\(\text{softmax}(\boldsymbol{O})\)来计算输出类别的概率分布。

含隐藏状态的循环神经网络

现在我们考虑输入数据存在时间相关性的情况。假设\(\boldsymbol{X}_t \in \mathbb{R}^{n \times d}\)是序列中时间步\(t\)的小批量输入，\(\boldsymbol{H}_t \in \mathbb{R}^{n \times h}\)是该时间步的隐藏变量。与多层感知机不同的是，这里我们保存上一时间步的隐藏变量\(\boldsymbol{H}_{t-1}\)，并引入一个新的权重参数\(\boldsymbol{W}_{hh} \in \mathbb{R}^{h \times h}\)，该参数用来描述在当前时间步如何使用上一时间步的隐藏变量。具体来说，时间步\(t\)的隐藏变量的计算由当前时间步的输入和上一时间步的隐藏变量共同决定：

\[\boldsymbol{H}_t = \phi(\boldsymbol{X}_t \boldsymbol{W}_{xh} + \boldsymbol{H}_{t-1} \boldsymbol{W}_{hh} + \boldsymbol{b}_h). \]

与多层感知机相比，我们在这里添加了\(\boldsymbol{H}_{t-1} \boldsymbol{W}_{hh}\)一项。由上式中相邻时间步的隐藏变量\(\boldsymbol{H}_t\)和\(\boldsymbol{H}_{t-1}\)之间的关系可知，这里的隐藏变量能够捕捉截至当前时间步的序列的历史信息，就像是神经网络当前时间步的状态或记忆一样。因此，该隐藏变量也称为隐藏状态。由于隐藏状态在当前时间步的定义使用了上一时间步的隐藏状态，上式的计算是循环的。使用循环计算的网络即循环神经网络（recurrent neural network）。

循环神经网络有很多种不同的构造方法。含上式所定义的隐藏状态的循环神经网络是极为常见的一种。若无特别说明，本章中的循环神经网络均基于上式中隐藏状态的循环计算。在时间步\(t\)，输出层的输出和多层感知机中的计算类似：

\[\boldsymbol{O}_t = \boldsymbol{H}_t \boldsymbol{W}_{hq} + \boldsymbol{b}_q. \]

循环神经网络的参数包括隐藏层的权重\(\boldsymbol{W}_{xh} \in \mathbb{R}^{d \times h}\)、\(\boldsymbol{W}_{hh} \in \mathbb{R}^{h \times h}\)和偏差 \(\boldsymbol{b}_h \in \mathbb{R}^{1 \times h}\)，以及输出层的权重\(\boldsymbol{W}_{hq} \in \mathbb{R}^{h \times q}\)和偏差\(\boldsymbol{b}_q \in \mathbb{R}^{1 \times q}\)。值得一提的是，即便在不同时间步，循环神经网络也始终使用这些模型参数。因此，循环神经网络模型参数的数量不随时间步的增加而增长。

图6.1展示了循环神经网络在3个相邻时间步的计算逻辑。在时间步\(t\)，隐藏状态的计算可以看成是将输入\(\boldsymbol{X}_t\)和前一时间步隐藏状态\(\boldsymbol{H}_{t-1}\)连结后输入一个激活函数为\(\phi\)的全连接层。该全连接层的输出就是当前时间步的隐藏状态\(\boldsymbol{H}_t\)，且模型参数为\(\boldsymbol{W}_{xh}\)与\(\boldsymbol{W}_{hh}\)的连结，偏差为\(\boldsymbol{b}_h\)。当前时间步\(t\)的隐藏状态\(\boldsymbol{H}_t\)将参与下一个时间步\(t+1\)的隐藏状态\(\boldsymbol{H}_{t+1}\)的计算，并输入到当前时间步的全连接输出层。

我们刚刚提到，隐藏状态中\(\boldsymbol{X}_t \boldsymbol{W}_{xh} + \boldsymbol{H}_{t-1} \boldsymbol{W}_{hh}\)的计算等价于\(\boldsymbol{X}_t\)与\(\boldsymbol{H}_{t-1}\)连结后的矩阵乘以\(\boldsymbol{W}_{xh}\)与\(\boldsymbol{W}_{hh}\)连结后的矩阵。接下来，我们用一个具体的例子来验证这一点。首先，我们构造矩阵X、W_xh、H和W_hh，它们的形状分别为(3, 1)、(1, 4)、(3, 4)和(4, 4)。将X与W_xh、H与W_hh分别相乘，再把两个乘法运算的结果相加，得到形状为(3, 4)的矩阵。

from mxnet import nd

X, W_xh = nd.random.normal(shape=(3, 1)), nd.random.normal(shape=(1, 4))
H, W_hh = nd.random.normal(shape=(3, 4)), nd.random.normal(shape=(4, 4))
nd.dot(X, W_xh) + nd.dot(H, W_hh)

[[ 5.0373516   2.6754622  -1.6607479  -0.40628886]
 [ 0.948454    0.46941757 -1.1866101  -1.180677  ]
 [-1.1514019   0.8373027  -2.197437   -5.2480164 ]]
<NDArray 3x4 @cpu(0)>

将矩阵X和H按列（维度1）连结，连结后的矩阵形状为(3, 5)。可见，连结后矩阵在维度1的长度为矩阵X和H在维度1的长度之和（\(1+4\)）。然后，将矩阵W_xh和W_hh按行（维度0）连结，连结后的矩阵形状为(5, 4)。最后将两个连结后的矩阵相乘，得到与上面代码输出相同的形状为(3, 4)的矩阵。

nd.dot(nd.concat(X, H, dim=1), nd.concat(W_xh, W_hh, dim=0))

[[ 5.0373516   2.6754622  -1.6607479  -0.40628862]
 [ 0.94845396  0.46941754 -1.1866102  -1.1806769 ]
 [-1.1514019   0.83730274 -2.1974368  -5.2480164 ]]
<NDArray 3x4 @cpu(0)>

应用：基于字符级循环神经网络的语言模型

最后我们介绍如何应用循环神经网络来构建一个语言模型。设小批量中样本数为1，文本序列为“想”“要”“有”“直”“升”“机”。图6.2演示了如何使用循环神经网络基于当前和过去的字符来预测下一个字符。在训练时，我们对每个时间步的输出层输出使用softmax运算，然后使用交叉熵损失函数来计算它与标签的误差。在图6.2中，由于隐藏层中隐藏状态的循环计算，时间步3的输出\(\boldsymbol{O}_3\)取决于文本序列“想”“要”“有”。 由于训练数据中该序列的下一个词为“直”，时间步3的损失将取决于该时间步基于序列“想”“要”“有”生成下一个词的概率分布与该时间步的标签“直”。

因为每个输入词是一个字符，因此这个模型被称为字符级循环神经网络（character-level recurrent neural network）。因为不同字符的个数远小于不同词的个数（对于英文尤其如此），所以字符级循环神经网络的计算通常更加简单。在接下来的几节里，我们将介绍它的具体实现。

小结

• 使用循环计算的网络即循环神经网络。
• 循环神经网络的隐藏状态可以捕捉截至当前时间步的序列的历史信息。
• 循环神经网络模型参数的数量不随时间步的增加而增长。
• 可以基于字符级循环神经网络来创建语言模型。

练习

• 如果使用循环神经网络来预测一段文本序列的下一个词，输出个数应该设为多少？
• 为什么循环神经网络可以表达某时间步的词基于文本序列中所有过去的词的条件概率？

循环神经网络的从零开始实现

在本节中，我们将从零开始实现一个基于字符级循环神经网络的语言模型，并在周杰伦专辑歌词数据集上训练一个模型来进行歌词创作。首先，我们读取周杰伦专辑歌词数据集：

import d2lzh as d2l
import math
from mxnet import autograd, nd
from mxnet.gluon import loss as gloss
import time

(corpus_indices, char_to_idx, idx_to_char,
 vocab_size) = d2l.load_data_jay_lyrics()

one-hot向量

为了将词表示成向量输入到神经网络，一个简单的办法是使用one-hot向量。假设词典中不同字符的数量为\(N\)（即词典大小vocab_size），每个字符已经同一个从0到\(N-1\)的连续整数值索引一一对应。如果一个字符的索引是整数\(i\), 那么我们创建一个全0的长为\(N\)的向量，并将其位置为\(i\)的元素设成1。该向量就是对原字符的one-hot向量。下面分别展示了索引为0和2的one-hot向量，向量长度等于词典大小。

nd.one_hot(nd.array([0, 2]), vocab_size)

[[1. 0. 0. ... 0. 0. 0.]
 [0. 0. 1. ... 0. 0. 0.]]
<NDArray 2x1027 @cpu(0)>

我们每次采样的小批量的形状是(批量大小, 时间步数)。下面的函数将这样的小批量变换成数个可以输入进网络的形状为(批量大小, 词典大小)的矩阵，矩阵个数等于时间步数。也就是说，时间步\(t\)的输入为\(\boldsymbol{X}_t \in \mathbb{R}^{n \times d}\)，其中\(n\)为批量大小，\(d\)为输入个数，即one-hot向量长度（词典大小）。

def to_onehot(X, size):  # 本函数已保存在d2lzh包中方便以后使用
    return [nd.one_hot(x, size) for x in X.T]

X = nd.arange(10).reshape((2, 5))
inputs = to_onehot(X, vocab_size)
len(inputs), inputs[0].shape

(5, (2, 1027))

初始化模型参数

接下来，我们初始化模型参数。隐藏单元个数 num_hiddens是一个超参数。

num_inputs, num_hiddens, num_outputs = vocab_size, 256, vocab_size
ctx = d2l.try_gpu()
print('will use', ctx)

def get_params():
    def _one(shape):
        return nd.random.normal(scale=0.01, shape=shape, ctx=ctx)

    # 隐藏层参数
    W_xh = _one((num_inputs, num_hiddens))
    W_hh = _one((num_hiddens, num_hiddens))
    b_h = nd.zeros(num_hiddens, ctx=ctx)
    # 输出层参数
    W_hq = _one((num_hiddens, num_outputs))
    b_q = nd.zeros(num_outputs, ctx=ctx)
    # 附上梯度
    params = [W_xh, W_hh, b_h, W_hq, b_q]
    for param in params:
        param.attach_grad()
    return params

will use gpu(0)

定义模型

我们根据循环神经网络的计算表达式实现该模型。首先定义init_rnn_state函数来返回初始化的隐藏状态。它返回由一个形状为(批量大小, 隐藏单元个数)的值为0的NDArray组成的元组。使用元组是为了更便于处理隐藏状态含有多个NDArray的情况。

def init_rnn_state(batch_size, num_hiddens, ctx):
    return (nd.zeros(shape=(batch_size, num_hiddens), ctx=ctx), )

下面的rnn函数定义了在一个时间步里如何计算隐藏状态和输出。这里的激活函数使用了tanh函数。“多层感知机”一节中介绍过，当元素在实数域上均匀分布时，tanh函数值的均值为0。

def rnn(inputs, state, params):
    # inputs和outputs皆为num_steps个形状为(batch_size, vocab_size)的矩阵
    W_xh, W_hh, b_h, W_hq, b_q = params
    H, = state
    outputs = []
    for X in inputs:
        H = nd.tanh(nd.dot(X, W_xh) + nd.dot(H, W_hh) + b_h)
        Y = nd.dot(H, W_hq) + b_q
        outputs.append(Y)
    return outputs, (H,)

做个简单的测试来观察输出结果的个数（时间步数），以及第一个时间步的输出层输出的形状和隐藏状态的形状。

state = init_rnn_state(X.shape[0], num_hiddens, ctx)
inputs = to_onehot(X.as_in_context(ctx), vocab_size)
params = get_params()
outputs, state_new = rnn(inputs, state, params)
len(outputs), outputs[0].shape, state_new[0].shape

(5, (2, 1027), (2, 256))

定义预测函数

以下函数基于前缀prefix（含有数个字符的字符串）来预测接下来的num_chars个字符。这个函数稍显复杂，其中我们将循环神经单元rnn设置成了函数参数，这样在后面小节介绍其他循环神经网络时能重复使用这个函数。

# 本函数已保存在d2lzh包中方便以后使用
def predict_rnn(prefix, num_chars, rnn, params, init_rnn_state,
                num_hiddens, vocab_size, ctx, idx_to_char, char_to_idx):
    state = init_rnn_state(1, num_hiddens, ctx)
    output = [char_to_idx[prefix[0]]]
    for t in range(num_chars + len(prefix) - 1):
        # 将上一时间步的输出作为当前时间步的输入
        X = to_onehot(nd.array([output[-1]], ctx=ctx), vocab_size)
        # 计算输出和更新隐藏状态
        (Y, state) = rnn(X, state, params)
        # 下一个时间步的输入是prefix里的字符或者当前的最佳预测字符
        if t < len(prefix) - 1:
            output.append(char_to_idx[prefix[t + 1]])
        else:
            output.append(int(Y[0].argmax(axis=1).asscalar()))
    return ''.join([idx_to_char[i] for i in output])

我们先测试一下predict_rnn函数。我们将根据前缀“分开”创作长度为10个字符（不考虑前缀长度）的一段歌词。因为模型参数为随机值，所以预测结果也是随机的。

predict_rnn('分开', 10, rnn, params, init_rnn_state, num_hiddens, vocab_size,
            ctx, idx_to_char, char_to_idx)

'分开鸣捏性目泣游试找抬夕'

裁剪梯度

循环神经网络中较容易出现梯度衰减或梯度爆炸。我们会在“通过时间反向传播”一节中解释原因。为了应对梯度爆炸，我们可以裁剪梯度（clip gradient）。假设我们把所有模型参数梯度的元素拼接成一个向量 \(\boldsymbol{g}\)，并设裁剪的阈值是\(\theta\)。裁剪后的梯度

\[ \min\left(\frac{\theta}{\|\boldsymbol{g}\|}, 1\right)\boldsymbol{g} \]

的\(L_2\)范数不超过\(\theta\)。

# 本函数已保存在d2lzh包中方便以后使用
def grad_clipping(params, theta, ctx):
    norm = nd.array([0], ctx)
    for param in params:
        norm += (param.grad ** 2).sum()
    norm = norm.sqrt().asscalar()
    if norm > theta:
        for param in params:
            param.grad[:] *= theta / norm

困惑度

我们通常使用困惑度（perplexity）来评价语言模型的好坏。回忆一下“softmax回归”一节中交叉熵损失函数的定义。困惑度是对交叉熵损失函数做指数运算后得到的值。特别地，

• 最佳情况下，模型总是把标签类别的概率预测为1，此时困惑度为1；
• 最坏情况下，模型总是把标签类别的概率预测为0，此时困惑度为正无穷；
• 基线情况下，模型总是预测所有类别的概率都相同，此时困惑度为类别个数。

显然，任何一个有效模型的困惑度必须小于类别个数。在本例中，困惑度必须小于词典大小vocab_size。

定义模型训练函数

跟之前章节的模型训练函数相比，这里的模型训练函数有以下几点不同：

1. 使用困惑度评价模型。
2. 在迭代模型参数前裁剪梯度。
3. 对时序数据采用不同采样方法将导致隐藏状态初始化的不同。相关讨论可参考“语言模型数据集（周杰伦专辑歌词）”一节。

另外，考虑到后面将介绍的其他循环神经网络，为了更通用，这里的函数实现更长一些。

# 本函数已保存在d2lzh包中方便以后使用
def train_and_predict_rnn(rnn, get_params, init_rnn_state, num_hiddens,
                          vocab_size, ctx, corpus_indices, idx_to_char,
                          char_to_idx, is_random_iter, num_epochs, num_steps,
                          lr, clipping_theta, batch_size, pred_period,
                          pred_len, prefixes):
    if is_random_iter:
        data_iter_fn = d2l.data_iter_random
    else:
        data_iter_fn = d2l.data_iter_consecutive
    params = get_params()
    loss = gloss.SoftmaxCrossEntropyLoss()

    for epoch in range(num_epochs):
        if not is_random_iter:  # 如使用相邻采样，在epoch开始时初始化隐藏状态
            state = init_rnn_state(batch_size, num_hiddens, ctx)
        l_sum, n, start = 0.0, 0, time.time()
        data_iter = data_iter_fn(corpus_indices, batch_size, num_steps, ctx)
        for X, Y in data_iter:
            if is_random_iter:  # 如使用随机采样，在每个小批量更新前初始化隐藏状态
                state = init_rnn_state(batch_size, num_hiddens, ctx)
            else:  # 否则需要使用detach函数从计算图分离隐藏状态
                for s in state:
                    s.detach()
            with autograd.record():
                inputs = to_onehot(X, vocab_size)
                # outputs有num_steps个形状为(batch_size, vocab_size)的矩阵
                (outputs, state) = rnn(inputs, state, params)
                # 拼接之后形状为(num_steps * batch_size, vocab_size)
                outputs = nd.concat(*outputs, dim=0)
                # Y的形状是(batch_size, num_steps)，转置后再变成长度为
                # batch * num_steps 的向量，这样跟输出的行一一对应
                y = Y.T.reshape((-1,))
                # 使用交叉熵损失计算平均分类误差
                l = loss(outputs, y).mean()
            l.backward()
            grad_clipping(params, clipping_theta, ctx)  # 裁剪梯度
            d2l.sgd(params, lr, 1)  # 因为误差已经取过均值，梯度不用再做平均
            l_sum += l.asscalar() * y.size
            n += y.size

        if (epoch + 1) % pred_period == 0:
            print('epoch %d, perplexity %f, time %.2f sec' % (
                epoch + 1, math.exp(l_sum / n), time.time() - start))
            for prefix in prefixes:
                print(' -', predict_rnn(
                    prefix, pred_len, rnn, params, init_rnn_state,
                    num_hiddens, vocab_size, ctx, idx_to_char, char_to_idx))

训练模型并创作歌词

现在我们可以训练模型了。首先，设置模型超参数。我们将根据前缀“分开”和“不分开”分别创作长度为50个字符（不考虑前缀长度）的一段歌词。我们每过50个迭代周期便根据当前训练的模型创作一段歌词。

num_epochs, num_steps, batch_size, lr, clipping_theta = 250, 35, 32, 1e2, 1e-2
pred_period, pred_len, prefixes = 50, 50, ['分开', '不分开']

下面采用随机采样训练模型并创作歌词。

train_and_predict_rnn(rnn, get_params, init_rnn_state, num_hiddens,
                      vocab_size, ctx, corpus_indices, idx_to_char,
                      char_to_idx, True, num_epochs, num_steps, lr,
                      clipping_theta, batch_size, pred_period, pred_len,
                      prefixes)

epoch 50, perplexity 69.080416, time 0.22 sec
 - 分开 我不要再的你  哼哈兮 快果我 别子我 我不要 干什么 我不要 我爱我的可爱女人 坏坏的让我疯狂的
 - 不分开 我不要再的你  哼哈兮 快果我 别子我 我不要 干什么 我不要 我爱我的可爱女人 坏坏的让我疯狂的
epoch 100, perplexity 10.197520, time 0.22 sec
 - 分开  我爱到这 我想要好我 不场 娘子 征不 弓箭的老 在小村外  让有什么 有一场热演 你色蜡烛 是
 - 不分开柳 我爱你这你 我不 我不 我不要再想 我不 我不 我不要再想 我不 我不 我不要再想 我不 我不 
epoch 150, perplexity 2.933384, time 0.22 sec
 - 分开 有直了不多 有话就满说 别人在怕羞 有蝪横著走 这里什么奇怪的事都有 包括像猫的狗 印地安老斑鸠 
 - 不分开吗 我叫你爸 你打我妈 这样种容 染不了痛 我不要再我 我不能这想 我不 我不 我不要再想你 不知不
epoch 200, perplexity 1.633695, time 0.22 sec
 - 分开 一直心上心仪的母斑鸠 包仔安蕃 在小镇 背对背决斗 一只灰狼 问候完空屋 白色蜡烛 温暖了空屋 白
 - 不分开简 我叫你爸 你打我妈 这样对吗后嘛这样 何么让酒牵点子B 瞎 说着心口斯 双截棍红的泥老 我都耍的
epoch 250, perplexity 1.334753, time 0.22 sec
 - 分开 一直走钩拳仪的母斑鸠 牛仔红蕃 在小镇 背对背决斗 一只灰狼 问候完空屋 白色蜡烛 温暖了空屋 白
 - 不分开期 然后将过去 慢慢温习 让我爱上你 那场悲剧 是你完美演出的一场戏 宁愿心碎哭泣 再狠狠忘记 你爱

接下来采用相邻采样训练模型并创作歌词。

train_and_predict_rnn(rnn, get_params, init_rnn_state, num_hiddens,
                      vocab_size, ctx, corpus_indices, idx_to_char,
                      char_to_idx, False, num_epochs, num_steps, lr,
                      clipping_theta, batch_size, pred_period, pred_len,
                      prefixes)

epoch 50, perplexity 60.953674, time 0.22 sec
 - 分开 我想要这 我想了这 我有了空 我有了空 我有了空 我有了空 我有了空 我有了空 我有了空 我有了空
 - 不分开 我想要这 我想了这 我有了空 我有了空 我有了空 我有了空 我有了空 我有了空 我有了空 我有了空
epoch 100, perplexity 7.151810, time 0.22 sec
 - 分开 我想要这样 我不要再想 我不能再想 我不 我不 我不要再想你 爱情我的见快就像龙卷风 不能开暴我的
 - 不分开只 你去那这不我 不知 你想很久了吧? 我说你的爱写在默 也想我不多你想一场悲剧 我想我这辈的注样 
epoch 150, perplexity 2.091185, time 0.22 sec
 - 分开 娘子我 印怪的枪我 泪 却九走听单默一步还 说录星到风的语瓣 古我一口吴侬软 的话是是一直了老 就
 - 不分开觉 你已经离开我 不知不觉 我跟了这节奏 后知后觉 又过了一个秋 后知后觉 我该好好生活 我该好好生
epoch 200, perplexity 1.281988, time 0.22 sec
 - 分开 我满到 爱怎么 三过了里 这人忆 的诉段 时一些风霜 老唱盘 旧皮箱 装满了明信片的铁盒里藏著一片
 - 不分开觉 你已经离开我 不知不觉 我跟了这节奏 后知后觉 又过了一个秋 后知后觉 我该好好生活 我该好好生
epoch 250, perplexity 1.183621, time 0.22 sec
 - 分开 问候到 它在空 装满了明信片的铁盒里藏著一片玫瑰花瓣 黄金葛爬满了雕花的门窗 夕阳斜斜映在斑驳的砖
 - 不分开觉 你已经离开我 不知不觉 我跟了这节奏 后知后觉 又过了一个秋 后知后觉 我该好好生活 我该好好生

小结

• 可以用基于字符级循环神经网络的语言模型来生成文本序列，例如创作歌词。
• 当训练循环神经网络时，为了应对梯度爆炸，可以裁剪梯度。
• 困惑度是对交叉熵损失函数做指数运算后得到的值。

练习

• 调调超参数，观察并分析对运行时间、困惑度以及创作歌词的结果造成的影响。
• 不裁剪梯度，运行本节中的代码，结果会怎样？
• 将pred_period变量设为1，观察未充分训练的模型（困惑度高）是如何创作歌词的。你获得了什么启发？
• 将相邻采样改为不从计算图分离隐藏状态，运行时间有没有变化？
• 将本节中使用的激活函数替换成ReLU，重复本节的实验。