李沐《动手学深度学习》循环神经网络 相关基础概念

系列文章

李沐《动手学深度学习》预备知识 张量操作及数据处理
李沐《动手学深度学习》预备知识 线性代数及微积分
李沐《动手学深度学习》线性神经网络 线性回归
李沐《动手学深度学习》线性神经网络 softmax回归
李沐《动手学深度学习》多层感知机 模型概念和代码实现
李沐《动手学深度学习》多层感知机 深度学习相关概念
李沐《动手学深度学习》深度学习计算
李沐《动手学深度学习》卷积神经网络 相关基础概念
李沐《动手学深度学习》卷积神经网络 经典网络模型

目录

• 系列文章
• 一、序列模型
• • （一）自回归模型
  • （二）马尔可夫模型
  • （三）训练和预测
• 二、文本预处理
• • （一）数据集读取
  • （二）词元化
  • （三）词表
• 三、语言模型和数据集
• • （一）学习语言模型
  • （二）马尔可夫模型与n元语法
  • （三）自然语言统计
  • （四）读取长序列数据
• 四、循环神经网络
• • （一）隐变量模型
  • （二）无隐状态的神经网络
  • （三）有隐状态的神经网络
  • （四）基于循环神经网络的字符级语言模型
  • （五）困惑度Perplexity
• 五、循环神经网络的从零开始实现
• 六、循环神经网络的简洁实现
• 七、通过时间反向传播
• • （一）通过时间反向传播的概念
  • （二）循环神经网络的梯度分析

---

教材：李沐《动手学深度学习》

---

卷积神经网络可以有效地处理空间信息， 循环神经网络（recurrent neural network，RNN）可以更好地处理序列信息。 循环神经网络通过引入状态变量存储过去的信息和当前的输入，从而可以确定当前的输出。

一、序列模型

序列数据的预测：
x t ∼ P ( x t ∣ x t − 1 , . . . , x 1 ) x_t \sim P(x_t|x_{t-1},...,x_1) xt∼P(xt∣xt−1,...,x1)

（一）自回归模型

如何有效的估计 P ( x t ∣ x t − 1 , . . . , x 1 ) P(x_t|x_{t-1},...,x_1) P(xt∣xt−1,...,x1)：

1. 自回归模型：使用长度为 r r r的观测序列 x t − 1 , . . . , x t − r x_{t-1},...,x_{t-r} xt−1,...,xt−r进行预测，可以保证参数的数量不变。
2. 隐变量自回归模型：保留一些对过去观测的总结 h t h_t ht，并且同时更新预测 x ^ t \hat x_t x^t和总结 h t h_t ht，即 x ^ t = P ( x t ∣ h t ) \hat x_t=P(x_t|h_t) x^t=P(xt∣ht)， h t = g ( h t − 1 , x t − 1 ) h_t=g(h_{t-1},x_{t-1}) ht=g(ht−1,xt−1)，由于 h t h_t ht从未被观测到，这类模型被称为隐变量自回归模型。
   

如何生成训练数据：

一个经典方法是使用历史观测来预测下一个未来观测。（假设序列本身的动力学不会随着特定值改变而改变） 因此，整个序列的估计值都将通过以下的方式获得：
P ( x 1 , . . . , x T ) = ∏ t = 1 T P ( x t ∣ x t − 1 , . . . , x 1 ) P(x_1,...,x_T)= \quad \prod_{t=1}^TP(x_t|x_{t-1},...,x_1) \quad P(x1,...,xT)=t=1∏TP(xt∣xt−1,...,x1)

（二）马尔可夫模型

马尔可夫性质：

• 一个随机过程在给定现在状态及所有过去状态情况下，其未来状态的条件概率分布仅依赖于当前状态，而与过去状态（即该过程的历史路径）是条件独立的；
• 无论过去的状态如何，系统的未来状态只取决于当前状态，而不受过去状态的影响。

马尔可夫条件：

自回归模型的近似法使用 x t − 1 , . . . , x t − r x_{t-1},...,x_{t-r} xt−1,...,xt−r而不是 x t − 1 , . . . , x 1 x_{t-1},...,x_1 xt−1,...,x1来估计 x t x_t xt，只要这种是近似精确地，就说序列满足马尔可夫条件。

一阶马尔可夫模型：（ r = 1 r=1 r=1）

