前言

前期回顾： Python深度学习篇五《深度学习用于计算机视觉》
上面这篇里面写了计算机视觉相关。

• 卷积神经网络是解决视觉分类问题的最佳工具。
• 卷积神经网络通过学习模块化模式和概念的层次结构来表示视觉世界。
• 卷积神经网络学到的表示很容易可视化，卷积神经网络不是黑盒。
• 现在你能够从头开始训练自己的卷积神经网络来解决图像分类问题。
• 你知道了如何使用视觉数据增强来防止过拟合。
• 你知道了如何使用预训练的卷积神经网络进行特征提取与模型微调。
• 你可以将卷积神经网络学到的过滤器可视化，也可以将类激活热力图可视化。

好，接下来切入正题。

本章包括以下内容：

• 将文本数据预处理为有用的数据表示
• 使用循环神经网络
• 使用一维卷积神经网络处理序列

本章将介绍使用深度学习模型处理文本（可以将其理解为单词序列或字符序列）、时间序列 和一般的序列数据。用于处理序列的两种基本的深度学习算法分别是循环神经网络（recurrent neural network）和一维卷积神经网络（1D convnet），后者是上一章介绍的二维卷积神经网络的 一维版本。本章将讨论这两种方法。

这些算法的应用包括：

• 文档分类和时间序列分类，比如识别文章的主题或书的作者；
• 时间序列对比，比如估测两个文档或两支股票行情的相关程度；
• 序列到序列的学习，比如将英语翻译成法语；
• 情感分析，比如将推文或电影评论的情感划分为正面或负面；
• 时间序列预测，比如根据某地最近的天气数据来预测未来天气。

本章的示例重点讨论两个小任务：一个是 IMDB 数据集的情感分析，这个任务前面介绍过； 另一个是温度预测。但这两个任务中所使用的技术可以应用于上面列出来的所有应用。

6.1　处理文本数据

文本是最常用的序列数据之一，可以理解为字符序列或单词序列，但最常见的是单词级处 理。后面几节介绍的深度学习序列处理模型都可以根据文本生成基本形式的自然语言理解，并 可用于文档分类、情感分析、作者识别甚至问答（QA，在有限的语境下）等应用。当然，请记住， 本章的这些深度学习模型都没有像人类一样真正地理解文本，而只是映射出书面语言的统计结构，但这足以解决许多简单的文本任务。深度学习用于自然语言处理是将模式识别应用于单词、 句子和段落，这与计算机视觉是将模式识别应用于像素大致相同。

与其他所有神经网络一样，深度学习模型不会接收原始文本作为输入，它只能处理数值张量。 文本向量化（vectorize）是指将文本转换为数值张量的过程。它有多种实现方法。

• 将文本分割为单词，并将每个单词转换为一个向量。
• 将文本分割为字符，并将每个字符转换为一个向量。
• 提取单词或字符的 n-gram，并将每个 n-gram 转换为一个向量。n-gram 是多个连续单词 或字符的集合（n-gram 之间可重叠）。

将文本分解而成的单元（单词、字符或 n-gram）叫作标记（token），将文本分解成标记的 过程叫作分词（tokenization）。所有文本向量化过程都是应用某种分词方案，然后将数值向量 与生成的标记相关联。这些向量组合成序列张量，被输入到深度神经网络中（见图 6-1）。将向量与标记相关联的方法有很多种。本节将介绍两种主要方法：对标记做 one-hot 编码（one-hot encoding）与标记嵌入［token embedding，通常只用于单词，叫作词嵌入（word embedding）］。 本节剩余内容将解释这些方法，并介绍如何使用这些方法，将原始文本转换为可以输入到 Keras 网络中的 Numpy 张量。

图 6-1　从文本到标记再到向量

理解 n-gram 和词袋

n-gram 是从一个句子中提取的 N 个（或更少）连续单词的集合。这一概念中的“单词” 也可以替换为“字符”。

下面来看一个简单的例子。考虑句子“The cat sat on the mat.”（“猫坐在垫子上”）。它 可以被分解为以下二元语法（2-grams）的集合。

{"The", "The cat", "cat", "cat sat", "sat",
 "sat on", "on", "on the", "the", "the mat", "mat"}

这个句子也可以被分解为以下三元语法（3-grams）的集合。

{"The", "The cat", "cat", "cat sat", "The cat sat",
 "sat", "sat on", "on", "cat sat on", "on the", "the",
 "sat on the", "the mat", "mat", "on the mat"}

这样的集合分别叫作二元语法袋（bag-of-2-grams）及三元语法袋（bag-of-3-grams）。这里袋（bag）这一术语指的是，我们处理的是标记组成的集合，而不是一个列表或序列，即标记没有特定的顺序。这一系列分词方法叫作词袋（bag-of-words）。

词袋是一种不保存顺序的分词方法（生成的标记组成一个集合，而不是一个序列，舍 弃了句子的总体结构），因此它往往被用于浅层的语言处理模型，而不是深度学习模型。提 取 n-gram 是一种特征工程，深度学习不需要这种死板而又不稳定的方法，并将其替换为分 层特征学习。本章后面将介绍的一维卷积神经网络和循环神经网络，都能够通过观察连续的 单词序列或字符序列来学习单词组和字符组的数据表示，而无须明确知道这些组的存在。因 此，本书不会进一步讨论 n-gram。但一定要记住，在使用轻量级的浅层文本处理模型时（比 如 logistic 回归和随机森林），n-gram 是一种功能强大、不可或缺的特征工程工具。

6.1.1　单词和字符的 one-hot 编码

one-hot 编码是将标记转换为向量的最常用、最基本的方法。在第 3 章的 IMDB 和路透社两 个例子中，你已经用过这种方法（都是处理单词）。它将每个单词与一个唯一的整数索引相关联， 然后将这个整数索引 i 转换为长度为 N 的二进制向量（N 是词表大小），这个向量只有第 i 个元 素是 1，其余元素都为 0。

当然，也可以进行字符级的 one-hot 编码。为了让你完全理解什么是 one-hot 编码以及如何实现 one-hot 编码，代码清单 6-1 和代码清单 6-2 给出了两个简单示例，一个是单词级的 one-hot 编码，另一个是字符级的 one-hot 编码。

代码清单 6-1 单词级的 one-hot 编码（简单示例）

import numpy as np
samples = ['The cat sat on the mat.', 'The dog ate my homework.']
token_index = {}
for sample in samples:
 for word in sample.split():
 if word not in token_index:
 token_index[word] = len(token_index) + 1
max_length = 10
results = np.zeros(shape=(len(samples),
 max_length,
 max(token_index.values()) + 1))
for i, sample in enumerate(samples):
 for j, word in list(enumerate(sample.split()))[:max_length]:
 index = token_index.get(word)
 results[i, j, index] = 1.

代码清单 6-2 字符级的 one-hot 编码（简单示例）

import string
samples = ['The cat sat on the mat.', 'The dog ate my homework.']
characters = string.printable
token_index = dict(zip(range(1, len(characters) + 1), characters))
max_length = 50
results = np.zeros((len(samples), max_length, max(token_index.keys()) + 1))
for i, sample in enumerate(samples):
 for j, character in enumerate(sample):
 index = token_index.get(character)
 results[i, j, index] = 1.

注意，Keras 的内置函数可以对原始文本数据进行单词级或字符级的 one-hot 编码。你应该 使用这些函数，因为它们实现了许多重要的特性，比如从字符串中去除特殊字符、只考虑数据集中前 N 个最常见的单词（这是一种常用的限制，以避免处理非常大的输入向量空间）。

代码清单 6-3 用 Keras 实现单词级的 one-hot 编码

from keras.preprocessing.text import Tokenizer
samples = ['The cat sat on the mat.', 'The dog ate my homework.']
tokenizer = Tokenizer(num_words=1000)
tokenizer.fit_on_texts(samples)
sequences = tokenizer.texts_to_sequences(samples)
one_hot_results = tokenizer.texts_to_matrix(samples, mode='binary')
word_index = tokenizer.word_index
print('Found %s unique tokens.' % len(word_index))

one-hot 编码的一种变体是所谓的 one-hot 散列技巧（one-hot hashing trick），如果词表中唯 一标记的数量太大而无法直接处理，就可以使用这种技巧。这种方法没有为每个单词显式分配 一个索引并将这些索引保存在一个字典中，而是将单词散列编码为固定长度的向量，通常用一 个非常简单的散列函数来实现。这种方法的主要优点在于，它避免了维护一个显式的单词索引， 从而节省内存并允许数据的在线编码（在读取完所有数据之前，你就可以立刻生成标记向量）。 这种方法有一个缺点，就是可能会出现散列冲突（hash collision），即两个不同的单词可能具有 相同的散列值，随后任何机器学习模型观察这些散列值，都无法区分它们所对应的单词。如果 散列空间的维度远大于需要散列的唯一标记的个数，散列冲突的可能性会减小。

代码清单 6-4 使用散列技巧的单词级的 one-hot 编码（简单示例）

samples = ['The cat sat on the mat.', 'The dog ate my homework.']
dimensionality = 1000
max_length = 10
results = np.zeros((len(samples), max_length, dimensionality))
for i, sample in enumerate(samples):
 for j, word in list(enumerate(sample.split()))[:max_length]:
 index = abs(hash(word)) % dimensionality
 results[i, j, index] = 1.

6.1.2　使用词嵌入

将单词与向量相关联还有另一种常用的强大方法，就是使用密集的词向量（word vector）， 也叫词嵌入（word embedding）。one-hot 编码得到的向量是二进制的、稀疏的（绝大部分元素都 是 0）、维度很高的（维度大小等于词表中的单词个数），而词嵌入是低维的浮点数向量（即密集向量，与稀疏向量相对），参见图 6-2。与 one-hot 编码得到的词向量不同，词嵌入是从数据中学习得到的。常见的词向量维度是 256、512 或 1024（处理非常大的词表时）。与此相对，onehot 编码的词向量维度通常为 20 000 或更高（对应包含 20 000 个标记的词表）。因此，词向量可以将更多的信息塞入更低的维度中。

图 6-2 one-hot 编码或 one-hot 散列得到的词表示是稀疏的、高维的、硬编码的， 而词嵌入是密集的、相对低维的，而且是从数据中学习得到的

获取词嵌入有两种方法。

• 在完成主任务（比如文档分类或情感预测）的同时学习词嵌入。在这种情况下，一开始 是随机的词向量，然后对这些词向量进行学习，其学习方式与学习神经网络的权重相同。
• 在不同于待解决问题的机器学习任务上预计算好词嵌入，然后将其加载到模型中。这些 词嵌入叫作预训练词嵌入（pretrained word embedding）。

我们来分别看一下这两种方法。

1. 利用 Embedding 层学习词嵌入

