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

文本是最常用的序列数据之一，可以理解为字符序列或单词序列，但最常见的是单词级处理。 深度学习用于自然语言处理是将模式识别应用于单词、句子和段落，这与计算机视觉是将模式识别应用于像素大致相同。

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

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

将文本分解而成的单元（单词、字符或 n-gram）叫作标记**（ token），将文本分解成标记的过程叫作分词（ tokenization）。所有文本向量化过程都是应用某种分词方案，然后将数值向量与生成的标记相关联。 这些向量组合成序列张量，被输入到深度神经网络中。
将向量与标记相关联的方法有很多种。本节将介绍两种主要方法：对标记做 one-hot 编码（ one-hot
encoding）与标记嵌入［ token embedding，通常只用于单词，叫作词嵌入（ word embedding）**］。
image.png

理解 n-gram 和词袋

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

For example，考虑句子“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 是一种功能强大、不可或缺的特征工程工具。

one-hot 编码

one-hot 编码是将标记转换为向量的最常用、最基本的方法。 它将每个单词与一个唯一的整数索引相关联，然后将这个整数索引 i 转换为长度为 N 的二进制向量（ N 是词表大小），这个向量只有第 i 个元素是 1，其余元素都为 0。 当然，也可以进行字符级的 one-hot 编码。

  1. """
  2. 单词级的 one-hot 编码
  3. """
  4. import numpy as np
  6. samples = ['The cat sat on the mat.', 'The dog ate my homework.']  # 样本
  8. token_index = {}  # 构建数据中所有 token 的索引
  9. for sample in samples:
  10.     # We simply tokenize the samples via the `split` method.
  11.     # in real life, we would also strip punctuation and special characters
  12.     # from the samples.
  13.     for word in sample.split():
  14.         if word not in token_index:
  15.             # Assign a unique index to each unique word
  16.             token_index[word] = len(token_index) + 1
  17.             # Note that we don't attribute index 0 to anything.
  19. max_length = 10  # 对样本进行分词。只考虑每个样本前 max_length 个单词
  20. results = np.zeros((len(samples), max_length, max(token_index.values()) + 1))  # store our results
  21. for i, sample in enumerate(samples):
  22.     for j, word in list(enumerate(sample.split()))[:max_length]:
  23.         index = token_index.get(word)
  24.         results[i, j, index] = 1.

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

one-hot 散列技巧

one-hot 编码的一种变体是所谓的 one-hot 散列技巧（ one-hot hashing trick），如果词表中唯一标记的数量太大而无法直接处理，就可以使用这种技巧。
这种方法没有为每个单词显式分配一个索引并将这些索引保存在一个字典中，而是将单词散列编码为固定长度的向量，通常用一个非常简单的散列函数来实现。

  • 优点：它避免了维护一个显式的单词索引，从而节省内存并允许数据的在线编码（在读取完所有数据之前，你就可以立刻生成标记向量）
  • 缺点：可能会出现散列冲突（ hash collision），随后任何机器学习模型观察这些散列值，都无法区分它们所对应的单词。

词嵌入 Word Embedding

将单词与向量相关联还有另一种常用的强大方法，就是使用密集的词向量（ word vector），也叫词嵌入（ word embedding）。

对于颜色，我们可以把它拆成三个特征维度，用这三个维度的组合理论上可以表示任意一种颜色。同理，对于词，我们也可以把它拆成指定数量的特征维度，词表中的每一个词都可以用这些维度组合成的向量来表示，这个就是 Word Embedding 的含义。

one-hot 编码得到的向量是二进制的、稀疏的（绝大部分元素都是 0）、维度很高的（维度大小等于词表中的单词个数），而词嵌入是低维的浮点数向量（即密集向量，与稀疏向量相对），参见图 6-2。与 one-hot 编码得到的词向量不同，词嵌入是从数据中学习得到的。
image.png
获取词嵌入有两种方法：

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

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

1. 利用 Embedding 层学习词嵌入

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

词向量之间的几何关系应该表示这些词之间的语义关系。词嵌入的作用应该是将人类的语言映射到几何空间中。一般来说，任意两个词向量之间的几何距离（比如 L2 距离）应该和这两个词的语义距离有关（表示不同事物的词被嵌入到相隔很远的点，而相关的词则更加靠近）。除了距离，你可能还希望嵌入空间中的特定方向也是有意义的。
For example： King - man + woman = Queen

世界上有许多种不同的语言，而且它们不是同构的，因为语言是特定文化和特定环境的反射。但从更实际的角度来说，一个好的词嵌入空间在很大程度上取决于你的任务。 英语电影评论情感分析模型的完美词嵌入空间，可能不同于英语法律文档分类模型的完美词嵌入空间，因为某些语义关系的重要性因任务而异。

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

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

