Python深度学习(三)深度学习用于文本和序列

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

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

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

一、处理文本数据

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

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

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

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

从文本到标记再到向量
从文本到标记再到向量

1. 单词和字符的one-hot 编码

one-hot编码是将标记转换为向量的最常用、最基本的方法。在IMDB和路透社两个例子中,你已经用过这种方法(都是处理单词)。它将每个单词与一个唯一的整数索引相关联,然后将这个整数索引 $i$ 转换为长度为 $N$ 的二进制向量($N$ 是词表大小),这个向量只有第 $i$ 个元素是1,其余元素都为0。
当然,也可以进行字符级的one-hot编码。为了让你完全理解什么是one-hot编码以及如何实现one-hot编码,下面给出了两个简单示例,一个是单词级的one-hot编码,另一个是字符级的one-hot编码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 单词级的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.
array([[[0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]],

       [[0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]]])
1
2
3
4
5
6
7
8
9
10
11
# 字符级的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.
array([[[1., 1., 1., ..., 1., 1., 1.],
        [1., 1., 1., ..., 1., 1., 1.],
        [1., 1., 1., ..., 1., 1., 1.],
        ...,
        [0., 0., 0., ..., 0., 0., 0.],
        [0., 0., 0., ..., 0., 0., 0.],
        [0., 0., 0., ..., 0., 0., 0.]],

       [[1., 1., 1., ..., 1., 1., 1.],
        [1., 1., 1., ..., 1., 1., 1.],
        [1., 1., 1., ..., 1., 1., 1.],
        ...,
        [0., 0., 0., ..., 0., 0., 0.],
        [0., 0., 0., ..., 0., 0., 0.],
        [0., 0., 0., ..., 0., 0., 0.]]])

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

1
2
3
4
5
6
7
8
9
# 用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),即两个不同的单词可能具有相同的散列值,随后任何机器学习模型观察这些散列值,都无法区分它们所对应的单词。如果散列空间的维度远大于需要散列的唯一标记的个数,散列冲突的可能性会减小。

1
2
3
4
5
6
7
8
9
# 使用散列技巧的单词级的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.
array([[[0., 0., 0., ..., 0., 0., 0.],
        [0., 0., 0., ..., 0., 0., 0.],
        [0., 0., 0., ..., 0., 0., 0.],
        ...,
        [0., 0., 0., ..., 0., 0., 0.],
        [0., 0., 0., ..., 0., 0., 0.],
        [0., 0., 0., ..., 0., 0., 0.]],

       [[0., 0., 0., ..., 0., 0., 0.],
        [0., 0., 0., ..., 0., 0., 0.],
        [0., 0., 0., ..., 0., 0., 0.],
        ...,
        [0., 0., 0., ..., 0., 0., 0.],
        [0., 0., 0., ..., 0., 0., 0.],
        [0., 0., 0., ..., 0., 0., 0.]]])

2. 使用词嵌入

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

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

获取词嵌入有两种方法。

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

1. 利用Embedding 层学习词嵌入

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

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

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

词嵌入空间的简单示例
词嵌入空间的简单示例

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

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

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

1
2
3
# 将一个Embedding 层实例化
from keras.layers import Embedding
embedding_layer = Embedding(1000, 64)

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

Embedding层
Embedding层

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

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

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

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

1
2
3
4
5
6
7
8
9
# 加载IMDB数据,准备用于Embedding层
from keras.datasets import imdb
from keras 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)
1
2
3
4
5
6
7
8
9
10
11
12
13
# 在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)
Model: "sequential_1"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
embedding_2 (Embedding)      (None, 20, 8)             80000     
_________________________________________________________________
flatten_1 (Flatten)          (None, 160)               0         
_________________________________________________________________
dense_1 (Dense)              (None, 1)                 161       
=================================================================
Total params: 80,161
Trainable params: 80,161
Non-trainable params: 0
_________________________________________________________________