要将一个词与一个密集向量相关联，最简单的方法就是随机选择向量。这种方法的问题在于， 得到的嵌入空间没有任何结构。例如，accurate 和 exact 两个词的嵌入可能完全不同，尽管它们在大多数句子里都是可以互换的。深度神经网络很难对这种杂乱的、非结构化的嵌入空间进行学习。

说得更抽象一点，词向量之间的几何关系应该表示这些词之间的语义关系。词嵌入的作用应该是将人类的语言映射到几何空间中。例如，在一个合理的嵌入空间中，同义词应该被嵌入 到相似的词向量中，一般来说，任意两个词向量之间的几何距离（比如 L2 距离）应该和这两个词的语义距离有关（表示不同事物的词被嵌入到相隔很远的点，而相关的词则更加靠近）。除了距离，你可能还希望嵌入空间中的特定方向也是有意义的。为了更清楚地说明这一点，我们来看一个具体示例。

在图 6-3 中，四个词被嵌入在二维平面上，这四个词分别是 cat（猫）、dog（狗）、wolf（狼） 和 tiger（虎）。对于我们这里选择的向量表示，这些词之间的某些语义关系可以被编码为几何变换。例如，从 cat 到 tiger 的向量与从 dog 到 wolf 的向量相等，这个向量可以被解释为“从宠物到野生动物”向量。同样，从 dog 到 cat 的向量与从 wolf 到 tiger 的向量也相等，它可以被解释为“从犬科到猫科”向量。

图 6-3　词嵌入空间的简单示例

在真实的词嵌入空间中，常见的有意义的几何变换的例子包括“性别”向量和“复数”向量。 例如，将 king（国王）向量加上 female（女性）向量，得到的是 queen（女王）向量。将 king（国王） 向量加上 plural（复数）向量，得到的是 kings 向量。词嵌入空间通常具有几千个这种可解释的、 并且可能很有用的向量。

有没有一个理想的词嵌入空间，可以完美地映射人类语言，并可用于所有自然语言处理任 务？可能有，但我们尚未发现。此外，也不存在人类语言（human language）这种东西。世界上有许多种不同的语言，而且它们不是同构的，因为语言是特定文化和特定环境的反射。但从更 实际的角度来说，一个好的词嵌入空间在很大程度上取决于你的任务。英语电影评论情感分析模型的完美词嵌入空间，可能不同于英语法律文档分类模型的完美词嵌入空间，因为某些语义关系的重要性因任务而异。

因此，合理的做法是对每个新任务都学习一个新的嵌入空间。幸运的是，反向传播让这种学习变得很简单，而 Keras 使其变得更简单。我们要做的就是学习一个层的权重，这个层就是 Embedding 层。

代码清单 6-5 将一个 Embedding 层实例化

from keras.layers import Embedding
embedding_layer = Embedding(1000, 64)

最好将 Embedding 层理解为一个字典，将整数索引（表示特定单词）映射为密集向量。它接收整数作为输入，并在内部字典中查找这些整数，然后返回相关联的向量。Embedding 层实际上是一种字典查找（见图 6-4）。

图 6-4 Embedding 层

Embedding 层的输入是一个二维整数张量，其形状为 (samples, sequence_length)， 每个元素是一个整数序列。它能够嵌入长度可变的序列，例如，对于前一个例子中的 Embedding 层，你可以输入形状为 (32, 10)（32 个长度为 10 的序列组成的批量）或 (64, 15)（64 个长度为 15 的序列组成的批量）的批量。不过一批数据中的所有序列必须具有相同的 长度（因为需要将它们打包成一个张量），所以较短的序列应该用 0 填充，较长的序列应该被截断。

这 个 Embedding 层返回一个形状为 (samples, sequencelength, embedding dimensionality) 的三维浮点数张量。然后可以用 RNN 层或一维卷积层来处理这个三维张量 （二者都会在后面介绍）。

将一个 Embedding 层实例化时，它的权重（即标记向量的内部字典）最开始是随机的，与其他层一样。在训练过程中，利用反向传播来逐渐调节这些词向量，改变空间结构以便下游模型可以利用。一旦训练完成，嵌入空间将会展示大量结构，这种结构专门针对训练模型所要解决的问题。

我们将这个想法应用于你熟悉的 IMDB 电影评论情感预测任务。首先，我们需要快速准备数据。将电影评论限制为前 10 000 个最常见的单词（第一次处理这个数据集时就是这么做的）， 然后将评论长度限制为只有 20 个单词。对于这 10 000 个单词，网络将对每个词都学习一个 8 维嵌入，将输入的整数序列（二维整数张量）转换为嵌入序列（三维浮点数张量），然后将这个 张量展平为二维，最后在上面训练一个 Dense 层用于分类。

代码清单 6-6 加载 IMDB 数据，准备用于 Embedding 层

from keras.datasets import imdb
from keras.layers import preprocessing
max_features = 10000
maxlen = 20
(x_train, y_train), (x_test, y_test) = imdb.load_data(
 num_words=max_features)
x_train = preprocessing.sequence.pad_sequences(x_train, maxlen=maxlen)
x_test = preprocessing.sequence.pad_sequences(x_test, maxlen=maxlen)

代码清单 6-7 在 IMDB 数据上使用 Embedding 层和分类器

from keras.models import Sequential
from keras.layers import Flatten, Dense, Embedding
model = Sequential()
model.add(Embedding(10000, 8, input_length=maxlen))
model.add(Flatten())
model.add(Dense(1, activation='sigmoid'))
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['acc'])
model.summary()
history = model.fit(x_train, y_train,
 epochs=10,
 batch_size=32,
 validation_split=0.2)

得到的验证精度约为 76%，考虑到仅查看每条评论的前 20 个单词，这个结果还是相当不错 的。但请注意，仅仅将嵌入序列展开并在上面训练一个 Dense 层，会导致模型对输入序列中的 每个单词单独处理，而没有考虑单词之间的关系和句子结构（举个例子，这个模型可能会将 this movie is a bomb 和 this movie is the bomb 两条都归为负面评论 a）。更好的做法是在嵌入序列上添 加循环层或一维卷积层，将每个序列作为整体来学习特征。这也是接下来几节的重点。

2. 使用预训练的词嵌入

有时可用的训练数据很少，以至于只用手头数据无法学习适合特定任务的词嵌入。那么应该怎么办？

你可以从预计算的嵌入空间中加载嵌入向量（你知道这个嵌入空间是高度结构化的，并且具有有用的属性，即抓住了语言结构的一般特点），而不是在解决问题的同时学习词嵌入。在自 然语言处理中使用预训练的词嵌入，其背后的原理与在图像分类中使用预训练的卷积神经网络是一样的：没有足够的数据来自己学习真正强大的特征，但你需要的特征应该是非常通用的， 比如常见的视觉特征或语义特征。在这种情况下，重复使用在其他问题上学到的特征，这种做法是有道理的。

这种词嵌入通常是利用词频统计计算得出的（观察哪些词共同出现在句子或文档中），用到的技术很多，有些涉及神经网络，有些则不涉及。Bengio 等人在 21 世纪初首先研究了一种思路， 就是用无监督的方法计算一个密集的低维词嵌入空间，但直到最有名且最成功的词嵌入方案之 一 word2vec 算法发布之后，这一思路才开始在研究领域和工业应用中取得成功。word2vec 算法 由 Google 的 Tomas Mikolov 于 2013 年开发，其维度抓住了特定的语义属性，比如性别。

有许多预计算的词嵌入数据库，你都可以下载并在 Keras 的 Embedding 层中使用。 word2vec 就是其中之一。另一个常用的是 GloVe（global vectors for word representation，词表示全局向量），由斯坦福大学的研究人员于 2014 年开发。这种嵌入方法基于对词共现统计矩阵进行因式分解。其开发者已经公开了数百万个英文标记的预计算嵌入，它们都是从维基百科数据 和 Common Crawl 数据得到的。

我们来看一下如何在 Keras 模型中使用 GloVe 嵌入。同样的方法也适用于 word2vec 嵌入或 其他词嵌入数据库。这个例子还可以改进前面刚刚介绍过的文本分词技术，即从原始文本开始， 一步步进行处理。

6.1.3　整合在一起：从原始文本到词嵌入

本节的模型与之前刚刚见过的那个类似：将句子嵌入到向量序列中，然后将其展平，最后在上面训练一个 Dense 层。但此处将使用预训练的词嵌入。此外，我们将从头开始，先下载 IMDB 原始文本数据，而不是使用 Keras 内置的已经预先分词的 IMDB 数据。

1. 下载 IMDB 数据的原始文本

首先，打开 http://mng.bz/0tIo，下载原始 IMDB 数据集并解压。

接下来，我们将训练评论转换成字符串列表，每个字符串对应一条评论。你也可以将评论 标签（正面 / 负面）转换成 labels 列表。

代码清单 6-8 处理 IMDB 原始数据的标签

import os
imdb_dir = '/Users/fchollet/Downloads/aclImdb'
train_dir = os.path.join(imdb_dir, 'train')
labels = []
texts = []
for label_type in ['neg', 'pos']:
 dir_name = os.path.join(train_dir, label_type)
 for fname in os.listdir(dir_name):
 if fname[-4:] == '.txt':
 f = open(os.path.join(dir_name, fname))
 texts.append(f.read())
 f.close()
 if label_type == 'neg':
 labels.append(0)
 else:
 labels.append(1)

2. 对数据进行分词

利用本节前面介绍过的概念，我们对文本进行分词，并将其划分为训练集和验证集。因为预训练的词嵌入对训练数据很少的问题特别有用（否则，针对于具体任务的嵌入可能效果更好）， 所以我们又添加了以下限制：将训练数据限定为前 200 个样本。因此，你需要在读取 200 个样本之后学习对电影评论进行分类。

代码清单 6-9 对 IMDB 原始数据的文本进行分词

from keras.preprocessing.text import Tokenizer
from keras.preprocessing.sequence import pad_sequences
import numpy as np
maxlen = 100
training_samples = 200
validation_samples = 10000
max_words = 10000
tokenizer = Tokenizer(num_words=max_words)
tokenizer.fit_on_texts(texts)
sequences = tokenizer.texts_to_sequences(texts)
word_index = tokenizer.word_index
print('Found %s unique tokens.' % len(word_index))
data = pad_sequences(sequences, maxlen=maxlen)
labels = np.asarray(labels)
print('Shape of data tensor:', data.shape)
print('Shape of label tensor:', labels.shape)
indices = np.arange(data.shape[0])
np.random.shuffle(indices)
data = data[indices]
labels = labels[indices]
x_train = data[:training_samples]
y_train = labels[:training_samples]
x_val = data[training_samples: training_samples + validation_samples]
y_val = labels[training_samples: training_samples + validation_samples]

3. 下载 GloVe 词嵌入