最好将 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. from keras.datasets import imdb
  2. from keras import preprocessing
  4. max_features = 10000  # # Number of words to consider as features
  5. maxlen = 20  # 在这么多单词后截断文本（这些单词都属于前 max_features 个最常见的单词）
  7. # 将数据加载为整数列表
  8. (x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=max_features)
  9. # This turns our lists of integers into a 2D integer tensor of shape `(samples, maxlen)`
  10. x_train = preprocessing.sequence.pad_sequences(x_train, maxlen=maxlen)
  11. x_test = preprocessing.sequence.pad_sequences(x_test, maxlen=maxlen)
  13. from keras.models import Sequential
  14. from keras.layers import Flatten, Dense
  16. model = Sequential()
  17. # We specify the maximum input length to our Embedding layer so we can later flatten the embedded inputs
  18. model.add(Embedding(10000, 8, input_length=maxlen))
  19. # After the Embedding layer, 
  20. # our activations have shape `(samples, maxlen, 8)`.
  22. # We flatten the 3D tensor of embeddings 
  23. # into a 2D tensor of shape `(samples, maxlen * 8)`
  24. model.add(Flatten())
  26. # We add the classifier on top
  27. model.add(Dense(1, activation='sigmoid'))
  28. model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['acc'])
  29. model.summary()
  31. history = model.fit(x_train, y_train,
  32.                     epochs=10,
  33.                     batch_size=32,
  34.                     validation_split=0.2)

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

2. 使用预训练的词嵌入

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

这种词嵌入通常是利用词频统计计算得出的（观察哪些词共同出现在句子或文档中），用到的技术很多，有些涉及神经网络，有些则不涉及。 Bengio 等人在 21 世纪初首先研究了一种思路，就是用无监督的方法计算一个密集的低维词嵌入空间 a，但直到最有名且最成功的词嵌入方案之 一 word2vec 算法发布之后，这一思路才开始在研究领域和工业应用中取得成功。 word2vec 算法由 Google 的 Tomas Mikolov 于 2013 年开发，其维度抓住了特定的语义属性，比如性别。 有许多预计算的词嵌入数据库，你都可以下载并在 Keras 的 Embedding 层中使用。word2vec 就是其中之一。另一个常用的是 GloVe（ global vectors for word representation，词表示全局向量），由斯坦福大学的研究人员于 2014 年开发。这种嵌入方法基于对词共现统计矩阵进行因式分解。其开发者已经公开了数百万个英文标记的预计算嵌入，它们都是从维基百科数据和 Common Crawl 数据得到的。

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

实战：将 Glove 词嵌入应用于 IMDB 评论情感分类

本节的模型与之前刚刚见过的那个类似：将句子嵌入到向量序列中，然后将其展平，最后在上面训练一个 Dense 层。但此处将使用预训练的词嵌入。

1. 下载数据并读入进程中

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

我们将训练评论转换成字符串列表，每个字符串对应一条评论，然后将评论标签（正面 / 负面）转换成 labels 列表。

  1. """
  2. 读取数据
  3. """
  4. import os
  5. from typing import List
  7. imdb_dir = r'E:\datasets\aclImdb\aclImdb'
  8. train_dir = os.path.join(imdb_dir, 'train')
  10. labels: List[int] = []  # 存储标签，neg 0，pos 1
  11. texts: List[str] = []  # 存储所有样本的数据，每个元素为一个样本的字符串
  13. for label_type in ['neg', 'pos']:
  14.     dir_name = os.path.join(train_dir, label_type)
  15.     for fname in os.listdir(dir_name):
  16.         if fname[-4:] == '.txt':
  17.             f = open(os.path.join(dir_name, fname))
  18.             texts.append(f.read())
  19.             f.close()
  20.             if label_type == 'neg':
  21.                 labels.append(0)
  22.             else:
  23.                 labels.append(1)