P ( x 1 , . . . , x T ) = ∏ t = 1 T P ( x t ∣ x t − 1 ) 当 P ( x 1 ∣ x 0 ) = P ( x 1 ) P(x_1,...,x_T)= \quad \prod_{t=1}^TP(x_t|x_{t-1}) \quad 当 P(x_1|x_0)=P(x_1) P(x1,...,xT)=t=1∏TP(xt∣xt−1)当P(x1∣x0)=P(x1)

x t x_t xt仅是离散值时，使用动态规划可以沿着马尔科夫链精确地计算结果：
P ( x t + 1 ∣ x t − 1 ) = ∑ x t P ( x t + 1 , x t , x t − 1 ) P ( x t − 1 ) = ∑ x t P ( x t + 1 ∣ x t , x t − 1 ) P ( x t , x t − 1 ) P ( x t − 1 ) = ∑ x t P ( x t + 1 ∣ x t ) P ( x t ∣ x t − 1 ) \begin{aligned} P(x_{t+1}|x_{t-1}) & = \frac{\sum {x_t}P(x{t+1},x_t,x_{t-1})}{P(x_{t-1})} \\ & = \frac{\sum {x_t}P(x{t+1}|x_t,x_{t-1})P(x_t,x_{t-1})}{P(x_{t-1})} \\ &=\sum_{x_t}P(x_{t+1}|x_t)P(x_t|x_{t-1}) \end{aligned} P(xt+1∣xt−1)=P(xt−1)∑xtP(xt+1,xt,xt−1)=P(xt−1)∑xtP(xt+1∣xt,xt−1)P(xt,xt−1)=xt∑P(xt+1∣xt)P(xt∣xt−1)

（三）训练和预测

使用正弦函数和一些可加性噪声来生成序列数据， 时间步为1,2,...,1000：

%matplotlib inline
import torch
from torch import nn
from d2l import torch as d2l

T = 1000  # 总共产生1000个点
time = torch.arange(1, T + 1, dtype=torch.float32)
x = torch.sin(0.01 * time) + torch.normal(0, 0.2, (T,))
d2l.plot(time, [x], 'time', 'x', xlim=[1, 1000], figsize=(6, 3))

将序列转换为模型的特征－标签（feature-label）对：

tau = 4 #定义4个时间步长
features = torch.zeros((T - tau, tau))#输入特征
for i in range(tau):
    features[:, i] = x[i: T - tau + i]
labels = x[tau:].reshape((-1, 1))#标签：比x少tau个元素

batch_size, n_train = 16, 600
# 只有前n_train个样本用于训练
train_iter = d2l.load_array((features[:n_train], labels[:n_train]),
                            batch_size, is_train=True)

使用一个相当简单的架构训练模型： 一个拥有两个全连接层的多层感知机，ReLU激活函数和平方损失

# 初始化网络权重的函数
def init_weights(m):
    if type(m) == nn.Linear:
        nn.init.xavier_uniform_(m.weight)

# 一个简单的多层感知机
def get_net():
    net = nn.Sequential(nn.Linear(4, 10),
                        nn.ReLU(),
                        nn.Linear(10, 1))
    net.apply(init_weights)
    return net

# 平方损失。注意：MSELoss计算平方误差时不带系数1/2
loss = nn.MSELoss(reduction='none')

训练模型：

def train(net, train_iter, loss, epochs, lr):
    trainer = torch.optim.Adam(net.parameters(), lr)
    for epoch in range(epochs):
        for X, y in train_iter:
            trainer.zero_grad()
            l = loss(net(X), y)
            l.sum().backward()
            trainer.step()
        print(f'epoch {epoch + 1}, '
              f'loss: {d2l.evaluate_loss(net, train_iter, loss):f}')

net = get_net()
train(net, train_iter, loss, 5, 0.01)

检查模型预测下一个时间步的能力， 也就是单步预测（one-step-ahead prediction）

onestep_preds = net(features)
d2l.plot([time, time[tau:]],
         [x.detach().numpy(), onestep_preds.detach().numpy()], 'time',
         'x', legend=['data', '1-step preds'], xlim=[1, 1000],
         figsize=(6, 3))

使用自己的预测（而不是原始数据）来进行多步预测

multistep_preds = torch.zeros(T)
multistep_preds[: n_train + tau] = x[: n_train + tau]
for i in range(n_train + tau, T):
    multistep_preds[i] = net(
        multistep_preds[i - tau:i].reshape((1, -1)))

d2l.plot([time, time[tau:], time[n_train + tau:]],
         [x.detach().numpy(), onestep_preds.detach().numpy(),
          multistep_preds[n_train + tau:].detach().numpy()], 'time',
         'x', legend=['data', '1-step preds', 'multistep preds'],
         xlim=[1, 1000], figsize=(6, 3))