得到的验证精度约为76%,考虑到仅查看每条评论的前20个单词,这个结果还是相当不错的。但请注意,仅仅将嵌入序列展开并在上面训练一个Dense层,会导致模型对输入序列中的每个单词单独处理,而没有考虑单词之间的关系和句子结构(举个例子,这个模型可能会将thismovie 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 嵌入或其他词嵌入数据库。这个例子还可以改进前面刚刚介绍过的文本分词技术,即从原始文本开始,一步步进行处理。

3. 从原始文本到词嵌入

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

下载IMDB 数据的原始文本

首先,打开http://mng.bz/0tIo ,下载原始IMDB 数据集并解压。接下来,我们将训练评论转换成字符串列表,每个字符串对应一条评论。你也可以将评论标签(正面/ 负面)转换成labels列表。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 处理IMDB原始数据的标签
import os
imdb_dir = 'data/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)

对数据进行分词

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

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
# 对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]
Found 88582 unique tokens.
Shape of data tensor: (25000, 100)
Shape of label tensor: (25000,)

下载GloVe词嵌入

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

对嵌入进行预处理

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

1
2
3
4
5
6
7
8
9
10
11
# 解析GloVe词嵌入文件
glove_dir = 'model/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))
Found 400000 word vectors.

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

1
2
3
4
5
6
7
8
# 准备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

定义模型

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

1
2
3
4
5
6
7
8
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: "sequential_2"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
embedding_3 (Embedding)      (None, 100, 100)          1000000   
_________________________________________________________________
flatten_2 (Flatten)          (None, 10000)             0         
_________________________________________________________________
dense_2 (Dense)              (None, 32)                320032    
_________________________________________________________________
dense_3 (Dense)              (None, 1)                 33        
=================================================================
Total params: 1,320,065
Trainable params: 1,320,065
Non-trainable params: 0
_________________________________________________________________

在模型中加载GloVe嵌入

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

1
2
3
# 将预训练的词嵌入加载到Embedding层中
model.layers[0].set_weights([embedding_matrix])
model.layers[0].trainable = False

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

训练模型与评估模型

下面编译并训练模型。

1
2
3
4
5
6
7
8
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('model/pre_trained_glove_model.h5')
1
2
3
4
5
6
7
8
9
10
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()
b
1
2
3
4
5
6
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()
b

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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))
Model: "sequential_3"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
embedding_4 (Embedding)      (None, 100, 100)          1000000   
_________________________________________________________________
flatten_3 (Flatten)          (None, 10000)             0         
_________________________________________________________________
dense_4 (Dense)              (None, 32)                320032    
_________________________________________________________________
dense_5 (Dense)              (None, 1)                 33        
=================================================================
Total params: 1,320,065
Trainable params: 1,320,065
Non-trainable params: 0
_________________________________________________________________

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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)
1
2
model.load_weights('model/pre_trained_glove_model.h5')
model.evaluate(x_test, y_test)
25000/25000 [==============================] - 1s 44us/step
[0.7739053187370301, 0.5541599988937378]

我们只用了很少的训练样本,得到这样的结果很不容易。

二、理解循环神经网络

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

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

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

循环网络:带有环的网络
循环网络:带有环的网络

为了将环(loop)和状态的概念解释清楚,我们用Numpy来实现一个简单RNN的前向传递。这个RNN的输入是一个张量序列,我们将其编码成大小为$(timesteps, input_features)$的二维张量。它对时间步(timestep)进行遍历,在每个时间步,它考虑$t$时刻的当前状态与$t$时刻的输入[形状为$(input_ features,)$],对二者计算得到$t$时刻的输出。然后,我们将下一个时间步的状态设置为上一个时间步的输出。对于第一个时间步,上一个时间步的输出没有定义,所以它没有当前状态。因此,你需要将状态初始化为一个全零向量,这叫作网络的初始状态(initial state)。

RNN的伪代码如下所示。

1
2
3
4
state_t = 0
for input_t in input_sequence:
output_t = f(input_t, state_t)
state_t = output_t