2. 对文本数据进行分词

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

  1. from keras.preprocessing.text import Tokenizer
  2. from keras.preprocessing.sequence import pad_sequences
  3. import numpy as np
  5. maxlen = 100  # We will cut reviews after 100 words
  6. training_samples = 200  # We will be training on 200 samples
  7. validation_samples = 10000  # We will be validating on 10000 samples
  8. max_words = 10000  # We will only consider the top 10,000 words in the dataset
  10. tokenizer = Tokenizer(num_words=max_words)  # 只考虑前 max_words 个单词
  11. tokenizer.fit_on_texts(texts)  # 构建单词索引
  12. sequences = tokenizer.texts_to_sequences(texts)  # 将字符串转换为整数索引组成的列表
  14. word_index = tokenizer.word_index
  15. print('Found %s unique tokens.' % len(word_index))
  17. data = pad_sequences(sequences, maxlen=maxlen)  # 将评论数据截断后的数据（在 maxlen 个单词之后进行截断）
  19. labels = np.asarray(labels)
  20. print('Shape of data tensor:', data.shape)
  21. print('Shape of label tensor:', labels.shape)
  23. # Split the data into a training set and a validation set
  24. # But first, shuffle the data, since we started from data
  25. # where sample are ordered (all negative first, then all positive).
  26. indices = np.arange(data.shape[0])
  27. np.random.shuffle(indices)
  28. data = data[indices]
  29. labels = labels[indices]
  31. x_train = data[:training_samples]
  32. y_train = labels[:training_samples]
  33. x_val = data[training_samples: training_samples + validation_samples]
  34. 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. 对嵌入进行预处理

读取并解析 Glove 词嵌入文件，构建 word -> vec 的索引

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

  1. glove_dir = r'E:\datasets\premodels\glove.6B'
  3. embeddings_index = {}
  4. f = open(os.path.join(glove_dir, 'glove.6B.100d.txt'), encoding='utf8')
  5. for line in f:
  6.     values = line.split()
  7.     word = values[0]
  8.     coefs = np.asarray(values[1:], dtype='float32')
  9.     embeddings_index[word] = coefs
  10. f.close()
  12. print('Found %s word vectors.' % len(embeddings_index))

准备 Glove 词嵌入矩阵

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

  1. embedding_dim = 100  # 词向量的维度
  3. embedding_matrix = np.zeros((max_words, embedding_dim))  # 词嵌入矩阵
  4. for word, i in word_index.items():
  5.     embedding_vector = embeddings_index.get(word)
  6.     if i < max_words:
  7.         if embedding_vector is not None:
  8.             # Words not found in embedding index will be all-zeros.
  9.             embedding_matrix[i] = embedding_vector

5. 定义模型架构

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

  1. from keras.models import Sequential
  2. from keras.layers import Embedding, Flatten, Dense
  4. model = Sequential()
  5. model.add(Embedding(max_words, embedding_dim, input_length=maxlen))
  6. model.add(Flatten())
  7. model.add(Dense(32, activation='relu'))
  8. model.add(Dense(1, activation='sigmoid'))
  9. model.summary()

6. 在模型中加载 Glove 嵌入

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

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

此外，需要冻结 Embedding 层（即将其 trainable 属性设为 False），其原理和预训练的卷积神经网络特征相同，你已经很熟悉了。

如果一个模型的一部分是经过预训练的（如 Embedding层），而另一部分是随机初始化的（如分类器），那么在训练期间不应该更新预训练的部分，以避免丢失它们所保存的信息。随机初始化的层会引起较大的梯度更新，会破坏已经学到的特征。

7. 训练模型与评估模型

编译并训练模型。

  1. model.compile(optimizer='rmsprop',
  2.               loss='binary_crossentropy',
  3.               metrics=['acc'])
  4. history = model.fit(x_train, y_train,
  5.                     epochs=10,
  6.                     batch_size=32,
  7.                     validation_data=(x_val, y_val))
  8. model.save_weights('pre_trained_glove_model.h5')

接下来，绘制模型性能随时间的变化：

  1. import matplotlib.pyplot as plt
  3. acc = history.history['acc']
  4. val_acc = history.history['val_acc']
  5. loss = history.history['loss']
  6. val_loss = history.history['val_loss']
  8. epochs = range(1, len(acc) + 1)
  10. plt.plot(epochs, acc, 'bo', label='Training acc')
  11. plt.plot(epochs, val_acc, 'b', label='Validation acc')
  12. plt.title('Training and validation accuracy')
  13. plt.legend()
  15. plt.figure()
  17. plt.plot(epochs, loss, 'bo', label='Training loss')
  18. plt.plot(epochs, val_loss, 'b', label='Validation loss')
  19. plt.title('Training and validation loss')
  20. plt.legend()
  22. plt.show()

image.pngimage.png
模型很快就开始过拟合，考虑到训练样本很少，这一点也不奇怪。出于同样的原因，验证精度的波动很大，但似乎达到了接近 60%。
注意，你的结果可能会有所不同。训练样本数太少，所以模型性能严重依赖于你选择的 200 个样本，而样本是随机选择的。

你也可以在不加载预训练词嵌入、也不冻结嵌入层的情况下训练相同的模型。 在这种情况下，你将会学到针对任务的输入标记的嵌入。如果有大量的可用数据，这种方法通常比预训练词嵌入更加强大。