k步预测

max_steps = 64

features = torch.zeros((T - tau - max_steps + 1, tau + max_steps))
# 列i（i<tau）是来自x的观测，其时间步从（i）到（i+T-tau-max_steps+1）
for i in range(tau):
    features[:, i] = x[i: i + T - tau - max_steps + 1]

# 列i（i>=tau）是来自（i-tau+1）步的预测，其时间步从（i）到（i+T-tau-max_steps+1）
for i in range(tau, tau + max_steps):
    features[:, i] = net(features[:, i - tau:i]).reshape(-1)

steps = (1, 4, 16, 64)
d2l.plot([time[tau + i - 1: T - max_steps + i] for i in steps],
         [features[:, (tau + i - 1)].detach().numpy() for i in steps], 'time', 'x',
         legend=[f'{i}-step preds' for i in steps], xlim=[5, 1000],
         figsize=(6, 3))

二、文本预处理

解析文本的常见预处理步骤：

• 将文本作为字符串加载到内存中
• 将字符串拆分为词元（如单词和字符）
• 建立一个词表，将拆分的词元映射到数字索引
• 将文本转换为数字索引序列，方便模型操作

（一）数据集读取

将数据集读取到由多条文本行组成的列表中，其中每条文本行都是一个字符串

#@save
d2l.DATA_HUB['time_machine'] = (d2l.DATA_URL + 'timemachine.txt',
                                '090b5e7e70c295757f55df93cb0a180b9691891a')

def read_time_machine():  #@save
    """将时间机器数据集加载到文本行的列表中"""
    with open(d2l.download('time_machine'), 'r') as f:
        lines = f.readlines()
    return [re.sub('[^A-Za-z]+', ' ', line).strip().lower() for line in lines]

lines = read_time_machine()
print(f'# 文本总行数: {len(lines)}')
print(lines[0])
print(lines[10])

（二）词元化

创建tokenize函数：

• 输入：文本行列表（列表中每个元素是一个文本序列）
• 将文本序列拆分成一个词元列表
• 输出：由词元列表组成的列表，其中的每个词元都是一个字符串

def tokenize(lines, token='word'):  #@save
    """将文本行拆分为单词或字符词元"""
    if token == 'word':
        return [line.split() for line in lines]
    elif token == 'char':
        return [list(line) for line in lines]
    else:
        print('错误：未知词元类型：' + token)

tokens = tokenize(lines)
for i in range(11):
    print(tokens[i])

（三）词表

为了对文本进行预处理，我们通常将文本拆分为词元，构建词表将词元字符串映射为数字索引，并将文本数据转换为词元索引以供模型操作。

构建词表（字典）：将字符串类型的词元映射到从0开始的数字索引中

• 合并训练集中的所有文档，对它们的唯一词元进行统计，得到的统计结果称之为语料corpus
• 根据每个唯一词元的出现频率，分配一个数字索引（移除很少出现的词元，降低复杂性）
• 语料库中不存在或已删除的任何词元都将映射到一个特定的未知词元""
• 可以选择增加一个列表，用于保存那些被保留的词元， 例如：填充词元（""）； 序列开始词元（""）； 序列结束词元（""）。

三、语言模型和数据集

（一）学习语言模型

为了训练语言模型，我们需要计算单词的概率， 以及给定前面几个单词后出现某个单词的条件概率。 这些概率本质上就是语言模型的参数。

• 基本概率规则：
  P ( x 1 , x 2 , . . . , x T ) = ∏ t = 1 T P ( x t ∣ x 1 , . . . , x t − 1 ) P(x_1,x_2,...,x_T)=\quad \prod_{t=1}^T P(x_t|x_1,...,x_{t-1}) \quad P(x1,x2,...,xT)=t=1∏TP(xt∣x1,...,xt−1)
• 包含了四个单词的一个文本序列的概率：
  P ( d e e p , l e a r n i n g , i s , f u n ) = P ( d e e p ) P ( l e a r n i n g ∣ d e e p ) P ( i s ∣ d e e p , l e a r n i n g ) P ( f u n ∣ d e e p , l e a r n i n g , i s ) P(deep,learning,is,fun)=P(deep)P(learning|deep)P(is|deep,learning)P(fun|deep,learning,is) P(deep,learning,is,fun)=P(deep)P(learning∣deep)P(is∣deep,learning)P(fun∣deep,learning,is)