你甚至可以给出具体的函数$f$:从输入和状态到输出的变换,其参数包括两个矩阵($W$和$U$)和一个偏置向量。它类似于前馈网络中密集连接层所做的变换,因此更详细的RNN伪代码如下:

1
2
3
4
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实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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的特征在于其时间步函数,比如前面例子中的这个函数

1. Keras 中的循环层

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

1
from keras.layers import SimpleRNN

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

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

1
2
3
4
5
6
from keras.models import Sequential
from keras.layers import Embedding, SimpleRNN
model = Sequential()
model.add(Embedding(10000, 32))
model.add(SimpleRNN(32))
model.summary()
Model: "sequential_4"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
embedding_5 (Embedding)      (None, None, 32)          320000    
_________________________________________________________________
simple_rnn_1 (SimpleRNN)     (None, 32)                2080      
=================================================================
Total params: 322,080
Trainable params: 322,080
Non-trainable params: 0
_________________________________________________________________

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

1
2
3
4
model = Sequential()
model.add(Embedding(10000, 32))
model.add(SimpleRNN(32, return_sequences=True))
model.summary()
Model: "sequential_5"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
embedding_6 (Embedding)      (None, None, 32)          320000    
_________________________________________________________________
simple_rnn_2 (SimpleRNN)     (None, None, 32)          2080      
=================================================================
Total params: 322,080
Trainable params: 322,080
Non-trainable params: 0
_________________________________________________________________

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

1
2
3
4
5
6
7
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()
Model: "sequential_6"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
embedding_7 (Embedding)      (None, None, 32)          320000    
_________________________________________________________________
simple_rnn_3 (SimpleRNN)     (None, None, 32)          2080      
_________________________________________________________________
simple_rnn_4 (SimpleRNN)     (None, None, 32)          2080      
_________________________________________________________________
simple_rnn_5 (SimpleRNN)     (None, None, 32)          2080      
_________________________________________________________________
simple_rnn_6 (SimpleRNN)     (None, 32)                2080      
=================================================================
Total params: 328,320
Trainable params: 328,320
Non-trainable params: 0
_________________________________________________________________

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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)
Loading data...
25000 train sequences
25000 test sequences
Pad sequences (samples x time)
input_train shape: (25000, 500)
input_test shape: (25000, 500)

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

1
2
3
4
5
6
7
8
9
10
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)
Train on 20000 samples, validate on 5000 samples
Epoch 1/10
20000/20000 [==============================] - 17s 832us/step - loss: 0.6298 - acc: 0.6252 - val_loss: 0.5190 - val_acc: 0.7454
Epoch 2/10
20000/20000 [==============================] - 17s 832us/step - loss: 0.4073 - acc: 0.8216 - val_loss: 0.3733 - val_acc: 0.8438
Epoch 3/10
20000/20000 [==============================] - 17s 844us/step - loss: 0.2946 - acc: 0.8804 - val_loss: 0.3948 - val_acc: 0.8318
Epoch 4/10
20000/20000 [==============================] - 17s 856us/step - loss: 0.2396 - acc: 0.9059 - val_loss: 0.4578 - val_acc: 0.8388
Epoch 5/10
20000/20000 [==============================] - 17s 870us/step - loss: 0.2003 - acc: 0.9233 - val_loss: 0.4395 - val_acc: 0.8168
Epoch 6/10
20000/20000 [==============================] - 18s 887us/step - loss: 0.1601 - acc: 0.9406 - val_loss: 0.5268 - val_acc: 0.8204
Epoch 7/10
20000/20000 [==============================] - 17s 874us/step - loss: 0.1124 - acc: 0.9612 - val_loss: 0.5143 - val_acc: 0.8048
Epoch 8/10
20000/20000 [==============================] - 18s 914us/step - loss: 0.0923 - acc: 0.9682 - val_loss: 0.4945 - val_acc: 0.8362
Epoch 9/10
20000/20000 [==============================] - 18s 877us/step - loss: 0.0507 - acc: 0.9839 - val_loss: 0.5826 - val_acc: 0.8092
Epoch 10/10
20000/20000 [==============================] - 18s 879us/step - loss: 0.0540 - acc: 0.9821 - val_loss: 0.5969 - val_acc: 0.8182
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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()
b
b

