0. 前言
目前为止仅接触到两种类型的数据:表格数据和图像数据。 对于图像数据,可以设计专门的卷积神经网络架构来为这类特殊的数据结构建模。 对于一张图像,我们需要有效地利用其像素位置,假若对图像中的像素位置进行重排,就会对图像中内容的推断造成极大的困难。
最重要的是,到目前为止我们默认数据都来自于某种分布, 并且所有样本都是独立同分布的 (independently and identically distributed,i.i.d.)。 然而,大多数的数据并非如此。 例如,文章中的单词是按顺序写的,如果顺序被随机地重排,就很难理解文章原始的意思。 同样,视频中的图像帧、对话中的音频信号以及网站上的浏览行为都是有顺序的。 因此,针对此类数据而设计特定模型,可能效果会更好。
另一个问题是:我们不仅可以接收一个序列作为输入,而且还可能期望继续猜测这个序列的后续。 例如,一个任务可以是继续预测$2, 4, 6, 8, 10, \ldots$。 这在时间序列分析中是相当常见的,可以用来预测股市的波动、 患者的体温曲线或者赛车所需的加速度。 我们需要能够处理这些数据的特定模型。
简言之,如果说卷积神经网络可以有效地处理空间信息, 那么本章介绍的循环神经网络(recurrent neural network,RNN)则可以更好地处理序列信息。 循环神经网络通过引入状态变量存储过去的信息和当前的输入,从而可以确定当前的输出。
许多使用循环网络的例子都是基于文本数据的,因此本章重点介绍语言模型。 主要内容包括对序列数据的详细探讨,文本预处理的实用技术,语言模型的基本概念,循环神经网络的设计方法。 最后会解析循环神经网络的梯度计算方法,以探讨训练此类网络时可能遇到的问题。
对应实践:https://github.com/silenceZheng66/deep_learning/blob/master/d2l/0x09.ipynb
0.1. 结论
- 内插法(在现有观测值之间进行估计)和外推法(对超出已知观测范围进行预测)在实践的难度上差别很大。因此对于所拥有的序列数据,在训练时始终要尊重其时间顺序,即最好不要基于未来的数据进行训练。
- 序列模型的估计需要专门的统计工具,两种较流行的选择是自回归模型和隐变量自回归模型。
- 对于时间是向前推进的因果模型,正向估计通常比反向估计更容易。
- 对于直到时间步$t$的观测序列,其在时间步$t+k$的预测输出是“$k$步预测”。随着对预测时间$k$值的增加,会造成误差的快速累积和预测质量的极速下降。
- 文本是序列数据的一种最常见的形式之一。
- 为了对文本进行预处理,通常将文本拆分为词元,构建词表将词元字符串映射为数字索引,并将文本数据转换为词元索引以供模型操作。
- 语言模型是自然语言处理的关键。
- $n$元语法通过截断相关性,为处理长序列提供了一种实用的模型。
- 长序列存在一个问题:很少出现或者从不出现。
- 齐普夫定律支配着单词的分布,这个分布不仅适用于一元语法,还适用于其他元语法。
- 通过拉普拉斯平滑法可以有效地处理结构丰富而频率不足的低频词词组。
- 读取长序列的主要方式是随机采样和顺序分区。在迭代过程中,后者可以保证来自两个相邻的小批量中的子序列在原始序列上也是相邻的。
- 对隐状态使用循环计算的神经网络称为循环神经网络(RNN)。
- 循环神经网络的隐状态可以捕获直到当前时间步序列的历史信息。
- 循环神经网络模型的参数数量不会随着时间步的增加而增加。
- 可以使用循环神经网络创建字符级语言模型。
- 可以使用困惑度来评价语言模型的质量。
- 可以训练一个基于循环神经网络的字符级语言模型,根据用户提供的文本的前缀生成后续文本。
- 一个简单的循环神经网络语言模型包括输入编码、循环神经网络模型和输出生成。
- 循环神经网络模型在训练以前需要初始化状态,不过随机抽样和顺序采样使用初始化方法不同。
- 当使用顺序采样时,我们需要分离梯度以减少计算量。
- 在进行任何预测之前,模型通过预热期进行自我更新(例如,获得比初始值更好的隐状态)。
- 梯度裁剪可以防止梯度爆炸,但不能应对梯度消失。
- 深度学习框架的高级API提供了循环神经网络层的实现。
- 高级API的循环神经网络层返回一个输出和一个更新后的隐状态,我们还需要计算整个模型的输出层。
- 相比从零实现的循环神经网络,使用高级API实现可以加速训练。
- “通过时间反向传播”仅仅适用于反向传播在具有隐状态的序列模型。
- 截断是计算方便性和数值稳定性的需要。截断包括:规则截断和随机截断。
- 矩阵的高次幂可能导致神经网络特征值的发散或消失,将以梯度爆炸或梯度消失的形式表现。
- 为了计算的效率,“通过时间反向传播”在计算期间会缓存中间值。
1. 序列模型
想象一下有人正在看网飞(Netflix)上的电影。一名忠实的用户会对每一部电影都给出评价,毕竟一部好电影需要更多的支持和认可。然而事实上随着时间的推移,人们对电影的看法会发生很大的变化。心理学家对这些现象起了名字:
- 锚定(anchoring)效应:基于其他人的意见做出评价。例如,奥斯卡颁奖后,受到关注的电影的评分会上升,尽管它还是原来那部电影。这种影响将持续几个月,直到人们忘记了这部电影曾经获得的奖项。结果表明,这种效应会使评分提高半个百分点以上。
- 享乐适应(hedonic adaption):人们迅速接受并且适应一种更好或者更坏的情况作为新的常态。例如,在看了很多好电影之后,人们会强烈期望下部电影会更好。因此在看过许多精彩电影后,一部普通的电影也可能被认为是糟糕的。
- 季节性(seasonality):少有观众喜欢在八月看圣诞老人的电影。
- 有时,电影会由于导演或演员在制作中的不当行为变得不受欢迎。
- 有些电影因为其极度糟糕只能成为小众电影。
简而言之,电影评分决不是固定不变的。因此,使用时间动力学可以得到更准确的电影推荐。当然,序列数据不仅仅是关于电影评分的。下面给出了更多的场景。
- 在使用程序时,许多用户都有很强的特定习惯。例如,在学生放学后社交媒体应用更受欢迎。在市场开放时股市交易软件更常用。
- 预测明天的股价要比过去的股价更困难,尽管两者都只是估计一个数字。在统计学中,前者(对超出已知观测范围进行预测)称为外推法(extrapolation),而后者(在现有观测值之间进行估计)称为内插法(interpolation)。
- 在本质上,音乐、语音、文本和视频都是连续的。如果它们的序列被重排,那么就会失去原有的意义。比如,一个文本标题“狗咬人”远没有“人咬狗”那么令人惊讶,尽管组成两句话的字完全相同。
- 地震具有很强的相关性,即大地震发生后,很可能会有几次小余震,这些余震的强度比非大地震后的余震要大得多。事实上,地震是时空相关的,即余震通常发生在很短的时间跨度和很近的距离内。
- 人类之间的互动也是连续的,这可以从微博上的争吵和辩论中看出。
1.1. 统计工具
处理序列数据需要统计工具和新的深度神经网络架构。 为了简单起见,以下图所示的股票价格(富时100指数)为例。
其中,用$x_t$表示价格,即在时间步(time step)$t \in \mathbb{Z}^+$时,观察到的价格$x_t$。注意$t$对于本文中的序列通常是离散的,并在整数或其子集上变化。假设一个交易员想在$t$日的股市中表现良好,于是通过以下途径预测$x_t$:
1.1.1. 自回归模型
为了实现这个预测,交易员可以使用回归模型(例如最简单的线性回归)。这里仅有一个主要问题:输入数据的数量,输入$x_{t-1}, \ldots, x_1$本身因$t$而异。也就是说,输入数据的数量这个数字将会随着我们遇到的数据量的增加而增加,因此需要一个近似方法来使这个计算变得容易处理。本章后面的大部分内容将围绕着如何有效估计$P(x_t \mid x_{t-1}, \ldots, x_1)$展开。简单地说,它归结为以下两种策略。
第一种策略,假设在现实情况下相当长的序列$x_{t-1}, \ldots, x_1$可能是不必要的,则只需要满足某个长度为$\tau$的时间跨度,即使用观测序列$x_{t-1}, \ldots, x_{t-\tau}$。当下获得的最直接的好处就是参数的数量总是不变的,至少在$t > \tau$时如此,这就使我们能够训练一个上述的深度网络。这种模型被称为自回归模型(autoregressive models),因为它们是对自己执行回归。
第二种策略,如下图所示,是保留一些对过去观测的总结$h_t$,并且同时更新预测$\hat{x}_t$和总结$h_t$。这就产生了基于$\hat{x}_t = P(x_t \mid h_{t})$估计$x_t$,以及公式$h_t = g(h_{t-1}, x_{t-1})$更新的模型。由于$h_t$从未被观测到,这类模型也被称为隐变量自回归模型(latent autoregressive models)。
这两种策略有一个显而易见的问题:如何生成训练数据?一个经典方法是使用历史观测来预测下一个未来观测。我们并不指望时间会停滞不前,但一个常见的假设是虽然特定值$x_t$可能会改变,但是序列本身的动力学不会改变。这样的假设是合理的,因为新的动力学一定受新的数据影响,而人们不可能用目前所掌握的数据来预测新的动力学。统计学家称不变的动力学为静止的(stationary)。因此,整个序列的估计值都将通过以下的方式获得:
注意,如果我们处理的是离散的对象(如单词),而不是连续的数字,则上述的考虑仍然有效。唯一的差别是,对于离散的对象,需要使用分类器而不是回归模型来估计条件概率$P(x_t \mid x_{t-1}, \ldots, x_1)$。
1.1.2. 马尔可夫模型
在自回归模型的近似法中使用$x_{t-1}, \ldots, x_{t-\tau}$而不是$x_{t-1}, \ldots, x_1$来估计$x_t$。只要这种是近似精确的,我们就说序列满足马尔可夫条件(Markov condition)。特别是,如果$\tau = 1$,得到一个一阶马尔可夫模型(first-order Markov model),$P(x)$由下式给出:
当假设$x_t$仅是离散值时,这样的模型特别棒,因为在这种情况下,使用动态规划可以沿着马尔可夫链精确地计算结果。例如可以高效地计算$P(x_{t+1} \mid x_{t-1})$:
利用这一事实,我们只需要考虑过去观察中的一个非常短的历史片段:$P(x_{t+1} \mid x_t, x_{t-1}) = P(x_{t+1} \mid x_t)$。隐马尔可夫模型中的动态规划超出了本节的范围,而动态规划这些计算工具已经在控制算法和强化学习算法广泛使用。
1.1.3. 因果关系
原则上,将$P(x_1, \ldots, x_T)$倒序展开也没什么问题。毕竟,基于条件概率公式总是可以写出:
事实上,如果基于一个马尔可夫模型,我们还可以得到一个反向的条件概率分布。但在许多情况下,数据存在一个自然的方向,即在时间上是前进的。未来的事件不能影响过去。因此,如果我们改变$x_t$,可能会影响未来发生的事情$x_{t+1}$,但不能反过来。也就是说,如果我们改变$x_t$,基于过去事件得到的分布不会改变。因此,解释$P(x_{t+1} \mid x_t)$应该比解释$P(x_t \mid x_{t+1})$更容易。例如在某些情况下,对于某些可加性噪声$\epsilon$,我们可以找到$x_{t+1} = f(x_t) + \epsilon$,而反之则不行。这个向前推进的方向恰好也是比较有用的方向。彼得斯等人对该主题的更多内容做了详尽的解释。
1.2. 训练
在实践中尝试一下上述统计工具。首先生成一些数据:使用正弦函数和一些可加性噪声来生成序列数据,时间步为$1, 2, \ldots, 1000$。
1 | import torch |
接下来将这个序列转换为模型的特征-标签(feature-label)对。基于嵌入维度$\tau$将数据映射为数据对$y_t = x_t$和$\mathbf{x}_t = [x_{t-\tau}, \ldots, x_{t-1}]$。这比我们提供的数据样本少了$\tau$个,因为我们没有足够的历史记录来描述前$\tau$个数据样本。一个简单的解决办法是:如果拥有足够长的序列就丢弃这几项;另一个方法是用零填充序列。这里我们仅使用前600个“特征-标签”对进行训练。
1 | # 嵌入维度 τ,决定了特征向量的维度(特征数和样本个数)。 |
这里使用一个相当简单的架构训练模型: 一个拥有两个全连接层的多层感知机,ReLU激活函数和平方损失。
1 | # 初始化网络权重的函数 |
现在训练模型,实现下面的训练代码的方式与前面几节中的循环训练基本相同。
1 | def train(net, train_iter, loss, epochs, lr): |
1.3. 预测
前面训练的损失很小,则可以期望模型有很好的工作效果。首先是检查模型预测下一个时间步的能力, 也就是单步预测(one-step-ahead prediction)。
1 | onestep_preds = net(features) |
可以看到确实单步预测效果不错。即使这些预测的时间步超过了$600+4$(n_train + tau
),其结果看起来仍然是可信的。然而有一个小问题:如果数据观察序列的时间步只到$604$,我们需要一步一步地向前迈进:
通常,对于直到$x_t$的观测序列,其在时间步$t+k$处的预测输出$\hat{x}_{t+k}$称为$k$步预测($k$-step-ahead-prediction)。由于观察已经到了$x_{604}$,它的$k$步预测是$\hat{x}_{604+k}$。则我们必须使用自己的预测(而不是原始数据)来进行多步预测,看效果如何:
1 | multistep_preds = torch.zeros(T) |
如上图所示,绿线的预测显然并不理想。经过几个预测步骤之后,预测的结果很快就会衰减到一个常数。这个算法效果如此差是由于错误的累积:假设在步骤$1$之后,我们积累了一些错误$\epsilon_1 = \bar\epsilon$。于是,步骤$2$的输入被扰动了$\epsilon_1$,结果积累的误差是依照次序的$\epsilon_2 = \bar\epsilon + c \epsilon_1$,其中$c$为某个常数,后面的预测误差依此类推。因此误差可能会相当快地偏离真实的观测结果。例如,未来$24$小时的天气预报往往相当准确,但超过这一点,精度就会迅速下降。本章及后续章节中将讨论如何改进这一点。
基于$k = 1, 4, 16, 64$,通过对整个序列预测的计算,来更仔细地看一下$k$步预测的困难。
1 | max_steps = 64 |
上图清楚地说明了当试图预测更远的未来时,预测的质量是如何变化的。 虽然“4步预测”看起来仍然不错,但超过这个跨度的任何预测几乎都是无用的。
2. 文本预处理
对于序列数据处理问题,上节中评估了所需的统计工具和预测时面临的挑战。 这样的数据存在许多种形式,文本是最常见例子之一。 例如,一篇文章可以被简单地看作是一串单词序列,甚至是一串字符序列。 本节将解析文本的常见预处理步骤。 这些步骤通常包括:
- 将文本作为字符串加载到内存中。
- 将字符串拆分为词元(如单词和字符)。
- 建立一个词表,将拆分的词元映射到数字索引。
- 将文本转换为数字索引序列,方便模型操作。
1 | import collections |
2.1. 读取数据集
首先从H.G.Well的《时光机器》中加载文本。 这是一个相当小的语料库,只有30000多个单词, 而现实中的文档集合可能会包含数十亿个单词。 下面的函数将数据集读取到由多条文本行组成的列表中,其中每条文本行都是一个字符串。 为简单起见这里忽略了标点符号和字母大写。
1 | # d2l.DATA_HUB、d2l.DATA_URL |
2.2. 词元化
tokenize
函数将文本行列表(lines
)作为输入,列表中的每个元素是一个文本序列(如一条文本行)。每个文本序列又被拆分成一个词元列表,词元(token)是文本的基本单位(单词或字母)。最后,返回一个由词元列表组成的列表,其中的每个词元都是一个字符串(string)。
1 | def tokenize(lines, token='word'): |
2.3. 词表
词元的类型是字符串,而模型需要的输入是数字,所以我们需要构建一个字典,通常也叫做词表(vocabulary),用来将字符串类型的词元映射到从$0$开始的数字索引中。首先将训练集中的所有文档合并在一起,对它们的唯一词元进行统计,得到的统计结果称之为语料(corpus)。然后根据每个唯一词元的出现频率,为其分配一个数字索引。很少出现的词元通常被移除,这可以降低复杂性。另外,语料库中不存在或已删除的任何词元都将映射到一个特定的未知词元“<unk>”。我们可以选择增加一个列表,用于保存那些被保留的词元,例如:填充词元(“<pad>”);序列开始词元(“<bos>”);序列结束词元(“<eos>”)。1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69class Vocab:
"""文本词表"""
def __init__(self, tokens=None, min_freq=0, reserved_tokens=None):
if tokens is None:
tokens = []
if reserved_tokens is None:
reserved_tokens = []
# 获取词元展平后的Counter对象。
counter = count_corpus(tokens)
# 私有变量,词元频率(事实上是伪私有)
# 按出现频率排序,sorted() 函数用于对所有可迭代的对象进行排序操作。
# counter.items()等同于字典的items()函数,返回一个可迭代的集合数据结构
# 参数key是用来进行比较的元素,指定可迭代对象中的一个元素来进行排序,这里指的是每一个tuple中的第二个元素,即频率
# reverse参数:True为降序,False为升序,默认False
self._token_freqs = sorted(counter.items(), key=lambda x: x[1],
reverse=True)
# 生成词元列表
# 左加使未知词元的索引为0, 如:['<unk>', ...]
self.idx_to_token = ['<unk>'] + reserved_tokens
# 生成词元与索引对应的字典
self.token_to_idx = {token: idx
for idx, token in enumerate(self.idx_to_token)}
for token, freq in self._token_freqs:
if freq < min_freq:
break
# 发现新词,在词元列表中加入该词,然后在词元-索引字典中添加该词及其索引
if token not in self.token_to_idx:
self.idx_to_token.append(token)
self.token_to_idx[token] = len(self.idx_to_token) - 1
def __len__(self):
return len(self.idx_to_token)
# 定义该方法使得Vocab类可以以 p[key] 的方式取值
# 此处‘key’的格式可以为单个词、list或tuple
def __getitem__(self, tokens):
# 单个词
if not isinstance(tokens, (list, tuple)):
# 如果查找不到则返回频率0
return self.token_to_idx.get(tokens, self.unk)
# 可遍历对象,返回一个频率列表
return [self.__getitem__(token) for token in tokens]
# 接受索引返回词元
def to_tokens(self, indices):
if not isinstance(indices, (list, tuple)):
return self.idx_to_token[indices]
return [self.idx_to_token[index] for index in indices]
# property装饰器,可以直接通过方法名来访问方法,不需要在方法名后添加圆括号“()”
# 如:vacab.unk、vacab.token_freqs
# 相当于getter方法,访问私有成员的接口
def unk(self): # 未知词元的索引为0
return 0
def token_freqs(self):
return self._token_freqs
def count_corpus(tokens):
"""统计词元的频率"""
# 这里的tokens是1D列表或2D列表
if len(tokens) == 0 or isinstance(tokens[0], list):
# 将词元列表展平成一个列表
tokens = [token for line in tokens for token in line]
# 返回一个Counter对象,该对象是一个高性能的容器数据类型,有许多作用
# 对于取频率这件事,直接dict(counter)就可以得到频率字典。
return collections.Counter(tokens)
使用时光机器数据集作为语料库来构建词表,然后打印前几个高频词元及其索引:1
2
3
4
5vocab = Vocab(tokens)
print(list(vocab.token_to_idx.items())[:10])
输出:
[('<unk>', 0), ('the', 1), ('i', 2), ('and', 3), ('of', 4), ('a', 5), ('to', 6), ('was', 7), ('in', 8), ('that', 9)]
可以将每一条文本行转换成一个数字索引列表:
1 | for i in [0, 10]: |
2.4. 功能整合
将所有功能打包到load_corpus_time_machine函数中, 该函数返回corpus(词元索引列表)和vocab(时光机器语料库的词表)。有两点需要注意:
- 为了简化后面章节中的训练,使用字符(而不是单词)实现文本词元化;
- 时光机器数据集中的每个文本行不一定是一个句子或一个段落,还可能是一个单词,因此返回的corpus展平为一维列表,而不是由多词元列表构成的一个列表。
1 | def load_corpus_time_machine(max_tokens=-1): |
3. 语言模型和数据集
假设长度为$T$的文本序列中的词元依次为$x_1, x_2, \ldots, x_T$。则$x_t$($1 \leq t \leq T$)可以被认为是文本序列在时间步$t$处的观测或标签。在给定这样的文本序列时,语言模型(language model)的目标是估计序列的联合概率:
例如,一个理想的语言模型只需一次抽取一个词元$x_t \sim P(x_t \mid x_{t-1}, \ldots, x_1)$就能够基于模型本身生成自然文本。从这样的模型中提取的文本都将作为自然语言来传递。只需要基于前面的对话片断中的文本,就足以生成一个有意义的对话。显然,我们离设计出这样的系统还很遥远,因为它需要“理解”文本,而不仅仅是生成语法合理的内容。
尽管如此,语言模型依然是非常有用的。例如,短语“to recognize speech”和“to wreck a nice beach”读音上听起来非常相似。这种相似性会导致语音识别中的歧义,但是这很容易通过语言模型来解决,因为第二句的语义很奇怪。同样,在文档摘要生成算法中,“狗咬人”比“人咬狗”出现的频率要高得多,或者“我想吃奶奶”是一个相当匪夷所思的语句,而“我想吃,奶奶”则要正常得多。
3.1. 学习语言模型
我们面对的问题是如何对一个文档,甚至是一个词元序列进行建模。假设在单词级别对文本数据进行词元化,可以依靠之前对序列模型的分析,从基本概率规则开始:
例如,包含了四个单词的一个文本序列的概率是:
为训练语言模型,需要计算单词的概率,以及给定前面几个单词后出现某个单词的条件概率。这些概率本质上就是语言模型的参数。
这里假设训练数据集是一个大型的文本语料库。比如维基百科的所有条目或者所有发布在网络上的文本。训练数据集中词的概率可以根据给定词的相对词频来计算。比如可以将估计值$\hat{P}(\text{deep})$计算为任何以单词“deep”开头的句子的概率。另一种(不太精确的)方法是统计单词“deep”在数据集中的出现次数,然后将其除以整个语料库中的单词总数。这种方法效果不错,特别是对于频繁出现的单词。
接下来可以尝试估计:
其中$n(x)$和$n(x, x’)$分别是单个单词和连续单词对的出现次数。由于连续单词对“deep learning”的出现频率要低得多,所以估计这类单词正确的概率要困难得多。特别是对于一些不常见的单词组合,要想找到足够的出现次数来获得准确的估计并不容易。而对于三个或者更多的单词组合,情况会变得更糟。许多合理的三个单词组合可能是存在的,但是在数据集中却找不到。除非有某种策略,来将这些单词组合指定为非零计数,否则将无法在语言模型中使用它们。如果数据集很小,或者单词非常罕见,那么这类单词出现一次的机会可能都找不到。
一种常见的策略是执行某种形式的拉普拉斯平滑(Laplace smoothing),具体方法是在所有计数中添加一个小常量。用$n$表示训练集中的单词总数,用$m$表示唯一单词的数量。此解决方案有助于处理单元素问题,例如通过:
其中,$\epsilon_1,\epsilon_2$和$\epsilon_3$是超参数。以$\epsilon_1$为例:当$\epsilon_1 = 0$时,不应用平滑;当$\epsilon_1$接近正无穷大时,$\hat{P}(x)$接近均匀概率分布$1/m$(可能是常数都忽略,然后上下消掉超参数)。上面的公式是文章的一个相当原始的变形。
但这样的模型很容易变得无效,原因如下:
1、模型需要存储所有的计数;
2、模型完全忽略了单词的意思。例如,“猫”(cat)和“猫科动物”(feline)可能出现在相关的上下文中,但是想根据上下文调整这类模型其实是相当困难的。
3、长单词序列大部分是没出现过的,因此一个模型如果只是简单地统计先前“看到”的单词序列频率,那么模型面对这种问题肯定是表现不佳的。
3.2. 马尔可夫模型与$n$元语法
回想一下马尔可夫模型,并且将其应用于语言建模。如果$P(x_{t+1} \mid x_t, \ldots, x_1) = P(x_{t+1} \mid x_t)$,则序列上的分布满足一阶马尔可夫性质。阶数越高,对应的依赖关系就越长。这种性质推导出了许多可以应用于序列建模的近似公式:
这里说一下我个人的理解,第一行的含义为“各个时刻的数据独立,与之前发生的事无关”,这与通过计数统计和平滑来建模单词的想法是一致的;第二行满足一阶马尔可夫性质,含义为“t时刻发生的概率或许可仅用t前一个时刻发生的事来断定”;第三行依赖关系更长,也就是满足二阶马尔可夫性质,含义为“t时刻发生的概率或许可仅用t前两个时刻发生的事来断定”。
事实上,上面的三个式子分别对应一、二、三元语法,涉及一个、两个和三个变量的概率公式分别被称为一元语法(unigram)、二元语法(bigram)和三元语法(trigram)模型。下面将学习如何去设计更好的模型。
3.3. 自然语言统计
学习在真实数据上如何进行自然语言统计。根据时光机器数据集构建词表,并打印前$10$个最常用的(频率最高的)单词。
1 | import random |
最流行的词看起来很无聊,这些词被称为停用词(stop words),因此可以被过滤掉。但它们本身仍然是有意义的,我们仍然会在模型中使用它们。另一个明显的问题是词频衰减的速度非常快,第$10$个还不到第$1$个的$1/5$。为了更好地理解,可以画出的词频图:
1 | freqs = [freq for token, freq in vocab.token_freqs] |
可以发现:词频以一种明确的方式迅速衰减。将前几个单词作为例外消除后,剩余的所有单词大致遵循双对数坐标图上的一条直线。这意味着单词的频率满足齐普夫定律(Zipf’s law),即第$i$个最常用单词的频率$n_i$为:
等价于
其中$\alpha$是刻画分布的指数,$c$是常数。这说明想要通过计数统计和平滑来建模单词是不可行的,这样建模的结果会大大高估尾部单词的频率,也就是所谓的不常用单词。那么其他的词元组合,比如二元语法、三元语法等等,又会如何呢?来看看二元语法的频率是否与一元语法的频率表现出相同的行为方式。
1 | # 一个去尾,一个掐头,然后zip在一起,读tuple出来 |
这里值得注意:在十个最频繁的词对中,有九个是由两个停用词组成的, 只有一个与“the time”有关。 下面再进一步看看三元语法的频率是否表现出相同的行为方式:
1 | # 去尾两个、掐头去尾、掐头两个,然后zip在一起 |
直观地对比三种模型中的词元频率:一元语法、二元语法和三元语法:
1 | bigram_freqs = [freq for token, freq in bigram_vocab.token_freqs] |
这张图非常令人振奋!可以得到以下结论:
1、除了一元语法词,单词序列似乎也遵循齐普夫定律,尽管其中的指数$\alpha$更小(指数的大小受序列长度的影响);
2、词表中$n$元组的数量并没有那么大,这说明语言中存在相当多的结构,这些结构给了我们应用模型的希望;
3、很多$n$元组很少出现,这使得拉普拉斯平滑非常不适合语言建模。作为代替,我们将使用基于深度学习的模型。
3.4. 读取长序列数据
由于序列数据本质上是连续的,在处理数据时需要解决这个问题。在文章的开头我们以一种相当特别的方式做到了这一点:当序列变得太长而不能被模型一次性全部处理时,可能去拆分这样的序列方便模型读取。
介绍模型前说一下总体策略:假设使用神经网络来训练语言模型,模型中的网络一次处理具有预定义长度(例如$n$个时间步)的一个小批量序列。现在的问题是如何随机生成一个小批量数据的特征和标签以供读取。
首先,由于文本序列可以是任意长的(如整本《时光机器》),则任意长的序列可以被划分为具有相同时间步数的子序列。当训练神经网络时,这样的小批量子序列将被输入到模型中。假设网络一次只处理具有$n$个时间步的子序列。 下图画出了从原始文本序列获得子序列的所有不同的方式,其中$n=5$,并且每个时间步的词元对应一个字符。我们可以选择任意偏移量来指示初始位置,所以有相当大的自由度。
那应该从图中选择哪一个呢?事实上他们都一样好。但如果我们只选择一个偏移量,那么用于训练网络的、所有可能的子序列的覆盖范围将是有限的。因此可以从随机偏移量开始划分序列,以同时获得覆盖性(coverage)和随机性(randomness)。下面将描述如何实现随机采样(random sampling)和顺序分区(sequential partitioning)策略。
3.4.1. 随机采样
在随机采样中,每个样本都是在原始的长序列上任意捕获的子序列。 在迭代过程中,来自两个相邻的、随机的、小批量中的子序列不一定在原始序列上相邻。 对于语言建模,目标是基于到目前为止我们看到的词元来预测下一个词元, 因此标签是移位了一个词元的原始序列(右移,或者说后移)。
下面的代码每次可以从数据中随机生成一个小批量,参数batch_size指定了每个小批量中子序列样本的数目, 参数num_steps是每个子序列中预定义的时间步数:
1 | def seq_data_iter_random(corpus, batch_size, num_steps): |
下面生成一个从$0$到$34$的序列。假设批量大小为$2$,时间步数为$5$,则可以生成$\lfloor (35 - 1) / 5 \rfloor= 6$个“特征-标签”子序列对。如果设置小批量大小为$2$,就只能得到$3$个小批量。
1 | my_seq = list(range(35)) |
3.4.2. 顺序分区
在迭代过程中,除了对原始序列可以随机抽样外,还可以保证两个相邻的小批量中的子序列在原始序列上也是相邻的。 这种策略在基于小批量的迭代过程中保留了拆分的子序列的顺序,因此称为顺序分区。
1 | def seq_data_iter_sequential(corpus, batch_size, num_steps): |
基于相同的设置,通过顺序分区读取每个小批量的子序列的特征X和标签Y。 可以看到迭代期间来自两个相邻的小批量中的子序列在原始序列中确实是相邻的。
1 | for X, Y in seq_data_iter_sequential(my_seq, batch_size=2, num_steps=5): |
将上面的两个采样函数包装到一个类中, 以便稍后可以将其用作数据迭代器:
1 | class SeqDataLoader: |
最后定义一个函数load_data_time_machine, 它同时返回数据迭代器和词表, 因此可以与其他带有load_data前缀的函数 (如d2l.load_data_fashion_mnist)类似地使用。
1 | def load_data_time_machine(batch_size, num_steps, |
4. 循环神经网络
上节中介绍了$n$元语法模型,其中单词$x_t$在时间步$t$的条件概率仅取决于前面$n-1$个单词。对于时间步$t-(n-1)$之前的单词,如果想将其可能产生的影响合并到$x_t$上,需要增加$n$的值,此时模型参数的数量也会随之呈指数增长,因为词表$\mathcal{V}$需要存储$|\mathcal{V}|^n$个数字,因此与其将$P(x_t \mid x_{t-1}, \ldots, x_{t-n+1})$模型化,不如使用隐变量模型:
其中$h_{t-1}$是隐状态(hidden state),也称为隐藏变量(hidden variable),它存储了到时间步$t-1$的序列信息。通常我们可以基于当前输入$x_{t}$和先前隐状态$h_{t-1}$来计算时间步$t$处的任何时间的隐状态:
对于函数$f$,隐变量模型不是近似值(这句没看懂)。$h_t$可以存储到目前为止观察到的所有数据,但这样的操作可能会使计算和存储的代价提高。
值得注意的是,具有隐藏单元的隐藏层和隐状态是两个截然不同的概念。隐藏层是在从输入到输出的路径上(主要以观测角度来理解,实际上也是层)的隐藏的层,而隐状态则是在给定步骤所做的任何事情(是以技术角度来定义,存在精心设计)的输入,并且这些状态只能通过先前时间步的数据来计算。
循环神经网络(recurrent neural networks,RNNs)是具有隐状态的神经网络。在介绍循环神经网络模型之前,先回顾一下多层感知机模型。
4.1. 无隐状态的神经网络
对单隐藏层的多层感知机。设隐藏层的激活函数为$\phi$,给定一个小批量样本$\mathbf{X} \in \mathbb{R}^{n \times d}$,其中批量大小为$n$,输入维度为$d$,则隐藏层的输出$\mathbf{H} \in \mathbb{R}^{n \times h}$通过下式计算:
上式中,隐藏层权重参数为$\mathbf{W}_{xh} \in \mathbb{R}^{d \times h}$,偏置参数为$\mathbf{b}_h \in \mathbb{R}^{1 \times h}$,以及隐藏单元的数目为$h$。因此求和时可以应用广播机制。接下来,将隐藏变量$\mathbf{H}$用作输出层的输入。输出层由下式给出:
其中,$\mathbf{O} \in \mathbb{R}^{n \times q}$是输出变量,$\mathbf{W}_{hq} \in \mathbb{R}^{h \times q}$是权重参数,$\mathbf{b}_q \in \mathbb{R}^{1 \times q}$是输出层的偏置参数。如果是分类问题,可以用$\text{softmax}(\mathbf{O})$来计算输出类别的概率分布。
对于这种网络,只要可以随机选择“特征-标签”对,并且通过自动微分和随机梯度下降能够学习网络参数就可以了。
4.2. 有隐状态的循环神经网络
有了隐状态后,情况就完全不同了。假设在时间步$t$有小批量输入$\mathbf{X}_t \in \mathbb{R}^{n \times d}$。也就是对$n$个序列样本的小批量,$\mathbf{X}_t$的每一行对应于来自该序列的时间步$t$处的一个样本($n \times d$)。接下来,用$\mathbf{H}_t \in \mathbb{R}^{n \times h}$表示时间步$t$的隐藏变量。与多层感知机不同的是,这里保存了前一个时间步的隐藏变量$\mathbf{H}_{t-1}$,并引入了一个新的权重参数$\mathbf{W}_{hh} \in \mathbb{R}^{h \times h}$,来描述如何在当前时间步中使用前一个时间步的隐藏变量。当前时间步隐藏变量由 当前时间步的输入 与 前一个时间步的隐藏变量 一起计算得出:
与无隐状态的情况相比,上式多添加了一项$\mathbf{H}_{t-1} \mathbf{W}_{hh}$,从而实例化了开头提到的公式:$h_t = f(x_{t}, h_{t-1})$。从相邻时间步的隐藏变量$\mathbf{H}_t$和$\mathbf{H}_{t-1}$之间的关系可知,这些变量捕获并保留了(通过作为参数参与下一次计算的方式)序列直到其当前时间步的历史信息,如同当前时间步下神经网络的状态或记忆,因此这些隐藏变量被称为隐状态(hidden state)。由于在当前时间步中,隐状态使用的定义与前一个时间步中使用的定义相同,所以上式中的计算是循环的(recurrent)。基于循环计算的隐状态神经网络被命名为循环神经网络(recurrent neural network)。在循环神经网络中执行上式隐状态计算的层称为循环层(recurrent layer)。
有许多不同的方法可以构建循环神经网络,上式定义的隐状态的循环神经网络是其中常见的一种。对于时间步$t$,输出层的输出类似于多层感知机中的计算:
循环神经网络的参数包括隐藏层的权重$\mathbf{W}_{xh} \in \mathbb{R}^{d \times h}, \mathbf{W}_{hh} \in \mathbb{R}^{h \times h}$和偏置$\mathbf{b}_h \in \mathbb{R}^{1 \times h}$,以及输出层的权重$\mathbf{W}_{hq} \in \mathbb{R}^{h \times q}$和偏置$\mathbf{b}_q \in \mathbb{R}^{1 \times q}$。在不同的时间步上,循环神经网络也使用这些相同模型参数。因此,循环神经网络的参数开销不会随着时间步的增加而增加。
下图展示了循环神经网络在三个相邻时间步的计算逻辑。在任意时间步$t$,隐状态的计算可以被视为:
- 拼接当前时间步$t$的输入$\mathbf{X}_t$和前一时间步$t-1$的隐状态$\mathbf{H}_{t-1}$;
- 将拼接的结果送入带有激活函数$\phi$的全连接层。全连接层的输出是当前时间步$t$的隐状态$\mathbf{H}_t$。
图中,模型参数是$\mathbf{W}_{xh}$和$\mathbf{W}_{hh}$的拼接(concat),以及$\mathbf{b}_h$的偏置。当前时间步$t$的隐状态$\mathbf{H}_t$将参与计算下一时间步$t+1$的隐状态$\mathbf{H}_{t+1}$。而且$\mathbf{H}_t$还将送入全连接输出层,用于计算当前时间步$t$的输出$\mathbf{O}_t$。
刚才提到,隐状态中$\mathbf{X}_t \mathbf{W}_{xh} + \mathbf{H}_{t-1} \mathbf{W}_{hh}$的计算,相当于$\mathbf{X}_t$和$\mathbf{H}_{t-1}$的拼接与$\mathbf{W}_{xh}$和$\mathbf{W}_{hh}$的拼接的矩阵乘法。这个性质可以通过数学证明,下面使用一个简单的代码来说明一下。
首先定义矩阵X
、W_xh
、H
和W_hh
,它们的形状分别为$(3,1)$、$(1,4)$、$(3,4)$和$(4,4)$。分别将X
乘以W_xh
,将H
乘以W_hh
,然后将这两个乘法相加,得到一个形状为$(3,4)$的矩阵。
1 | import torch |
现在沿列(轴1)拼接矩阵X
和H
,沿行(轴0)拼接矩阵W_xh
和W_hh
。这两个拼接分别产生形状$(3, 5)$和形状$(5, 4)$的矩阵。再将这两个拼接的矩阵相乘,可得到与上面相同形状$(3, 4)$的输出矩阵
1 | torch.matmul(torch.cat((X, H), 1), torch.cat((W_xh, W_hh), 0)) |
4.3. 基于循环神经网络的字符级语言模型
回想一下3中的语言模型,我们的目标是根据过去的和当前的词元预测下一个词元,因此将原始序列移位一个词元作为标签。Bengio等人首先提出使用神经网络进行语言建模。下面看一下如何使用循环神经网络来构建语言模型。设小批量大小为1,批量中的文本序列为“machine”。为简化后续的训练,此处使用字符级语言模型(character-level language model),将文本词元化为字符而不是单词。 下图演示了如何通过基于字符级语言建模的循环神经网络,使用当前的和先前的字符预测下一个字符。
在训练过程中,我们对每个时间步的输出层的输出进行softmax操作,然后利用交叉熵损失计算模型输出和标签之间的误差。由于隐藏层中隐状态的循环计算,上图中的第$3$个时间步的输出$\mathbf{O}_3$由文本序列“m”“a”和“c”确定。由于训练数据中这个文本序列的下一个字符是“h”,因此第$3$个时间步的损失将取决于下一个字符的概率分布,而下一个字符是基于特征序列“m”“a”“c”和这个时间步的标签“h”生成的。
(Personal Statement:这里的意思应该是损失是由与标签对比后计算得到的,而损失会影响模型参数的更新,进一步影响模型的预测结果,而不是说标签会直接影响,因为模型的根本目的是预测下一字符是什么。正确的说法应该是“下一个字符是基于特征序列‘m’‘a’‘c’和损失值生成的”)
在实践中使用的批量大小$n>1$,每个词元都由一个$d$维向量表示。因此,在时间步$t$输入$\mathbf X_t$将是一个$n\times d$矩阵,这与在4.2中的讨论相同,也与1.2中近似。
4.4. 困惑度(Perplexity)
现在来讨论如何度量语言模型的质量,这将用于评估基于循环神经网络的模型。一个好的语言模型能够用高度准确的词元来预测我们接下来会看到什么。请看下列由不同的语言模型给出的对“It is raining …”的续写:
- “It is raining outside”(外面下雨了);
- “It is raining banana tree”(香蕉树下雨了);
- “It is raining piouw;kcj pwepoiut”。
就质量而言,例$1$显然是最合乎情理、在逻辑上最连贯的。虽然这个模型可能没有很准确地反映出后续词的语义,比如,“It is raining in San Francisco”(旧金山下雨了)和“It is raining in winter”(冬天下雨了)可能才是更完美的合理扩展,但该模型已经能够捕捉到跟在后面的是哪类单词。例$2$则要糟糕得多,因为其产生了一个无意义的续写。尽管如此,至少该模型已经学会了如何拼写单词,以及单词之间的某种程度的相关性。最后,例$3$表明了训练不足的模型是无法正确地拟合数据的。
或许可以通过计算序列的似然概率来度量模型的质量,但这是一个难以理解、难以比较的数字。较短的序列比较长的序列更有可能出现,因此评估模型产生长篇巨著的可能性会比产生中篇小说的要小得多。
信息论这时可以派上用场了。前文在引入softmax回归时定义了熵、交叉熵,并在信息论在线附录中讨论了更多的信息论知识(还没看)。如果想要压缩文本,我们可以根据当前词元集预测的下一个词元。一个更好的语言模型应该能更准确地预测下一个词元。因此,它应该允许我们在压缩序列时花费更少的比特。所以可以通过一个序列中所有的$n$个词元的交叉熵损失的平均值来衡量:
其中$P$由语言模型给出,$x_t$是在时间步$t$从该序列中观察到的实际词元。这使得不同长度的文档的性能具有了可比性。由于历史原因,自然语言处理的科学家更喜欢使用困惑度(perplexity)来表达,它是上式的指数:
困惑度(perplexity)的基本思想是:给测试集的句子赋予较高概率值的语言模型较好,当语言模型训练完之后,测试集中的句子都是正常的句子,那么训练好的模型就是在测试集上的概率越高越好,此概率越高,困惑度越小,越“收敛”。
困惑度是“下一个词元的实际选择数的调和平均数”,请看下方案例。
- 在最好的情况下,模型总是完美地估计标签词元的概率为1。在这种情况下,模型的困惑度为1。
- 在最坏的情况下,模型总是预测标签词元的概率为0。在这种情况下,困惑度是正无穷大。
- 在基准线情况下,模型的预测是词表的所有可用词元上的均匀分布。这种情况下,困惑度等于词表中唯一词元的数量。如果在没有任何压缩的情况下存储序列,这将是我们能做的最好的编码方式。因此这种方式提供了一个重要的下限,任何实际模型都必须超越这个下限。
调和平均数
: 调和平均数(harmonic mean)又称倒数平均数,是总体各统计变量倒数的算术平均数的倒数。简单调和平均数的公式为:
关于基准线情况的补充,有种说法是这样的:
在看到一个语言模型报告其perplexity是109时,我们可以直观的理解为,平均情况下,这个语言模型预测下一个词时,其认为有109个词等可能地可以作为下一个词的合理选择。
5. 循环神经网络的从零实现
从头开始基于循环神经网络实现字符级语言模型,将在H.G.Wells的时光机器数据集上训练。详细代码实现参见对应实践。
5.1. 独热编码
在train_iter中,每个词元都表示为一个数字索引, 将这些索引直接输入神经网络可能会使学习变得困难。 通常将每个词元表示为更具表现力的特征向量。 最简单的表示为独热编码(one-hot encoding)。
简言之,将每个索引映射为相互不同的单位向量:假设词表中不同词元的数目为$N$(即len(vocab)
),词元索引的范围为$0$到$N-1$。如果词元的索引是整数$i$,那么我们将创建一个长度为$N$的全$0$向量,并将第$i$处的元素设置为$1$。此向量是原始词元的一个独热向量。
每次采样的小批量数据形状是二维张量: (批量大小,时间步数)。 one_hot函数将这样一个小批量数据转换成三维张量, 张量的最后一个维度等于词表大小(len(vocab))。 通常会转换输入的维度以获得形状为(时间步数,批量大小,词表大小)的输出。 这将使我们能够更方便地通过最外层的维度, 一步一步地更新小批量数据的隐状态。
1 | from torch.nn import functional as F |
5.2. 初始化模型参数
初始化循环神经网络模型的模型参数。 隐藏单元数num_hiddens是一个可调的超参数。 当训练语言模型时,输入和输出来自相同的词表。 因此,它们具有相同的维度,即词表的大小。
1 | def get_params(vocab_size, num_hiddens, device): |
5.3. 循环神经网络模型
定义循环神经网络模型, 首先需要一个init_rnn_state函数在初始化时返回隐状态。 这个函数的返回是一个张量,张量全用0填充,形状为(批量大小,隐藏单元数)。 后面的章节中会遇到隐状态包含多个变量的情况,使用元组可以更容易地处理些。
1 | def init_rnn_state(batch_size, num_hiddens, device): |
下面的rnn
函数定义了如何在一个时间步内计算隐状态和输出。循环神经网络模型通过inputs
最外层的维度实现循环,以便逐时间步更新小批量数据的隐状态H
。此外,这里使用$\tanh$函数作为激活函数。当元素在实数上满足均匀分布时,$\tanh$函数的平均值为0。
1 | def rnn(inputs, state, params): |
创建一个类来包装这些函数, 并存储从零开始实现的循环神经网络模型的参数。
1 | class RNNModelScratch: |
5.4. 预测
首先定义预测函数来生成prefix
之后的新字符,prefix
是一个用户提供的包含多个字符的字符串。在循环遍历prefix
中的开始字符时,我们不断地将隐状态传递到下一个时间步,但是不生成任何输出。这被称为预热(warm-up)期,因为在此期间模型会自我更新(例如,更新隐状态),但不会进行预测。预热结束后,隐状态的值通常比刚开始的初始值更适合预测,从而预测字符并输出它们。
1 | def predict_ch8(prefix, num_preds, net, vocab, device): |
5.5. 梯度裁剪
对于上述的循环神经网络,不仅有纵向的深度(输入到输出),还有横向的“深度”(从第一个时间步到末时间步),对于长度为$T$的序列,在迭代中计算这$T$个时间步上的梯度,将会在反向传播过程中产生长度为$\mathcal{O}(T)$的矩阵乘法链。当$T$较大时,它可能导致数值不稳定,例如梯度爆炸或梯度消失。因此,循环神经网络模型往往需要额外的方式来支持稳定训练。
一般在通过梯度下降解决优化问题(优化某个目标)时,采用迭代方式更新模型参数,更新操作是对参数向量$\mathbf{x}$,将其推向负梯度$\mathbf{g}$的方向上(在随机梯度下降中该梯度在随机抽样的小批量中计算)。例如,使用$\eta > 0$作为学习率时,在一次迭代中,我们将$\mathbf{x}$更新为$\mathbf{x} - \eta \mathbf{g}$。此时进一步假设目标函数$f$表现良好,即函数$f$在常数$L$下是利普希茨连续的(Lipschitz continuous)。也就是说,对于任意$\mathbf{x}$和$\mathbf{y}$有:
如果我们通过$\eta \mathbf{g}$更新参数向量,则目标值的变化取决于学习率、梯度的范数和$L$:
这意味着目标的变化不会超过$L \eta |\mathbf{g}|$。这个上限的值较小既是坏事也是好事。坏的方面,它限制了取得进展的速度;好的方面,它限制了事情变糟的程度,尤其当我们朝着错误的方向前进时。
有时梯度可能很大(梯度爆炸),优化算法可能无法收敛,可以通过降低$\eta$的学习率来解决这个问题。但如果很少得到大的梯度时,不可能对所有情况采取降低学习率的方式,这个做法会减缓我们在所有步骤中的进展,只是为了处理罕见的梯度爆炸事件。一个流行的替代方案是通过将梯度$\mathbf{g}$投影回给定半径(例如$\theta$)的球来裁剪梯度$\mathbf{g}$。如下式:
这样做后,梯度范数永远不会超过$\theta$,并且更新后的梯度完全与$\mathbf{g}$的原始方向对齐。它还有一个值得拥有的副作用,即限制任何给定的小批量数据(以及其中任何给定的样本)对参数向量的影响,这赋予了模型一定程度的稳定性。梯度裁剪提供了一个快速修复梯度爆炸的方法,虽然它并不能完全解决问题,但它是众多有效的技术之一。
下面定义一个函数来裁剪模型的梯度,在此计算了所有模型参数的梯度的范数。
1 | def grad_clipping(net, theta): |
5.6. 训练
在训练模型之前,定义一个函数在一个迭代周期内训练模型。这与之前讲到的训练模型的方式有三个不同之处。
- 序列数据的不同采样方法(随机采样和顺序分区)将导致隐状态初始化的差异。
- 在更新模型参数之前会裁剪梯度,这样操作的目的是,即使训练过程中某个点上发生了梯度爆炸,也能保证模型不会发散。
- 用困惑度来评价模型,这样的度量确保了不同长度的序列具有可比性。
当使用顺序采样(顺序分区)时,我们只在每个迭代周期的开始位置初始化隐状态。由于下一个小批量数据中的第$i$个子序列样本与当前第$i$个子序列样本相邻,因此当前小批量数据最后一个样本的隐状态,将用于初始化下一个小批量数据第一个样本的隐状态。这样,存储在隐状态中的序列的历史信息可以在一个迭代周期内流经相邻的子序列。然而,在任何一点隐状态的计算,都依赖于同一迭代周期中前面所有的小批量数据,这使得梯度计算变得复杂。为了降低计算量,在处理任何一个小批量数据之前,通常先分离梯度,使得隐状态的梯度计算总是限制在一个小批量数据的时间步内。
当使用随机抽样时,因为每个样本都是在一个随机位置抽样的,因此需要为每个迭代周期重新初始化隐状态。与之前章节中的train_epoch_ch3
函数相同,updater
是更新模型参数的常用函数。它既可以是从头开始实现的d2l.sgd
函数,也可以是深度学习框架中内置的优化函数。
1 | def train_epoch_ch8(net, train_iter, loss, updater, device, use_random_iter): |
训练函数,既支持从零开始实现, 也可以使用高级API来实现。
1 | def train_ch8(net, train_iter, vocab, lr, num_epochs, device, |
然后开始训练即可,因为在数据集中只使用了10000个词元, 所以模型需要更多的迭代周期来更好地收敛。
6. 循环神经网络的框架实现
使用深度学习框架的高级API提供的函数更有效地实现相同的语言模型。
6.1. 读取数据集
1 | import torch |
6.2. 定义模型
构造一个具有256个隐藏单元的单隐藏层的循环神经网络层rnn_layer。虽然目前还没有讨论多层循环神经网络的意义。目前仅需要将多层理解为一层循环神经网络的输出被用作下一层循环神经网络的输入就足够了。
1 | num_hiddens = 256 |
使用张量来初始化隐状态,它的形状是(隐藏层数,批量大小,隐藏单元数)。
1 | state = torch.zeros((1, batch_size, num_hiddens)) |
通过一个隐状态和一个输入,就可以用更新后的隐状态计算输出。 需要强调的是,rnn_layer的“输出”(Y)不涉及输出层的计算: 它是指每个时间步的隐状态,这些隐状态可以用作后续输出层的输入。
1 | X = torch.rand(size=(num_steps, batch_size, len(vocab))) |
为一个完整的循环神经网络模型定义了一个RNNModel类。 由于rnn_layer只包含隐藏的循环层,我们还需要创建一个单独的输出层。
1 | class RNNModel(nn.Module): |
6.3. 训练与预测
在训练模型之前,基于一个具有随机权重的模型进行预测:
1 | device = torch.device('mps') |
很明显,这种模型根本不能输出好的结果。
下面开始使用预备好的超参数进行训练,结果会好的多。
1 | num_epochs, lr = 500, 1 |
由于深度学习框架的高级API对代码进行了更多的优化,该模型相比从零实现在较短的时间内达到了较低的困惑度。
在M1芯片的机器上训练如果使用GPU可能会训练不出结果,估计是显存问题。
7. 通过时间反向传播
本节会更深入地探讨序列模型反向传播的细节, 以及相关的数学原理。之前实践中遇到的“梯度爆炸”、“梯度消失”、对循环神经网络“分离梯度”等概念也会得到充分的解释。
通过时间反向传播(backpropagation through time,BPTT)实际上是循环神经网络中反向传播技术的一个特定应用。它要求我们将循环神经网络的计算图一次展开一个时间步, 以获得模型变量和参数之间的依赖关系。 然后,基于链式法则,应用反向传播来计算和存储梯度。 由于序列可能相当长,因此依赖关系也可能相当长。 例如,某个1000个字符的序列, 其第一个词元可能会对最后位置的词元产生重大影响。 这在计算上是不可行的(它需要的时间和内存都太多了), 并且还需要超过1000个矩阵的乘积才能得到非常难以捉摸的梯度。 这个过程充满了计算与统计的不确定性。 下面将阐述过程中会发生什么以及如何在实践中解决它们。
7.1. 循环神经网络的梯度分析
从一个描述循环神经网络工作原理的简化模型开始,此模型忽略了隐状态的特性及其更新方式的细节。这里的数学表示没有明确地区分标量、向量和矩阵,因为这些细节对于分析并不重要,反而只会使本小节中的符号变得混乱。
这个简化模型中将时间步$t$的隐状态表示为$h_t$,输入表示为$x_t$,输出表示为$o_t$。前面提到过,输入和隐状态可以拼接后与隐藏层中的一个权重变量相乘。这里分别使用$w_h$和$w_o$来表示隐藏层和输出层的权重。每个时间步的隐状态和输出可以写为:
其中$f$和$g$分别是隐藏层和输出层的变换。则可以获得一个链${\ldots, (x_{t-1}, h_{t-1}, o_{t-1}), (x_{t}, h_{t}, o_t), \ldots}$,它们通过循环计算彼此依赖。在这个序列上正向传播相当简单,一次一个时间步的遍历三元组$(x_t, h_t, o_t)$,然后通过一个目标函数在所有$T$个时间步内评估输出$o_t$和对应的标签$y_t$之间的差异:
而反向传播则相对棘手,特别是在计算目标函数$L$关于参数$w_h$的梯度时。按照链式法则:
上式中乘积的第一项和第二项很容易计算,而第三项$\partial h_t/\partial w_h$是使事情变得棘手的地方,因为这一项需要循环地计算参数$w_h$对$h_t$的影响。根据$ h_t = f(x_t, h_{t-1}, w_h) $产生的递归计算,$h_t$既依赖于$h_{t-1}$又依赖于$w_h$,其中$h_{t-1}$的计算也依赖于$w_h$。因此,使用链式法则产生:
为导出梯度$\frac{\partial h_t}{\partial w_h}$的计算通式,设有三个序列${a_{t}},{b_{t}},{c_{t}}$,当$t=1,2,\ldots$时,序列满足$a_{0}=0$且$a_{t}=b_{t}+c_{t}a_{t-1}$。对于$t\geq 1$,很容易得出:
对应替换$a_t$、$b_t$和$c_t$:
由于前面计算公式中的梯度计算满足$a_{t}=b_{t}+c_{t}a_{t-1}$,则可以得到:
虽然可以使用链式法则递归地计算$\partial h_t/\partial w_h$,但当$t$很大时这个链就会变得很长,我们需要想办法来处理这一问题。
7.1.1. 完全计算
我们可以简单的递归计算上式中的全部总和,但这样的计算非常缓慢,并且可能会发生梯度爆炸, 因为初始条件的微小变化就可能会对结果产生巨大的影响,这类似于蝴蝶效应,即初始条件的很小变化就会导致结果发生不成比例的变化。 这对于我们追求的 能很好泛化高稳定性模型的预测器 是背道而驰的。 因此实践中这种方法几乎从未使用过。
7.1.2. 截断时间步
然后我们想到或许可以在$\tau$步后截断上式中的求和计算。这会带来真实梯度的近似,只需将求和终止为$\partial h_{t-\tau}/\partial w_h$。在实践中这种方法很凑效,它通常被称为截断的通过时间反向传播。这样做会导致该模型主要侧重于短期影响,而不是长期影响。这种截断是可取的,因为它会将估计值偏向更简单和更稳定的模型。
7.1.3. 随机截断
在普通的“固定截断”上继续发展,则或许可以用一个随机变量替换$\partial h_t/\partial w_h$,该随机变量在预期中是正确的,但是会截断序列。这个随机变量是通过使用序列$\xi_t$来实现的,该序列预定义了$0 \leq \pi_t \leq 1$,其中$P(\xi_t = 0) = 1-\pi_t$且$P(\xi_t = \pi_t^{-1}) = \pi_t$,则有$E[\xi_t] = 1$。使用它来替换前式中的梯度$\partial h_t/\partial w_h$得到:
从$\xi_t$的定义中推导出来$E[z_t] = \partial h_t/\partial w_h$。每当$\xi_t = 0$时,递归计算终止在这个$t$时间步。这导致了不同长度序列的加权和,其中长序列出现的很少,所以将适当地加大权重。这个想法是由塔莱克和奥利维尔提出的。
7.1.4. 比较上述计算策略
上图说明了基于循环神经网络使用通过时间反向传播分析《时间机器》书中前几个字符的三种策略:
- 第一行采用随机截断,方法是将文本划分为不同长度的片断;
- 第二行采用常规截断,方法是将文本分解为相同长度的子序列。这也是我们在循环神经网络实验中一直在做的;
- 第三行采用通过时间的完全反向传播,结果是产生了在计算上不可行的表达式。
遗憾的是,虽然随机截断在理论上具有吸引力,但很可能是由于多种因素在实践中并不比常规截断更好。首先,在对过去若干个时间步经过反向传播后,观测结果足以捕获实际的依赖关系。其次,增加的方差抵消了时间步数越多梯度越精确的事实。第三,我们真正想要的是只有短范围交互的模型。因此,模型需要的正是截断的通过时间反向传播方法所具备的轻度正则化效果。
7.2. 通过时间反向传播的细节
在讨论一般性原则之后,来看一下通过时间反向传播问题的细节。与上一小节中的分析不同,本小节将展示如何计算目标函数相对于所有分解模型参数的梯度。为保持简单,设有一个没有偏置参数的循环神经网络,其在隐藏层中的激活函数使用恒等映射($\phi(x)=x$)。对于时间步$t$,设单个样本的输入及其对应的标签分别为$\mathbf{x}_t \in \mathbb{R}^d$和$y_t$。计算隐状态$\mathbf{h}_t \in \mathbb{R}^h$和输出$\mathbf{o}_t \in \mathbb{R}^q$的方式为:
其中权重参数为$\mathbf{W}_{hx} \in \mathbb{R}^{h \times d}$、$\mathbf{W}_{hh} \in \mathbb{R}^{h \times h}$和$\mathbf{W}_{qh} \in \mathbb{R}^{q \times h}$。用$l(\mathbf{o}_t, y_t)$表示时间步$t$处(即从序列开始起的超过$T$个时间步)的损失函数,则目标函数的总体损失是:
为了在循环神经网络的计算过程中可视化模型变量和参数之间的依赖关系,可以为模型绘制一个计算图,如下图所示。利用计算图可以看到很多东西,比如时间步3的隐状态$\mathbf{h}_3$的计算取决于模型参数$\mathbf{W}_{hx}$和$\mathbf{W}_{hh}$,以及最终时间步的隐状态$\mathbf{h}_2$以及当前时间步的输入$\mathbf{x}_3$。
上中的模型参数是$\mathbf{W}_{hx}$、$\mathbf{W}_{hh}$和$\mathbf{W}_{qh}$。通常,训练该模型需要对这些参数进行梯度计算:$\partial L/\partial \mathbf{W}_{hx}$、$\partial L/\partial \mathbf{W}_{hh}$和$\partial L/\partial \mathbf{W}_{qh}$。根据依赖关系,我们可以沿箭头的相反方向遍历计算图,依次计算和存储梯度。为灵活地表示链式法则中不同形状的矩阵、向量和标量的乘法,继续采用$\text{prod}$运算符表示参数乘法以及一些必要操作。
首先,在任意时间步$t$,目标函数关于模型输出的微分计算是相当简单的:
现在可以计算目标函数关于输出层中参数$\mathbf{W}_{qh}$的梯度:$\partial L/\partial \mathbf{W}_{qh} \in \mathbb{R}^{q \times h}$。基于计算图,目标函数$L$通过$\mathbf{o}_1, \ldots, \mathbf{o}_T$依赖于$\mathbf{W}_{qh}$。依据链式法则,得到
其中$\partial L/\partial \mathbf{o}_t$是由第一步给出的。
接下来,由计算图知在最后的时间步$T$,目标函数$L$仅通过$\mathbf{o}_T$依赖于隐状态$\mathbf{h}_T$。使用链式法可以很容易地得到梯度$\partial L/\partial \mathbf{h}_T \in \mathbb{R}^h$:
当目标函数$L$通过$\mathbf{h}_{t+1}$和$\mathbf{o}_t$依赖$\mathbf{h}_t$时,对任意时间步$t < T$来说都变得更加棘手。根据链式法则,隐状态的梯度$\partial L/\partial \mathbf{h}_t \in \mathbb{R}^h$在任何时间步骤$t < T$时都可以递归地计算为:
为了进行分析,对于任何时间步$1 \leq t \leq T$展开递归计算得:
我们可以从上式中看到,这个简单的线性例子已经展现了长序列模型的一些关键问题:它陷入到$\mathbf{W}_{hh}^\top$的潜在的非常大的幂。在这个幂中,小于1的特征值将会消失,大于1的特征值将会发散。这在数值上是不稳定的,表现形式为梯度消失或梯度爆炸。解决此问题的一种方法是按照计算方便的需要截断指定大小的时间步长。实践中这种截断是通过在给定数量的时间步之后分离梯度来实现的。后面将学习更复杂的序列模型(如长短期记忆模型)是如何进一步缓解这一问题的。
最后,计算图表明:目标函数$L$通过隐状态$\mathbf{h}_1, \ldots, \mathbf{h}_T$依赖于隐藏层中的模型参数$\mathbf{W}_{hx}$和$\mathbf{W}_{hh}$。为了计算有关这些参数的梯度$\partial L / \partial \mathbf{W}_{hx} \in \mathbb{R}^{h \times d}$和$\partial L / \partial \mathbf{W}_{hh} \in \mathbb{R}^{h \times h}$,可以应用链式规则得:
其中$\partial L/\partial \mathbf{h}_t$是由$ \frac{\partial L}{\partial \mathbf{h}_T} = \text{prod}\left(\frac{\partial L}{\partial \mathbf{o}_T}, \frac{\partial \mathbf{o}_T}{\partial \mathbf{h}_T} \right) = \mathbf{W}_{qh}^\top \frac{\partial L}{\partial \mathbf{o}_T} $和$ \frac{\partial L}{\partial \mathbf{h}_t} = \text{prod}\left(\frac{\partial L}{\partial \mathbf{h}_{t+1}}, \frac{\partial \mathbf{h}_{t+1}}{\partial \mathbf{h}_t} \right) + \text{prod}\left(\frac{\partial L}{\partial \mathbf{o}_t}, \frac{\partial \mathbf{o}_t}{\partial \mathbf{h}_t} \right) = \mathbf{W}_{hh}^\top \frac{\partial L}{\partial \mathbf{h}_{t+1}} + \mathbf{W}_{qh}^\top \frac{\partial L}{\partial \mathbf{o}_t} $递归计算得到的,是影响数值稳定性的关键量。
由于BPTT是反向传播在循环神经网络中的应用方式,所以训练循环神经网络交替使用正向传播和BPTT。BPTT依次计算并存储上述梯度。具体而言,存储的中间值会被重复使用,以避免重复计算,例如存储$\partial L/\partial \mathbf{h}_t$,以便在计算$\partial L / \partial \mathbf{W}_{hx}$和$\partial L / \partial \mathbf{W}_{hh}$时使用。