打开 https://nlp.stanford.edu/projects/glove，下载 2014 年英文维基百科的预计算嵌入。这是 一个 822 MB 的压缩文件，文件名是 glove.6B.zip，里面包含 400 000 个单词（或非单词的标记） 的 100 维嵌入向量。解压文件。

4. 对嵌入进行预处理

我们对解压后的文件（一个 .txt 文件）进行解析，构建一个将单词（字符串）映射为其向量表示（数值向量）的索引。

代码清单 6-10　解析 GloVe 词嵌入文件

glove_dir = '/Users/fchollet/Downloads/glove.6B'
embeddings_index = {}
f = open(os.path.join(glove_dir, 'glove.6B.100d.txt'))
for line in f:
 values = line.split()
 word = values[0]
 coefs = np.asarray(values[1:], dtype='float32')
 embeddings_index[word] = coefs
f.close()
print('Found %s word vectors.' % len(embeddings_index))

接下来，需要构建一个可以加载到 Embedding 层中的嵌入矩阵。它必须是一个形状为 (max_words, embedding_dim) 的矩阵，对于单词索引（在分词时构建）中索引为 i 的单词， 这个矩阵的元素 i 就是这个单词对应的 embedding_dim 维向量。注意，索引 0 不应该代表任何 单词或标记，它只是一个占位符。

代码清单 6-11　准备 GloVe 词嵌入矩阵

embedding_dim = 100
embedding_matrix = np.zeros((max_words, embedding_dim))
for word, i in word_index.items():
 if i < max_words:
 embedding_vector = embeddings_index.get(word)
 if embedding_vector is not None:
 embedding_matrix[i] = embedding_vector

5. 定义模型

我们将使用与前面相同的模型架构。

代码清单 6-12　模型定义