处理这个数据集的第一个简单方法得到的测试精度是88%。不幸的是,与这个基准相比,这个小型循环网络的表现并不好(验证精度只有85%)。问题的部分原因在于,输入只考虑了前500 个单词,而不是整个序列,因此,RNN获得的信息比前面的基准模型更少。另一部分原因在于,SimpleRNN不擅长处理长序列,比如文本。其他类型的循环层的表现要好得多。我们来看几个更高级的循环层。

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单元开始讲起。因为有许多个权重矩阵,所以对单元中的$W$和$U$两个矩阵添加下标字母$o$(Wo 和Uo),表示输出。

讨论LSTM层的出发点:SimpleRNN层
讨论LSTM层的出发点:SimpleRNN层

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

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

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

但这三个变换都具有各自的权重矩阵,我们分别用字母$i$、$j$和$k$作为下标。目前的模型架构如下所示:

1
2
3
4
5
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)
c_t+1 = i_t * k_t + c_t * f_t

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

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

3. Keras中一个LSTM 的具体例子

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

1
2
3
4
5
6
7
8
9
10
11
12
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)
Train on 20000 samples, validate on 5000 samples
Epoch 1/10
20000/20000 [==============================] - 44s 2ms/step - loss: 0.5221 - acc: 0.7523 - val_loss: 0.3656 - val_acc: 0.8520
Epoch 2/10
20000/20000 [==============================] - 43s 2ms/step - loss: 0.3005 - acc: 0.8812 - val_loss: 0.3048 - val_acc: 0.8766
Epoch 3/10
20000/20000 [==============================] - 43s 2ms/step - loss: 0.2410 - acc: 0.9086 - val_loss: 0.3063 - val_acc: 0.8700
Epoch 4/10
20000/20000 [==============================] - 43s 2ms/step - loss: 0.2031 - acc: 0.9252 - val_loss: 0.3210 - val_acc: 0.8862
Epoch 5/10
20000/20000 [==============================] - 43s 2ms/step - loss: 0.1816 - acc: 0.9348 - val_loss: 0.3304 - val_acc: 0.8542
Epoch 6/10
20000/20000 [==============================] - 43s 2ms/step - loss: 0.1661 - acc: 0.9412 - val_loss: 0.3082 - val_acc: 0.8778
Epoch 7/10
20000/20000 [==============================] - 44s 2ms/step - loss: 0.1480 - acc: 0.9482 - val_loss: 0.3066 - val_acc: 0.8738
Epoch 8/10
20000/20000 [==============================] - 45s 2ms/step - loss: 0.1429 - acc: 0.9513 - val_loss: 0.4828 - val_acc: 0.8404
Epoch 9/10
20000/20000 [==============================] - 47s 2ms/step - loss: 0.1278 - acc: 0.9554 - val_loss: 0.3790 - val_acc: 0.8838
Epoch 10/10
20000/20000 [==============================] - 49s 2ms/step - loss: 0.1162 - acc: 0.9593 - val_loss: 0.3512 - val_acc: 0.8512

LSTM更适用于评论分析全局的长期性结构(这正是LSTM所擅长的),对情感分析问题帮助不大。对于这样的基本问题,观察每条评论中出现了哪些词及其出现频率就可以很好地解决。这也正是第一个全连接方法的做法。但还有更加困难的自然语言处理问题,特别是问答和机器翻译,这时LSTM的优势就明显了。

三、循环神经网络的高级用法

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

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

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

1. 温度预测问题

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

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

1
2
3
4
5
6
7
8
9
10
11
import os
data_dir = 'data/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))
['"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)"']
420451

从输出可以看出,共有 420 551 行数据(每行是一个时间步,记录了一个日期和 14 个与天气有关的值),接下来,将 420 551 行数据转换成一个Numpy数组。