• 条件概率的估计：

P ^ ( d e e p ) \hat{P}(deep) P^(deep)可以计算为任何以单词"deep"开头的句子的概率，一种方法是统计单词"deep"在数据集中的出现次数，然后除以整个语料库的单词总数
P ^ ( l e a r n i n g ∣ d e e p ) = n ( d e e p , l e a r n i n g ) n ( d e e p ) \hat{P}(learning|deep)=\frac{n(deep,learning)}{n(deep)} P^(learning∣deep)=n(deep)n(deep,learning)

但是对于一些不常见的单词组合，要想找到足够的出现次数来获得准确的估计并不容易。

• 执行某种形式的拉普拉斯平滑：在所有计数中添加一个小常量
  其中 ϵ 1 \epsilon_1 ϵ1、 ϵ 2 \epsilon_2 ϵ2和 ϵ 3 \epsilon_3 ϵ3是超参数。以 ϵ 1 \epsilon_1 ϵ1为例：当 ϵ 1 \epsilon_1 ϵ1为0时，不应用平滑；当 ϵ 1 \epsilon_1 ϵ1接近正无穷大时， P ^ ( x ) \hat{P}(x) P^(x)接近均匀概率分布 1 / m 1/m 1/m。
  P ^ ( x ) = n ( x ) + ϵ 1 / m n + ϵ 1 P ^ ( x ′ ∣ x ) = n ( x , x ′ ) + ϵ 2 P ^ ( x ′ ) n ( x ) + ϵ 2 P ^ ( x ′ ′ ∣ x , x ′ ) = n ( x , x ′ , x ′ ′ ) + ϵ 3 P ^ ( x ′ ′ ) n ( x , x ′ ) + ϵ 3 \hat{P}(x)=\frac{n(x)+\epsilon_1/m}{n+\epsilon_1}\\ \hat{P}(x'|x)=\frac{n(x,x')+\epsilon_2\hat{P}(x')}{n(x)+\epsilon_2}\\ \hat{P}(x''|x,x')=\frac{n(x,x',x'')+\epsilon_3\hat{P}(x'')}{n(x,x')+\epsilon_3} P^(x)=n+ϵ1n(x)+ϵ1/mP^(x′∣x)=n(x)+ϵ2n(x,x′)+ϵ2P^(x′)P^(x′′∣x,x′)=n(x,x′)+ϵ3n(x,x′,x′′)+ϵ3P^(x′′)

拉普拉斯平滑法可以有效处理结构丰富而频率不足的低频词词组，然而这样的模型很容易变得无效：

1. 我们需要存储所有的计数；
2. 完全忽略了单词的意思（例如，"猫"（cat）和"猫科动物"（feline）可能出现在相关的上下文中， 但是想根据上下文调整这类模型其实是相当困难的）；
3. 长单词序列大部分是没出现过的， 因此一个模型如果只是简单地统计先前"看到"的单词序列频率， 那么模型面对这种问题肯定是表现不佳的。

（二）马尔可夫模型与n元语法

如果 P ( x t + 1 ∣ x t , . . . , x 1 ) = P ( x t + 1 ∣ x t ) P(x_{t+1}|x_t,...,x_1)=P(x_{t+1}|x_t) P(xt+1∣xt,...,x1)=P(xt+1∣xt)，则序列上的分布满足一阶马尔可夫性质。阶数越高，对应的依赖关系就越长，由此可以推出许多应用于序列建模的近似公式：
P ( x 1 , x 2 , x 3 , x 4 ) = P ( x 1 ) P ( x 2 ) P ( x 3 ) P ( x 4 ) P ( x 1 , x 2 , x 3 , x 4 ) = P ( x 1 ) P ( x 2 ∣ x 1 ) P ( x 3 ∣ x 2 ) P ( x 4 ∣ x 3 ) P ( x 1 , x 2 , x 3 , x 4 ) = P ( x 1 ) P ( x 2 ∣ x 1 ) P ( x 3 ∣ x 1 , x 2 ) P ( x 4 ∣ x 2 , x 3 ) P(x_1,x_2,x_3,x_4)=P(x_1)P(x_2)P(x_3)P(x_4)\\ P(x_1,x_2,x_3,x_4)=P(x_1)P(x_2|x_1)P(x_3|x_2)P(x_4|x_3)\\ P(x_1,x_2,x_3,x_4)=P(x_1)P(x_2|x_1)P(x_3|x_1,x_2)P(x_4|x_2,x_3) P(x1,x2,x3,x4)=P(x1)P(x2)P(x3)P(x4)P(x1,x2,x3,x4)=P(x1)P(x2∣x1)P(x3∣x2)P(x4∣x3)P(x1,x2,x3,x4)=P(x1)P(x2∣x1)P(x3∣x1,x2)P(x4∣x2,x3)