from keras.models import Sequential
from keras.layers import Embedding, Flatten, Dense
model = Sequential()
model.add(Embedding(max_words, embedding_dim, input_length=maxlen))
model.add(Flatten())
model.add(Dense(32, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
model.summary()

6. 在模型中加载 GloVe 嵌入

Embedding 层只有一个权重矩阵，是一个二维的浮点数矩阵，其中每个元素 i 是与索引 i 相关联的词向量。够简单。将准备好的 GloVe 矩阵加载到 Embedding 层中，即模型的第一层。

代码清单 6-13　将预训练的词嵌入加载到 Embedding 层中

model.layers[0].set_weights([embedding_matrix])
model.layers[0].trainable = False

此外，需要冻结 Embedding 层（即将其 trainable 属性设为 False），其原理和预训练的卷积神经网络特征相同，你已经很熟悉了。如果一个模型的一部分是经过预训练的（如 Embedding 层），而另一部分是随机初始化的（如分类器），那么在训练期间不应该更新预训练的部分，以 避免丢失它们所保存的信息。随机初始化的层会引起较大的梯度更新，会破坏已经学到的特征。

7. 训练模型与评估模型

编译并训练模型。

代码清单 6-14　训练与评估

model.compile(optimizer='rmsprop',
 loss='binary_crossentropy',
 metrics=['acc'])
history = model.fit(x_train, y_train,
 epochs=10,
 batch_size=32,
 validation_data=(x_val, y_val))
model.save_weights('pre_trained_glove_model.h5')

接下来，绘制模型性能随时间的变化（见图 6-5 和图 6-6）。

代码清单 6-15　绘制结果

import matplotlib.pyplot as plt
acc = history.history['acc']
val_acc = history.history['val_acc']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(1, len(acc) + 1)
plt.plot(epochs, acc, 'bo', label='Training acc')
plt.plot(epochs, val_acc, 'b', label='Validation acc')
plt.title('Training and validation accuracy')
plt.legend()
plt.figure()
plt.plot(epochs, loss, 'bo', label='Training loss')
plt.plot(epochs, val_loss, 'b', label='Validation loss')
plt.title('Training and validation loss')
plt.legend()
plt.show()

图 6-5　使用预训练词嵌入时的训练损失和验证损失

图 6-6　使用预训练词嵌入时的训练精度和验证精度

模型很快就开始过拟合，考虑到训练样本很少，这一点也不奇怪。出于同样的原因，验证 精度的波动很大，但似乎达到了接近 60%。

注意，你的结果可能会有所不同。训练样本数太少，所以模型性能严重依赖于你选择的 200 个样本，而样本是随机选择的。如果你得到的结果很差，可以尝试重新选择 200 个不同的随机样本，你可以将其作为练习（在现实生活中无法选择自己的训练数据）。

你也可以在不加载预训练词嵌入、也不冻结嵌入层的情况下训练相同的模型。在这种情况下， 你将会学到针对任务的输入标记的嵌入。如果有大量的可用数据，这种方法通常比预训练词嵌 入更加强大，但本例只有 200 个训练样本。我们来试一下这种方法（见图 6-7 和图 6-8）。

代码清单 6-16　在不使用预训练词嵌入的情况下，训练相同的模型

from keras.models import Sequential
from keras.layers import Embedding, Flatten, Dense
model = Sequential()
model.add(Embedding(max_words, embedding_dim, input_length=maxlen))
model.add(Flatten())
model.add(Dense(32, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
model.summary()
model.compile(optimizer='rmsprop',
 loss='binary_crossentropy',
 metrics=['acc'])
history = model.fit(x_train, y_train,
 epochs=10,
 batch_size=32,
 validation_data=(x_val, y_val))

图 6-7　不使用预训练词嵌入时的训练损失和验证损失

图 6-8　不使用预训练词嵌入时的训练精度和验证精度

验证精度停留在 50% 多一点。因此，在本例中，预训练词嵌入的性能要优于与任务一起学习的嵌入。如果增加样本数量，情况将很快发生变化，你可以把它作为一个练习。

最后，我们在测试数据上评估模型。首先，你需要对测试数据进行分词。

代码清单 6-17　对测试集数据进行分词

test_dir = os.path.join(imdb_dir, 'test')
labels = []
texts = []
for label_type in ['neg', 'pos']:
 dir_name = os.path.join(test_dir, label_type)
 for fname in sorted(os.listdir(dir_name)):
 if fname[-4:] == '.txt':
 f = open(os.path.join(dir_name, fname))
 texts.append(f.read())
 f.close()
 if label_type == 'neg':
 labels.append(0)
 else:
 labels.append(1)
sequences = tokenizer.texts_to_sequences(texts)
x_test = pad_sequences(sequences, maxlen=maxlen)
y_test = np.asarray(labels)

接下来，加载并评估第一个模型。

代码清单 6-18　在测试集上评估模型

model.load_weights('pre_trained_glove_model.h5')
model.evaluate(x_test, y_test)

测试精度达到了令人震惊的 56% ！只用了很少的训练样本，得到这样的结果很不容易。

6.1.4　小结

现在你已经学会了下列内容

• 将原始文本转换为神经网络能够处理的格式。
• 使用 Keras 模型的 Embedding 层来学习针对特定任务的标记嵌入。
• 使用预训练词嵌入在小型自然语言处理问题上获得额外的性能提升。

6.2　理解循环神经网络

目前你见过的所有神经网络（比如密集连接网络和卷积神经网络）都有一个主要特点，那就是它们都没有记忆。它们单独处理每个输入，在输入与输入之间没有保存任何状态。对于这 样的网络，要想处理数据点的序列或时间序列，你需要向网络同时展示整个序列，即将序列转 换成单个数据点。例如，你在 IMDB 示例中就是这么做的：将全部电影评论转换为一个大向量， 然后一次性处理。这种网络叫作前馈网络（feedforward network）。

与此相反，当你在阅读这个句子时，你是一个词一个词地阅读（或者说，眼睛一次扫视一 次扫视地阅读），同时会记住之前的内容。这让你能够动态理解这个句子所传达的含义。生物智 能以渐进的方式处理信息，同时保存一个关于所处理内容的内部模型，这个模型是根据过去的 信息构建的，并随着新信息的进入而不断更新。

循环神经网络（RNN，recurrent neural network）采用同样的原理，不过是一个极其简化的版本：它处理序列的方式是，遍历所有序列元素，并保存一个状态（state），其中包含与已查看内容相关的信息。实际上，RNN 是一类具有内部环的神经网络（见图 6-9）。在处理两个不同的 独立序列（比如两条不同的 IMDB 评论）之间，RNN 状态会被重置，因此，你仍可以将一个序列看作单个数据点，即网络的单个输入。真正改变的是，数据点不再是在单个步骤中进行处理， 相反，网络内部会对序列元素进行遍历。

图 6-9　循环网络：带有环的网络

为了将环（loop）和状态的概念解释清楚，我们用 Numpy 来实现一个简单 RNN 的前向传递。 这个 RNN 的输入是一个张量序列，我们将其编码成大小为 (timesteps, inputfeatures) 的二维张量。它对时间步（timestep）进行遍历，在每个时间步，它考虑 t 时刻的当前状态与 t 时刻的输入［形状为 (input features,)］，对二者计算得到 t 时刻的输出。然后，我们将 下一个时间步的状态设置为上一个时间步的输出。对于第一个时间步，上一个时间步的输出没

有定义，所以它没有当前状态。因此，你需要将状态初始化为一个全零向量，这叫作网络的初 始状态（initial state）。

RNN 的伪代码如下所示。

代码清单 6-19 RNN 伪代码

state_t = 0
for input_t in input_sequence:
 output_t = f(input_t, state_t)
 state_t = output_t

你甚至可以给出具体的函数 f：从输入和状态到输出的变换，其参数包括两个矩阵（W 和 U） 和一个偏置向量。它类似于前馈网络中密集连接层所做的变换。

代码清单 6-20　更详细的 RNN 伪代码

state_t = 0
for input_t in input_sequence:
 output_t = activation(dot(W, input_t) + dot(U, state_t) + b)
 state_t = output_t

为了将这些概念的含义解释得更加清楚，我们为简单 RNN 的前向传播编写一个简单的 Numpy 实现。

代码清单 6-21　简单 RNN 的 Numpy 实现

import numpy as np
timesteps = 100
input_features = 32
output_features = 64
inputs = np.random.random((timesteps, input_features))
state_t = np.zeros((output_features,))
W = np.random.random((output_features, input_features))
U = np.random.random((output_features, output_features))
b = np.random.random((output_features,))
successive_outputs = []
for input_t in inputs:
 output_t = np.tanh(np.dot(W, input_t) + np.dot(U, state_t) + b)
 successive_outputs.append(output_t)
 state_t = output_t
final_output_sequence = np.stack(successive_outputs, axis=0)

足够简单。总之，RNN 是一个 for 循环，它重复使用循环前一次迭代的计算结果，仅此而已。 当然，你可以构建许多不同的RNN，它们都满足上述定义。这个例子只是最简单的RNN表述之一。 RNN 的特征在于其时间步函数，比如前面例子中的这个函数（见图 6-10）。

output_t = np.tanh(np.dot(W, input_t) + np.dot(U, state_t) + b)

图 6-10　一个简单的 RNN，沿时间展开

注意 本例中，最终输出是一个形状为 (timesteps, output_features) 的二维张量，其中 每个时间步是循环在 t 时刻的输出。输出张量中的每个时间步 t 包含输入序列中时间步 0~t 的信息，即关于全部过去的信息。因此，在多数情况下，你并不需要这个所有输出 组成的序列，你只需要最后一个输出（循环结束时的 output_t），因为它已经包含了整 个序列的信息。

6.2.1 Keras 中的循环层

上面 Numpy 的简单实现，对应一个实际的 Keras 层，即 SimpleRNN 层。

from keras.layers import SimpleRNN

二者有一点小小的区别：SimpleRNN 层能够像其他 Keras 层一样处理序列批量，而不是 像 Numpy 示例那样只能处理单个序列。因此，它接收形状为 (batch_size, timesteps, input_features) 的输入，而不是 (timesteps, input_features)。

与 Keras 中的所有循环层一样，SimpleRNN 可以在两种不同的模式下运行：一种是返回每 个时间步连续输出的完整序列，即形状为 (batch_size, timesteps, output_features) 的三维张量；另一种是只返回每个输入序列的最终输出，即形状为 (batchsize, output features) 的二维张量。这两种模式由 return_sequences 这个构造函数参数来控制。我们 来看一个使用 SimpleRNN 的例子，它只返回最后一个时间步的输出。

>>> from keras.models import Sequential
>>> from keras.layers import Embedding, SimpleRNN
>>> model = Sequential()
>>> model.add(Embedding(10000, 32))
>>> model.add(SimpleRNN(32))
>>> model.summary()
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
embedding_22 (Embedding) (None, None, 32) 320000
_________________________________________________________________
simple_rnn_10 (SimpleRNN) (None, 32) 2080
=================================================================
Total params: 322,080
Trainable params: 322,080
Non-trainable params: 0

下面这个例子返回完整的状态序列。

>>> model = Sequential()
>>> model.add(Embedding(10000, 32))
>>> model.add(SimpleRNN(32, return_sequences=True))
>>> model.summary()
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
embedding_23 (Embedding) (None, None, 32) 320000
_________________________________________________________________
simple_rnn_11 (SimpleRNN) (None, None, 32) 2080
=================================================================
Total params: 322,080
Trainable params: 322,080
Non-trainable params: 0

为了提高网络的表示能力，将多个循环层逐个堆叠有时也是很有用的。在这种情况下，你需要让所有中间层都返回完整的输出序列。

>>> model = Sequential()
>>> model.add(Embedding(10000, 32))
>>> model.add(SimpleRNN(32, return_sequences=True))
>>> model.add(SimpleRNN(32, return_sequences=True))
>>> model.add(SimpleRNN(32, return_sequences=True))
>>> model.add(SimpleRNN(32))
>>> model.summary()
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
embedding_24 (Embedding) (None, None, 32) 320000
_________________________________________________________________
simple_rnn_12 (SimpleRNN) (None, None, 32) 2080
_________________________________________________________________
simple_rnn_13 (SimpleRNN) (None, None, 32) 2080
_________________________________________________________________
simple_rnn_14 (SimpleRNN) (None, None, 32) 2080
_________________________________________________________________
simple_rnn_15 (SimpleRNN) (None, 32) 2080
=================================================================
Total params: 328,320
Trainable params: 328,320
Non-trainable params: 0

接下来，我们将这个模型应用于 IMDB 电影评论分类问题。首先，对数据进行预处理。

代码清单 6-22　准备 IMDB 数据

from keras.datasets import imdb
from keras.preprocessing import sequence
max_features = 10000
maxlen = 500
batch_size = 32
print('Loading data...')
(input_train, y_train), (input_test, y_test) = imdb.load_data(
 num_words=max_features)
print(len(input_train), 'train sequences')
print(len(input_test), 'test sequences')
print('Pad sequences (samples x time)')
input_train = sequence.pad_sequences(input_train, maxlen=maxlen)
input_test = sequence.pad_sequences(input_test, maxlen=maxlen)
print('input_train shape:', input_train.shape)
print('input_test shape:', input_test.shape)

我们用一个 Embedding 层和一个 SimpleRNN 层来训练一个简单的循环网络。

代码清单 6-23　用 Embedding 层和 SimpleRNN 层来训练模型

from keras.layers import Dense
model = Sequential()
model.add(Embedding(max_features, 32))
model.add(SimpleRNN(32))
model.add(Dense(1, activation='sigmoid'))
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['acc'])
history = model.fit(input_train, y_train,
 epochs=10,
 batch_size=128,
 validation_split=0.2)

接下来显示训练和验证的损失和精度（见图 6-11 和图 6-12）。

代码清单 6-24　绘制结果

import matplotlib.pyplot as plt
acc = history.history['acc']
val_acc = history.history['val_acc']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(1, len(acc) + 1)
plt.plot(epochs, acc, 'bo', label='Training acc')
plt.plot(epochs, val_acc, 'b', label='Validation acc')
plt.title('Training and validation accuracy')
plt.legend()
plt.figure()
plt.plot(epochs, loss, 'bo', label='Training loss')
plt.plot(epochs, val_loss, 'b', label='Validation loss')
plt.title('Training and validation loss')
plt.legend()
plt.show()

图 6-11　将 SimpleRNN 应用于 IMDB 的训练损失和验证损失

图 6-12　将 SimpleRNN 应用于 IMDB 的训练精度和验证精度

提醒一下，在第 3 章，处理这个数据集的第一个简单方法得到的测试精度是 88%。不幸的是， 与这个基准相比，这个小型循环网络的表现并不好（验证精度只有 85%）。问题的部分原因在于， 输入只考虑了前 500 个单词，而不是整个序列，因此，RNN 获得的信息比前面的基准模型更少。 另一部分原因在于，SimpleRNN 不擅长处理长序列，比如文本。

其他类型的循环层的表现要好得多。我们来看几个更高级的循环层。

6.2.2　理解 LSTM 层和 GRU 层

SimpleRNN 并不是 Keras 中唯一可用的循环层，还有另外两个：LSTM 和 GRU。在实践中总会用到其中之一，因为 SimpleRNN 通常过于简化，没有实用价值。SimpleRNN 的最大问题是， 在时刻 t，理论上来说，它应该能够记住许多时间步之前见过的信息，但实际上它是不可能学 到这种长期依赖的。其原因在于梯度消失问题（vanishing gradient problem），这一效应类似于 在层数较多的非循环网络（即前馈网络）中观察到的效应：随着层数的增加，网络最终变得无 法训练。Hochreiter、Schmidhuber 和 Bengio 在 20 世纪 90 年代初研究了这一效应的理论原因 a。 LSTM 层和 GRU 层都是为了解决这个问题而设计的。

先来看 LSTM 层。其背后的长短期记忆（LSTM，long short-term memory）算法由 Hochreiter 和 Schmidhuber 在 1997 年开发 b，是二人研究梯度消失问题的重要成果。

LSTM 层是 SimpleRNN 层的一种变体，它增加了一种携带信息跨越多个时间步的方法。假设有一条传送带，其运行方向平行于你所处理的序列。序列中的信息可以在任意位置跳上传送带， 然后被传送到更晚的时间步，并在需要时原封不动地跳回来。这实际上就是 LSTM 的原理：它 保存信息以便后面使用，从而防止较早期的信号在处理过程中逐渐消失。

为了详细了解 LSTM，我们先从 SimpleRNN 单元开始讲起（见图 6-13）。因为有许多个权 重矩阵，所以对单元中的 W 和 U 两个矩阵添加下标字母 o（Wo 和 Uo），表示输出。

图 6-13　讨论 LSTM 层的出发点：SimpleRNN 层

我们向这张图像中添加额外的数据流，其中携带着跨越时间步的信息。它在不同的时间步 的值叫作 Ct，其中 C 表示携带（carry）。这些信息将会对单元产生以下影响：它将与输入连接 和循环连接进行运算（通过一个密集变换，即与权重矩阵作点积，然后加上一个偏置，再应用 一个激活函数），从而影响传递到下一个时间步的状态（通过一个激活函数和一个乘法运算）。从概念上来看，携带数据流是一种调节下一个输出和下一个状态的方法（见图 6-14）。到目前为 止都很简单。

图 6-14　从 SimpleRNN 到 LSTM：添加一个携带轨道

下面来看这一方法的精妙之处，即携带数据流下一个值的计算方法。它涉及三个不同的变换， 这三个变换的形式都和 SimpleRNN 单元相同。

y = activation(dot(state_t, U) + dot(input_t, W) + b)

但这三个变换都具有各自的权重矩阵，我们分别用字母 i、j 和 k 作为下标。目前的模型 架构如下所示（这可能看起来有些随意，但请多一点耐心）。

代码清单 6-25 LSTM 架构的详细伪代码（1/2）

output_t = activation(dot(state_t, Uo) + dot(input_t, Wo) + dot(C_t, Vo) + bo)
i_t = activation(dot(state_t, Ui) + dot(input_t, Wi) + bi)
f_t = activation(dot(state_t, Uf) + dot(input_t, Wf) + bf)
k_t = activation(dot(state_t, Uk) + dot(input_t, Wk) + bk)

对 i_t、f_t 和 k_t 进行组合，可以得到新的携带状态（下一个 c_t）。

代码清单 6-26 LSTM 架构的详细伪代码（2/2）

c_t+1 = i_t * k_t + c_t * f_t

图 6-15 给出了添加上述架构之后的图示。LSTM 层的内容我就介绍完了。不算复杂吧？

图 6-15　剖析 LSTM

如果要更哲学一点，你还可以解释每个运算的目的。比如你可以说，将 c_t 和 f_t 相乘， 是为了故意遗忘携带数据流中的不相关信息。同时，i_t 和 k_t 都提供关于当前的信息，可以 用新信息来更新携带轨道。但归根结底，这些解释并没有多大意义，因为这些运算的实际效果 是由参数化权重决定的，而权重是以端到端的方式进行学习，每次训练都要从头开始，不可能 为某个运算赋予特定的目的。RNN 单元的类型（如前所述）决定了你的假设空间，即在训练期 间搜索良好模型配置的空间，但它不能决定 RNN 单元的作用，那是由单元权重来决定的。同一 个单元具有不同的权重，可以实现完全不同的作用。因此，组成 RNN 单元的运算组合，最好被 解释为对搜索的一组约束，而不是一种工程意义上的设计。

对于研究人员来说，这种约束的选择（即如何实现 RNN 单元）似乎最好是留给最优化算法来完成（比如遗传算法或强化学习过程），而不是让人类工程师来完成。在未来，那将是我们构 建网络的方式。总之，你不需要理解关于 LSTM 单元具体架构的任何内容。作为人类，理解它不应该是你要做的。你只需要记住 LSTM 单元的作用：允许过去的信息稍后重新进入，从而解决梯度消失问题。

6.2.3 Keras 中一个 LSTM 的具体例子

现在我们来看一个更实际的问题：使用 LSTM 层来创建一个模型，然后在 IMDB 数据上 训练模型（见图 6-16 和图 6-17）。这个网络与前面介绍的 SimpleRNN 网络类似。你只需指定 LSTM 层的输出维度，其他所有参数（有很多）都使用 Keras 默认值。Keras 具有很好的默认值， 无须手动调参，模型通常也能正常运行。

代码清单 6-27　使用 Keras 中的 LSTM 层

from keras.layers import LSTM
model = Sequential()
model.add(Embedding(max_features, 32))
model.add(LSTM(32))
model.add(Dense(1, activation='sigmoid'))
model.compile(optimizer='rmsprop',
 loss='binary_crossentropy',
 metrics=['acc'])
history = model.fit(input_train, y_train,
 epochs=10,
 batch_size=128,
 validation_split=0.2)

图 6-16　将 LSTM 应用于 IMDB 的训练损失和验证损失

图 6-17　将 LSTM 应用于 IMDB 的训练精度和验证精度

这一次，验证精度达到了 89%。还不错，肯定比 SimpleRNN 网络好多了，这主要是因为 LSTM 受梯度消失问题的影响要小得多。这个结果也比第 3 章的全连接网络略好，虽然使用的数据量比第 3 章要少。此处在 500 个时间步之后将序列截断，而在第 3 章是读取整个序列。

但对于一种计算量如此之大的方法而言，这个结果也说不上是突破性的。为什么 LSTM 不 能表现得更好？一个原因是你没有花力气来调节超参数，比如嵌入维度或 LSTM 输出维度。另 一个原因可能是缺少正则化。但说实话，主要原因在于，适用于评论分析全局的长期性结构（这 正是 LSTM 所擅长的），对情感分析问题帮助不大。对于这样的基本问题，观察每条评论中出现 了哪些词及其出现频率就可以很好地解决。这也正是第一个全连接方法的做法。但还有更加困难的自然语言处理问题，特别是问答和机器翻译，这时 LSTM 的优势就明显了。

6.2.4　小结

现在你已经学会了以下内容。

• 循环神经网络（RNN）的概念及其工作原理。
• 长短期记忆（LSTM）是什么，为什么它在长序列上的效果要好于普通 RNN。
• 如何使用 Keras 的 RNN 层来处理序列数据。

接下来，我们将介绍 RNN 几个更高级的功能，这可以帮你有效利用深度学习序列模型。

6.3　循环神经网络的高级用法

本节将介绍提高循环神经网络的性能和泛化能力的三种高级技巧。学完本节，你将会掌握用 Keras 实现循环网络的大部分内容。我们将在温度预测问题中介绍这三个概念。在这个问题中， 数据点时间序列来自建筑物屋顶安装的传感器，包括温度、气压、湿度等，你将要利用这些数据来预测最后一个数据点 24 小时之后的温度。这是一个相当有挑战性的问题，其中包含许多处理时间序列时经常遇到的困难。

我们将会介绍以下三种技巧。

• 循环 dropout（recurrent dropout）。这是一种特殊的内置方法，在循环层中使用 dropout 来降低过拟合。
• 堆叠循环层（stacking recurrent layers）。这会提高网络的表示能力（代价是更高的计算负 荷）。
• 双向循环层（bidirectional recurrent layer）。将相同的信息以不同的方式呈现给循环网络， 可以提高精度并缓解遗忘问题。

6.3.1　温度预测问题

到目前为止，我们遇到的唯一一种序列数据就是文本数据，比如 IMDB 数据集和路透社数据集。但除了语言处理，其他许多问题中也都用到了序列数据。在本节的所有例子中，我 们将使用一个天气时间序列数据集，它由德国耶拿的马克思 • 普朗克生物地球化学研究所的气 象站记录。

在这个数据集中，每 10 分钟记录 14 个不同的量（比如气温、气压、湿度、风向等），其中 包含多年的记录。原始数据可追溯到 2003 年，但本例仅使用 2009—2016 年的数据。这个数据 集非常适合用来学习处理数值型时间序列。我们将会用这个数据集来构建模型，输入最近的一 些数据（几天的数据点），可以预测 24 小时之后的气温。

下载并解压数据，如下所示。

cd ~/Downloads
mkdir jena_climate
cd jena_climate
wget https://s3.amazonaws.com/keras-datasets/jena_climate_2009_2016.csv.zip
unzip jena_climate_2009_2016.csv.zip

来观察一下数据。

代码清单 6-28　观察耶拿天气数据集的数据

import os
data_dir = '/users/fchollet/Downloads/jena_climate'
fname = os.path.join(data_dir, 'jena_climate_2009_2016.csv')
f = open(fname)
data = f.read()
f.close()
lines = data.split('\n')
header = lines[0].split(',')
lines = lines[1:]
print(header)
print(len(lines))

从输出可以看出，共有 420 551 行数据（每行是一个时间步，记录了一个日期和 14 个与天 气有关的值），还输出了下列表头。

["Date Time",
 "p (mbar)",
 "T (degC)",
 "Tpot (K)",
 "Tdew (degC)",
 "rh (%)",
 "VPmax (mbar)",
 "VPact (mbar)",
 "VPdef (mbar)",
 "sh (g/kg)",
 "H2OC (mmol/mol)",
 "rho (g/m**3)",
 "wv (m/s)",
 "max. wv (m/s)",
 "wd (deg)"]

接下来，将 420 551 行数据转换成一个 Numpy 数组。

代码清单 6-29　解析数据

import numpy as np
float_data = np.zeros((len(lines), len(header) - 1))
for i, line in enumerate(lines):
 values = [float(x) for x in line.split(',')[1:]]
 float_data[i, :] = values

比如，温度随时间的变化如图 6-18 所示（单位：摄氏度）。在这张图中，你可以清楚地看 到温度每年的周期性变化。

代码清单 6-30　绘制温度时间序列

from matplotlib import pyplot as plt
temp = float_data[:, 1] # 温度（单位：摄氏度）
plt.plot(range(len(temp)), temp)

图 6-18　在数据集整个时间范围内的温度（单位：摄氏度）

图 6-19 给出了前 10 天温度数据的图像。因为每 10 分钟记录一个数据，所以每天有 144 个 数据点。

代码清单 6-31　绘制前 10 天的温度时间序列

plt.plot(range(1440), temp[:1440])

图 6-19　数据集中前 10 天的温度（单位：摄氏度）

在这张图中，你可以看到每天的周期性变化，尤其是最后 4 天特别明显。另外请注意，这 10 天一定是来自于很冷的冬季月份。

如果你想根据过去几个月的数据来预测下个月的平均温度，那么问题很简单，因为数据具有可靠的年度周期性。但从几天的数据来看，温度看起来更混乱一些。以天作为观察尺度，这个时间序列是可以预测的吗？我们来寻找这个问题的答案。

6.3.2　准备数据

这个问题的确切表述如下：一个时间步是 10 分钟，每 steps 个时间步采样一次数据，给 定过去 lookback 个时间步之内的数据，能否预测 delay 个时间步之后的温度？用到的参数值如下。

• lookback = 720：给定过去 5 天内的观测数据。
• steps = 6：观测数据的采样频率是每小时一个数据点。
• delay = 144：目标是未来 24 小时之后的数据。 开始之前，你需要完成以下两件事。
• 将数据预处理为神经网络可以处理的格式。这很简单。数据已经是数值型的，所以不需 要做向量化。但数据中的每个时间序列位于不同的范围（比如温度通道位于 -20 到 +30 之间，但气压大约在 1000 毫巴上下）。你需要对每个时间序列分别做标准化，让它们在 相似的范围内都取较小的值。
• 编写一个 Python 生成器，以当前的浮点数数组作为输入，并从最近的数据中生成数据批 量，同时生成未来的目标温度。因为数据集中的样本是高度冗余的（对于第 N 个样本和 第 N+1 个样本，大部分时间步都是相同的），所以显式地保存每个样本是一种浪费。相反， 我们将使用原始数据即时生成样本。

预处理数据的方法是，将每个时间序列减去其平均值，然后除以其标准差。我们将使用前 200 000 个时间步作为训练数据，所以只对这部分数据计算平均值和标准差。

代码清单 6-32　数据标准化

mean = float_data[:200000].mean(axis=0)
float_data -= mean
std = float_data[:200000].std(axis=0)
float_data /= std

代码清单 6-33 给出了将要用到的生成器。它生成了一个元组 (samples, targets)，其中 samples 是输入数据的一个批量，targets 是对应的目标温度数组。生成器的参数如下。

• data：浮点数数据组成的原始数组，在代码清单 6-32 中将其标准化。
• lookback：输入数据应该包括过去多少个时间步。
• delay：目标应该在未来多少个时间步之后。
• min_index 和 max_index：data 数组中的索引，用于界定需要抽取哪些时间步。这有 助于保存一部分数据用于验证、另一部分用于测试。
• shuffle：是打乱样本，还是按顺序抽取样本。
• batch_size：每个批量的样本数。
• step：数据采样的周期（单位：时间步）。我们将其设为 6，为的是每小时抽取一个数据点。

代码清单 6-33　生成时间序列样本及其目标的生成器

def generator(data, lookback, delay, min_index, max_index,
 shuffle=False, batch_size=128, step=6):
 if max_index is None:
 max_index = len(data) - delay - 1
 i = min_index + lookback
 while 1:
 if shuffle:
 rows = np.random.randint(
 min_index + lookback, max_index, size=batch_size)
 else:
 if i + batch_size >= max_index:
 i = min_index + lookback
 rows = np.arange(i, min(i + batch_size, max_index))
 i += len(rows)
 samples = np.zeros((len(rows),
 lookback // step,
 data.shape[-1]))
 targets = np.zeros((len(rows),))
 for j, row in enumerate(rows):
 indices = range(rows[j] - lookback, rows[j], step)
 samples[j] = data[indices]
 targets[j] = data[rows[j] + delay][1]
 yield samples, targets

下面，我们使用这个抽象的 generator 函数来实例化三个生成器：一个用于训练，一个用于验证，还有一个用于测试。每个生成器分别读取原始数据的不同时间段：训练生成器读取前 200 000 个时间步，验证生成器读取随后的 100 000 个时间步，测试生成器读取剩下的时间步。

代码清单 6-34　准备训练生成器、验证生成器和测试生成器

lookback = 1440
step = 6
delay = 144
batch_size = 128
train_gen = generator(float_data,
 lookback=lookback,
 delay=delay,
 min_index=0,
 max_index=200000,
 shuffle=True,
 step=step,
 batch_size=batch_size)
val_gen = generator(float_data,
 lookback=lookback,
 delay=delay,
 min_index=200001,
 max_index=300000,
 step=step,
 batch_size=batch_size)
test_gen = generator(float_data,
 lookback=lookback,
 delay=delay,
 min_index=300001,
 max_index=None,
 step=step,
 batch_size=batch_size)
val_steps = (300000 - 200001 - lookback) //batch_size
test_steps = (len(float_data) - 300001 - lookback) //batch_size 

6.3.3　一种基于常识的、非机器学习的基准方法

开始使用黑盒深度学习模型解决温度预测问题之前，我们先尝试一种基于常识的简单方法。 它可以作为合理性检查，还可以建立一个基准，更高级的机器学习模型需要打败这个基准才能 表现出其有效性。面对一个尚没有已知解决方案的新问题时，这种基于常识的基准方法很有用。 一个经典的例子就是不平衡的分类任务，其中某些类别比其他类别更常见。如果数据集中包含 90% 的类别 A 实例和 10% 的类别 B 实例，那么分类任务的一种基于常识的方法就是对新样本 始终预测类别“A”。这种分类器的总体精度为 90%，因此任何基于学习的方法在精度高于 90% 时才能证明其有效性。有时候，这样基本的基准方法可能很难打败。

本例中，我们可以放心地假设，温度时间序列是连续的（明天的温度很可能接近今天的温 度），并且具有每天的周期性变化。因此，一种基于常识的方法就是始终预测 24 小时后的温度 等于现在的温度。我们使用平均绝对误差（MAE）指标来评估这种方法。

np.mean(np.abs(preds - targets))

下面是评估的循环代码。

代码清单 6-35　计算符合常识的基准方法的 MAE

def evaluate_naive_method():
 batch_maes = []
 for step in range(val_steps):
 samples, targets = next(val_gen)
 preds = samples[:, -1, 1]
 mae = np.mean(np.abs(preds - targets))
 batch_maes.append(mae)
 print(np.mean(batch_maes))
evaluate_naive_method()

得到的 MAE 为 0.29。因为温度数据被标准化成均值为 0、标准差为 1，所以无法直接对这 个值进行解释。它转化成温度的平均绝对误差为 0.29×temperature_std 摄氏度，即 2.57℃。

代码清单 6-36　将 MAE 转换成摄氏温度误差

celsius_mae = 0.29 * std[1]

这个平均绝对误差还是相当大的。接下来的任务是利用深度学习知识来改进结果。

6.3.4　一种基本的机器学习方法

在尝试机器学习方法之前，建立一个基于常识的基准方法是很有用的；同样，在开始研究复杂且计算代价很高的模型（比如 RNN）之前，尝试使用简单且计算代价低的机器学习模型也 是很有用的，比如小型的密集连接网络。这可以保证进一步增加问题的复杂度是合理的，并且会带来真正的好处。

代码清单 6-37 给出了一个密集连接模型，首先将数据展平，然后通过两个 Dense 层并运行。 注意，最后一个 Dense 层没有使用激活函数，这对于回归问题是很常见的。我们使用 MAE 作 为损失。评估数据和评估指标都与常识方法完全相同，所以可以直接比较两种方法的结果。

代码清单 6-37　训练并评估一个密集连接模型

from keras.models import Sequential
from keras import layers
from keras.optimizers import RMSprop
model = Sequential()
model.add(layers.Flatten(input_shape=(lookback // step, float_data.shape[-1])))
model.add(layers.Dense(32, activation='relu'))
model.add(layers.Dense(1))
model.compile(optimizer=RMSprop(), loss='mae')
history = model.fit_generator(train_gen,
 steps_per_epoch=500,
 epochs=20,
 validation_data=val_gen,
 validation_steps=val_steps)

我们来显示验证和训练的损失曲线（见图 6-20）。

代码清单 6-38　绘制结果

import matplotlib.pyplot as plt
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(1, len(loss) + 1)
plt.figure()
plt.plot(epochs, loss, 'bo', label='Training loss')
plt.plot(epochs, val_loss, 'b', label='Validation loss')
plt.title('Training and validation loss')
plt.legend()
plt.show()

图 6-20　简单的密集连接网络在耶拿温度预测任务上的训练损失和验证损失

部分验证损失接近不包含学习的基准方法，但这个结果并不可靠。这也展示了首先建立这 个基准方法的优点，事实证明，超越这个基准并不容易。我们的常识中包含了大量有价值的信息， 而机器学习模型并不知道这些信息。

你可能会问，如果从数据到目标之间存在一个简单且表现良好的模型（即基于常识的基准 方法），那为什么我们训练的模型没有找到这个模型并进一步改进呢？原因在于，这个简单的解决方案并不是训练过程所要寻找的目标。我们在模型空间（即假设空间）中搜索解决方案，这 个模型空间是具有我们所定义的架构的所有两层网络组成的空间。这些网络已经相当复杂了。 如果你在一个复杂模型的空间中寻找解决方案，那么可能无法学到简单且性能良好的基准方法， 虽然技术上来说它属于假设空间的一部分。通常来说，这对机器学习是一个非常重要的限制： 如果学习算法没有被硬编码要求去寻找特定类型的简单模型，那么有时候参数学习是无法找到 简单问题的简单解决方案的。

6.3.5　第一个循环网络基准

第一个全连接方法的效果并不好，但这并不意味着机器学习不适用于这个问题。前一个方 法首先将时间序列展平，这从输入数据中删除了时间的概念。我们来看一下数据本来的样子： 它是一个序列，其中因果关系和顺序都很重要。我们将尝试一种循环序列处理模型，它应该特 别适合这种序列数据，因为它利用了数据点的时间顺序，这与第一个方法不同。

我们将使用 Chung 等人在 2014 年开发的 GRU 层 a，而不是上一节介绍的 LSTM 层。门控循 环单元（GRU，gated recurrent unit）层的工作原理与 LSTM 相同。但它做了一些简化，因此运 行的计算代价更低（虽然表示能力可能不如 LSTM）。机器学习中到处可以见到这种计算代价与 表示能力之间的折中。

代码清单 6-39　训练并评估一个基于 GRU 的模型

from keras.models import Sequential
from keras import layers
from keras.optimizers import RMSprop
model = Sequential()
model.add(layers.GRU(32, input_shape=(None, float_data.shape[-1])))
model.add(layers.Dense(1))
model.compile(optimizer=RMSprop(), loss='mae')
history = model.fit_generator(train_gen,
 steps_per_epoch=500,
 epochs=20,
 validation_data=val_gen,
 validation_steps=val_steps)

图 6-21 显示了模型结果。效果好多了！远优于基于常识的基准方法。这证明了机器学习的 价值，也证明了循环网络与序列展平的密集网络相比在这种任务上的优势。

图 6-21　使用 GRU 在耶拿温度预测任务上的训练损失和验证损失

新的验证 MAE 约为 0.265（在开始显著过拟合之前），反标准化转换成温度的平均绝对误 差为 2.35℃。与最初的误差 2.57℃相比，这个结果确实有所提高，但可能仍有改进的空间。

6.3.6　使用循环 dropout 来降低过拟合

从训练和验证曲线中可以明显看出，模型出现过拟合：几轮过后，训练损失和验证损失就 开始显著偏离。我们已经学过降低过拟合的一种经典技术——dropout，即将某一层的输入单 元随机设为 0，其目的是打破该层训练数据中的偶然相关性。但在循环网络中如何正确地使用 dropout，这并不是一个简单的问题。人们早就知道，在循环层前面应用 dropout，这种正则化会 妨碍学习过程，而不是有所帮助。2015 年，在关于贝叶斯深度学习的博士论文中 a，Yarin Gal 确 定了在循环网络中使用 dropout 的正确方法：对每个时间步应该使用相同的 dropout 掩码（dropout mask，相同模式的舍弃单元），而不是让 dropout 掩码随着时间步的增加而随机变化。此外，为 了对 GRU、LSTM 等循环层得到的表示做正则化，应该将不随时间变化的 dropout 掩码应用于层 的内部循环激活（叫作循环 dropout 掩码）。对每个时间步使用相同的 dropout 掩码，可以让网络 沿着时间正确地传播其学习误差，而随时间随机变化的 dropout 掩码则会破坏这个误差信号，并 且不利于学习过程。

Yarin Gal 使用 Keras 开展这项研究，并帮助将这种机制直接内置到 Keras 循环层中。Keras 的每个循环层都有两个与 dropout 相关的参数：一个是 dropout，它是一个浮点数，指定该层 输入单元的 dropout 比率；另一个是 recurrent_dropout，指定循环单元的 dropout 比率。我 们向 GRU 层中添加 dropout 和循环 dropout，看一下这么做对过拟合的影响。因为使用 dropout 正则化的网络总是需要更长的时间才能完全收敛，所以网络训练轮次增加为原来的 2 倍。

代码清单 6-40　训练并评估一个使用 dropout 正则化的基于 GRU 的模型

from keras.models import Sequential
from keras import layers
from keras.optimizers import RMSprop
model = Sequential()
model.add(layers.GRU(32,
 dropout=0.2,
 recurrent_dropout=0.2,
 input_shape=(None, float_data.shape[-1])))
model.add(layers.Dense(1))
model.compile(optimizer=RMSprop(), loss='mae')
history = model.fit_generator(train_gen,
 steps_per_epoch=500,
 epochs=40,
 validation_data=val_gen,
 validation_steps=val_steps)

结果如图 6-22 所示。成功！前 30 个轮次不再过拟合。不过，虽然评估分数更加稳定，但 最佳分数并没有比之前低很多。

图 6-22　使用 dropout 正则化的 GRU 在耶拿温度预测任务上的训练损失和验证损失

6.3.7　循环层堆叠

模型不再过拟合，但似乎遇到了性能瓶颈，所以我们应该考虑增加网络容量。回想一下机 器学习的通用工作流程：增加网络容量通常是一个好主意，直到过拟合变成主要的障碍（假设 你已经采取基本步骤来降低过拟合，比如使用 dropout）。只要过拟合不是太严重，那么很可能 是容量不足的问题。

增加网络容量的通常做法是增加每层单元数或增加层数。循环层堆叠（recurrent layer stacking）是构建更加强大的循环网络的经典方法，例如，目前谷歌翻译算法就是 7 个大型LSTM 层的堆叠——这个架构很大。

在 Keras 中逐个堆叠循环层，所有中间层都应该返回完整的输出序列（一个 3D 张量），而 不是只返回最后一个时间步的输出。这可以通过指定 return_sequences=True 来实现。

代码清单 6-41　训练并评估一个使用 dropout 正则化的堆叠 GRU 模型

from keras.models import Sequential
from keras import layers
from keras.optimizers import RMSprop
model = Sequential()
model.add(layers.GRU(32,
 dropout=0.1,
 recurrent_dropout=0.5,
 return_sequences=True,
 input_shape=(None, float_data.shape[-1])))
model.add(layers.GRU(64, activation='relu',
 dropout=0.1,
 recurrent_dropout=0.5))
model.add(layers.Dense(1))
model.compile(optimizer=RMSprop(), loss='mae')
history = model.fit_generator(train_gen,
 steps_per_epoch=500,
 epochs=40,
 validation_data=val_gen,
 validation_steps=val_steps)

结果如图 6-23 所示。可以看到，添加一层的确对结果有所改进，但并不显著。我们可以得 出两个结论。

• 因为过拟合仍然不是很严重，所以可以放心地增大每层的大小，以进一步改进验证损失。 但这么做的计算成本很高。
• 添加一层后模型并没有显著改进，所以你可能发现，提高网络能力的回报在逐渐减小。

图 6-23　堆叠 GRU 网络在耶拿温度预测任务上的训练损失和验证损失

6.3.8　使用双向 RNN

本节介绍的最后一种方法叫作双向 RNN（bidirectional RNN）。双向 RNN 是一种常见的 RNN 变体，它在某些任务上的性能比普通 RNN 更好。它常用于自然语言处理，可谓深度学习 对自然语言处理的瑞士军刀。

RNN 特别依赖于顺序或时间，RNN 按顺序处理输入序列的时间步，而打乱时间步或反转 时间步会完全改变 RNN 从序列中提取的表示。正是由于这个原因，如果顺序对问题很重要（比 如温度预测问题），RNN 的表现会很好。双向 RNN 利用了 RNN 的顺序敏感性：它包含两个普 通 RNN，比如你已经学过的 GRU 层和 LSTM 层，每个 RN 分别沿一个方向对输入序列进行处理 （时间正序和时间逆序），然后将它们的表示合并在一起。通过沿这两个方向处理序列，双向 RNN 能够捕捉到可能被单向 RNN 忽略的模式。

值得注意的是，本节的 RNN 层都是按时间正序处理序列（更早的时间步在前），这可能是 一个随意的决定。至少，至今我们还没有尝试质疑这个决定。如果 RNN 按时间逆序处理输入序 列（更晚的时间步在前），能否表现得足够好呢？我们在实践中尝试一下这种方法，看一下会发 生什么。你只需要编写一个数据生成器的变体，将输入序列沿着时间维度反转（即将最后一行 代码替换为 yield samples[:, ::-1, :], targets）。本节第一个实验用到了一个单 GRU 层的网络，我们训练一个与之相同的网络，得到的结果如图 6-24 所示。

图 6-24　对于耶拿温度预测任务，GRU 在逆序序列上训练得到的训练损失和验证损失

逆序 GRU 的效果甚至比基于常识的基准方法还要差很多，这说明在本例中，按时间正序处 理对成功解决问题很重要。这非常合理：GRU 层通常更善于记住最近的数据，而不是久远的数据， 与更早的数据点相比，更靠后的天气数据点对问题自然具有更高的预测能力（这也是基于常识 的基准方法非常强大的原因）。因此，按时间正序的模型必然会优于时间逆序的模型。重要的是， 对许多其他问题（包括自然语言）而言，情况并不是这样：直觉上来看，一个单词对理解句子 的重要性通常并不取决于它在句子中的位置。我们尝试对 6.2 节 IMDB 示例中的 LSTM 应用相 同的技巧。

代码清单 6-42　使用逆序序列训练并评估一个 LSTM

from keras.datasets import imdb
from keras.preprocessing import sequence
from keras import layers
from keras.models import Sequential
max_features = 10000
maxlen = 500
(x_train, y_train), (x_test, y_test) = imdb.load_data(
 num_words=max_features)
x_train = [x[::-1] for x in x_train]
x_test = [x[::-1] for x in x_test]
x_train = sequence.pad_sequences(x_train, maxlen=maxlen)
x_test = sequence.pad_sequences(x_test, maxlen=maxlen)
model = Sequential()
model.add(layers.Embedding(max_features, 128))
model.add(layers.LSTM(32))
model.add(layers.Dense(1, activation='sigmoid'))
model.compile(optimizer='rmsprop',
 loss='binary_crossentropy',
 metrics=['acc'])
history = model.fit(x_train, y_train,
 epochs=10,
 batch_size=128,
 validation_split=0.2)

模型性能与正序 LSTM 几乎相同。值得注意的是，在这样一个文本数据集上，逆序处理的 效果与正序处理一样好，这证实了一个假设：虽然单词顺序对理解语言很重要，但使用哪种顺 序并不重要。重要的是，在逆序序列上训练的 RNN 学到的表示不同于在原始序列上学到的表示， 正如在现实世界中，如果时间倒流（你的人生是第一天死去、最后一天出生），那么你的心智模 型也会完全不同。在机器学习中，如果一种数据表示不同但有用，那么总是值得加以利用，这 种表示与其他表示的差异越大越好，它们提供了查看数据的全新角度，抓住了数据中被其他方 法忽略的内容，因此可以提高模型在某个任务上的性能。这是集成（ensembling）方法背后的直 觉，我们将在第 7 章介绍集成的概念。

双向 RNN 正是利用这个想法来提高正序 RNN 的性能。它从两个方向查看数据（见图 6-25）， 从而得到更加丰富的表示，并捕捉到仅使用正序 RNN 时可能忽略的一些模式。

图 6-25　双向 RNN 层的工作原理

在 Keras 中将一个双向 RNN 实例化，我们需要使用 Bidirectional 层，它的第一个参数 是一个循环层实例。Bidirectional 对这个循环层创建了第二个单独实例，然后使用一个实例 按正序处理输入序列，另一个实例按逆序处理输入序列。我们在 IMDB 情感分析任务上来试一 下这种方法。

代码清单 6-43　训练并评估一个双向 LSTM

model = Sequential()
model.add(layers.Embedding(max_features, 32))
model.add(layers.Bidirectional(layers.LSTM(32)))
model.add(layers.Dense(1, activation='sigmoid'))
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['acc'])
history = model.fit(x_train, y_train,
 epochs=10,
 batch_size=128,
 validation_split=0.2)

这个模型的表现比上一节的普通 LSTM 略好，验证精度超过 89%。这个模型似乎也很快就 开始过拟合，这并不令人惊讶，因为双向层的参数个数是正序 LSTM 的 2 倍。添加一些正则化， 双向方法在这个任务上可能会有很好的表现。

接下来，我们尝试将相同的方法应用于温度预测任务。

代码清单 6-44　训练一个双向 GRU

from keras.models import Sequential
from keras import layers
from keras.optimizers import RMSprop
model = Sequential()
model.add(layers.Bidirectional(
 layers.GRU(32), input_shape=(None, float_data.shape[-1])))
model.add(layers.Dense(1))
model.compile(optimizer=RMSprop(), loss='mae')
history = model.fit_generator(train_gen,
 steps_per_epoch=500,
 epochs=40,
 validation_data=val_gen,
 validation_steps=val_steps)

这个模型的表现与普通 GRU 层差不多一样好。其原因很容易理解：所有的预测能力肯定都 来自于正序的那一半网络，因为我们已经知道，逆序的那一半在这个任务上的表现非常糟糕（本 例同样是因为，最近的数据比久远的数据更加重要）。

6.3.9　更多尝试

为了提高温度预测问题的性能，你还可以尝试下面这些方法。

• 在堆叠循环层中调节每层的单元个数。当前取值在很大程度上是任意选择的，因此可能 不是最优的。
• 调节 RMSprop 优化器的学习率。
• 尝试使用 LSTM 层代替 GRU 层。
• 在循环层上面尝试使用更大的密集连接回归器，即更大的 Dense 层或 Dense 层的堆叠。
• 不要忘记最后在测试集上运行性能最佳的模型（即验证 MAE 最小的模型）。否则，你开发的网络架构将会对验证集过拟合。

正如前面所说，深度学习是一门艺术而不是科学。我们可以提供指导，对于给定问题哪些方法可能有用、哪些方法可能没用，但归根结底，每个问题都是独一无二的，你必须根据经验对不同的策略进行评估。目前没有任何理论能够提前准确地告诉你，应该怎么做才能最优地解决问题。你必须不断迭代。

6.3.10　小结

下面是你应该从本节中学到的要点。

• 我们在第 4 章学过，遇到新问题时，最好首先为你选择的指标建立一个基于常识的基准。 如果没有需要打败的基准，那么就无法分辨是否取得了真正的进步。
• 在尝试计算代价较高的模型之前，先尝试一些简单的模型，以此证明增加计算代价是有 意义的。有时简单模型就是你的最佳选择。
• 如果时间顺序对数据很重要，那么循环网络是一种很适合的方法，与那些先将时间数据 展平的模型相比，其性能要更好。
• 想要在循环网络中使用 dropout，你应该使用一个不随时间变化的 dropout 掩码与循环 dropout 掩码。这二者都内置于 Keras 的循环层中，所以你只需要使用循环层的 dropout 和 recurrent_dropout 参数即可。
• 与单个 RNN 层相比，堆叠 RNN 的表示能力更加强大。但它的计算代价也更高，因此不 一定总是需要。虽然它在机器翻译等复杂问题上很有效，但在较小、较简单的问题上可 能不一定有用。
• 双向 RNN 从两个方向查看一个序列，它对自然语言处理问题非常有用。但如果在序列 数据中最近的数据比序列开头包含更多的信息，那么这种方法的效果就不明显。

注意 有两个重要的概念我们这里没有详细介绍：循环注意（recurrent attention）和序列掩码 （sequence masking）。这两个概念通常对自然语言处理特别有用，但并不适用于温度预测 问题。你可以在学完本书后对其做进一步研究。

市场与机器学习

有些读者肯定想要采用我们这里介绍的方法，并尝试将其应用于预测股票市场上证券 的未来价格（或货币汇率等）。市场的统计特征与天气模式等自然现象有很大差别。如果你 只能访问公开可用的数据，那么想要用机器学习来打败市场是一项非常困难的任务，你很可 能会白白浪费时间和资源，却什么也得不到。

6.4　用卷积神经网络处理序列

第 5 章我们学习了卷积神经网络（convnet），并知道它在计算机视觉问题上表现出色，原因 在于它能够进行卷积运算，从局部输入图块中提取特征，并能够将表示模块化，同时可以高效 地利用数据。这些性质让卷积神经网络在计算机视觉领域表现优异，同样也让它对序列处理特 别有效。时间可以被看作一个空间维度，就像二维图像的高度或宽度。

对于某些序列处理问题，这种一维卷积神经网络的效果可以媲美 RNN，而且计算代价通常 要小很多。最近，一维卷积神经网络［通常与空洞卷积核（dilated kernel）一起使用］已经在音 频生成和机器翻译领域取得了巨大成功。除了这些具体的成就，人们还早已知道，对于文本分 类和时间序列预测等简单任务，小型的一维卷积神经网络可以替代 RNN，而且速度更快。

6.4.1　理解序列数据的一维卷积

前面介绍的卷积层都是二维卷积，从图像张量中提取二维图块并对每个图块应用相同的变 换。按照同样的方法，你也可以使用一维卷积，从序列中提取局部一维序列段（即子序列），见 图 6-26。

这种一维卷积层可以识别序列中的局部模式。因为对每个序列段执行相同的输入变换，所 以在句子中某个位置学到的模式稍后可以在其他位置被识别，这使得一维卷积神经网络具有平 移不变性（对于时间平移而言）。举个例子，使用大小为 5 的卷积窗口处理字符序列的一维卷积 神经网络，应该能够学习长度不大于 5 的单词或单词片段，并且应该能够在输入句子中的任何位置识别这些单词或单词段。因此，字符级的一维卷积神经网络能够学会单词构词法。

6-26 一维卷积神经网络的工作原理：每个输出时间步都是利用输入序列 在时间维度上的一小段得到的

6.4.2　序列数据的一维池化

你已经学过二维池化运算，比如二维平均池化和二维最大池化，在卷积神经网络中用于对 图像张量进行空间下采样。一维也可以做相同的池化运算：从输入中提取一维序列段（即子序列）， 然后输出其最大值（最大池化）或平均值（平均池化）。与二维卷积神经网络一样，该运算也是 用于降低一维输入的长度（子采样）。

6.4.3　实现一维卷积神经网络

Keras 中的一维卷积神经网络是 Conv1D 层，其接口类似于 Conv2D。它接收的输入是形状 为 (samples, time, features) 的三维张量，并返回类似形状的三维张量。卷积窗口是时 间轴上的一维窗口（时间轴是输入张量的第二个轴）。

我们来构建一个简单的两层一维卷积神经网络，并将其应用于我们熟悉的 IMDB 情感分类 任务。提醒一下，获取数据并预处理的代码如下所示。

代码清单 6-45　准备 IMDB 数据

from keras.datasets import imdb
from keras.preprocessing import sequence
max_features = 10000
max_len = 500
print('Loading data...')
(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=max_features)
print(len(x_train), 'train sequences')
print(len(x_test), 'test sequences')
print('Pad sequences (samples x time)')
x_train = sequence.pad_sequences(x_train, maxlen=max_len)
x_test = sequence.pad_sequences(x_test, maxlen=max_len)
print('x_train shape:', x_train.shape)
print('x_test shape:', x_test.shape)

一维卷积神经网络的架构与第 5 章的二维卷积神经网络相同，它是 Conv1D 层和 MaxPooling1D 层的堆叠，最后是一个全局池化层或 Flatten 层，将三维输出转换为二维输出，让你可以向模 型中添加一个或多个 Dense 层，用于分类或回归。

不过二者有一点不同：一维卷积神经网络可以使用更大的卷积窗口。对于二维卷积层， 3×3 的卷积窗口包含 3×3=9 个特征向量；但对于一位卷积层，大小为 3 的卷积窗口只包含 3 个卷积向量。因此，你可以轻松使用大小等于 7 或 9 的一维卷积窗口。

用于 IMDB 数据集的一维卷积神经网络示例如下所示。

代码清单 6-46　在 IMDB 数据上训练并评估一个简单的一维卷积神经网络

from keras.models import Sequential
from keras import layers
from keras.optimizers import RMSprop
model = Sequential()
model.add(layers.Embedding(max_features, 128, input_length=max_len))
model.add(layers.Conv1D(32, 7, activation='relu'))
model.add(layers.MaxPooling1D(5))
model.add(layers.Conv1D(32, 7, activation='relu'))
model.add(layers.GlobalMaxPooling1D())
model.add(layers.Dense(1))
model.summary()
model.compile(optimizer=RMSprop(lr=1e-4),
 loss='binary_crossentropy',
 metrics=['acc'])
history = model.fit(x_train, y_train,
 epochs=10,
 batch_size=128,
 validation_split=0.2)

图 6-27 和图 6-28 给出了模型的训练结果和验证结果。验证精度略低于 LSTM，但在 CPU 和 GPU 上的运行速度都要更快（速度提高多少取决于具体配置，会有很大差异）。现在，你可以 使用正确的轮数（4 轮）重新训练这个模型，然后在测试集上运行。这个结果可以让我们确信， 在单词级的情感分类任务上，一维卷积神经网络可以替代循环网络，并且速度更快、计算代价 更低。

图 6-27　简单的一维卷积神经网络在 IMDB 数据上的训练损失和验证损失

图 6-28　简单的一维卷积神经网络在 IMDB 数据上的训练精度和验证精度

6.4.4　结合 CNN 和 RNN 来处理长序列

一维卷积神经网络分别处理每个输入序列段，所以它对时间步的顺序不敏感（这里所说顺 序的范围要大于局部尺度，即大于卷积窗口的大小），这一点与 RNN 不同。当然，为了识别更 长期的模式，你可以将许多卷积层和池化层堆叠在一起，这样上面的层能够观察到原始输入中 更长的序列段，但这仍然不是一种引入顺序敏感性的好方法。想要证明这种方法的不足，一种 方法是在温度预测问题上使用一维卷积神经网络，在这个问题中顺序敏感性对良好的预测结果 非常关键。以下示例复用了前面定义的这些变量：float_data、train_gen、val_gen 和 val_steps。

代码清单 6-47　在耶拿数据上训练并评估一个简单的一维卷积神经网络

from keras.models import Sequential
from keras import layers
from keras.optimizers import RMSprop
model = Sequential()
model.add(layers.Conv1D(32, 5, activation='relu',
 input_shape=(None, float_data.shape[-1])))
model.add(layers.MaxPooling1D(3))
model.add(layers.Conv1D(32, 5, activation='relu'))
model.add(layers.MaxPooling1D(3))
model.add(layers.Conv1D(32, 5, activation='relu'))
model.add(layers.GlobalMaxPooling1D())
model.add(layers.Dense(1))
model.compile(optimizer=RMSprop(), loss='mae')
history = model.fit_generator(train_gen,
 steps_per_epoch=500,
 epochs=20,
 validation_data=val_gen,
 validation_steps=val_steps)

图 6-29 给出了训练和验证的 MAE。

图 6-29　简单的一维卷积神经网络在耶拿温度预测任务上的训练损失和验证损失

验证 MAE 停留在 0.4~0.5，使用小型卷积神经网络甚至无法击败基于常识的基准方法。同样， 这是因为卷积神经网络在输入时间序列的所有位置寻找模式，它并不知道所看到某个模式的时 间位置（距开始多长时间，距结束多长时间等）。对于这个具体的预测问题，对最新数据点的解 释与对较早数据点的解释应该并不相同，所以卷积神经网络无法得到有意义的结果。卷积神经 网络的这种限制对于 IMDB 数据来说并不是问题，因为对于与正面情绪或负面情绪相关联的关 键词模式，无论出现在输入句子中的什么位置，它所包含的信息量是一样的。

要想结合卷积神经网络的速度和轻量与 RNN 的顺序敏感性，一种方法是在 RNN 前面使用 一维卷积神经网络作为预处理步骤（见图 6-30）。对于那些非常长，以至于 RNN 无法处理的序列 （比如包含上千个时间步的序列），这种方法尤其有用。卷积神经网络可以将长的输入序列转换为 高级特征组成的更短序列（下采样）。然后，提取的特征组成的这些序列成为网络中 RNN 的输入。

图 6-30　结合一维 CNN 和 RNN 来处理长序列

这种方法在研究论文和实际应用中并不多见，可能是因为很多人并不知道。这种方法非常 有效，应该被更多人使用。我们尝试将其应用于温度预测数据集。因为这种方法允许操作更长 的序列，所以我们可以查看更早的数据（通过增大数据生成器的 lookback 参数）或查看分辨 率更高的时间序列（通过减小生成器的 step 参数）。这里我们任意地将 step 减半，得到时间 序列的长度变为之前的两倍，温度数据的采样频率变为每 30 分钟一个数据点。本示例复用了之 前定义的 generator 函数。

代码清单 6-48　为耶拿数据集准备更高分辨率的数据生成器

step = 3
lookback = 720
delay = 144
train_gen = generator(float_data,
 lookback=lookback,
 delay=delay,
 min_index=0,
 max_index=200000,
 shuffle=True,
 step=step)
val_gen = generator(float_data,
 lookback=lookback,
 delay=delay,
 min_index=200001,
 max_index=300000,
 step=step)
 test_gen = generator(float_data,
 lookback=lookback,
 delay=delay,
 min_index=300001,
 max_index=None,
 step=step)
val_steps = (300000 - 200001 - lookback) // 128
test_steps = (len(float_data) - 300001 - lookback) // 128

下面是模型，开始是两个 Conv1D 层，然后是一个 GRU 层。模型结果如图 6-31 所示。

代码清单 6-49　结合一维卷积基和 GRU 层的模型

from keras.models import Sequential
from keras import layers
from keras.optimizers import RMSprop
model = Sequential()
model.add(layers.Conv1D(32, 5, activation='relu',
 input_shape=(None, float_data.shape[-1])))
model.add(layers.MaxPooling1D(3))
model.add(layers.Conv1D(32, 5, activation='relu'))
model.add(layers.GRU(32, dropout=0.1, recurrent_dropout=0.5))
model.add(layers.Dense(1))
model.summary()
model.compile(optimizer=RMSprop(), loss='mae')
history = model.fit_generator(train_gen,
 steps_per_epoch=500,
 epochs=20,
 validation_data=val_gen,
 validation_steps=val_steps)

图 6-31　一维卷积神经网络 +GRU 在耶拿温度预测任务上的训练损失和验证损失

从验证损失来看，这种架构的效果不如只用正则化 GRU，但速度要快很多。它查看了两倍 的数据量，在本例中可能不是非常有用，但对于其他数据集可能非常重要。

6.4.5　小结

下面是你应该从本节中学到的要点。

• 二维卷积神经网络在二维空间中处理视觉模式时表现很好，与此相同，一维卷积神经网 络在处理时间模式时表现也很好。对于某些问题，特别是自然语言处理任务，它可以替 代 RNN，并且速度更快。
• 通常情况下，一维卷积神经网络的架构与计算机视觉领域的二维卷积神经网络很相似， 它将 Conv1D 层和 MaxPooling1D 层堆叠在一起，最后是一个全局池化运算或展平操作。
• 因为 RNN 在处理非常长的序列时计算代价很大，但一维卷积神经网络的计算代价很小， 所以在 RNN 之前使用一维卷积神经网络作为预处理步骤是一个好主意，这样可以使序 列变短，并提取出有用的表示交给 RNN 来处理。

转载请注明：xuhss » Python深度学习篇六《深度学习用于文本和序列》