1
2
3
4
5
6
7
8
9
10
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

# 绘制温度时间序列
from matplotlib import pyplot as plt
temp = float_data[:, 1] # 温度(单位:摄氏度)
plt.plot(range(len(temp)), temp)
b

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

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

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

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

2. 准备数据

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

  • lookback = 720:给定过去 5 天内的观测数据。
  • steps = 6:观测数据的采样频率是每小时一个数据点。
  • delay = 144:目标是未来 24 小时之后的数据。

开始之前,你需要完成以下两件事。

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

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

1
2
3
4
mean = float_data[:200000].mean(axis=0)
float_data -= mean
std = float_data[:200000].std(axis=0)
float_data /= std

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

  • data:浮点数数据组成的原始数组,我们已将其标准化。
  • lookback:输入数据应该包括过去多少个时间步。
  • delay:目标应该在未来多少个时间步之后。
  • min_indexmax_index:data 数组中的索引,用于界定需要抽取哪些时间步。这有助于保存一部分数据用于验证、另一部分用于测试。
  • shuffle:是打乱样本,还是按顺序抽取样本。
  • batch_size:每个批量的样本数。
  • step:数据采样的周期(单位:时间步)。我们将其设为6,为的是每小时抽取一个数据点。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 生成时间序列样本及其目标的生成器
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 个时间步,测试生成器读取剩下的时间步。

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
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

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

开始使用黑盒深度学习模型解决温度预测问题之前,我们先尝试一种基于常识的简单方法。它可以作为合理性检查,还可以建立一个基准,更高级的机器学习模型需要打败这个基准才能表现出其有效性。面对一个尚没有已知解决方案的新问题时,这种基于常识的基准方法很有用。

一个经典的例子就是不平衡的分类任务,其中某些类别比其他类别更常见。如果数据集中包含 90% 的类别 A 实例和 10% 的类别B 实例,那么分类任务的一种基于常识的方法就是对新样本始终预测类别“A”。这种分类器的总体精度为90%,因此任何基于学习的方法在精度高于90%时才能证明其有效性。有时候,这样基本的基准方法可能很难打败。

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

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

下面是评估的循环代码。

1
2
3
4
5
6
7
8
9
10
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()
# 0.2897359729905486

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

1
2
3
4
# 将 MAE 转换成摄氏温度误差
celsius_mae = 0.29 * std[1]
celsius_mae
# 2.5672247338393395

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

4. 一种基本的机器学习方法

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 训练并评估一个密集连接模型
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)
1
2
3
4
5
6
7
8
9
10
11
# 绘制曲线
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()
b

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

你可能会问,如果从数据到目标之间存在一个简单且表现良好的模型(即基于常识的基准方法),那为什么我们训练的模型没有找到这个模型并进一步改进呢?原因在于,这个简单的解决方案并不是训练过程所要寻找的目标。我们在模型空间(即假设空间)中搜索解决方案,这个模型空间是具有我们所定义的架构的所有两层网络组成的空间。这些网络已经相当复杂了。如果你在一个复杂模型的空间中寻找解决方案,那么可能无法学到简单且性能良好的基准方法,虽然技术上来说它属于假设空间的一部分。

通常来说,这对机器学习是一个非常重要的限制:如果学习算法没有被硬编码要求去寻找特定类型的简单模型,那么有时候参数学习是无法找到简单问题的简单解决方案的。

5. 第一个循环网络基准

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
# 训练并评估一个基于 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. 使用循环dropout来降低过拟合

从训练和验证曲线中可以明显看出,模型出现过拟合:几轮过后,训练损失和验证损失就开始显著偏离。我们已经学过降低过拟合的一种经典技术——dropout,即将某一层的输入单元随机设为0,其目的是打破该层训练数据中的偶然相关性。但在循环网络中如何正确地使用dropout,这并不是一个简单的问题。人们早就知道,在循环层前面应用dropout,这种正则化会妨碍学习过程,而不是有所帮助。2015 年,在关于贝叶斯深度学习的博士论文中,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倍。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 训练并评估一个使用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=1,
validation_data=val_gen,
validation_steps=val_steps)