涉及到一个、两个和三个变量的概率公式分别被称为一元语法、二元语法和三元语法模型，n元语法通过截断相关性，为处理长序列提供了一种实用的模型。

n元语法模型：单词 x t x_t xt在时间步t的条件概率仅取决于前面n-1个单词。

（三）自然语言统计

• 存在许多停用词（stop words），可以被过滤掉
• 词频以一种明确的方式迅速衰减，将前几个单词作为例外消除后，剩余的所有单词大致遵循双对数坐标图上的一条直线，这意味着单词的频率满足齐普夫定律。

（四）读取长序列数据

读取长序列的主要方式是随机采样和顺序分区。在迭代过程中，顺序分区可以保证来自两个相邻的小批量中的子序列在原始序列上也是相邻的。

1. 随机采样
   在随机采样中，每个样本都是在原始的长序列上任意捕获的子序列。 在迭代过程中，来自两个相邻的、随机的、小批量中的子序列不一定在原始序列上相邻。 对于语言建模，目标是基于到目前为止我们看到的词元来预测下一个词元， 因此标签是移位了一个词元的原始序列。
2. 顺序分区
   在迭代过程中，除了对原始序列可以随机抽样外， 我们还可以保证两个相邻的小批量中的子序列在原始序列上也是相邻的。 这种策略在基于小批量的迭代过程中保留了拆分的子序列的顺序，因此称为顺序分区。

四、循环神经网络

（一）隐变量模型

隐变量模型的概念：

n元语法模型中单词 x t x_t xt在时间步t的条件概率仅取决于前面n-1个单词。对于时间步 t − ( n − 1 ) t-(n-1) t−(n−1)之前的单词，如果想要将其可能产生的影响合并到 x t x_t xt上，需要增加n，模型参数的数量也会呈指数增长，因此采用隐变量模型：
P ( x t ∣ x t − 1 , . . . , x 1 ) ≈ P ( x t ∣ h t − 1 ) P(x_t|x_{t-1},...,x_1)\approx P(x_t|h_{t-1}) P(xt∣xt−1,...,x1)≈P(xt∣ht−1)
h t − 1 h_{t-1} ht−1是隐状态（隐藏变量），存储了到时间步t-1的序列信息，可以基于当前输入和先前隐状态来处理时间步t处的任何时间的隐状态：
h t = f ( x t , h t − 1 ) h_t=f(x_t,h_{t-1}) ht=f(xt,ht−1)

隐藏层与隐状态：

隐藏层和隐状态是两个截然不同的概念：

• 隐藏层是在从输入到输出的路径上（以观测角度来理解）的隐藏的层；
• 隐状态是在给定步骤所做的任何事情（以技术角度来定义）的输入， 并且这些状态只能通过先前时间步的数据来计算。

循环神经网络：

循环神经网络（recurrent neural networks，RNNs） 是具有隐状态的神经网络

（二）无隐状态的神经网络

只有单隐藏层的多层感知机：

• 隐藏层的输出： H = ϕ ( X W x h + b h ) H=\phi(XW_{xh}+b_h) H=ϕ(XWxh+bh)
• 输出层： O = H W h q + b q O=HW_{hq}+b_q O=HWhq+bq

（三）有隐状态的神经网络

当前时间步的隐藏变量： H t = ϕ ( X t W x h + H t − 1 W h h + b h ) H_t=\phi(X_tW_{xh}+H_{t-1}W_{hh}+b_h) Ht=ϕ(XtWxh+Ht−1Whh+bh)

隐状态：隐藏变量 H t H_t Ht和 H t − 1 H_{t-1} Ht−1等捕获并保留了序列直到其当前时间步的历史信息， 就如当前时间步下神经网络的状态或记忆， 因此这样的隐藏变量被称为隐状态。

循环：当前时间步隐状态的定义和前一个时间步中的定义相同，因此称为循环的

循环神经网络：基于循环计算的隐状态神经网络

循环层：在循环神经网络中执行计算的层

输出层： O t = H t W h q + b q O_t=H_tW_{hq}+b_q Ot=HtWhq+bq

