第6章 深度学习用于文本和序列
- 用于处理序列的两种基本的深度学习算法分别是循环神经网络（recurrent neural network）和一维卷积神经网络（1D convnet），这些算法的应用包括：（1）文档分类和时间序列分类，比如识别文字的主题或书的作者；（2）时间序列对比，比如估测两个文档或两支股票行情的相关程度；（3）序列到序列的学习，比如将英语翻译成法语；（4）情感分析，比如将推文或电影评论的情感划分为正面或负面；（5）时间序列预测，比如根据某地最近的天气数据来预测未来天气。
6.1 处理文本数据
- 文本是最常用的序列数据之一，可以理解为字符序列或单词序列，但最常见的是单词级处理。后面几节介绍的深度学习序列处理模型都可以根据文本生成基本形式的自然语言理解，并可用于文档分类、情感分析、作者识别甚至问答（QA，在有限的语境下）等应用。当然，请记住，本章的这些深度学习模型都没有像人类一样真正地理解文本，而只是映射出书面语言的统计结构，但这足以解决许多简单的文本分类任务。深度学习用于自然语言处理是将模式识别应用于单词、句子和段落，这与计算机视觉将模式识别应用于像素大致相同。
- 与其他所有神经网络一样，深度学习模型不会接收原始文本作为输入，它只能处理数值张量。文本向量化（vectorize）是指将文本转换为数值张量的过程。它有多种实现方法：（1）将文本分割为单词，并将每个单词转换为一个向量。（2）将文本分割为字符，并将每个字符转换为一个向量。（3）提取单词或字符的n-gram，并将每个n-gram转换为一个向量。n-gram是多个连续单词或字符的集合（n-gram之间可重叠）。
- 将文本分解而成的单元（单词、字符或n-gram）叫作标记（token），将文本分解成标记的过程叫作分词（tokenization）。所有文本向量化过程都是应用某种分词方案，然后将数值向量与生产的标记相关联。这些向量组合成序列张量，被输入到深度神经网络中。将向量与标记相关联的方法有很多种。本节将介绍两种主要方法：对标记做one-hot编码（one-hot encoding）与标记嵌入（token embedding，通常只用于单词，叫作词嵌入（word embedding））。
理解n-gram和词袋
- n-gram是从一个句子中提取的N个（或更少）连续单词的集合。这一概念中的“单词”也可以替换为“字符”。
- 袋（bag）这一术语指的是标记组成的集合，而不是一个列表或序列，即标记没有特定的顺序。
- 词袋是一种不保存顺序的分词方法（生成的标记组成一个集合，而不是一个序列，舍弃了句子的总体结构），因此它往往被用于浅层的语言处理模型，而不是深度学习模型。提取n-gram是一种特征工程，深度学习不需要这种四班而又不稳定的方法，并将其替换为分层特征学习。本章后面将介绍的一维卷积神经网络和循环神经网络，都能够通过观察连续的单词序列或字符序列来学习单词组合字符组的数据表示，而无须明确知道这些组的存在。在使用轻量级的浅层文本处理模型时（比如logistic回归和随机森林），n-gram是一种功能强大、不可或缺的特征工程工具。
6.1.1 单词和字符的one-hot编码
- one-hot编码是将标记转换为向量最常用、最基本的方法。它将每个单词与一个唯一的整数索引相关联，然后将这个整数索引 i i i转为为长度为 N N N的二进制向量（ N N N是词表大小），这个向量只有第 i i i个元素是1，其余元素都为0。当然，也可以进行字符级的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.
print(results)
import string
import numpy as np
samples = ['The cat sat on the mat.', 'The dog ate my homework.']
characters = string.printable
token_index = dict(zip(characters, range(1, len(characters) + 1)))
max_length = 50
results = np.zeros((len(samples), max_length, max(token_index.values()) + 1))
for i, sample in enumerate(samples):
for j, character in enumerate(sample):
index = token_index.get(character)
results[i, j, index] = 1.
print(results)
- 注意，Keras的内置函数可以对原始文本数据进行单词级或字符级的one-hot编码。你应该使用这些函数，因为它们实现了许多重要的特性，比如从字符串中去除特殊字符、只考虑数据集中前 N N N个最常见的单词（这是一种常用的限制，以避免处理非常大的输入向量空间）。
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 hasing trick），如果词表中唯一标记的数量太大而无法直接处理，就可以使用这种技巧。这种方法没有为每个单词显示分配一个索引并将这些索引保存在一个字典中，而是将单词散列编码为固定长度的向量，通常用一个非常简单的散列函数来实现。这种方法的主要优点在于，它避免了维护一个显式的单词索引，从而节省内存并允许数据的在线编码（在读取完所有数据之前，你就可以立刻生成标记向量）。这种方法有一个缺点，就是可能会出现散列冲突（hash collision），即两个不同的单词可能具有相同的散列值，随后任何机器学习模型观察这些散列值，都无法区分它们所对应的单词。如散列空间的维度远大于需要散列的唯一标记的个数，散列冲突的可能性会减小。
import numpy as np
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.
print(results)
6.1.2 使用词嵌入
- 将单词与向量相关联还有另一种常用的强大方法，就是使用密集的词向量（word vector），也叫词嵌入（word embedding）。one-hot编码得到的向量是二进制的、稀疏的（绝大部分元素都是0）、维度很高的（维度大小等于词表中的单词个数），而词嵌入是低维的浮点数向量（即密集向量，与稀疏向量相对）。与one-hot编码得到的词向量不同，词嵌入是从数据中学习得到的。常见的词向量维度是256、512或1024（处理非常大的词表时）。与此相对，one-hot编码的词向量维度通常为20000或更高（对应包含20000个标记的词表）。因此，词嵌入可以将更多的信息塞入更低的维度中。
- 获取词嵌入有两种方法：（1）在完成主任务（比如文档分类或情感预测）的同时学习词嵌入。在这种情况下，一开始是随机的词向量，然后对这些词向量进行学习，其学习方式与学习神经网络的权重相同。
- 在不同于待解决问题的机器学习任务上预计算好词嵌入，然后将其加载到模型中。这些词嵌入叫作预训练词嵌入（pretrained word embedding）。
1.利用Embedding层学习词嵌入
- 要将一个词与一个密集向量相关联，最简单的方法就是随机选择向量。这种方法的问题在于，得到的嵌入空间没有任何结构。例如，accurate和exact两个词的嵌入可能完全不同，尽管它们在大多数句子里都是可以互换的。深度神经网络很难对这种杂乱的、非结构化的嵌入空间进行学习。
- 说得更抽象一点，词向量之间的几何关系应该表示这些词之间的语义关系。词嵌入的作用应该是将人类的语言映射到几何空间中。例如，在一个合理的嵌入空间中，同义词应该被嵌入到相似的词向量中，一般来说，任意两个词向量之间的几何距离（比如L2距离）应该和这两个词的语义距离有关（表示不同事物的词被嵌入到相隔很远的点，而相关的词则更加靠近）。除了距离，你可能还希望嵌入空间中的特定方法也是有意义的。
- 在真实的词嵌入空间中，常见的有意义的几何变换的例子包括“性别”向量和“复数”向量。例如，将king（国王）向量加上female（女性）向量，得到的是queen（女王）向量。将king（国王）向量加上plural（复数）向量，得到的是kings向量。词嵌入空间通常具有几千个这种可解释的、并且可能很有用的向量。
- 有没有一个理想的词嵌入空间，可以完美地映射人类语言，并可用于所有的自然语言处理任务？可能有，但我们尚未发现。此外，也不存在人类语言（human language）这种东西。世界上，有许多种不同的语言，而且它们不是同构的，因为语言是特定文化和特定环境的反射。但从更实际的角度来说，一个好的词嵌入空间在很大程度上取决于你的任务。英语电影评论情感分析模型的完美词嵌入空间，可能不同于法律文档分类模型的完美词嵌入空间，因为某些语义关系的重要性因任务而异。
- 因此，合理的做法是对每个新任务都学习一个新的嵌入空间。幸运的是，反向传播让这种学习变得很简单，而Keras使其变得更简单。完美要做的就是学习一个层的权重，这个层就是Embedding层。
from keras.layers import Embedding
embedding_layer = Embedding(1000, 64)
- 最好将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电影评论情感预测任务。首先，将电影评论限制为前10000个最常见的单词，然后将评论长度限制为只有20个单词。对于这10000个单词，网络将对每个单词学习一个8维嵌入，将输入的整数序列（二维整数张量）转换为嵌入序列（三维浮点数张量），然后将这个张量展平为二维，最后在上面训练一个Dense层用于分类。
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)
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'))
print(model.summary())
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['acc'])
history = model.fit(x_train, y_train, epochs=10, batch_size=32, validation_split=0.2)
- 仅仅将嵌入序列展开并在上面训练一个Dense层，会导致模型对输入序列中的每个单词单独处理，而没有考虑单词直接的关系和句子结构（模型可能会将this movie is a bomb和this movie is the bomb两条都归为负面评论）。更好的做法是在嵌入序列上添加循环层或一维卷积层，将每个序列作为整体来学习特征。
2.使用预训练的词嵌入
- 有时可用的训练数据很少，以至于只用手头数据无法学习适合特定任务的词嵌入。这时可以从预计算的嵌入空间中加载嵌入向量（你知道这个嵌入空间是高度结构化的，并且具有有用的属性，即抓住了语言结构的一般特点），而不是在解决问题的同时学习词嵌入。在自然语言处理中使用预训练的词嵌入，其背后的原理与在图像分类中使用预训练的卷积神经网络是一样的：没有足够的数据来自己学习真正强大的特征，但你需要的特征应该是非常通用的，比如常见的视觉特征或语义特征。在这种情况下，重复使用在其他问题上学到的特征，这种做法是有道理的。
- 这种词嵌入通常是利用词频统计计算得出的（观察那些词共同出现在句子或文档中）,用到的技术很多，有些涉及神经网络，有些则不涉及。Bengio等人在21世纪初首先研究了一种思路，就是用无监督的方法计算一个密集的低维词嵌入空间，但知道最有名且最成功的词嵌入方案之一word2vec算法发布之后，这一思路才开始在研究领域和工业应用中取得成功。word2vec算法由Google的Tomas Mikolov于2013年开发，其维度抓住了特定的语义属性，比如性别。
- 有许多预计算的词嵌入数据库，你都可以下载并在Keras的Embedding层中使用。word2vec就是其中之一。另一个常用的是GloVe(global vectors for word representation, 词表示全局向量)，由斯坦福大学的研究人员于2014年开发。这种嵌入方法基于对词共现统计矩阵进行因式分解。其开发者已经公开了数百万个英文标记的预计算嵌入，它们都是从维基百科数据和Common Crawl数据得到的。
6.1.3 整合在一起：从原始文本到词嵌入
- 本节的模型与之前刚刚见过的那个类似：将句子嵌入到向量序列中，然后将其展平，最后在上面训练一个Dense层。但此处将使用预训练的词嵌入。此外，我们将从头开始，先下载IMDB原始文本数据，而不是使用Keras内置的已经预先分词的IMDB数据。
1.下载IMDB数据的原始文本
- 首先，打开http://mng.bz/0tIo，下载原始IMDB数据集并解压。
- 接下来，我们将训练评论转换成字符串列表，每个字符串对应一条评论。你也可以将评论标签（正面/负面）转换成labels列表。
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):
f = open(os.path.join(dir_name, fname),'r', encoding='utf-8')
texts.append(f.read())
f.close()
if label_type == 'neg':
labels.append(0)
else:
labels.append(1)
2.对数据进行分词
- 利用本节前面介绍过的概念，我们对文本进行分词，并将其划分为训练集和验证集。因为预训练的词嵌入对训练数据很少的问题特别有用（否则，针对于具体任务的嵌入可能效果更好），所以我们又添加了以下限制：将训练数据限定为前200个样本。因此，你需要在读取200个样本之后学习对电影评论进行分类。
from keras.preprocessing.text import Tokenizer
from keras.preprocessing.sequence import pad_sequences
import numpy as np
maxlen = 100
train_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 tolens.' % 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[:train_samples]
y_train = labels[:train_samples]
x_val = data[train_samples:train_samples + validation_samples]
y_val = labels[train_samples:train_samples + validation_samples]
3. 下载Glove词嵌入
- 打开https://nlp.stanford.edu/projects/glove，下载2014年英文维基百科的预计算嵌入。这是一个822MB的压缩文件，文件名是glove.6B.zip，里面包含400000个单词（或非单词的标记）的100位嵌入向量。
4.对嵌入进行预处理
glove_dir = "../data"
embeddings_index = {}
f = open(os.path.join(glove_dir, 'glove.6B.100d.txt'), 'r', encoding='utf-8')
for line in f:
values = line.strip().split()
word = values[0]
coefs = np.asarray(values[1:], dtype='float32')
embeddings_index[word] = coefs
f.close()
print('Flound %s word vectors.' % len(embeddings_index))
- 接下来，需要构建一个可以加载到Embedding层中的嵌入矩阵。它必须是一个形状为(max_words, embedding_dim)的矩阵，对于单词索引（在分词时构建）中索引为 i i i的单词，这个矩阵的元素 i i i就是这个单词对应的embedding_dim维向量。注意，索引0不应该代表任何单词或标记，它只是一个占位符。
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.定义模型
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'))
print(model.summary())
6.在模型中加载GloVe嵌入
- Embedding层只有一个权重矩阵，是一个二维的浮点数矩阵，其中每个元素 i i i是与索引 i i i相关联的词向量。将准备好的GloVe矩阵加载到Embedding层中，即模型的第一层。
model.layers[0].set_weights([embedding_matrix])
model.layers[0].trainable = False
- 此外，需要冻结Embedding层（即将其trainable属性设为False），其原理和预训练的卷积神经网络特征相同。如果一个模型的一部分是经过预训练的（如Embedding层），而另一部分是随机初始化的（如分类器），那么在训练期间不应该更新预训练的部分，以避免丢失它们所保存的信息。随机初始化的层会引起较大的梯度更新，会破坏已经学到的特征。
7.训练模型与评估模型
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')
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()
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), 'r', encoding='utf-8')
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)
model.load_weights('pre_trained_glove_model.h5')
print(model.evaluate(x_test, y_test))