成功!前30个轮次不再过拟合。不过,虽然评估分数更加稳定,但最佳分数并没有比之前低很多。

7. 循环层堆叠

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 训练并评估一个使用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=1,
validation_data=val_gen,
validation_steps=val_steps)

可以看到,添加一层的确对结果有所改进,但并不显著。我们可以得出两个结论:

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

8. 使用双向RNN

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

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

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 使用逆序序列训练并评估一个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)
Train on 20000 samples, validate on 5000 samples
Epoch 1/10
20000/20000 [==============================] - 83s 4ms/step - loss: 0.4988 - acc: 0.7621 - val_loss: 0.3412 - val_acc: 0.8684
Epoch 2/10
20000/20000 [==============================] - 85s 4ms/step - loss: 0.3184 - acc: 0.8795 - val_loss: 0.3068 - val_acc: 0.8814
Epoch 3/10
20000/20000 [==============================] - 86s 4ms/step - loss: 0.2544 - acc: 0.9025 - val_loss: 0.3151 - val_acc: 0.8798
Epoch 4/10
20000/20000 [==============================] - 78s 4ms/step - loss: 0.2133 - acc: 0.9225 - val_loss: 0.3849 - val_acc: 0.8544
Epoch 5/10
20000/20000 [==============================] - 83s 4ms/step - loss: 0.1877 - acc: 0.9332 - val_loss: 0.3698 - val_acc: 0.8684
Epoch 6/10
20000/20000 [==============================] - 73s 4ms/step - loss: 0.1675 - acc: 0.9416 - val_loss: 0.3680 - val_acc: 0.8418
Epoch 7/10
20000/20000 [==============================] - 76s 4ms/step - loss: 0.1474 - acc: 0.9488 - val_loss: 0.4329 - val_acc: 0.8504
Epoch 8/10
20000/20000 [==============================] - 70s 4ms/step - loss: 0.1316 - acc: 0.9559 - val_loss: 0.4002 - val_acc: 0.8484
Epoch 9/10
20000/20000 [==============================] - 77s 4ms/step - loss: 0.1163 - acc: 0.9593 - val_loss: 0.3937 - val_acc: 0.8736
Epoch 10/10
20000/20000 [==============================] - 73s 4ms/step - loss: 0.1023 - acc: 0.9685 - val_loss: 0.4931 - val_acc: 0.8652

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

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

双向RNN层的工作原理
双向RNN层的工作原理

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

1
2
3
4
5
6
7
8
9
10
# 训练并评估一个双向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)
Train on 20000 samples, validate on 5000 samples
Epoch 1/10
20000/20000 [==============================] - 133s 7ms/step - loss: 0.5509 - acc: 0.7215 - val_loss: 0.3725 - val_acc: 0.8560
Epoch 2/10
20000/20000 [==============================] - 146s 7ms/step - loss: 0.3318 - acc: 0.8729 - val_loss: 0.4149 - val_acc: 0.8526
Epoch 3/10
20000/20000 [==============================] - 134s 7ms/step - loss: 0.2647 - acc: 0.9024 - val_loss: 0.8188 - val_acc: 0.7226
Epoch 4/10
20000/20000 [==============================] - 136s 7ms/step - loss: 0.2384 - acc: 0.9178 - val_loss: 0.3252 - val_acc: 0.8760
Epoch 5/10
20000/20000 [==============================] - 143s 7ms/step - loss: 0.2025 - acc: 0.9269 - val_loss: 0.4345 - val_acc: 0.8728
Epoch 6/10
20000/20000 [==============================] - 146s 7ms/step - loss: 0.1841 - acc: 0.9362 - val_loss: 0.3524 - val_acc: 0.8728
Epoch 7/10
20000/20000 [==============================] - 136s 7ms/step - loss: 0.1692 - acc: 0.9416 - val_loss: 0.4050 - val_acc: 0.8450
Epoch 8/10
20000/20000 [==============================] - 138s 7ms/step - loss: 0.1523 - acc: 0.9474 - val_loss: 0.4994 - val_acc: 0.8456
Epoch 9/10
20000/20000 [==============================] - 141s 7ms/step - loss: 0.1356 - acc: 0.9538 - val_loss: 0.4161 - val_acc: 0.8792
Epoch 10/10
20000/20000 [==============================] - 141s 7ms/step - loss: 0.1338 - acc: 0.9547 - val_loss: 0.3581 - val_acc: 0.8648

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
# 训练一个双向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=10,
validation_data=val_gen,
validation_steps=val_steps)

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