循环神经网络的参数： W x h W_{xh} Wxh、 W h h W_{hh} Whh、 b h b_h bh、 W h q W_{hq} Whq、 b q b_q bq，由于不同时间步下，循环神经网络也是使用这些模型参数，因此循环神经网络的参数开销不会随着时间步的增加而增加。

（四）基于循环神经网络的字符级语言模型

基于字符级语言建模的循环神经网络， 使用当前的和先前的字符预测下一个字符：

训练过程：对每个时间步的输出层的输出进行softmax操作，然后利用交叉熵损失计算模型输出和标签之间的误差

（五）困惑度Perplexity

一个序列中所有的n个词元的交叉熵损失的平均值:
1 n ∑ t = 1 n − l o g P ( x t ∣ x t − 1 , . . . , x 1 ) \frac{1}{n}\sum_{t=1}^n-logP(x_t|x_{t-1},...,x_1) n1t=1∑n−logP(xt∣xt−1,...,x1)

困惑度的最好的理解是"下一个词元的实际选择数的调和平均数"：
e x p ( − 1 n ∑ t = 1 n l o g P ( x t ∣ x t − 1 , . . . , x 1 ) ) exp(-\frac{1}{n}\sum_{t=1}^nlogP(x_t|x_{t-1},...,x_1)) exp(−n1t=1∑nlogP(xt∣xt−1,...,x1))

我们可以使用困惑度来评价语言模型的质量。

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

1. 独热编码
   每次采样的小批量数据形状是二维张量：（批量大小，时间步数）。one_hot函数将这样一个小批量数据转换成三维张量， 张量的最后一个维度等于词表大小（len(vocab)）。

X = torch.arange(10).reshape((2, 5))
F.one_hot(X.T, 28).shape

我们经常转换输入的维度，以便获得形状为 （时间步数，批量大小，词表大小）的输出。 这将使我们能够更方便地通过最外层的维度， 一步一步地更新小批量数据的隐状态。

2. 初始化模型参数
   隐藏单元数num_hiddens是一个可调的超参数。 当训练语言模型时，输入和输出来自相同的词表。 因此，它们具有相同的维度，即词表的大小。

def get_params(vocab_size, num_hiddens, device):
    num_inputs = num_outputs = vocab_size

    def normal(shape):
        return torch.randn(size=shape, device=device) * 0.01

    # 隐藏层参数
    W_xh = normal((num_inputs, num_hiddens))
    W_hh = normal((num_hiddens, num_hiddens))
    b_h = torch.zeros(num_hiddens, device=device)
    # 输出层参数
    W_hq = normal((num_hiddens, num_outputs))
    b_q = torch.zeros(num_outputs, device=device)
    # 附加梯度
    params = [W_xh, W_hh, b_h, W_hq, b_q]
    for param in params:
        param.requires_grad_(True)
    return params

3. 循环神经网络模型
   为了定义循环神经网络模型， 我们首先需要一个init_rnn_state函数在初始化时返回隐状态。 这个函数的返回是一个张量，张量全用0填充， 形状为（批量大小，隐藏单元数）。

def init_rnn_state(batch_size, num_hiddens, device):
    return (torch.zeros((batch_size, num_hiddens), device=device), )

rnn函数定义了如何在一个时间步内计算隐状态和输出。 循环神经网络模型通过inputs最外层的维度实现循环， 以便逐时间步更新小批量数据的隐状态H。 此外，这里使用tanh函数作为激活函数。 当元素在实数上满足均匀分布时，tanh函数的平均值为0。

def rnn(inputs, state, params):
    # inputs的形状：(时间步数量，批量大小，词表大小)
    W_xh, W_hh, b_h, W_hq, b_q = params
    H, = state
    outputs = []
    # X的形状：(批量大小，词表大小)
    for X in inputs:
        H = torch.tanh(torch.mm(X, W_xh) + torch.mm(H, W_hh) + b_h)
        Y = torch.mm(H, W_hq) + b_q
        outputs.append(Y)
    return torch.cat(outputs, dim=0), (H,)

将函数整合成一个类：

class RNNModelScratch: #@save
    """从零开始实现的循环神经网络模型"""
    def __init__(self, vocab_size, num_hiddens, device,
                 get_params, init_state, forward_fn):
        self.vocab_size, self.num_hiddens = vocab_size, num_hiddens
        self.params = get_params(vocab_size, num_hiddens, device)
        self.init_state, self.forward_fn = init_state, forward_fn

    def __call__(self, X, state):
        X = F.one_hot(X.T, self.vocab_size).type(torch.float32)
        return self.forward_fn(X, state, self.params)

    def begin_state(self, batch_size, device):
        return self.init_state(batch_size, self.num_hiddens, device)

4. 预测
   定义预测函数来生成prefix之后的新字符， 其中的prefix是一个用户提供的包含多个字符的字符串。 在循环遍历prefix中的开始字符时， 我们不断地将隐状态传递到下一个时间步，但是不生成任何输出。 这被称为预热（warm-up）期， 因为在此期间模型会自我更新（例如，更新隐状态）， 但不会进行预测。 预热期结束后，隐状态的值通常比刚开始的初始值更适合预测， 从而预测字符并输出它们。

def predict_ch8(prefix, num_preds, net, vocab, device):  #@save
    """在prefix后面生成新字符"""
    state = net.begin_state(batch_size=1, device=device)
    outputs = [vocab[prefix[0]]]
    get_input = lambda: torch.tensor([outputs[-1]], device=device).reshape((1, 1))
    for y in prefix[1:]:  # 预热期
        _, state = net(get_input(), state)
        outputs.append(vocab[y])
    for _ in range(num_preds):  # 预测num_preds步
        y, state = net(get_input(), state)
        outputs.append(int(y.argmax(dim=1).reshape(1)))
    return ''.join([vocab.idx_to_token[i] for i in outputs])

5. 梯度裁剪
   将梯度 g g g投影回给定半径 （例如 θ \theta θ）的球来裁剪梯度 g g g：
   g ← m i n ( 1 , θ ∣ ∣ g ∣ ∣ ) g g\leftarrow min(1,\frac{\theta}{||g||})g g←min(1,∣∣g∣∣θ)g

优点：梯度范数永远不会超过 θ \theta θ，一定程度上可以修复梯度爆炸，另外更新后的梯度完全与 g g g的原始方向对齐。

def grad_clipping(net, theta):  #@save
    """裁剪梯度"""
    if isinstance(net, nn.Module):
        params = [p for p in net.parameters() if p.requires_grad]
    else:
        params = net.params
    norm = torch.sqrt(sum(torch.sum((p.grad ** 2)) for p in params))
    if norm > theta:
        for param in params:
            param.grad[:] *= theta / norm

6. 训练
   • 序列数据的不同采样方法（随机采样和顺序分区）将导致隐状态初始化的差异。
   • 在更新模型参数之前会裁剪梯度。 这样的操作的目的是，即使训练过程中某个点上发生了梯度爆炸，也能保证模型不会发散。
   • 用困惑度来评价模型，这样的度量确保了不同长度的序列具有可比性。

#@save
def train_epoch_ch8(net, train_iter, loss, updater, device, use_random_iter):
    """训练网络一个迭代周期（定义见第8章）"""
    state, timer = None, d2l.Timer()
    metric = d2l.Accumulator(2)  # 训练损失之和,词元数量
    for X, Y in train_iter:
        if state is None or use_random_iter:
            # 在第一次迭代或使用随机抽样时初始化state
            state = net.begin_state(batch_size=X.shape[0], device=device)
        else:
            if isinstance(net, nn.Module) and not isinstance(state, tuple):
                # state对于nn.GRU是个张量
                state.detach_()
            else:
                # state对于nn.LSTM或对于我们从零开始实现的模型是个张量
                for s in state:
                    s.detach_()
        y = Y.T.reshape(-1)
        X, y = X.to(device), y.to(device)
        y_hat, state = net(X, state)
        l = loss(y_hat, y.long()).mean()
        if isinstance(updater, torch.optim.Optimizer):
            updater.zero_grad()
            l.backward()
            grad_clipping(net, 1)
            updater.step()
        else:
            l.backward()
            grad_clipping(net, 1)
            # 因为已经调用了mean函数
            updater(batch_size=1)
        metric.add(l * y.numel(), y.numel())
    return math.exp(metric[0] / metric[1]), metric[1] / timer.stop()

六、循环神经网络的简洁实现

1. 数据集读取

import torch
from torch import nn
from torch.nn import functional as F
from d2l import torch as d2l

batch_size, num_steps = 32, 35
train_iter, vocab = d2l.load_data_time_machine(batch_size, num_steps)

2. 构造一个具有256个隐藏单元的单隐藏层的循环神经网络层rnn_layer

num_hiddens = 256
rnn_layer = nn.RNN(len(vocab), num_hiddens)

3. 使用张量来初始化隐状态，它的形状是（隐藏层数，批量大小，隐藏单元数）