9. 更多尝试

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

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

四、用卷积神经网络处理序列

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

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

1. 理解序列数据的一维卷积

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

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

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

2. 序列数据的一维池化

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

3. 实现一维卷积神经网络

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
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)

一维卷积神经网络的架构与二维卷积神经网络相同,它是Conv1D层和MaxPooling1D层的堆叠,最后是一个全局池化层或Flatten层,将三维输出转换为二维输出,让你可以向模型中添加一个或多个Dense层,用于分类或回归。不过二者有一点不同:一维卷积神经网络可以使用更大的卷积窗口。对于二维卷积层,$3×3$的卷积窗口包含$3×3=9$个特征向量;但对于一位卷积层,大小为3的卷积窗口只包含3个卷积向量。因此,你可以轻松使用大小等于7或9 的一维卷积窗口。

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 在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)

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

简单的一维卷积神经网络在IMDB数据上的训练精度和验证精度
简单的一维卷积神经网络在IMDB数据上的训练损失和验证损失
简单的一维卷积神经网络在IMDB数据上的训练精度和验证精度
简单的一维卷积神经网络在IMDB数据上的训练损失和验证损失

4. 结合CNN和RNN来处理长序列

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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=10,
validation_data=val_gen,
validation_steps=val_steps)

下图给出了训练和验证的MAE

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

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

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

结合一维CNN和RNN来处理长序列
结合一维CNN和RNN来处理长序列

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

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
# 为耶拿数据集准备更高分辨率的数据生成器
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层。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 结合一维卷积基和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)
一维卷积神经网络+GRU在耶拿温度预测任务上的训练损失和验证损失
一维卷积神经网络+GRU在耶拿温度预测任务上的训练损失和验证损失

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

5. 小结

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

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

五、本文总结

  • 你在本文学到了以下技术,它们广泛应用于序列数据(从文本到时间序列)组成的数据集。
    • 如何对文本分词
    • 什么是词嵌入,如何使用词嵌入。
    • 什么是循环网络,如何使用循环网络。
    • 如何堆叠 RNN层和使用双向RNN,以构建更加强大的序列处理模型。
    • 如何使用一维卷积神经网络来处理序列。
    • 如何结合一维卷积神经网络和 RNN来处理长序列。
  • 你可以用 RNN 进行时间序列回归(“预测未来”)、时间序列分类、时间序列异常检测和序列标记(比如找出句子中的人名或日期)。
  • 同样,你可以将一维卷积神经网络用于机器翻译(序列到序列的卷积模型,比如SliceNet)、文档分类和拼写校正。
  • 如果序列数据的整体顺序很重要,那么最好使用循环网络来处理。时间序列通常都是这样,最近的数据可能比久远的数据包含更多的信息量。
  • 如果整体顺序没有意义,那么一维卷积神经网络可以实现同样好的效果,而且计算代价更小。文本数据通常都是这样,在句首发现关键词和在句尾发现关键词一样都很有意义。
  • 版权声明: 本博客所有文章除特别声明外,著作权归作者所有。转载请注明出处!

扫一扫,分享到微信

微信分享二维码
  • Copyrights © 2020-2021 chenk
  • 由 帅气的CK本尊 强力驱动
  • 访问人数: | 浏览次数:

请我喝杯咖啡吧~

支付宝
微信