state = torch.zeros((1, batch_size, num_hiddens))
state.shape

4. 用更新后的隐状态计算输出

X = torch.rand(size=(num_steps, batch_size, len(vocab)))
Y, state_new = rnn_layer(X, state)
Y.shape, state_new.shape

5. 为一个完整的循环神经网络模型定义了一个RNNModel类

#@save
class RNNModel(nn.Module):
    """循环神经网络模型"""
    def __init__(self, rnn_layer, vocab_size, **kwargs):
        super(RNNModel, self).__init__(**kwargs)
        self.rnn = rnn_layer
        self.vocab_size = vocab_size
        self.num_hiddens = self.rnn.hidden_size
        # 如果RNN是双向的（之后将介绍），num_directions应该是2，否则应该是1
        if not self.rnn.bidirectional:
            self.num_directions = 1
            self.linear = nn.Linear(self.num_hiddens, self.vocab_size)
        else:
            self.num_directions = 2
            self.linear = nn.Linear(self.num_hiddens * 2, self.vocab_size)

    def forward(self, inputs, state):
        X = F.one_hot(inputs.T.long(), self.vocab_size)
        X = X.to(torch.float32)
        Y, state = self.rnn(X, state)
        # 全连接层首先将Y的形状改为(时间步数*批量大小,隐藏单元数)
        # 它的输出形状是(时间步数*批量大小,词表大小)。
        output = self.linear(Y.reshape((-1, Y.shape[-1])))
        return output, state

    def begin_state(self, device, batch_size=1):
        if not isinstance(self.rnn, nn.LSTM):
            # nn.GRU以张量作为隐状态
            return  torch.zeros((self.num_directions * self.rnn.num_layers,
                                 batch_size, self.num_hiddens),
                                device=device)
        else:
            # nn.LSTM以元组作为隐状态
            return (torch.zeros((
                self.num_directions * self.rnn.num_layers,
                batch_size, self.num_hiddens), device=device),
                    torch.zeros((
                        self.num_directions * self.rnn.num_layers,
                        batch_size, self.num_hiddens), device=device))

6. 训练与预测

七、通过时间反向传播

（一）通过时间反向传播的概念

1. 通过时间反向传播（backpropagation through time，BPTT） 是循环神经网络中反向传播技术的一个特定应用；
2. 基本流程：
   • 将循环神经网络的计算图一次展开一个时间步，以获得模型变量和参数之间的依赖关系；
   • 基于链式法则，应用反向传播计算和存储梯度。
3. 与传统反向传播的对比
   与传统的反向传播算法不同，BPTT算法需要将误差从输出层向后传播到任意时间步，从而更新网络的权重。这使得BPTT方法可以处理任意长度的序列数据，而其他方法可能无法处理。
4. BPTT的基本思想是将序列数据展开成一个有向无环图（DAG），其中每个时间步对应于图中的一个节点，然后通过反向传播计算损失函数对于每个时间步的梯度。这个梯度信息然后被传播回到网络中，用于更新权重。

（二）循环神经网络的梯度分析

循环神经网络的前向传播和反向传播：

前向传播：一次一个时间步的遍历三元组 ( x t , h t , o t ) (x_t,h_t,o_t) (xt,ht,ot)，然后通过一个目标函数在所有 T T T个时间步内评估输出 o t o_t ot和对应的标签 y t y_t yt之间的差异
L ( x 1 , . . . , x T , y 1 , . . . , y T , w h , w o ) = 1 T ∑ t = 1 T l ( y t , o t ) L(x_1,...,x_T,y_1,...,y_T,w_h,w_o)=\frac{1}{T}\sum_{t=1}^Tl(y_t,o_t) L(x1,...,xT,y1,...,yT,wh,wo)=T1t=1∑Tl(yt,ot)

反向传播：可以使用链式法则递归地计算， 但当t很大时这个链就会变得很长

完全计算： 直接按照链式法则进行递归的计算。但是计算非常缓慢，并且可能会发生梯度爆炸。

截断时间步： 在r步后截断求和计算。在实践中，这种方式工作得很好。 它通常被称为截断的通过时间反向传播。 这样做导致该模型主要侧重于短期影响，而不是长期影响。 这在现实中是可取的，因为它会将估计值偏向更简单和更稳定的模型。

随机截断： 用一个随机变量替换 ∂ h t / ∂ w h \partial h_t/\partial w_h ∂ht/∂wh， 该随机变量在预期中是正确的，但是会截断序列。